/* Helper functions */
function __file_fsname:string (file:long) %{ /* pure */
	struct file *file = (struct file *)(long)THIS->file;
	struct dentry *dentry = file? kread(&(file->f_dentry)) : NULL;
	struct inode *d_inode = dentry? kread(&(dentry->d_inode)) : NULL;
	if (d_inode == NULL)
		strlcpy(THIS->__retvalue, "NULL", MAXSTRINGLEN);
	else {
		struct super_block *i_sb = kread(&(d_inode->i_sb));
		struct file_system_type *s_type = kread(&(i_sb->s_type));
		const char *name = kread(&(s_type->name));
		deref_string(THIS->__retvalue, name, MAXSTRINGLEN);
	}
	CATCH_DEREF_FAULT();
%}

probe never
{
	printf("%d",GROUP_NFS)
}
probe addevent.nfs
       = addevent.nfs.entry,
         addevent.nfs.return
{}

probe addevent.nfs.entry
	= addevent.nfs.fop.entry,
	  addevent.nfs.aop.entry,
	  addevent.nfs.proc.entry
{}

probe addevent.nfs.return
	= addevent.nfs.fop.return,
	  addevent.nfs.aop.return,
	  addevent.nfs.proc.return
{}

probe addevent.nfs.fop
      = addevent.nfs.fop.entry,
        addevent.nfs.fop.return
{}

probe addevent.nfs.fop.entry
       =
	addevent.nfs.fop.llseek.entry,
	addevent.nfs.fop.read.entry,
	addevent.nfs.fop.write.entry,
	addevent.nfs.fop.aio_read.entry,
	addevent.nfs.fop.aio_write.entry,
	addevent.nfs.fop.mmap.entry,
	addevent.nfs.fop.open.entry,
	addevent.nfs.fop.flush.entry,
	addevent.nfs.fop.release.entry,
	addevent.nfs.fop.fsync.entry,
	addevent.nfs.fop.lock.entry,
	addevent.nfs.fop.sendfile.entry,
	addevent.nfs.fop.check_flags.entry
{}

probe addevent.nfs.fop.return
       =
	addevent.nfs.fop.llseek.return,
	addevent.nfs.fop.read.return,
	addevent.nfs.fop.write.return,
	addevent.nfs.fop.aio_read.return,
	addevent.nfs.fop.aio_write.return,
	addevent.nfs.fop.mmap.return,
	addevent.nfs.fop.open.return,
	addevent.nfs.fop.flush.return,
	addevent.nfs.fop.release.return,
	addevent.nfs.fop.fsync.return,
	addevent.nfs.fop.lock.return,
	addevent.nfs.fop.sendfile.return
//	addevent.nfs.fop.check_flags.return
{}

%{
    void getdevice(char * ,int * ,int *);
%}
function log_nfs_return (hookid:long,ret_val:long)
%{
	_lket_trace(_GROUP_NFS,THIS->hookid,"%4b",THIS->ret_val);
%}

probe addevent.nfs.fop.llseek.entry
      += _addevent.nfs.fop.llseek.entry
{
	update_record()
}

probe _addevent.nfs.fop.llseek.entry
       = nfs.fop.llseek
{
	log_fop_llseek(s_id,fileid,offset,origin)
}

function log_fop_llseek(s_id:long,ino:long,offset:long,origin:long)%{ /*pure*/
	char * s_id = (char *)((long)THIS->s_id);
	int major,minor;

	getdevice(s_id,&major,&minor);
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_LLSEEK_ENTRY,"%1b%1b%8b%8b%1b",(_FMT_)major,(_FMT_)minor,
			                            THIS->ino,THIS->offset,THIS->origin);
%}

probe addevent.nfs.fop.llseek.return
      += _addevent.nfs.fop.llseek.return
{
	update_record()
}

probe _addevent.nfs.fop.llseek.return
      = nfs.fop.llseek.return
{
	log_nfs_return(HOOKID_NFS_FOP_LLSEEK_RETURN,$return)
}

probe addevent.nfs.fop.read.entry
      += _addevent.nfs.fop.read.entry
{
	update_record()
}

probe _addevent.nfs.fop.read.entry
      = nfs.fop.read
{
	filesystem = __file_fsname($filp)

	if(filesystem == "nfs")
		log_fop_rw(HOOKID_NFS_FOP_READ_ENTRY,s_id,fileid,buf,len,pos)
}

function log_fop_rw(hookid:long,s_id:long,ino:long,buf:long,len:long,pos:long) %{ /*pure*/
	char * s_id = (char *)((long)THIS->s_id);
	int major,minor;

	getdevice(s_id,&major,&minor);
	_lket_trace(_GROUP_NFS,THIS->hookid,"%1b%1b%8b%8b%8b%8b",(_FMT_)major,(_FMT_)minor,
			           THIS->ino,THIS->buf,THIS->len,THIS->pos);	
%}

probe addevent.nfs.fop.read.return
      += _addevent.nfs.fop.read.return
{
	update_record()
}

probe _addevent.nfs.fop.read.return
      = nfs.fop.read.return
{
//	log_nfs_return(HOOKID_NFS_FOP_READ_RETURN,$return)
}

probe addevent.nfs.fop.write.entry
      += _addevent.nfs.fop.write.entry
{
	update_record()
}

probe _addevent.nfs.fop.write.entry
      = nfs.fop.write
{
	filesystem = __file_fsname($filp)

	if(filesystem == "nfs")
		log_fop_rw(HOOKID_NFS_FOP_WRITE_ENTRY,s_id,fileid,buf,len,pos)
}

probe addevent.nfs.fop.write.return
      += _addevent.nfs.fop.write.return
{
	update_record()
}

probe _addevent.nfs.fop.write.return
      = nfs.fop.write.return
{
//	log_nfs_return(HOOKID_NFS_FOP_WRITE_RETURN,$return)
}

probe addevent.nfs.fop.aio_read.entry
      += _addevent.nfs.fop.aio_read.entry
{
	update_record()
}

probe _addevent.nfs.fop.aio_read.entry
     = nfs.fop.aio_read 
{
	log_fop_rw(HOOKID_NFS_FOP_AIOREAD_ENTRY,s_id,fileid,buf,len,pos)
}

probe addevent.nfs.fop.aio_read.return
      += _addevent.nfs.fop.aio_read.return
{
	update_record()
}

probe _addevent.nfs.fop.aio_read.return
      = nfs.fop.aio_read.return
{
	log_nfs_return(HOOKID_NFS_FOP_AIOREAD_RETURN,$return)
}

probe addevent.nfs.fop.aio_write.entry
      += _addevent.nfs.fop.aio_write.entry
{
	update_record()
}

probe _addevent.nfs.fop.aio_write.entry
     = nfs.fop.aio_write
{
	log_fop_rw(HOOKID_NFS_FOP_AIOWRITE,s_id,fileid,buf,len,pos)
}

probe addevent.nfs.fop.aio_write.return
      += _addevent.nfs.fop.aio_write.return
{
	update_record()
}

probe _addevent.nfs.fop.aio_write.return
      = nfs.fop.aio_write.return
{
	log_nfs_return(HOOKID_NFS_FOP_AIOWRITE_RETURN,$return)
}

probe addevent.nfs.fop.mmap.entry
      += _addevent.nfs.fop.mmap.entry
{
	update_record()
}

probe _addevent.nfs.fop.mmap.entry
     = nfs.fop.mmap 
{
	log_fop_mmap(s_id,fileid,vm_start,vm_end,vm_flags)
}

function log_fop_mmap(s_id:long,ino:long,vm_start:long,
                                  vm_end:long,vm_flags:long)
%{/*pure*/
	char * s_id = (char *)((long)THIS->s_id);
	int major,minor;

	getdevice(s_id,&major,&minor);
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_MMAP_ENTRY,"%1b%1b%8b%8b%8b%4b",
		(_FMT_)major,(_FMT_)minor, THIS->ino,THIS->vm_start,
		THIS->vm_end,THIS->vm_flags);
%}

probe addevent.nfs.fop.mmap.return
      += _addevent.nfs.fop.mmap.return
{
	update_record()
}

probe _addevent.nfs.fop.mmap.return
     = nfs.fop.mmap.return
{
	log_nfs_return(HOOKID_NFS_FOP_MMAP_RETURN,$return)
}

probe addevent.nfs.fop.open.entry
      += _addevent.nfs.fop.open.entry
{
	update_record()
}

probe _addevent.nfs.fop.open.entry
     = nfs.fop.open 
{
	log_fop_open(s_id,fileid,flag,filename)
}

function log_fop_open(s_id:long,ino:long,flag :long , filename:string)
%{/*pure*/
	char * s_id = (char *)((long)THIS->s_id);
	int major,minor;

	getdevice(s_id,&major,&minor);
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_OPEN_ENTRY,"%1b%1b%8b%4b%0s",
		(_FMT_)major,(_FMT_)minor, THIS->ino,THIS->flag,THIS->filename);
%}

probe addevent.nfs.fop.open.return
      += _addevent.nfs.fop.open.return
{
	update_record()
}

probe _addevent.nfs.fop.open.return
     = nfs.fop.open.return
{
	log_nfs_return(HOOKID_NFS_FOP_OPEN_RETURN,$return)
}

probe addevent.nfs.fop.flush.entry
      += _addevent.nfs.fop.flush.entry
{
	update_record()
}

probe _addevent.nfs.fop.flush.entry
     = nfs.fop.flush 
{
	log_fop_flush(s_id,fileid,ndirty)
}

function log_fop_flush(s_id:long,ino:long,ndirty:long)
%{/*pure*/
	char * s_id = (char *)((long)THIS->s_id);
	int major,minor;

	getdevice(s_id,&major,&minor);
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_FLUSH_ENTRY,"%1b%1b%8b%4b",
		(_FMT_)major,(_FMT_)minor, THIS->ino,THIS->ndirty);
%}

probe addevent.nfs.fop.flush.return
      += _addevent.nfs.fop.flush.return
{
	update_record()
}

probe _addevent.nfs.fop.flush.return
     = nfs.fop.flush.return
{
	log_nfs_return(HOOKID_NFS_FOP_FLUSH_RETURN,$return)
}

probe addevent.nfs.fop.release.entry
      += _addevent.nfs.fop.release.entry
{
	update_record()
}

probe _addevent.nfs.fop.release.entry
     = nfs.fop.release 
{
	log_fop_release(s_id,fileid,mode)
}

function log_fop_release(s_id:long,ino:long,mode:long)
%{/*pure*/
	char * s_id = (char *)((long)THIS->s_id);
	int major,minor;

	getdevice(s_id,&major,&minor);
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_RELEASE_ENTRY,"%1b%1b%8b%2b",
		(_FMT_)major,(_FMT_)minor,
		THIS->ino,THIS->mode);
%}

probe addevent.nfs.fop.release.return
      += _addevent.nfs.fop.release.return
{
	update_record()
}

probe _addevent.nfs.fop.release.return
     = nfs.fop.release.return
{
	log_nfs_return(HOOKID_NFS_FOP_RELEASE_RETURN,$return)
}

probe addevent.nfs.fop.fsync.entry
      += _addevent.nfs.fop.fsync.entry
{
	update_record()
}

probe _addevent.nfs.fop.fsync.entry
     = nfs.fop.fsync 
{
	log_fop_fsync(s_id,fileid,ndirty)
}

function log_fop_fsync(s_id:long,ino:long,ndirty:long)
%{/*pure*/
	char * s_id = (char *)((long)THIS->s_id);
	int major,minor;

	getdevice(s_id,&major,&minor);
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_FSYNC_ENTRY,"%1b%1b%8b%4b",
		(_FMT_)major,(_FMT_)minor, THIS->ino,THIS->ndirty);
%}

probe addevent.nfs.fop.fsync.return
      += _addevent.nfs.fop.fsync.return
{
	update_record()
}

probe _addevent.nfs.fop.fsync.return
     = nfs.fop.fsync.return
{
	log_nfs_return(HOOKID_NFS_FOP_FSYNC_RETURN,$return)
}

probe addevent.nfs.fop.lock.entry
      += _addevent.nfs.fop.lock.entry
{
	update_record()
}

probe _addevent.nfs.fop.lock.entry
     = nfs.fop.lock 
{
	log_fop_lock(s_id,fileid,fl_start,fl_end,fl_type,fl_flag,cmd)
}

function log_fop_lock(s_id:long,ino:long,fl_start:long,fl_end:long,fl_type:long,fl_flag:long,cmd:long)
%{/*pure*/
	char * s_id = (char *)((long)THIS->s_id);
	int major,minor;

	getdevice(s_id,&major,&minor);
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_LOCK_ENTRY,"%1b%1b%8b%8b%8b%1b%1b%4b",
		(_FMT_)major,(_FMT_)minor, THIS->ino,THIS->fl_start,THIS->fl_end,
		THIS->fl_type,THIS->fl_flag,THIS->cmd);
%}

probe addevent.nfs.fop.lock.return
      += _addevent.nfs.fop.lock.return
{
	update_record()
}

probe _addevent.nfs.fop.lock.return
     = nfs.fop.lock.return
{
	log_nfs_return(HOOKID_NFS_FOP_LOCK_RETURN,$return)
}

probe addevent.nfs.fop.sendfile.entry
      += _addevent.nfs.fop.sendfile.entry
{
	update_record()
}

probe _addevent.nfs.fop.sendfile.entry
     = nfs.fop.sendfile 
{
	log_fop_sendfile(s_id,fileid,count,ppos)
}

function log_fop_sendfile(s_id:long,ino:long,count:long,ppos:long)
%{/*pure*/
	char * s_id = (char *)((long)THIS->s_id);
	int major,minor;

	getdevice(s_id,&major,&minor);
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_SENDFILE_ENTRY,"%1b%1b%8b%8b%8b",
		(_FMT_)major,(_FMT_)minor, THIS->ino,THIS->count,THIS->ppos);
%}

probe addevent.nfs.fop.sendfile.return
      += _addevent.nfs.fop.sendfile.return
{
	update_record()
}

probe _addevent.nfs.fop.sendfile.return
     = nfs.fop.sendfile.return
{
	log_nfs_return(HOOKID_NFS_FOP_SENDFILE_RETURN,$return)
}

probe addevent.nfs.fop.check_flags.entry
      += _addevent.nfs.fop.check_flags.entry
{
	update_record()
}

probe _addevent.nfs.fop.check_flags.entry
     = nfs.fop.check_flags 
{
	log_fop_check_flags(flag)
}

function log_fop_check_flags(flag:long)
%{/*pure*/
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_CHECKFLAGS_ENTRY,"%4b",THIS->flag);
%}

///FIXME: unable to resovle $return
/*
probe addevent.nfs.fop.check_flags.return
      += _addevent.nfs.fop.check_flags.return
{
	update_record()
}

probe _addevent.nfs.fop.check_flags.return
     = nfs.fop.check_flags.return
{
	log_nfs_return(HOOKID_NFS_FOP_CHECKFLAGS_RETURN,$return)
}
*/


probe addevent.nfs.aop
      = addevent.nfs.aop.entry,
        addevent.nfs.aop.return
{}

probe addevent.nfs.aop.entry
       =
       addevent.nfs.aop.readpage.entry,
       addevent.nfs.aop.readpages.entry,
       addevent.nfs.aop.writepage.entry,
       addevent.nfs.aop.writepages.entry,
       addevent.nfs.aop.release_page.entry ?,
       addevent.nfs.aop.set_page_dirty.entry,
       addevent.nfs.aop.prepare_write.entry,
       addevent.nfs.aop.commit_write.entry
{}

probe addevent.nfs.aop.return
       =
       addevent.nfs.aop.readpage.return,
       addevent.nfs.aop.readpages.return,
       addevent.nfs.aop.writepage.return,
       addevent.nfs.aop.writepages.return,
       addevent.nfs.aop.release_page.return ?,
       addevent.nfs.aop.set_page_dirty.return,
       addevent.nfs.aop.prepare_write.return,
       addevent.nfs.aop.commit_write.return
{}

probe addevent.nfs.aop.readpages.entry
      += _addevent.nfs.aop.readpages.entry
{
	update_record()
}

probe _addevent.nfs.aop.readpages.entry
      = nfs.aop.readpages
{
	log_aop_readpages(fileid,rpages,nr_pages)
}

function log_aop_readpages(ino:long,rpages:long,nr_pages:long)
%{/*pure*/
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_READPAGES_ENTRY,"%8b%4b%4b",
		THIS->ino,THIS->rpages,THIS->nr_pages);
%}

probe addevent.nfs.aop.readpages.return
      += _addevent.nfs.aop.readpages.return
{
	update_record()
}

probe _addevent.nfs.aop.readpages.return
     = nfs.aop.readpages.return
{
	log_nfs_return(HOOKID_NFS_AOP_READPAGES_RETURN,$return)
}

probe addevent.nfs.aop.readpage.entry
      += _addevent.nfs.aop.readpage.entry
{
	update_record()
}

probe _addevent.nfs.aop.readpage.entry
      = nfs.aop.readpage
{
	log_aop_readpage(fileid,rsize,__page,page_index)
}

function log_aop_readpage(ino:long,rsize:long,__page:long,page_index:long)
%{/*pure*/
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_READPAGE_ENTRY,"%8b%4b%8b%8b",
		THIS->ino,THIS->rsize,THIS->__page,THIS->page_index);
%}

probe addevent.nfs.aop.readpage.return
      += _addevent.nfs.aop.readpage.return
{
	update_record()
}

probe _addevent.nfs.aop.readpage.return
     = nfs.aop.readpage.return
{
	log_nfs_return(HOOKID_NFS_AOP_READPAGE_RETURN,$return)
}

probe addevent.nfs.aop.writepage.entry
      += _addevent.nfs.aop.writepage.entry
{
	update_record()
}

probe _addevent.nfs.aop.writepage.entry
      = nfs.aop.writepage
{
	log_aop_writepage(fileid,wsize,__page,page_index)
}

function log_aop_writepage(ino:long,wsize:long,__page:long,page_index:long)
%{/*pure*/
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_WRITEPAGE_ENTRY,"%8b%4b%8b%8b",
		THIS->ino,THIS->wsize,THIS->__page,THIS->page_index);
%}

probe addevent.nfs.aop.writepage.return
      += _addevent.nfs.aop.writepage.return
{
	update_record()
}

probe _addevent.nfs.aop.writepage.return
     = nfs.aop.writepage.return
{
	log_nfs_return(HOOKID_NFS_AOP_WRITEPAGE_RETURN,$return)
}

probe addevent.nfs.aop.writepages.entry
      += _addevent.nfs.aop.writepages.entry
{
	update_record()
}

probe _addevent.nfs.aop.writepages.entry
      = nfs.aop.writepages
{
	log_aop_writepages(fileid,wpages,nr_to_write)
}

function log_aop_writepages(ino:long,wpages:long,nr_to_write:long)
%{/*pure*/
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_WRITEPAGES_ENTRY,"%8b%4b%8b",
		THIS->ino,THIS->wpages,THIS->nr_to_write);
%}

probe addevent.nfs.aop.writepages.return
      += _addevent.nfs.aop.writepages.return
{
	update_record()
}

probe _addevent.nfs.aop.writepages.return
     = nfs.aop.writepages.return
{
	log_nfs_return(HOOKID_NFS_AOP_WRITEPAGES_RETURN,$return)
}

probe addevent.nfs.aop.prepare_write.entry
      += _addevent.nfs.aop.prepare_write.entry
{
	update_record()
}

probe _addevent.nfs.aop.prepare_write.entry
      = nfs.aop.prepare_write
{
	log_aop_prepare_write(fileid,__page,page_index)
}

function log_aop_prepare_write(ino:long,__page:long,page_index:long)
%{/*pure*/
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_PREPAREWRITE_ENTRY,"%8b%8b%8b",
		THIS->ino,THIS->__page,THIS->page_index);
%}

probe addevent.nfs.aop.prepare_write.return
      += _addevent.nfs.aop.prepare_write.return
{
	update_record()
}

probe _addevent.nfs.aop.prepare_write.return
     = nfs.aop.prepare_write.return
{
	log_nfs_return(HOOKID_NFS_AOP_PREPAREWRITE_RETURN,$return)
}

probe addevent.nfs.aop.commit_write.entry
      += _addevent.nfs.aop.commit_write.entry
{
	update_record()
}

probe _addevent.nfs.aop.commit_write.entry
      = nfs.aop.commit_write
{
	log_aop_commit_write(fileid,__page,page_index,offset,count)
}

function log_aop_commit_write(ino:long,__page:long,page_index:long,offset:long,count:long)
%{/*pure*/
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_COMMITWRITE_ENTRY,"%8b%8b%8b%4b%4b",
		THIS->ino,THIS->__page, THIS->page_index,THIS->offset,THIS->count);
%}

probe addevent.nfs.aop.commit_write.return
      += _addevent.nfs.aop.commit_write.return
{
	update_record()
}

probe _addevent.nfs.aop.commit_write.return
     = nfs.aop.commit_write.return
{
	log_nfs_return(HOOKID_NFS_AOP_COMMITWRITE_RETURN,$return)
}

probe addevent.nfs.aop.set_page_dirty.entry
      += _addevent.nfs.aop.set_page_dirty.entry
{
	update_record()
}

probe _addevent.nfs.aop.set_page_dirty.entry
      = nfs.aop.set_page_dirty
{
	log_aop_set_page_dirty(__page,page_flag)
}

function log_aop_set_page_dirty(__page:long,page_flag:long)
%{/*pure*/
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_SETPAGEDIRTY_ENTRY,"%8b%1b",
		THIS->__page,THIS->page_flag);
%}

probe addevent.nfs.aop.set_page_dirty.return
      += _addevent.nfs.aop.set_page_dirty.return
{
	update_record()
}

probe _addevent.nfs.aop.set_page_dirty.return
     = nfs.aop.set_page_dirty.return
{
	log_nfs_return(HOOKID_NFS_AOP_SETPAGEDIRTY_RETURN,$return)
}

probe addevent.nfs.aop.release_page.entry
      += _addevent.nfs.aop.release_page.entry
{
	update_record()
}

probe _addevent.nfs.aop.release_page.entry
      = nfs.aop.release_page
{
	log_aop_release_page(__page,page_index)
}

function log_aop_release_page(__page:long,page_index:long)
%{/*pure*/
	_lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_RELEASEPAGE_ENTRY,"%8b%8b",
		THIS->__page,THIS->page_index);
%}

probe addevent.nfs.aop.release_page.return
      += _addevent.nfs.aop.release_page.return
{
	update_record()
}

probe _addevent.nfs.aop.release_page.return
     = nfs.aop.release_page.return
{
	log_nfs_return(HOOKID_NFS_AOP_RELEASEPAGE_RETURN,$return)
}