src/lket.5.in:

document nfs trace hooks

tapset/nfsd.stp, tapset/nfs_proc.stp, tapset/nfs.stp:
Change NFS file identifier. Change NFS version data type
from String to INT. Add version variable to nfs_open
and nfs_release.

LKET/iosyscall.stp:
change log_iosyscall_sync() be sync with different timing methods.

LKET/utils.stp:
add reset_maxaction() since there are too many functions called inside "probe begin".

LKET/nfsd.stp, LKET/nfs_proc.stp, LKET/nfs.stp:
New trace hooks for NFS, including both NFS client and server side activities.

LKET/register_event.stp:
Add the register event calls for NFS trace hooks.

1 files changed, 741 insertions, 0 deletions

diff --git a/tapset/LKET/nfs.stp b/tapset/LKET/nfs.stp
new file mode 100755
index 00000000..924b2c28
--- /dev/null
+++ b/tapset/LKET/nfs.stp
@@ -0,0 +1,741 @@
+probe never
+{
+	printf("%d",GROUP_NFS)
+}
+probe addevent.nfs
+       = addevent.nfs.entries,
+         addevent.nfs.return
+{}
+
+probe addevent.nfs.entries
+	= addevent.nfs.fop.entries,
+	  addevent.nfs.aop.entries,
+	  addevent.nfs.proc.entries
+{}
+
+probe addevent.nfs.return
+	= addevent.nfs.fop.return,
+	  addevent.nfs.aop.return,
+	  addevent.nfs.proc.return
+{}
+
+probe addevent.nfs.fop
+      = addevent.nfs.fop.entries,
+        addevent.nfs.fop.return
+{}
+
+probe addevent.nfs.fop.entries
+       =
+       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
+{}
+
+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
+{}
+
+%{
+    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 *)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 = kernel_string($filp->f_dentry->d_inode->i_sb->s_type->name)
+
+	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 *)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 = kernel_string($filp->f_dentry->d_inode->i_sb->s_type->name)
+
+	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 *)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 *)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 *)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 *)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 *)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 *)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 *)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);
+%}
+
+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.entries
+       =
+       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)
+}