vfs.stp:

New tapset from Thomas Zanussi(trz@us.ibm.com) to probe vfs layer activities.

nfs.stp:
New tapset from Li Xuepeng(xuepengl@cn.ibm.com) to probe nfs file operations
and nfs address space operations on client side.

nfs_proc.stp:
New tapset from Li Xuepeng to probe some nfs RPC procedure stub functions
on client side.

nfsd.stp:
New tapset from Li Xuepeng to probe nfs server side activities, including
some RPC procedure stub functions, nfsd dispatch routine, and nfsd_* functions

5 files changed, 4105 insertions, 0 deletions

diff --git a/tapset/ChangeLog b/tapset/ChangeLog
index 26af7d31..3a38486d 100644
--- a/tapset/ChangeLog
+++ b/tapset/ChangeLog
@@ -1,3 +1,15 @@
+2006-08-23  Li Guanglei <guanglei@cn.ibm.com>
+
+	* vfs.stp: New tapset from Thomas Zanussi(trz@us.ibm.com) to probe
+	vfs layer activities.
+	* nfs.stp: New tapset from Li Xuepeng(xuepengl@cn.ibm.com) to probe
+	nfs file operations and nfs address space operations on client side.
+	* nfs_proc.stp: New tapset from Li Xuepeng to probe some nfs RPC 
+	procedure stub functions on client side.
+	* nfsd.stp: New tapset from Li Xuepeng to probe nfs server side 
+	activities, including some RPC procedure stub functions, nfsd 
+	dispatch routine, and nfsd_* functions
+	
 2006-08-22  Li Guanglei <guanglei@cn.ibm.com>
 
 	* signal.stp: More variables for signal.do_action and
diff --git a/tapset/nfs.stp b/tapset/nfs.stp
new file mode 100644
index 00000000..e1609dad
--- /dev/null
+++ b/tapset/nfs.stp
@@ -0,0 +1,999 @@
+%{
+#include <linux/kernel.h>
+#include <linux/nfs_fs.h>
+%}
+/*Get struct nfs_inode from struct inode*/
+%{ 
+  struct nfs_inode * __nfs_i (struct inode *inode)
+  {
+    struct nfs_inode * nfsi = NFS_I(inode);
+
+    return (nfsi);
+  }
+%}
+
+/*Get cache_validity flag from struct inode*/
+function __nfsi_cache_valid:long(inode:long) %{ /* pure */
+    struct inode * inode = (struct inode *)(THIS->inode);
+    struct nfs_inode * nfsi;
+  
+    nfsi = __nfs_i(inode);
+    THIS->__retvalue = nfsi->cache_validity;
+%}
+
+/*Get read_cache_jiffies from struct inode*/
+function __nfsi_rcache_time :long (inode:long) %{ /* pure */
+    struct inode * inode = (struct inode *)(THIS->inode);
+    struct nfs_inode * nfsi = (struct nfs_inode *) __nfs_i(inode);
+
+    THIS->__retvalue = nfsi->read_cache_jiffies;
+%}
+
+/*Get attrtimeo from struct inode*/
+function __nfsi_attr_time :long (inode:long) %{ /* pure */
+    struct inode * inode = (struct inode *)(THIS->inode);
+    struct nfs_inode * nfsi = (struct nfs_inode *) __nfs_i(inode);
+
+    THIS->__retvalue = nfsi->attrtimeo;
+%}
+
+/*Get ndirty from struct inode*/
+function __nfsi_ndirty:long (inode:long) %{ /* pure */
+      struct inode *inode = (struct inode *)(THIS->inode);
+      struct nfs_inode *nfsi = NFS_I(inode);
+ 
+      THIS->__retvalue = nfsi->ndirty;
+%}
+
+/*Get rsize from struct inode*/
+function __nfs_server_rsize:long (inode:long) %{ /* pure */
+       struct inode * inode = (struct inode *)(THIS->inode);
+
+       THIS->__retvalue = NFS_SERVER(inode)->rsize;
+%}
+
+/*Get wsize from struct inode*/
+function __nfs_server_wsize:long (inode:long) %{ /* pure */
+       struct inode * inode = (struct inode *)(THIS->inode);
+
+       THIS->__retvalue = NFS_SERVER(inode)->wsize;
+%}
+
+/*Get rpages from struct inode*/
+function __nfs_rpages:long (inode:long) %{ /* pure */
+       struct inode * inode = (struct inode *)(THIS->inode);
+
+       THIS->__retvalue = NFS_SERVER(inode)->rpages;
+%}
+
+/*Get wpages from struct inode*/
+function __nfs_wpages:long(inode:long) %{ /* pure */
+      struct inode *inode = (struct inode*)(THIS->inode);
+      THIS->__retvalue = NFS_SERVER(inode)->wpages;
+%}
+
+/*Get struct inode from struct page*/
+function __p2i :long(page:long) %{ /* pure */
+      struct page *page = (struct page *)(THIS->page);
+      THIS->__retvalue = (long)page->mapping->host;
+%}
+
+/*Get i_flags from struct page*/
+function __p2i_flag : long (page:long) %{ /* pure */
+      struct page *page = (struct page *) (THIS->page);
+      THIS->__retvalue = page->mapping->host->i_flags;
+%}
+
+/*Get i_state from struct page*/
+function __p2i_state :long (page:long) %{ /* pure */
+      struct page *page = (struct page *) (THIS->page);
+      THIS->__retvalue = page->mapping->host->i_state;
+%}
+
+/*Get i_size from struct page*/
+function __p2i_size :long (page:long) %{ /* pure */
+      struct page *page = (struct page *) (THIS->page);
+      THIS->__retvalue = page->mapping->host->i_size;
+%}
+
+/*Get s_flags from struct page*/
+function __p2sb_flag:long (page:long) %{ /* pure */
+      struct page *page = (struct page *)(THIS->page);
+      THIS->__retvalue = page->mapping->host->i_sb->s_flags;
+%}
+
+function __d_loff_t :long (ppos :long) %{ /* pure */
+     loff_t * ppos = (loff_t *) (THIS->ppos);
+     
+     THIS->__retvalue =(long) *ppos;
+%}
+
+probe nfs.fop.entries = nfs.fop.llseek,
+                        nfs.fop.read,
+                        nfs.fop.write,
+                        nfs.fop.aio_read,
+                        nfs.fop.aio_write,
+                        nfs.fop.mmap,
+                        nfs.fop.open,
+                        nfs.fop.flush,
+                        nfs.fop.release,
+                        nfs.fop.fsync,
+                        nfs.fop.lock,
+                        nfs.fop.sendfile
+{
+}
+
+probe nfs.fop.return = nfs.fop.llseek.return,
+                        nfs.fop.read.return,
+                        nfs.fop.write.return,
+                        nfs.fop.aio_read.return,
+                        nfs.fop.aio_write.return,
+                        nfs.fop.mmap.return,
+                        nfs.fop.open.return,
+                        nfs.fop.flush.return,
+                        nfs.fop.release.return,
+                        nfs.fop.fsync.return,
+                        nfs.fop.lock.return,
+                        nfs.fop.sendfile.return
+{
+}
+
+/*probe nfs.fop.llseek
+ *
+ *  Fires when do a llseek operation on nfs,it probes
+ *  llseek file operation of nfs
+ *
+ *  Arguments:
+ *     dev : device identifier
+ *     ino : inode number
+ *     offset : the offset of the file will be repositioned
+ *     origin : the original position. The possible value could be:
+ *         SEEK_SET
+ *               The offset is set to offset bytes.
+ *         SEEK_CUR
+ *               The offset is set to its current location plus offset bytes.
+ *         SEEK_END
+ *               The offset is set to the size of the file plus offset bytes.
+ *
+*/
+probe nfs.fop.llseek = kernel.function ("nfs_file_llseek") ?,
+                       module("nfs").function("nfs_file_llseek") ?
+{
+        dev = $filp->f_dentry->d_inode->i_sb->s_dev
+        ino = $filp->f_dentry->d_inode->i_ino
+        maxbyte = $filp->f_dentry->d_inode->i_sb->s_maxbytes
+        offset = $offset
+        origin = $origin
+
+        name = "nfs.fop.llseek"
+        argstr = sprintf("%d, %d", offset, origin)
+}
+
+probe nfs.fop.llseek.return = kernel.function ("nfs_file_llseek").return ?,
+                              module("nfs").function("nfs_file_llseek").return ?
+{
+        name = "nfs.fop.llseek.return"
+        retstr = sprintf("%d", $return)
+}
+/*probe nfs.fop.read
+ *
+ * Fires when do a read operation on nfs,it probes
+ * read file operation of nfs
+ * 
+ * Arguments:
+ *        
+ *
+*/
+probe nfs.fop.read = vfs.do_sync_read
+{
+        name = "nfs.fop.read"
+}
+
+probe nfs.fop.read.return = vfs.do_sync_read.return
+{
+        name = "nfs.fop.read.return"
+}
+
+/*probe nfs.fop.write
+ *
+ * Fires when do a write operation on nfs,it probes
+ * write file operation of nfs
+ * 
+ * Arguments:
+ *        
+ *
+*/
+
+probe nfs.fop.write = vfs.do_sync_write
+{
+        name = "nfs.fop.write"
+}
+
+probe nfs.fop.write.return = vfs.do_sync_write.return
+{
+        name = "nfs.fop.write.return"
+}
+
+/*probe nfs.fop.aio_read
+ *
+ * It probes aio_read file operation of nfs
+ * 
+ * Arguments:
+ *    dev : device identifier
+ *    ino : inode number        
+ *    count : read bytes
+ *    pos   : current position of file   
+ *    buf   : the address of buf in user space
+ *    parent_name : parent dir name
+ *    file_name : file name
+ *    cache_valid : cache related bit mask flag
+ *    cache_time : when we started read-caching this inode
+ *    attrtimeo :  how long the cached information is assumed
+ *                 to be valid.
+ *   We need to revalidate the cached attrs for this inode if
+ *
+ *      jiffies - read_cache_jiffies > attrtimeo
+*/
+probe nfs.fop.aio_read = kernel.function ("nfs_file_read") ?,
+                       module("nfs").function("nfs_file_read") ?
+{
+        dev = $iocb->ki_filp->f_dentry->d_inode->i_sb->s_dev
+        ino = $iocb->ki_filp->f_dentry->d_inode->i_ino
+
+        count = $count
+        pos = $pos
+        buf = $buf
+
+        parent_name = kernel_string($iocb->ki_filp->f_dentry->d_parent->d_name->name)
+        file_name = kernel_string($iocb->ki_filp->f_dentry->d_name->name)
+
+
+        cache_valid = __nfsi_cache_valid($iocb->ki_filp->f_dentry->d_inode)
+        cache_time  = __nfsi_rcache_time($iocb->ki_filp->f_dentry->d_inode)
+        attr_time   = __nfsi_attr_time($iocb->ki_filp->f_dentry->d_inode)
+
+        flag =  $iocb->ki_filp->f_flags
+
+        name = "nfs.fop.aio_read"
+        argstr = sprintf("%p,%d, %d",buf,count, pos)
+
+        size = count
+        units = "bytes"
+}
+
+
+probe nfs.fop.aio_read.return = kernel.function ("nfs_file_read").return ?,
+                                module("nfs").function("nfs_file_read").return ?
+{
+        name = "nfs.fop.aio_read.return"
+        retstr = sprintf("%d", $return)
+
+        if ($return > 0) {
+                size = $return
+                units = "bytes"
+        }
+}
+
+/*probe nfs.fop.aio_write
+ *
+ * It probes aio_write file operation of nfs
+ * 
+ * Arguments:
+ *    dev : device identifier
+ *    ino : inode number        
+ *    count : read bytes
+ *    pos   : offset of the file 
+ *    buf   : the address of buf in user space
+ *    parent_name : parent dir name
+ *    file_name : file name
+ *
+*/
+probe nfs.fop.aio_write = kernel.function("nfs_file_write") ?,
+                          module("nfs").function("nfs_file_write") ?
+{
+        dev = $iocb->ki_filp->f_dentry->d_inode->i_sb->s_dev
+        ino = $iocb->ki_filp->f_dentry->d_inode->i_ino
+
+        count = $count
+        pos = $pos
+        buf = $buf
+               
+        parent_name = kernel_string($iocb->ki_filp->f_dentry->d_parent->d_name->name)
+        file_name = kernel_string($iocb->ki_filp->f_dentry->d_name->name)
+
+        name = "nfs.fop.aio.write"
+        argstr = sprintf("%p, %d, %d", buf, count, pos)
+
+        size = count
+        units = "bytes"
+}
+
+probe nfs.fop.aio_write.return =  kernel.function("nfs_file_write").return ?,
+                          module("nfs").function("nfs_file_write").return ?
+{
+        name = "nfs.fop.aio_write.return"
+        retstr = sprintf("%d", $return)
+
+        if ($return > 0) {
+                size = $return
+                units = "bytes"
+        }
+}
+
+/*probe nfs.fop.mmap
+ *
+ * Fires when do an mmap operation on nfs,
+ * it probes mmap operation of nfs
+ * 
+ * Arguments:
+ *    dev : device identifier
+ *    ino : inode number        
+ *    vm_start :  start address within vm_mm 
+ *    vm_end   :  the first byte after end address within vm_mm
+ *    vm_flag  :  vm flags
+ *    buf   : the address of buf in user space
+ *    parent_name : parent dir name
+ *    file_name : file name
+ *    cache_valid : cache related bit mask flag
+ *    cache_time : when we started read-caching this inode
+ *    attrtimeo :  how long the cached information is assumed
+ *                 to be valid.
+ *   We need to revalidate the cached attrs for this inode if
+ *
+ *      jiffies - read_cache_jiffies > attrtimeo
+*/
+probe nfs.fop.mmap = kernel.function("nfs_file_mmap") ?,
+                     module("nfs").function("nfs_file_mmap") ?
+{
+        dev = $file->f_dentry->d_inode->i_sb->s_dev
+        ino = $file->f_dentry->d_inode->i_ino
+
+        vm_start = $vma->vm_start
+        vm_end = $vma->vm_end
+        vm_flags = $vma->vm_flags
+
+        parent_name = kernel_string($file->f_dentry->d_parent->d_name->name)
+        file_name = kernel_string($file->f_dentry->d_name->name)
+
+        cache_valid = __nfsi_cache_valid($file->f_dentry->d_inode)
+        cache_time  = __nfsi_rcache_time($file->f_dentry->d_inode)
+        attr_time   = __nfsi_attr_time($file->f_dentry->d_inode)
+
+        name = "nfs.fop.mmap"
+        argstr = sprintf("0x%x, 0x%x, 0x%x", vm_start, vm_end, vm_flags)
+}
+
+probe nfs.fop.mmap.return = kernel.function("nfs_file_mmap").return ?,
+                     module("nfs").function("nfs_file_mmap").return ?
+{
+        name = "nfs.fop.mmap.return"
+        retstr = sprintf("%d", $return)
+}
+
+/*probe nfs.fop.open
+ *
+ * Fires when do an open operation on nfs,
+ * it probes open file operation of nfs
+ * 
+ * Arguments:
+ *    dev : device identifier
+ *    ino : inode number        
+ *    file_name : file name
+ *    flag : file flag
+ *    i_size : file length in bytes 
+*/
+probe nfs.fop.open = kernel.function("nfs_file_open") ?,
+                     module("nfs").function("nfs_file_open") ?
+{
+        dev = $filp->f_dentry->d_inode->i_sb->s_dev
+        ino = $inode->i_ino
+
+        filename = kernel_string($filp->f_dentry->d_name->name)
+        flag = $filp->f_flags   
+
+        i_size = $inode->i_size
+   
+        name = "nfs.fop.open"
+        argstr = sprintf("%d,%d, %s", flag, ino, filename)
+}
+
+probe nfs.fop.open.return = kernel.function("nfs_file_open").return ?,
+                            module("nfs").function("nfs_file_open").return ?
+{
+        name = "nfs.fop.open.return"
+        retstr = sprintf("%d", $return)        
+}
+
+/*probe nfs.fop.flush
+ *
+ * Fires when do a flush file operation on nfs,
+ * it probes flush file operation of nfs
+ * 
+ * Arguments:
+ *    dev : device identifier
+ *    ino : inode number        
+ *    mode : file mode
+ *    ndirty : number of dirty page
+*/
+probe nfs.fop.flush = kernel.function("nfs_file_flush") ?,
+                      module("nfs").function("nfs_file_flush") ?
+{
+        dev = $file->f_dentry->d_inode->i_sb->s_dev
+        ino = $file->f_dentry->d_inode->i_ino;
+
+        mode = $file->f_mode
+        ndirty = __nfsi_ndirty($file->f_dentry->d_inode)
+
+        name = "nfs.fop.flush"
+        argstr = sprintf("%d",ino)
+}
+
+probe nfs.fop.flush.return = kernel.function("nfs_file_flush").return ?,
+                      module("nfs").function("nfs_file_flush").return ?
+{
+        name = "nfs.fop.flush.return"
+        retstr = sprintf("%d",$return)
+}
+
+/*probe nfs.fop.release
+ *
+ * Fires when do a release page operation on nfs,
+ * it probes release file operation of nfs
+ * 
+ * Arguments:
+ *    dev : device identifier
+ *    ino : inode number        
+ *    mode : file mode
+*/
+probe nfs.fop.release = kernel.function("nfs_file_release") ?,
+                      module("nfs").function("nfs_file_release") ?
+{
+        dev = $filp->f_dentry->d_inode->i_sb->s_dev
+        ino = $inode->i_ino
+
+        mode = $filp->f_mode
+
+        name = "nfs.fop.release"
+        argstr = sprintf("%d" , ino)
+}
+
+probe nfs.fop.release.return = kernel.function("nfs_file_release").return ?,
+                               module("nfs").function("nfs_file_release").return ?
+{
+        name = "nfs.fop.release.return"
+        retstr = sprintf("%d", $return)
+}
+
+/*probe nfs.fop.fsync
+ *
+ * Fires when do a fsync operation on nfs,
+ * it probes fsync file operation of nfs
+ * 
+ * Arguments:
+ *    dev : device identifier
+ *    ino : inode number       
+ *    ndirty : number of dirty pages 
+*/
+probe nfs.fop.fsync = kernel.function("nfs_fsync") ?,
+                      module("nfs").function("nfs_fsync") ?
+{
+        dev = $file->f_dentry->d_inode->i_sb->s_dev
+        ino = $file->f_dentry->d_inode->i_ino
+
+        ndirty = __nfsi_ndirty($file->f_dentry->d_inode)
+
+        name = "nfs.fop.fsync"
+	argstr = sprintf("%d",ino)  
+}
+
+probe nfs.fop.fsync.return = kernel.function("nfs_fsync").return ?,
+                             module("nfs").function("nfs_fsync").return ?
+{
+        name = "nfs.fop.fsync.return"
+        retstr = sprintf("%d", $return)
+}
+
+/*probe nfs.fop.lock
+ *
+ * Fires when do a file lock operation on nfs,
+ * it probes lock file operation of nfs
+ * 
+ * Arguments:
+ *    dev : device identifier
+ *    ino : inode number      
+ *    i_mode : file type and access rights
+ *    cmd : cmd arguments
+ *    fl_type :lock type
+ *    fl_flag : lock flags
+ *    fl_start : starting offset of locked region 
+ *    fl_end   : ending offset of locked region  
+*/
+probe nfs.fop.lock = kernel.function("nfs_lock") ?,
+                     module("nfs").function("nfs_lock") ?
+{
+        dev = $filp->f_dentry->d_inode->i_sb->s_dev
+        ino = $filp->f_dentry->d_inode->i_ino
+ 
+        i_mode = $filp->f_dentry->d_inode->i_mode
+        cmd = $cmd
+ 
+        fl_type = $fl->fl_type
+        fl_flag = $fl->fl_flags
+        fl_start = $fl->fl_start
+        fl_end  = $fl->fl_end
+
+        name = "nfs.fop.lock"
+        argstr = sprintf("%d,%d",cmd,i_mode)
+}
+
+probe nfs.fop.lock.return = kernel.function("nfs_lock").return ?,
+                             module("nfs").function("nfs_lock").return ?
+{
+         name = "nfs.fop.lock.return"
+         retstr = sprintf("%d",$return)
+}
+
+
+/*probe nfs.fop.sendfile
+ *
+ * Fires when do a send file  operation on nfs,
+ * it probes sendfile file operation of nfs
+ * 
+ * Arguments:
+ *    dev : device identifier
+ *    ino : inode number     
+ *    count : read bytes
+ *    ppos : current position of file
+ *    cache_valid : cache related bit mask flag
+ *    cache_time : when we started read-caching this inode
+ *    attrtimeo :  how long the cached information is assumed
+ *                 to be valid.
+ *   We need to revalidate the cached attrs for this inode if
+ *
+ *      jiffies - read_cache_jiffies > attrtimeo
+*/
+probe nfs.fop.sendfile = kernel.function("nfs_file_sendfile") ?,
+                              module("nfs").function("nfs_file_sendfile") ?
+{
+
+        dev = $filp->f_dentry->d_inode->i_sb->s_dev
+        ino = $filp->f_dentry->d_inode->i_ino
+
+        count = $count
+        ppos  = __d_loff_t($ppos)
+
+        cache_valid = __nfsi_cache_valid($filp->f_dentry->d_inode)
+        cache_time  = __nfsi_rcache_time($filp->f_dentry->d_inode)
+        attr_time   = __nfsi_attr_time($filp->f_dentry->d_inode)
+
+
+        name = "nfs.fop.sendfile"
+        argstr = sprintf("%d,%d", count,ppos)
+
+        size = count
+        units = "bytes"
+}
+
+probe nfs.fop.sendfile.return = kernel.function("nfs_file_sendfile").return ?,
+                              module("nfs").function("nfs_file_sendfile").return ?
+{
+        name = "nfs.fopsendfile.return"
+        retstr = sprintf("%d", $return)
+
+        if ($return > 0) {
+                size = $return
+                units = "bytes"
+        }
+}
+
+/*probe nfs.fop.check_flags
+ *
+ * Fires when do a checking flag  operation on nfs,
+ * it probes check_flag file operation of nfs
+ * 
+ * Arguments:
+ *    flag : file flag
+*/
+probe nfs.fop.check_flags =  kernel.function("nfs_check_flags") ?,
+                             module("nfs").function("nfs_check_flags") ?
+{
+        flag = $flags
+        
+        name = "nfs.fop.check_flags"
+        argstr = sprintf("%d",flag)
+}
+
+probe nfs.fop.check_flags.return =  kernel.function("nfs_check_flags").return ?,
+                             module("nfs").function("nfs_check_flags").return ?
+{
+        name = "nfs.fop.check_flags.return"
+        retstr = sprintf("%d",$return)
+}
+
+probe nfs.aop.entries = nfs.aop.readpage,
+                        nfs.aop.readpages,
+                        nfs.aop.writepage,
+                        nfs.aop.writepages,
+                        nfs.aop.prepare_write,
+                        nfs.aop.commit_write,
+                        nfs.aop.release_page
+{
+}
+ 
+probe nfs.aop.return = nfs.aop.readpage.return,
+                        nfs.aop.readpages.return,
+                        nfs.aop.writepage.return,
+                        nfs.aop.writepages.return,
+                        nfs.aop.prepare_write.return,
+                        nfs.aop.commit_write.return,
+                        nfs.aop.release_page.return
+{
+}
+
+/* probe nfs.aop.readpage
+ *
+ *   Read the page ,only fies when a previous async
+ *   read operation failed
+ *
+ * Arguments:
+ *   __page : the address of page
+ *   dev : device identifier
+ *   ino : inode number    
+ *   i_flag : file flags
+ *   i_size : file length in bytes
+ *   sb_flag : super block flags
+ *   file  : file argument
+ *   page_index : offset within mapping, can used a 
+                  page identifier and position identifier
+                  in the page frame
+ *   rsize :  read size  (in bytes)
+ *   size :  number of pages to be read in this execution 
+ */
+probe nfs.aop.readpage = kernel.function ("nfs_readpage") ?,
+        module("nfs").function ("nfs_readpage") ?
+{
+        __page = $page
+        dev = __page_dev(__page)
+        ino = __page_ino(__page)
+
+        i_flag = __p2i_flag($page) 
+        i_size = __p2i_size($page)
+ 
+        sb_flag = __p2sb_flag($page) 
+
+        file = $file
+        page_index = $page->index
+        
+        __inode = __p2i($page) 
+        rsize = __nfs_server_rsize(__inode)
+
+        name = "nfs.aop.readpage"
+        argstr = sprintf("%d,%d" , page_index,r_size)
+
+        size = 1
+        units = "pages"
+}
+
+probe nfs.aop.readpage.return = kernel.function ("nfs_readpage").return ?,
+        module("nfs").function ("nfs_readpage").return ?
+{
+        name = "nfs.aop.readpage.return"
+        retstr = sprintf("%d", $return)
+
+        size = 1
+        units = "pages"
+}
+
+/* probe nfs.aop.readpages
+ *
+ * Fies when in readahead way,read several pages once
+ * Arguments:
+ *   dev : device identifier
+ *   ino : inode number   
+ *   nr_pages :  number of pages to be read in this execution 
+ *   file : filp argument
+ *   rpages : read size (in pages) 
+ *   rsize  : read size (in bytes)
+ *   size :  number of pages to be read in this execution 
+ */
+probe nfs.aop.readpages =  kernel.function ("nfs_readpages") ?,
+        module("nfs").function ("nfs_readpages") ?
+{
+        dev = $mapping->host->i_sb->s_dev
+        ino = $mapping->host->i_ino
+
+        nr_pages = $nr_pages
+        file = $filp
+
+        rpages = __nfs_rpages($mapping->host)
+        rsize  = __nfs_server_rsize($mapping->host)
+
+        name = "nfs.aop.readpages"
+        argstr = sprintf("%d" , nr_pages)
+
+        size = nr_pages
+        units = "pages"
+}
+
+probe nfs.aop.readpages.return = kernel.function ("nfs_readpages").return ?,
+        module("nfs").function ("nfs_readpages").return ?
+{
+        name = "nfs.aop.readpages.return"
+        retstr = sprintf("%d", $return)
+
+
+        if($return > 0 )
+        {
+            size = retstr
+        }
+        units = "pages"
+}
+/*probe nfs.aop.set_page_dirty
+ *
+ *   __set_page_dirty_nobuffers is used to set a page dirty,but
+ *   not all the buffers.
+ *
+ *  Arguments:
+ *     __page : the address of page
+ *      page_flag : page flags
+*/
+probe nfs.aop.set_page_dirty =
+            kernel.function ("__set_page_dirty_nobuffers") ?,
+             module("nfs").function ("__set_page_dirty_nobuffers") ?
+{
+ /*       dev = $mapping->host->i_sb->s_dev
+        devname = __find_bdevname(dev, $mapping->host->i_sb->s_bdev)
+        ino = $mapping->host->i_ino
+*/
+        __page = $page
+        page_flag = $page->flags
+
+        name = "nfs.aop.set_page_dirty"
+        argstr = sprintf("%d",flag)
+}
+
+probe nfs.aop.set_page_dirty.return =
+            kernel.function ("__set_page_dirty_nobuffers") .return?,
+            module("nfs").function ("__set_page_dirty_nobuffers").return ?
+{
+        name = "nfs.aop.set_page_dirty.return"
+        retstr = sprintf("%d", $return)
+}
+
+/*probe nfs.aop.writepage
+ *
+ *   Write an mapped page to the server
+ *
+ *  Arguments:
+ *     __page : the address of page
+ *     dev : device identifier
+ *     ino : inode number  
+ *     for_reclaim : a flag of writeback_control, indicates if it's invoked from the page allocator 
+ *     for_kupdate : a flag of writeback_control, indicates if it's a kupdate writeback
+ *      The priority of wb is decided by above two flags
+ *     i_flag : file flags
+ *     i_size : file length in bytes
+ *     i_state : inode state flags
+ *     sb_flag : super block flags
+ *     page_index : offset within mapping, can used a 
+                    page identifier and position identifier
+                    in the page frame
+ *     wsize :  write size
+ *     size  :  number of pages to be written in this execution 
+*/
+probe nfs.aop.writepage =  kernel.function ("nfs_writepage") ?,
+             module("nfs").function ("nfs_writepage") ?
+{
+        __page = $page
+        dev = __page_dev(__page)
+        ino = __page_ino(__page)
+        
+
+        for_reclaim = $wbc->for_reclaim
+        for_kupdate = $wbc->for_kupdate
+
+        i_flag = __p2i_flag($page) 
+        i_state = __p2i_state($page)
+        i_size = __p2i_size($page)
+
+        sb_flag = __p2sb_flag($page) 
+
+
+        page_index = $page->index
+
+        __inode = __p2i($page)
+        wsize = __nfs_server_wsize(__inode)            
+ 
+        name = "nfs.aop.writepage"
+        argstr = sprintf("%d",page_index)
+
+        size = 1
+        units = "pages"
+}
+
+probe nfs.aop.writepage.return =  kernel.function ("nfs_writepage").return ?,
+             module("nfs").function ("nfs_writepage").return ?
+{
+        name = "nfs.aop.writepage.return"
+        retstr = sprintf("%d", $return)
+}
+
+/*probe nfs.aop.writepages
+ *  Write several dirty pages to the serve
+ *Arguments:
+ *     dev : device identifier
+ *     ino : inode number  
+ *     for_reclaim : a flag of writeback_control, indicates if it's invoked from the page allocator 
+ *     for_kupdate : a flag of writeback_control, indicates if it's a kupdate writeback
+ *      The priority of wb is decided by above two flags
+ *      wsize :  write size
+ *      wpages : write size (in pages)
+ *      nr_to_write : number of pages to be written in this execution  
+ *      size : number of pages to be written in this execution  
+*/
+probe nfs.aop.writepages =  kernel.function ("nfs_writepages") ?,
+             module("nfs").function ("nfs_writepages") ?
+{
+        dev = $mapping->host->i_sb->s_dev
+        ino = $mapping->host->i_ino
+
+        for_reclaim = $wbc->for_reclaim
+        for_kupdate = $wbc->for_kupdate
+        nr_to_write = $wbc->nr_to_write
+
+        wsize = __nfs_server_wsize($mapping->host)
+        wpages = __nfs_wpages($mapping->host)
+
+        name = "nfs.aop.writepages"
+        argstr = sprintf("%d",nr_to_write)
+
+        size = nr_to_write
+        units = "pages"         
+}
+
+probe nfs.aop.writepages.return =  kernel.function ("nfs_writepages").return ?,
+             module("nfs").function ("nfs_writepages").return ?
+{
+        name = "nfs.aop.writepages.return"
+        retstr = sprintf("%d", $return)
+}
+/*probe nfs.aop.prepare_write
+ *  Fires when do write operation on nfs.
+ *     Prepare a page for writing
+ *     Look for a request corresponding to the page. If there
+ *     is one, and it belongs to another file, we flush it out
+ *     before we try to copy anything into the page. 
+ *     Also do the same if we find a request from an existing
+ *     dropped page
+ *
+ *  Arguments:
+ *     __page : the address of page
+ *     dev : device identifier
+ *     ino : inode number 
+ *     offset : start address of this write operation 
+ *     to     : end address of this write operation 
+ *     page_index : offset within mapping, can used a 
+                     page identifier and position identifier
+                     in the page frame
+ *     size   : read bytes
+*/
+probe nfs.aop.prepare_write=  kernel.function ("nfs_prepare_write") ?,
+             module("nfs").function ("nfs_prepare_write") ?
+{
+        dev = __page_dev(__page)
+        devname = __find_bdevname(dev, __page_bdev(__page))
+        ino = __page_ino(__page)      
+  
+        offset = $offset
+        to = $to
+       
+        page_index = $page->index
+        __page = $page
+
+        name = "nfs.aop.prepare_write"
+        argstr = sprintf("%d", page_index)
+
+        size = to - offset
+        units = "bytes"        
+}
+
+probe nfs.aop.prepare_write.return = 
+                 kernel.function ("nfs_prepare_write").return ?,
+                 module("nfs").function ("nfs_prepare_write").return ?
+{
+        name = "nfs.aop.nfs_prepare_write.return"
+        retstr = sprintf("%d", $return)
+}
+
+/*probe nfs.aop.commit_write
+ *  Fires when do a write operation on nfs,
+ *  often after prepare_write
+ *
+ *  Update and possibly write a cached page of an NFS file
+ *
+ *  Arguments:
+ *     __page : the address of page
+ *     dev : device identifier
+ *     ino : inode number
+ *     offset : start address of this write operation 
+ *     to     : end address of this write operation
+ *     i_flag : file flags
+ *     i_size : file length in bytes
+ *     sb_flag : super block flags
+ *     page_index : offset within mapping, can used a 
+                    page identifier and position identifier
+                    in the page frame
+ *     size   : read bytes
+ */ 
+probe nfs.aop.commit_write=  kernel.function ("nfs_commit_write") ?,
+             module("nfs").function ("nfs_commit_write") ?
+{
+         __page = $page
+        dev = __page_dev(__page)
+        ino = __page_ino(__page)
+
+        offset = $offset
+        to = $to
+      
+
+        i_flag = __p2i_flag($page) 
+        i_size = __p2i_size($page)
+
+        sb_flag = __p2sb_flag($page) 
+
+        page_index = $page->index
+     
+        name = "nfs.aop.commit_write"
+        argstr = sprintf("%d, %d",offset , to)
+
+        size = to - offset
+        units = "bytes"
+}
+
+
+probe nfs.aop.commit_write.return=  
+             kernel.function ("nfs_commit_write").return ?,
+             module("nfs").function ("nfs_commit_write").return? 
+{
+        name = "nfs.aop.nfs_commit_write.return"
+        retstr = sprintf("%d", $return)
+}
+
+/*probe nfs.aop.release_page
+ *  Fires when do a release operation on nfs,
+ *  
+ *
+ *  Arguments:
+ *     __page : the address of page
+ *     dev : device identifier
+ *     ino : inode number
+ *     page_index : offset within mapping, can used a 
+                    page identifier and position identifier
+                    in the page frame
+ *     size : release pages
+*/
+probe nfs.aop.release_page =  kernel.function ("nfs_release_page") ?,
+             module("nfs").function ("nfs_release_page")?
+{
+        __page = $page
+        dev = __page_dev(__page)
+        ino = __page_ino(__page)
+
+//        gfp = $gfp
+        page_index = $page->index
+
+        name = "nfs.aop.releasepage"
+        argstr = sprintf("%d", page_index)
+
+        size = 1
+        units = "pages"
+
+}  
+
+probe nfs.aop.release_page.return =  kernel.function ("nfs_release_page").return ?,
+             module("nfs").function ("nfs_release_page").return?
+{
+        name = "nfs.aop.nfs_release_page.return"
+        retstr = sprintf("%d", $return)
+}
+
diff --git a/tapset/nfs_proc.stp b/tapset/nfs_proc.stp
new file mode 100644
index 00000000..292b5af7
--- /dev/null
+++ b/tapset/nfs_proc.stp
@@ -0,0 +1,1443 @@
+%{
+	#include <linux/nfs_fs.h>
+%}
+
+%{
+/*Get ip address from a rpc_task*/
+	__u32 get_ip(struct rpc_task *);
+/*Get protocol types from a rpc_task*/
+	int get_prot(struct rpc_task *);
+%}
+%{
+     __u32 get_ip(struct rpc_task * task)
+     {
+        struct rpc_clnt * tk_client;
+        struct rpc_xprt * cl_xprt;
+        tk_client = task->tk_client;
+        cl_xprt= tk_client->cl_xprt;
+
+        return cl_xprt->addr.sin_addr.s_addr;
+     }
+     int get_prot(struct rpc_task * task)
+     {
+        struct rpc_clnt * tk_client;
+        struct rpc_xprt * cl_xprt;
+        tk_client = task->tk_client;
+        cl_xprt= tk_client->cl_xprt;
+
+        return cl_xprt->prot;
+    }
+%}
+/*
+  0:get ip address
+  1:get proto
+*/
+function __i2n_ip_proto :long(dir:long,index:long) %{ /* pure */
+	int index = (int) (THIS->index);
+	struct inode * dir = (struct inode *)(THIS->dir);
+        struct rpc_clnt * clnt = NFS_CLIENT(dir);
+        struct rpc_xprt * cl_xprt = clnt->cl_xprt;
+        struct sockaddr_in * addr = &(cl_xprt->addr);
+
+        if(index == 0)
+		THIS->__retvalue = addr->sin_addr.s_addr;
+        else
+		THIS->__retvalue = cl_xprt->prot;
+%}
+
+/*
+  0:get ip address
+  1:get proto
+*/
+function __nfs_data_ip_proto:long (rdata :long,index :long) %{ /* pure */
+        int index = (int)(THIS->index);
+        struct nfs_read_data * rdata = (struct nfs_read_data *)(THIS->rdata);
+	struct rpc_task    *task = &(rdata->task);
+
+	if(index == 0)
+		THIS->__retvalue = get_ip(task);
+	else
+		THIS->__retvalue = get_prot(task);
+%}
+
+function __nfsv4_bitmask :long(dir:long,i:long) %{ /* pure */
+        int i = (int) (THIS->i);
+	struct inode * dir = (struct inode *)(THIS->dir);
+        struct nfs_server * server = NFS_SERVER(dir);
+
+        THIS->__retvalue = server->attr_bitmask[i];
+
+%}
+
+function __getfh_inode :long(dir:long) %{ /* pure */
+	struct inode * dir = (struct inode *)(THIS->dir);
+	struct nfs_fh * fh = NFS_FH(dir);
+
+	THIS->__retvalue =(long) fh;
+%}
+probe nfs.proc.entries = nfs.proc.lookup,
+			nfs.proc.read,
+			nfs.proc.write,
+			nfs.proc.commit,
+			nfs.proc.read_setup,
+			nfs.proc.write_setup,
+			nfs.proc.commit_setup,
+			nfs.proc.read_done,
+			nfs.proc.write_done,
+			nfs.proc.commit_done,
+			nfs.proc.open,
+			nfs.proc.create,
+			nfs.proc.rename,
+			nfs.proc.remove,
+			nfs.proc.release
+{
+}
+
+
+probe nfs.proc.return = nfs.proc.lookup.return,
+			nfs.proc.read.return,
+			nfs.proc.write.return,
+			nfs.proc.commit.return,
+			nfs.proc.read_done.return,
+			nfs.proc.write_done.return,
+			nfs.proc.commit_done.return,
+			nfs.proc.open.return,
+			nfs.proc.create.return,
+			nfs.proc.rename.return,
+			nfs.proc.remove.return,
+			nfs.proc.release.return  
+{
+}
+
+/*
+*probe nfs.proc.lookup
+*
+* Fires when client opens/searchs a file on server
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   filename : the name of  file which client opens/searchs on server
+*   name_len : the length of file name
+*   bitmask0:
+*   bitmask1 :V4 bitmask representing the set of attributes 
+*             supported on this filesystem (only in probe nfs.proc4.lookup)
+* 
+*/
+probe nfs.proc.lookup = nfs.proc2.lookup,
+                        nfs.proc3.lookup,
+                        nfs.proc4.lookup
+{
+}
+
+probe nfs.proc.lookup.return = nfs.proc2.lookup.return,
+                               nfs.proc3.lookup.return,
+                               nfs.proc4.lookup.return
+{}
+
+probe nfs.proc2.lookup = kernel.function("nfs_proc_lookup")?,
+                         module("nfs").function("nfs_proc_lookup")?
+{
+	server_ip = __i2n_ip_proto($dir,0)
+        prot   = __i2n_ip_proto($dir,1)
+        version = "NFSV2"
+
+	filename = kernel_string($name->name)
+        name_len = $name->len
+
+        name = "nfs.proc2.lookup"
+        argstr = sprintf("%s",filename) 
+}
+
+probe nfs.proc2.lookup.return = kernel.function("nfs_proc_lookup").return?,
+                                module("nfs").function("nfs_proc_lookup").return?
+{
+        version = "NFSV2"
+	name = "nfs.proc2.lookup.return"
+	retstr = sprintf("%d", $return)
+}
+
+probe nfs.proc3.lookup = kernel.function("nfs3_proc_lookup")?,
+                         module("nfs").function("nfs3_proc_lookup")?
+{
+
+	server_ip = __i2n_ip_proto($dir,0)
+        prot   = __i2n_ip_proto($dir,1)
+        version = "NFSV3"
+
+	filename = kernel_string($name->name)
+        name_len = $name->len
+
+        name = "nfs.proc3.lookup"
+        argstr = sprintf("%s",filename) 
+}
+
+
+probe nfs.proc3.lookup.return = kernel.function("nfs3_proc_lookup").return?,
+                                module("nfs").function("nfs3_proc_lookup").return?
+{
+        version = "NFSV3"
+	name = "nfs.proc3.lookup.return"
+	retstr = sprintf("%d", $return)
+}
+
+probe nfs.proc4.lookup = kernel.function("nfs4_proc_lookup")?,
+                         module("nfs").function("nfs4_proc_lookup")?
+{
+
+	server_ip = __i2n_ip_proto($dir,0)
+        prot   = __i2n_ip_proto($dir,1)
+        version = "NFSV4"
+
+	filename = kernel_string($name->name)
+        name_len = $name->len
+        bitmask0 = __nfsv4_bitmask($dir,0)
+        bitmask1 = __nfsv4_bitmask($dir,1)
+
+        name = "nfs.proc4.lookup"
+        argstr = sprintf("%s",filename) 
+}
+
+probe nfs.proc4.lookup.return = kernel.function("nfs4_proc_lookup").return?,
+                                module("nfs").function("nfs4_proc_lookup").return?
+{
+        version = "NFSV4"
+	name = "nfs.proc4.lookup.return"
+	retstr = sprintf("%d", $return)
+}
+
+/*
+*probe nfs.proc.read
+*
+* Fires when client synchronously reads file from server 
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   flags  : used to set task->tk_flags in rpc_init_task function
+*   size:
+*   count : read bytes in this execution
+*   offset : the file offset
+* 
+*/
+probe nfs.proc.read = nfs.proc2.read ,
+                      nfs.proc3.read ,
+                      nfs.proc4.read 
+{}
+
+
+probe nfs.proc.read.return = nfs.proc2.read.return ,
+                      nfs.proc3.read.return ,
+                      nfs.proc4.read.return 
+{
+}
+
+probe nfs.proc2.read = kernel.function("nfs_proc_read") ?,
+                       module("nfs").function("nfs_proc_read")?
+{
+	server_ip = __nfs_data_ip_proto($rdata,0)
+        prot = __nfs_data_ip_proto($rdata,1)
+        version = "NFSV2"
+
+	flags = $rdata->flags
+        count = $rdata->args->count
+        offset = $rdata->args->offset
+
+	name = "nfs.proc2.read"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+probe nfs.proc2.read.return = kernel.function("nfs_proc_read").return ?,
+                       module("nfs").function("nfs_proc_read").return?
+{
+        version = "NFSV2"
+	name = "nfs.proc2.read.return"
+	retstr = sprintf("%d", $return)
+       
+        if(retsrt >= 0)
+        {  
+        	size = retstr
+	        units = "bytes"
+	}
+}
+
+probe nfs.proc3.read = kernel.function("nfs3_proc_read") ?,
+                       module("nfs").function("nfs3_proc_read")?
+{
+	server_ip = __nfs_data_ip_proto($rdata,0)
+        prot = __nfs_data_ip_proto($rdata,1)
+        version = "NFSV3"
+
+	flags = $rdata->flags
+        count = $rdata->args->count
+        offset = $rdata->args->offset
+
+	name = "nfs.proc3.read"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+
+probe nfs.proc3.read.return = kernel.function("nfs3_proc_read").return ?,
+                       module("nfs").function("nfs3_proc_read").return?
+{
+        version = "NFSV3"
+	name = "nfs.proc3.read.return"
+	retstr = sprintf("%d", $return)
+
+        if(retsrt >= 0)
+        {  
+        	size = retstr
+	        units = "bytes"
+	}
+}
+
+
+probe nfs.proc4.read = kernel.function("nfs4_proc_read") ?,
+                       module("nfs").function("nfs4_proc_read")?
+{
+	server_ip = __nfs_data_ip_proto($rdata,0)
+        prot = __nfs_data_ip_proto($rdata,1)
+        version = "NFSV4"
+
+	flags = $rdata->flags
+        count = $rdata->args->count
+        offset = $rdata->args->offset
+
+	name = "nfs.proc4.read"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+
+probe nfs.proc4.read.return = kernel.function("nfs4_proc_read").return ?,
+                       module("nfs").function("nfs4_proc_read").return?
+{
+        version = "NFSV4"
+	name = "nfs.proc4.read.return"
+	retstr = sprintf("%d", $return)
+        
+        if(retsrt >= 0)
+        {  
+        	size = retstr
+	        units = "bytes"
+	}
+}
+
+
+/*
+*probe nfs.proc.write
+*
+* Fires when client synchronously writes file to server 
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   flags  : used to set task->tk_flags in rpc_init_task function
+*   count :
+*   size  : read bytes in this execution
+*   offset : the file offset
+*   bitmask0:
+*   bitmask1 :V4 bitmask representing the set of attributes 
+*             supported on this filesystem (only in probe nfs.proc4.lookup)
+*/
+
+probe nfs.proc.write = nfs.proc2.write ,
+                      nfs.proc3.write ,
+                      nfs.proc4.write 
+{}
+
+
+probe nfs.proc.write.return = nfs.proc2.write.return ,
+                      nfs.proc3.write.return ,
+                      nfs.proc4.write.return 
+{}
+
+probe nfs.proc2.write = kernel.function("nfs_proc_write")?,
+                        module("nfs").function("nfs_proc_write")
+{
+      
+	server_ip = __nfs_data_ip_proto($wdata,0)
+        prot = __nfs_data_ip_proto($wdata,1)
+        version = "NFSV2"
+
+	flags = $wdata->flags
+        count = $wdata->args->count
+        offset = $wdata->args->offset
+
+	name = "nfs.proc2.write"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+
+probe nfs.proc2.write.return = kernel.function("nfs_proc_write").return ?,
+                       module("nfs").function("nfs_proc_write").return?
+{
+        version = "NFSV2"
+	name = "nfs.proc2.write.return"
+	retstr = sprintf("%d", $return)
+        
+        if(retsrt >= 0)
+        {  
+        	size = retstr
+	        units = "bytes"
+	}
+}
+
+
+probe nfs.proc3.write = kernel.function("nfs3_proc_write")?,
+                        module("nfs").function("nfs3_proc_write")
+{
+      
+	server_ip = __nfs_data_ip_proto($wdata,0)
+        prot = __nfs_data_ip_proto($wdata,1)
+        version = "NFSV3"
+
+	flags = $wdata->flags
+        count = $wdata->args->count
+        offset = $wdata->args->offset
+
+	name = "nfs.proc3.write"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+
+probe nfs.proc3.write.return = kernel.function("nfs3_proc_write").return ?,
+                       module("nfs").function("nfs3_proc_write").return?
+{
+        version = "NFSV3"
+	name = "nfs.proc3.write.return"
+	retstr = sprintf("%d", $return)
+        
+        if(retsrt >= 0)
+        {  
+        	size = retstr
+	        units = "bytes"
+	}
+}
+
+
+probe nfs.proc4.write = kernel.function("nfs4_proc_write")?,
+                        module("nfs").function("nfs4_proc_write")
+{
+      
+	server_ip = __nfs_data_ip_proto($wdata,0)
+        prot = __nfs_data_ip_proto($wdata,1)
+        version = "NFSV4"
+
+	flags = $wdata->flags
+        count = $wdata->args->count
+        offset = $wdata->args->offset
+        bitmask0 = __nfsv4_bitmask($wdata->inode,0)
+        bitmask1 = __nfsv4_bitmask($wdata->inode,1)
+
+	name = "nfs.proc4.write"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+
+probe nfs.proc4.write.return = kernel.function("nfs4_proc_write").return ?,
+                       module("nfs").function("nfs4_proc_write").return?
+{
+        version = "NFSV4"
+	name = "nfs.proc4.write.return"
+	retstr = sprintf("%d", $return)
+        
+        if(retsrt >= 0)
+        {  
+        	size = retstr
+	        units = "bytes"
+	}
+}
+
+/*
+*probe nfs.proc.commit
+*
+* Fires when client writes the buffered data to disk,the buffered 
+* data is asynchronously written by client before
+* The commit function works in sync way,not exist in NFSV2
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   flags  : used to set task->tk_flags in rpc_init_task function
+*   count :
+*   size  : read bytes in this execution
+*   offset : the file offset
+*   bitmask0:
+*   bitmask1 :V4 bitmask representing the set of attributes 
+*             supported on this filesystem (only in probe nfs.proc4.lookup)
+*/
+probe nfs.proc.commit = nfs.proc3.commit,
+                        nfs.proc4.commit
+{}
+
+probe nfs.proc.commit.return = nfs.proc3.commit.return,
+                               nfs.proc4.commit.return
+{}
+
+probe nfs.proc3.commit = kernel.function ("nfs3_proc_commit")?,
+                         module("nfs").function("nfs3_proc_commit")?
+{
+	server_ip = __nfs_data_ip_proto($cdata,0)
+        prot = __nfs_data_ip_proto($cdata,1)
+        version = "NFSV3"
+
+        count = $cdata->args->count
+        offset = $cdata->args->offset
+
+	name = "nfs.proc3.commit"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+probe nfs.proc3.commit.return = kernel.function ("nfs3_proc_commit").return?,
+                         module("nfs").function("nfs3_proc_commit").return?
+{
+        version = "NFSV3"
+	name = "nfs.proc3.commit.return"
+	retstr = sprintf("%d", $return)
+        
+        if(retsrt >= 0)
+        {  
+        	size = retstr
+	        units = "bytes"
+	}
+}
+
+
+probe nfs.proc4.commit = kernel.function ("nfs4_proc_commit")?,
+                         module("nfs").function("nfs4_proc_commit")?
+{
+	server_ip = __nfs_data_ip_proto($cdata,0)
+        prot = __nfs_data_ip_proto($cdata,1)
+        version = "NFSV4"
+
+        count = $cdata->args->count
+        offset = $cdata->args->offset
+        bitmask0 = __nfsv4_bitmask($cdata->inode,0)
+        bitmask1 = __nfsv4_bitmask($cdata->inode,1)
+
+	name = "nfs.proc4.commit"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+probe nfs.proc4.commit.return = kernel.function ("nfs4_proc_commit").return?,
+                         module("nfs").function("nfs4_proc_commit").return?
+{
+        version = "NFSV4"
+	name = "nfs.proc4.commit.return"
+	retstr = sprintf("%d", $return)
+        
+        if(retsrt >= 0)
+        {  
+        	size = retstr
+	        units = "bytes"
+	}
+}
+
+/*
+*probe nfs.proc.read_setup
+*
+* The read_setup function is used to setup a read rpc task,not do
+* a real read operation.
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   count :
+*   size  : read bytes in this execution
+*   offset : the file offset 
+*/
+probe nfs.proc.read_setup = nfs.proc2.read_setup ,
+                      nfs.proc3.read_setup ,
+                      nfs.proc4.read_setup 
+{}
+
+
+
+probe nfs.proc2.read_setup = kernel.function("nfs_proc_read_setup") ?,
+                       module("nfs").function("nfs_proc_read_setup")?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV2"
+
+        count = $data->args->count
+        offset = $data->args->offset
+
+	name = "nfs.proc2.read_setup"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+
+probe nfs.proc3.read_setup = kernel.function("nfs3_proc_read_setup") ?,
+                       module("nfs").function("nfs3_proc_read_setup")?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV3"
+	fh = 
+
+        count = $data->args->count
+        offset = $data->args->offset
+
+	name = "nfs.proc3.read_setup"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+
+
+
+probe nfs.proc4.read_setup = kernel.function("nfs4_proc_read_setup") ?,
+                       module("nfs").function("nfs4_proc_read_setup")?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV4"
+
+        count = $data->args->count
+        offset = $data->args->offset
+	//timestamp = $jiffies
+
+	name = "nfs.proc4.read_setup"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+
+/*probe nfs.proc.read_done
+*
+* Fires when a read reply is received or some read error occur
+* (timeout or socket shutdown)
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   status : result of last operation
+*   count  : read size of last operation
+*   offset : the file offset of last operation
+*   timestamp : time stamp ,which is used for lease renewal (only
+    in nfs.proc4.read_done)
+*/
+probe nfs.proc.read_done = nfs.proc2.read_done,
+                           nfs.proc3.read_done,
+                           nfs.proc4.read_done
+{}
+
+probe nfs.proc.read_done.return = nfs.proc2.read_done.return,
+                           nfs.proc3.read_done.return,
+                           nfs.proc4.read_done.return
+{}
+
+probe nfs.proc2.read_done = kernel.function("nfs_read_done")?,
+                            module("nfs").function("nfs_read_done")?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV2"
+
+	status = $task->tk_status
+	offset = $data->args->offset
+	count = $data->args->count
+
+	name = "nfs.proc2.read_done"
+        argstr = sprintf("%d",status)
+
+}
+
+probe nfs.proc2.read_done.return = kernel.function("nfs_read_done").return?,
+                            module("nfs").function("nfs_read_done").return?
+{
+        version = "NFSV2"
+	name = "nfs.proc2.read_done.return"
+	retstr = sprintf("%d", $return)
+}
+
+
+probe nfs.proc3.read_done = kernel.function("nfs3_read_done")?,
+                            module("nfs").function("nfs3_read_done")?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV3"
+
+	status = $task->tk_status
+	offset = $data->args->offset
+	count = $data->args->count
+
+	name = "nfs.proc3.read_done"
+        argstr = sprintf("%d",status)
+
+}
+
+probe nfs.proc3.read_done.return = kernel.function("nfs3_read_done").return?,
+                            module("nfs").function("nfs3_read_done").return?
+{
+        version = "NFSV3"
+	name = "nfs.proc3.read_done.return"
+	retstr = sprintf("%d", $return)
+}
+
+
+probe nfs.proc4.read_done = kernel.function("nfs4_read_done")?,
+                            module("nfs").function("nfs4_read_done")?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV4"
+
+	status = $task->tk_status
+	offset = $data->args->offset
+	count = $data->args->count
+        timestamp = $data->timestamp
+
+	name = "nfs.proc4.read_done"
+        argstr = sprintf("%d",status)
+
+}
+
+probe nfs.proc4.read_done.return = kernel.function("nfs4_read_done").return?,
+                            module("nfs").function("nfs4_read_done").return?
+{
+        version = "NFSV4"
+	name = "nfs.proc4.read_done.return"
+	retstr = sprintf("%d", $return)
+}
+
+/*probe nfs.proc.write_setup
+*
+* The write_setup function is used to setup a write rpc task,not do
+* a real write operation.
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   size :
+*   count : read bytes in this execution
+*   offset : the file offset
+*   how : used to set args.stable.
+*         The stable value could be:
+*         NFS_UNSTABLE,NFS_DATA_SYNC,NFS_FILE_SYNC(in nfs.proc3.write_setup and nfs.proc4.write_setup)
+*   bitmask0:
+*   bitmask1 :V4 bitmask representing the set of attributes 
+*             supported on this filesystem (only in probe nfs.proc4.lookup)
+*/
+
+probe nfs.proc.write_setup = nfs.proc2.write_setup,
+                             nfs.proc3.write_setup,
+                             nfs.proc4.write_setup
+{}
+
+
+probe nfs.proc2.write_setup = kernel.function("nfs_proc_write_setup") ?,
+                              module("nfs").function("nfs_proc_write_setup") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV2"
+
+        count = $data->args->count
+        offset = $data->args->offset
+
+	name = "nfs.proc2.write_setup"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+
+probe nfs.proc3.write_setup = kernel.function("nfs3_proc_write_setup") ?,
+                              module("nfs").function("nfs3_proc_write_setup") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV3"
+
+        count = $data->args->count
+        offset = $data->args->offset
+	how = $how
+
+	name = "nfs.proc3.write_setup"
+	argstr = sprintf("%d,%d,%d",count,offset,how)
+
+        size = count
+        units = "bytes"
+}
+
+probe nfs.proc4.write_setup = kernel.function("nfs4_proc_write_setup") ?,
+                              module("nfs").function("nfs4_proc_write_setup") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV4"
+
+        count = $data->args->count
+        offset = $data->args->offset
+	how = $how
+        bitmask0 = __nfsv4_bitmask($data->inode,0)
+        bitmask1 = __nfsv4_bitmask($data->inode,1)
+	//timestamp = $jiffies
+	
+	name = "nfs.proc4.write_setup"
+	argstr = sprintf("%d,%d,%d",count,offset,how)
+
+        size = count
+        units = "bytes"
+}
+
+
+/*probe nfs.proc.write_done
+*
+* Fires when a write reply is received or some write error occur
+* (timeout or socket shutdown)
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   status : result of last operation
+*   valid  : fattr->valid ,indicates which fields are valid 
+*   count  : read size of last operation
+*   offset : the file offset of last operation
+*   timestamp : time stamp ,which is used for lease renewal (only
+    in nfs.proc4.write_done)
+*/
+probe nfs.proc.write_done = nfs.proc2.write_done,
+                            nfs.proc3.write_done,
+                            nfs.proc4.write_done 
+{}
+
+probe nfs.proc.write_done.return = nfs.proc2.write_done.return,
+                            nfs.proc3.write_done.return,
+                            nfs.proc4.write_done.return 
+{}
+
+probe nfs.proc2.write_done = kernel.function("nfs_write_done") ?,
+                             module("nfs").function("nfs_write_done") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV2"
+
+	status = $task->tk_status
+	valid = $data->res->fattr->valid
+	offset = $data->args->offset
+	count = $data->args->count
+
+	name = "nfs.proc2.write_done"
+	argstr = sprintf("%d",status)
+}
+
+probe nfs.proc2.write_done.return = kernel.function("nfs_write_done").return ?,
+                             module("nfs").function("nfs_write_done").return ?
+{
+        version = "NFSV2"
+	name = "nfs.proc2.write_done.return"
+	retstr = sprintf("%d", $return)
+}
+
+probe nfs.proc3.write_done = kernel.function("nfs3_write_done") ?,
+                             module("nfs").function("nfs3_write_done") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV3"
+
+	status = $task->tk_status
+	valid = $data->res->fattr->valid
+	offset = $data->args->offset
+	count = $data->args->count
+
+	name = "nfs.proc3.write_done"
+	argstr = sprintf("%d",status)
+}
+
+probe nfs.proc3.write_done.return = kernel.function("nfs3_write_done").return ?,
+                             module("nfs").function("nfs3_write_done").return ?
+{
+        version = "NFSV3"
+	name = "nfs.proc3.write_done.return"
+	retstr = sprintf("%d", $return)
+}
+
+probe nfs.proc4.write_done = kernel.function("nfs4_write_done") ?,
+                             module("nfs").function("nfs4_write_done") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV4"
+
+	status = $task->tk_status
+	valid = $data->res->fattr->valid
+	offset = $data->args->offset
+	count = $data->args->count
+	timestamp = $data->timestamp
+
+	name = "nfs.proc4.write_done"
+	argstr = sprintf("%d",status)
+}
+
+probe nfs.proc4.write_done.return = kernel.function("nfs4_write_done").return ?,
+                             module("nfs").function("nfs4_write_done").return ?
+{
+        version = "NFSV4"
+	name = "nfs.proc4.write_done.return"
+	retstr = sprintf("%d", $return)
+}
+
+
+/*probe nfs.proc.commit_setup
+*
+* The commit_setup function is used to setup a commit rpc task,not do
+* a real commit operation.It is not exist in NFSV2
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   size :
+*   count : read bytes in this execution
+*   offset : the file offset
+*   bitmask0:
+*   bitmask1 :V4 bitmask representing the set of attributes 
+*             supported on this filesystem (only in probe nfs.proc4.lookup)
+*/
+
+probe nfs.proc.commit_setup =nfs.proc3.commit_setup,
+                             nfs.proc4.commit_setup
+{}
+
+
+probe nfs.proc3.commit_setup = kernel.function("nfs3_proc_commit_setup") ?,
+                              module("nfs").function("nfs3_proc_commit_setup") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV3"
+
+        count = $data->args->count
+        offset = $data->args->offset
+
+	name = "nfs.proc3.commit_setup"
+	argstr = sprintf("%d,%d,%d",count,offset,how)
+
+        size = count
+        units = "bytes"
+}
+
+probe nfs.proc4.commit_setup = kernel.function("nfs4_proc_commit_setup") ?,
+                              module("nfs").function("nfs4_proc_commit_setup") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV4"
+
+        count = $data->args->count
+        offset = $data->args->offset
+        bitmask0 = __nfsv4_bitmask($data->inode,0)
+        bitmask1 = __nfsv4_bitmask($data->inode,1)
+	//timestamp = $jiffies
+	
+	name = "nfs.proc4.commit_setup"
+	argstr = sprintf("%d,%d,%d",count,offset,how)
+
+        size = count
+        units = "bytes"
+}
+
+
+/*probe nfs.proc.commit_done
+*
+* Fires when a commit reply is received or some commit operation error occur
+* (timeout or socket shutdown)
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version
+*   status : result of last operation
+*   valid  : fattr->valid ,indicates which fields are valid 
+*   count  : read size of last operation
+*   offset : the file offset of last operation
+*   timestamp : time stamp ,which is used for lease renewal (only
+    in nfs.proc4.commit_done)
+*/
+probe nfs.proc.commit_done = 
+                            nfs.proc3.commit_done,
+                            nfs.proc4.commit_done 
+{}
+
+probe nfs.proc.commit_done.return = 
+                            nfs.proc3.commit_done.return,
+                            nfs.proc4.commit_done.return 
+{}
+
+
+probe nfs.proc3.commit_done = kernel.function("nfs3_commit_done") ?,
+                             module("nfs").function("nfs3_commit_done") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV3"
+
+	status = $task->tk_status
+        count = $data->args->count
+        offset = $data->args->offset
+	valid = $data->res->fattr->valid
+
+	name = "nfs.proc3.commit_done"
+	argstr = sprintf("%d",status)
+}
+
+probe nfs.proc3.commit_done.return = kernel.function("nfs3_commit_done").return ?,
+                             module("nfs").function("nfs3_commit_done").return ?
+{
+        version = "NFSV3"
+	name = "nfs.proc3.commit_done.return"
+	retstr = sprintf("%d", $return)
+}
+
+probe nfs.proc4.commit_done = kernel.function("nfs4_commit_done") ?,
+                             module("nfs").function("nfs4_commit_done") ?
+{
+	server_ip = __nfs_data_ip_proto($data,0)
+        prot = __nfs_data_ip_proto($data,1)
+        version = "NFSV4"
+
+	status = $task->tk_status
+        count = $data->args->count
+        offset = $data->args->offset
+	valid = $data->res->fattr->valid
+	timestamp = $data->timestamp
+
+	name = "nfs.proc4.commit_done"
+	argstr = sprintf("%d",status)
+}
+
+probe nfs.proc4.commit_done.return = kernel.function("nfs4_commit_done").return ?,
+                             module("nfs").function("nfs4_commit_done").return ?
+{
+        version = "NFSV4"
+	name = "nfs.proc4.commit_done.return"
+	retstr = sprintf("%d", $return)
+}
+/*probe nfs.proc.open
+*
+*  Allocate file read/write context information
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version(the function is used for all NFS version)
+*   filename : file name 
+*   flag   : file flag
+*   mode   : file  mode
+*/
+
+probe nfs.proc.open = kernel.function("nfs_open") ?,
+                      module("nfs").function("nfs_open") ?
+{
+	server_ip = __i2n_ip_proto($inode,0)
+	prot = __i2n_ip_proto($inode,1)  	
+	version = "NFS"
+
+	filename = kernel_string($filp->f_dentry->d_name->name)
+	flag = $filp->f_flags
+	mode = $filp->f_mode
+
+	name = "nfs.proc.open"
+	argstr = sprintf("%s,%d,%d",filename,flag,mode)
+}
+
+probe nfs.proc.open.return = kernel.function("nfs_open").return ?,
+                      module("nfs").function("nfs_open").return ?
+{
+	version = "NFS"
+	name = "nfs.proc.open.return"
+	retstr = sprintf("%d", $return)
+}
+
+/*probe nfs.proc.release
+*
+*  Release file read/write context information
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version(the function is used for all NFS version)
+*   filename : file name 
+*   flag   : file flag
+*   mode   : file  mode
+*/
+probe nfs.proc.release= kernel.function("nfs_release") ?,
+                      module("nfs").function("nfs_release") ?
+{
+	server_ip = __i2n_ip_proto($inode,0)
+	prot = __i2n_ip_proto($inode,1)  	
+	version = "NFS"
+
+	filename = kernel_string($filp->f_dentry->d_name->name)
+	flag = $filp->f_flags
+	mode = $filp->f_mode
+
+	name = "nfs.proc.release"
+	argstr = sprintf("%s,%d,%d",filename,flag,mode)
+}
+
+probe nfs.proc.release.return = kernel.function("nfs_release").return ?,
+                      module("nfs").function("nfs_release").return ?
+{
+	version = "NFS"
+	name = "nfs.proc.release.return"
+	retstr = sprintf("%d", $return)
+}
+/*
+*probe nfs.proc4.hadle_exception (only for NFSV4)
+* This is the error handling routine for processes for nfsv4
+*
+* Arguments:
+*  errorcode : indicates the type of error
+*/
+probe nfs.proc4.handle_exception = kernel.function("nfs4_handle_exception") ?,
+                               module("nfs").function("nfs4_handle_exception")?
+{
+	version = "NFSV4"
+	
+        errorcode = $errorcode
+
+        name = "nfs.proc4.handle_exception"
+        argstr =  sprintf("%d",errorcode)
+}
+
+probe nfs.proc4.handle_exception.return = kernel.function("nfs4_handle_exception").return ?,
+                               module("nfs").function("nfs4_handle_exception").return?
+{
+        name = "nfs.proc4.handle_exception.return"
+        retstr =  sprintf("%d",$return)
+}
+
+/*
+* probe nfs.proc.create
+*   Fires when client creates a file on server
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version(the function is used for all NFS version)
+*   fh : file handler of parent dir
+*   filename : file name 
+*   filelen : length of file name
+*   flag : indicates create mode(only for NFSV3 and NFSV4)
+*/
+probe nfs.proc.create = nfs.proc2.create,
+                        nfs.proc3.create,
+                        nfs.proc4.create
+{}
+
+probe nfs.proc.create.return = nfs.proc2.create.return,
+                               nfs.proc3.create.return,
+                               nfs.proc4.create.return
+{}
+
+probe nfs.proc2.create = kernel.function("nfs_proc_create")?,
+                         module("nfs").function("nfs_proc_create")?
+{
+	server_ip = __i2n_ip_proto($dir,0)
+	prot = __i2n_ip_proto($dir,1)  	
+	version = "NFSv2"
+
+	fh = __getfh_inode($dir)
+	filename = kernel_string($dentry->d_name->name)
+	filelen = $dentry->d_name->len
+
+	name = "nfs.proc2.create"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfs.proc2.create.return = kernel.function("nfs_proc_create").return?,
+                         module("nfs").function("nfs_proc_create").return?
+{
+	name = "nfs.proc2.create.return"
+	version = "NFSV2"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfs.proc3.create = kernel.function("nfs3_proc_create")?,
+                         module("nfs").function("nfs3_proc_create")?
+{
+	server_ip = __i2n_ip_proto($dir,0)
+	prot = __i2n_ip_proto($dir,1)  	
+	version = "NFSv3"
+
+	fh = __getfh_inode($dir)
+	filename = kernel_string($dentry->d_name->name)
+	filelen = $dentry->d_name->len
+	flag = $flags
+
+	name = "nfs.proc3.create"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfs.proc3.create.return = kernel.function("nfs3_proc_create").return?,
+                         module("nfs").function("nfs3_proc_create").return?
+{
+	name = "nfs.proc3.create.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfs.proc4.create = kernel.function("nfs4_proc_create")?,
+                         module("nfs").function("nfs4_proc_create")?
+{
+	server_ip = __i2n_ip_proto($dir,0)
+	prot = __i2n_ip_proto($dir,1)  	
+	version = "NFSv4"
+
+	fh = __getfh_inode($dir)
+	filename = kernel_string($dentry->d_name->name)
+	filelen = $dentry->d_name->len
+	flag = $flags
+
+	name = "nfs.proc4.create"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfs.proc4.create.return = kernel.function("nfs4_proc_create").return?,
+                         module("nfs").function("nfs4_proc_create").return?
+{
+	name = "nfs.proc4.create.return"
+	version = "NFSV4"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+* probe nfs.proc.remove
+*   Fires when client removes a file on server
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version(the function is used for all NFS version)
+*   fh : file handler of parent dir
+*   filename : file name 
+*   filelen : length of file name
+*/
+probe nfs.proc.remove = nfs.proc2.remove,
+                        nfs.proc3.remove,
+                        nfs.proc4.remove
+{}
+
+probe nfs.proc.remove.return = nfs.proc2.remove.return,
+                               nfs.proc3.remove.return,
+                               nfs.proc4.remove.return
+{}
+
+probe nfs.proc2.remove = kernel.function("nfs_proc_remove")?,
+                         module("nfs").function("nfs_proc_remove")?
+{
+	server_ip = __i2n_ip_proto($dir,0)
+	prot = __i2n_ip_proto($dir,1)  	
+	version = "NFSv2"
+
+	fh = __getfh_inode($dir)
+	filename = kernel_string($name->name)
+	filelen = $name->len
+
+	name = "nfs.proc2.remove"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfs.proc2.remove.return = kernel.function("nfs_proc_remove").return?,
+                         module("nfs").function("nfs_proc_remove").return?
+{
+	name = "nfs.proc2.remove.return"
+	version = "NFSV2"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfs.proc3.remove = kernel.function("nfs3_proc_remove")?,
+                         module("nfs").function("nfs3_proc_remove")?
+{
+	server_ip = __i2n_ip_proto($dir,0)
+	prot = __i2n_ip_proto($dir,1)  	
+	version = "NFSv3"
+
+	fh = __getfh_inode($dir)
+	filename = kernel_string($name->name)
+	filelen = $name->len
+
+	name = "nfs.proc3.remove"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfs.proc3.remove.return = kernel.function("nfs3_proc_remove").return?,
+                         module("nfs").function("nfs3_proc_remove").return?
+{
+	name = "nfs.proc3.remove.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfs.proc4.remove = kernel.function("nfs4_proc_remove")?,
+                         module("nfs").function("nfs4_proc_remove")?
+{
+	server_ip = __i2n_ip_proto($dir,0)
+	prot = __i2n_ip_proto($dir,1)  	
+	version = "NFSv4"
+
+	fh = __getfh_inode($dir)
+	filename = kernel_string($name->name)
+	filelen = $name->len
+
+	name = "nfs.proc4.remove"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfs.proc4.remove.return = kernel.function("nfs4_proc_remove").return?,
+                         module("nfs").function("nfs4_proc_remove").return?
+{
+	name = "nfs.proc4.remove.return"
+	version = "NFSV4"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+* probe nfs.proc.rename
+*   Fires when client renames a file on server
+*
+* Arguments:
+*   server_ip : ip address of server
+*   prot  : transfer protocol
+*   version : nfs version(the function is used for all NFS version)
+*   old_fh : file handler of old parent dir
+*   new_fh : file handler of new parent dir
+*   old_name : old file name 
+*   old_filelen : length of old file name
+*   new_name : new file name 
+*   new_filelen : length of new file name
+*/
+probe nfs.proc.rename = nfs.proc2.rename,
+                        nfs.proc3.rename,
+                        nfs.proc4.rename
+{}
+
+probe nfs.proc.rename.return = nfs.proc2.rename.return,
+                               nfs.proc3.rename.return,
+                               nfs.proc4.rename.return
+{}
+
+probe nfs.proc2.rename = kernel.function("nfs_proc_rename")?,
+                         module("nfs").function("nfs_proc_rename")?
+{
+	server_ip = __i2n_ip_proto($old_dir,0)
+	prot = __i2n_ip_proto($old_dir,1)  	
+	version = "NFSv2"
+
+	old_fh = __getfh_inode($old_dir)
+	old_name = kernel_string($old_name->name)
+	old_filelen = $old_name->len
+	new_fh = __getfh_inode($new_dir)
+	new_name = kernel_string($new_name->name)
+	new_filelen = $new_name->len
+
+	name = "nfs.proc2.remove"
+	argstr = sprintf("%s,%s",old_name,new_name)
+}
+
+probe nfs.proc2.rename.return = kernel.function("nfs_proc_rename").return?,
+                         module("nfs").function("nfs_proc_rename").return?
+{
+	name = "nfs.proc2.rename.return"
+	version = "NFSV2"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfs.proc3.rename = kernel.function("nfs3_proc_rename")?,
+                         module("nfs").function("nfs3_proc_rename")?
+{
+	server_ip = __i2n_ip_proto($old_dir,0)
+	prot = __i2n_ip_proto($old_dir,1)  	
+	version = "NFSv3"
+
+	old_fh = __getfh_inode($old_dir)
+	old_name = kernel_string($old_name->name)
+	old_filelen = $old_name->len
+	new_fh = __getfh_inode($new_dir)
+	new_name = kernel_string($new_name->name)
+	new_filelen = $new_name->len
+
+	name = "nfs.proc3.remove"
+	argstr = sprintf("%s,%s",old_name,new_name)
+}
+
+probe nfs.proc3.rename.return = kernel.function("nfs3_proc_rename").return?,
+                         module("nfs").function("nfs3_proc_rename").return?
+{
+	name = "nfs.proc3.rename.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfs.proc4.rename = kernel.function("nfs4_proc_rename")?,
+                         module("nfs").function("nfs4_proc_rename")?
+{
+	server_ip = __i2n_ip_proto($old_dir,0)
+	prot = __i2n_ip_proto($old_dir,1)  	
+	version = "NFSv4"
+
+	old_fh = __getfh_inode($old_dir)
+	old_name = kernel_string($old_name->name)
+	old_filelen = $old_name->len
+	new_fh = __getfh_inode($new_dir)
+	new_name = kernel_string($new_name->name)
+	new_filelen = $new_name->len
+
+	name = "nfs.proc4.remove"
+	argstr = sprintf("%s,%s",old_name,new_name)
+}
+
+probe nfs.proc4.rename.return = kernel.function("nfs4_proc_rename").return?,
+                         module("nfs").function("nfs4_proc_rename").return?
+{
+	name = "nfs.proc4.rename.return"
+	version = "NFSV4"
+	retstr = sprintf("%d",$return)
+}
diff --git a/tapset/nfsd.stp b/tapset/nfsd.stp
new file mode 100644
index 00000000..15d170f2
--- /dev/null
+++ b/tapset/nfsd.stp
@@ -0,0 +1,1059 @@
+%{
+#include <linux/sunrpc/svc.h>
+#include <linux/nfsd/nfsd.h>
+#include <linux/nfsd/cache.h>
+#include <linux/nfsd/xdr.h>
+#include <linux/nfsd/xdr3.h>
+%}
+
+%{
+/*Get file handle from struct svc_fh */
+char * fh_fmt(struct svc_fh * fhp)
+{
+	 struct knfsd_fh *fh = &fhp->fh_handle;
+
+	static char buf[80];
+	sprintf(buf, "%d: %08x %08x %08x %08x %08x %08x",
+		fh->fh_size,
+		fh->fh_base.fh_pad[0],
+		fh->fh_base.fh_pad[1],
+		fh->fh_base.fh_pad[2],
+		fh->fh_base.fh_pad[3],
+		fh->fh_base.fh_pad[4],
+		fh->fh_base.fh_pad[5]);
+	return buf;
+}
+
+%}
+
+/*
+ *1 : nfsd.proc2.lookup
+ *2 : nfsd.proc3.lookup
+ *3 : nfsd.proc2.read
+ *4 : nfsd.proc3.read
+ *5 : nfsd.proc2.write
+ *6 : nfsd.proc3.write
+ *7 : nfsd.proc3.commit
+ *8 : nfsd.proc2.create
+ *9 : nfsd.proc3.create
+ *10: nfsd.proc2.remove
+ *11: nfsd.proc3.remove
+ *12 :nfsd.proc2.rename.ffh
+ *13 :nfsd.proc2.rename.tfh
+ *14 :nfsd.proc3.rename.ffh
+ *15 :nfsd.proc3.rename.tfh
+ */
+
+/*Get file handler from argp,the index indicates the type of argp*/
+function __get_fh:string (argp:long,index:long) %{ /* pure */
+	int index = (int)(THIS->index);
+	struct nfsd_diropargs * argp = NULL ;
+	struct nfsd3_diropargs * argp3 = NULL ;
+	struct nfsd_readargs * argpr = NULL;
+	struct nfsd3_readargs * argpr3 = NULL;
+	struct nfsd_writeargs * argpw = NULL;
+	struct nfsd3_writeargs * argpw3 = NULL;
+	struct nfsd3_commitargs * argpc3 = NULL;
+	struct nfsd_createargs *argpcr = NULL;
+	struct nfsd3_createargs *argpcr3 = NULL;
+	struct nfsd_diropargs *argpre = NULL;
+	struct nfsd3_diropargs *argpre3 = NULL;
+	struct nfsd_renameargs *argpren = NULL;
+	struct nfsd3_renameargs *argpren3 = NULL;
+	struct svc_fh * fhp = NULL;
+	char * buf;
+
+	switch(index)
+	{
+	case 1: argp = (struct nfsd_diropargs *)THIS->argp;
+		fhp = &argp->fh;
+		break;
+	case 2: argp3 = (struct nfsd3_diropargs *)THIS->argp;
+		fhp = &argp3->fh;
+		break;
+	case 3: argpr = (struct nfsd_readargs * )THIS->argp;
+		fhp = &argpr->fh;
+		break;
+	case 4: argpr3 = (struct nfsd3_readargs * )THIS->argp;
+		fhp = &argpr3->fh;
+		break;
+	case 5: argpw = (struct nfsd_writeargs * )THIS->argp;
+		fhp = &argpw->fh;
+		break;
+	case 6: argpw3 = (struct nfsd3_writeargs * )THIS->argp;
+		fhp = &argpw3->fh;
+		break;
+	case 7: argpc3 = (struct nfsd3_commitargs * )THIS->argp;
+		fhp = &argpc3->fh;
+		break;
+	case 8: argpcr = (struct nfsd_createargs * )THIS->argp;
+		fhp = &argpcr->fh;
+		break;
+	case 9: argpcr3 = (struct nfsd3_createargs * )THIS->argp;
+		fhp = &argpcr3->fh;
+		break;
+	case 10: argpre = (struct nfsd_diropargs * )THIS->argp;
+		fhp = &argpre->fh;
+		break;
+	case 11: argpre3 = (struct nfsd3_diropargs * )THIS->argp;
+		fhp = &argpre3->fh;
+		break;
+	case 12: argpren = (struct nfsd_renameargs * )THIS->argp;
+		fhp = &argpren->ffh;
+		break;
+	case 13: argpren = (struct nfsd_renameargs * )THIS->argp;
+		fhp = &argpren->tfh;
+		break;
+	case 14: argpren3 = (struct nfsd3_renameargs * )THIS->argp;
+		fhp = &argpren3->ffh;
+		break;
+	case 15: argpren3 = (struct nfsd3_renameargs * )THIS->argp;
+		fhp = &argpren3->tfh;
+		break;
+	}
+	
+	if(fhp == NULL)
+	{
+		_stp_printf("the fhp is NULL");
+	}
+	else
+	{
+		buf = fh_fmt(fhp);
+//	_stp_printf("%s:\n",buf);
+		strlcpy (THIS->__retvalue,buf,80);
+	}
+%}
+/*Get file handler from struct svc_fh , it will call
+fh_fmt function*/
+function __svc_fh:string(fh :long) %{  /* pure */
+	struct svc_fh * fhp = (struct svc_fh *) (THIS->fh);
+	char * buf ;
+	
+	buf =  fh_fmt(fhp); 	
+	strlcpy (THIS->__retvalue,buf,80);
+%}
+
+function p_long:long(cnt:long) %{ /* pure */
+	unsigned long * count = (unsigned long *)(THIS->cnt);
+	
+	THIS->__retvalue = *count;
+%}
+/*
+*probe nfsd.dispatch
+*  Fires when server receives a NFS operation from client 
+*
+*Arguments:
+*  client_ip : the ip address of client
+*  proto : transfer protocol
+*  version : nfs version
+*  xid : transmission id
+*  prog : program number
+*  proc : procedure number
+*/
+probe nfsd.dispatch = kernel.function("nfsd_dispatch")?,
+                      module("nfsd").function("nfsd_dispatch") ?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+	version = $rqstp->rq_vers
+
+	xid = $rqstp->rq_xid
+	prog = $rqstp->rq_prog
+	proc = $rqstp->rq_proc
+
+	name = "nfsd.dispatch"
+	argstr = sprintf("%d,%d",version,proto)
+}
+
+probe nfsd.dispatch.return = kernel.function("nfsd_dispatch").return?,
+                      module("nfsd").function("nfsd_dispatch").return ?
+{
+	name = "nfsd.dispatch.return"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfsd.proc.entries = nfsd.proc.lookup,
+                          nfsd.proc.read,
+                          nfsd.proc.write,
+                          nfsd.proc.commit,
+                          nfsd.proc.compound,
+                          nfsd.proc.rename,
+			  nfsd.proc.create
+{} 
+
+probe nfsd.proc.return = nfsd.proc.lookup.return,
+                          nfsd.proc.read.return,
+                          nfsd.proc.write.return,
+                          nfsd.proc.commit.return,
+                          nfsd.proc.compound.return,
+                          nfsd.proc.rename.return,
+                          nfsd.proc.create.return
+{} 
+
+/*
+*probe nfsd.proc.lookup
+*  Fires when client opens/searchs file on server
+*
+*Arguments:
+*  client_ip : the ip address of client
+*  proto : transfer protocol
+*  version : nfs version
+*  fh  : file handle of parent dir (the first part is the length of the file handle)
+*  filename : file name 
+*  filelen  : the length of file name
+*/
+probe nfsd.proc.lookup = nfsd.proc2.lookup,
+                         nfsd.proc3.lookup
+{}
+
+probe nfsd.proc.lookup.return = nfsd.proc2.lookup.return,
+                         nfsd.proc3.lookup.return
+{}
+
+probe nfsd.proc2.lookup = kernel.function("nfsd_proc_lookup") ?,
+                          module("nfsd").function("nfsd_proc_lookup") ?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV2"
+	fh = __get_fh($argp,1)
+
+	filename = kernel_string($argp->name)
+	filelen = $argp->len
+
+	name = "nfsd.proc2.lookup"
+	argstr = sprintf("%s",filename)
+}
+
+ 
+probe nfsd.proc2.lookup.return = kernel.function("nfsd_proc_lookup").return ?,
+                          module("nfsd").function("nfsd_proc_lookup").return ?
+{
+	name = "nfsd.proc2.lookup.return"
+	version = "NFSV2"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfsd.proc3.lookup = kernel.function("nfsd3_proc_lookup") ?,
+                          module("nfsd").function("nfsd3_proc_lookup") ?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV3"
+	fh = __get_fh($argp,1)
+
+	filename = kernel_string($argp->name)
+	filelen = $argp->len
+
+	name = "nfsd.proc3.lookup"
+	argstr = sprintf("%s",filename)
+} 
+
+probe nfsd.proc3.lookup.return = kernel.function("nfsd3_proc_lookup").return ?,
+                          module("nfsd").function("nfsd3_proc_lookup").return ?
+{
+	name = "nfsd.proc3.lookup.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+
+
+/*
+*probe nfsd.proc.read
+*  Fires when client read file on server
+*
+*Arguments:
+*  client_ip : the ip address of client
+*  proto : transfer protocol
+*  version : nfs version
+*  fh  : file handle (the first part is the length of the file handle)
+*  size:
+*  count : read bytes
+*  offset : the offset of file 
+*  vec : struct kvec ,includes buf address in kernel address
+         and length of each buffer
+*  vlen : read blocks 
+*/
+probe nfsd.proc.read = nfsd.proc2.read,
+                       nfsd.proc3.read
+{}
+
+probe nfsd.proc.read.return = nfsd.proc2.read.return,
+                       nfsd.proc3.read.return
+{
+
+}
+
+probe nfsd.proc2.read = kernel.function("nfsd_proc_read")?,
+                        module("nfsd").function("nfsd_proc_read")?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV2"
+	fh = __get_fh($argp,3)
+
+	count = $argp->count 
+	offset = $argp->offset 
+	vec = $argp->vec
+	vlen = $argp->vlen
+
+	name = "nfsd.proc2.read"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+ 
+probe nfsd.proc2.read.return = kernel.function("nfsd_proc_read").return?,
+                        module("nfsd").function("nfsd_proc_read").return?
+{
+	name = "nfsd.proc2.read.return"
+	version = "NFSV2"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfsd.proc3.read = kernel.function("nfsd3_proc_read")?,
+                        module("nfsd").function("nfsd3_proc_read")?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV3"
+	fh = __get_fh($argp,4)
+
+	count = $argp->count 
+	offset = $argp->offset 
+	vec = $argp->vec
+	vlen = $argp->vlen
+
+	name = "nfsd.proc3.read"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+ 
+probe nfsd.proc3.read.return = kernel.function("nfsd3_proc_read").return?,
+                        module("nfsd").function("nfsd3_proc_read").return?
+{
+	name = "nfsd.proc3.read.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+*probe nfsd.proc.write
+*  Fires when client writes data to  file on server
+*
+*Arguments:
+*  client_ip : the ip address of client
+*  proto : transfer protocol
+*  version : nfs version
+*  fh  : file handle (the first part is the length of the file handle)
+*  size:
+*  count : read bytes
+*  offset : the offset of file 
+*  vec : struct kvec ,includes buf address in kernel address
+         and length of each buffer
+*  vlen : read blocks 
+*  stable : argp->stable(only in nfs.proc3.write)
+*/
+probe nfsd.proc.write = nfsd.proc2.write,
+                       nfsd.proc3.write
+{}
+
+probe nfsd.proc.write.return = nfsd.proc2.write.return,
+                       nfsd.proc3.write.return
+{
+
+}
+
+probe nfsd.proc2.write = kernel.function("nfsd_proc_write")?,
+                        module("nfsd").function("nfsd_proc_write")?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV2"
+	fh = __get_fh($argp,5)
+
+	count = $argp->len
+	offset = $argp->offset 
+	vec = $argp->vec
+	vlen = $argp->vlen
+
+	name = "nfsd.proc2.write"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+ 
+probe nfsd.proc2.write.return = kernel.function("nfsd_proc_write").return?,
+                        module("nfsd").function("nfsd_proc_write").return?
+{
+	name = "nfsd.proc2.write.return"
+	version = "NFSV2"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfsd.proc3.write = kernel.function("nfsd3_proc_write")?,
+                        module("nfsd").function("nfsd3_proc_write")?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV3"
+	fh = __get_fh($argp,6)
+
+	count = $argp->count 
+	offset = $argp->offset 
+	vec = $argp->vec
+	vlen = $argp->vlen
+	stable = $argp->stable
+
+	name = "nfsd.proc3.write"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+ 
+probe nfsd.proc3.write.return = kernel.function("nfsd3_proc_write").return?,
+                        module("nfsd").function("nfsd3_proc_write").return?
+{
+	name = "nfsd.proc3.write.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+*probe nfsd.proc.commit
+*  Fires when client does a commit operation,which is
+*  used to flush the data written by async operation before
+*  to disk
+*
+*Arguments:
+*  client_ip : the ip address of client
+*  proto : transfer protocol
+*  version : nfs version
+*  fh  : file handle (the first part is the length of the file handle)
+*  size:
+*  count : read bytes
+*  offset : the offset of file 
+*/
+probe nfsd.proc.commit =  nfsd.proc3.commit
+{}
+
+probe nfsd.proc.commit.return = nfsd.proc3.commit.return
+{
+
+}
+
+probe nfsd.proc3.commit = kernel.function("nfsd3_proc_commit")?,
+                        module("nfsd").function("nfsd3_proc_commit")?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV3"
+	fh = __get_fh($argp,7) 
+
+	count = $argp->count 
+	offset = $argp->offset 
+
+	name = "nfsd.proc3.commit"
+	argstr = sprintf("%d,%d",count,offset)
+
+        size = count
+        units = "bytes"
+}
+
+probe nfsd.proc3.commit.return = kernel.function("nfsd3_proc_commit").return?,
+                        module("nfsd").function("nfsd3_proc_commit").return?
+{
+	name = "nfsd.proc3.commit.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+*probe nfsd.proc.create
+* Fires when clients create a file on server side.
+*
+* Arguments:
+*  client_ip : the ip address of client
+*  proto : transfer protocol
+*  version : nfs version
+*  fh  : file handle (the first part is the length of the file handle)
+*  filename : file name
+*  filelen : length of file name
+*/
+probe nfsd.proc.create = nfsd.proc2.create,
+                         nfsd.proc3.create
+{}
+probe nfsd.proc.create.return = nfsd.proc2.create.return,
+                                nfsd.proc3.create.return
+{}
+
+probe nfsd.proc2.create = kernel.function("nfsd_proc_create")?,
+                         module("nfsd").function("nfsd_proc_create")
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV2"
+	fh = __get_fh($argp,8)
+
+	filename  = kernel_string($argp->name) 
+	filelen = $argp->len
+
+	name = "nfsd.proc2.create"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfsd.proc2.create.return =  kernel.function("nfsd_proc_create").return?,
+                                 module("nfsd").function("nfsd_proc_create").return
+{
+	name = "nfsd.proc2.create.return"
+	version = "NFSV2"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfsd.proc3.create = kernel.function("nfsd3_proc_create")?,
+                         module("nfsd").function("nfsd3_proc_create")
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV3"
+	fh = __get_fh($argp,9)
+
+	filename  = kernel_string($argp->name) 
+	filelen = $argp->len
+	
+	name = "nfsd.proc3.create"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfsd.proc3.create.return =  kernel.function("nfsd3_proc_create").return?,
+                                 module("nfsd").function("nfsd3_proc_create").return
+{
+	name = "nfsd.proc3.create.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+*probe nfsd.proc.remove
+* Fires when clients removes a file on server side.
+*
+* Arguments:
+*  client_ip : the ip address of client
+*  proto : transfer protocol
+*  version : nfs version
+*  fh  : file handle (the first part is the length of the file handle)
+*  filename : file name
+*  filelen : length of file name
+*/
+probe nfsd.proc.remove = nfsd.proc2.remove,
+                         nfsd.proc3.remove
+{}
+probe nfsd.proc.remove.return = nfsd.proc2.remove.return,
+                                nfsd.proc3.remove.return
+{}
+
+probe nfsd.proc2.remove = kernel.function("nfsd_proc_remove")?,
+                         module("nfsd").function("nfsd_proc_remove")
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV2"
+	fh = __get_fh($argp,10)
+
+	filename  = kernel_string($argp->name) 
+	filelen = $argp->len
+
+	name = "nfsd.proc2.remove"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfsd.proc2.remove.return =  kernel.function("nfsd_proc_remove").return?,
+                                 module("nfsd").function("nfsd_proc_remove").return
+{
+	name = "nfsd.proc2.remove.return"
+	version = "NFSV2"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfsd.proc3.remove = kernel.function("nfsd3_proc_remove")?,
+                         module("nfsd").function("nfsd3_proc_remove")
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV3"
+	fh = __get_fh($argp,11)
+
+	filename  = kernel_string($argp->name) 
+	filelen = $argp->len
+	
+	name = "nfsd.proc3.remove"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfsd.proc3.remove.return =  kernel.function("nfsd3_proc_remove").return?,
+                                 module("nfsd").function("nfsd3_proc_remove").return?
+{
+	name = "nfsd.proc3.remove.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+* probe nfsd.proc.rename
+*  Fires when clients rename a file on server side
+*
+* Arguments:
+*   fh : file handler of old path
+*   tfh : file handler of new path
+*   filename : old file name 
+*   tname : new file name
+*   flen : length of old file name 
+*   tlen : length of new file name
+*/
+probe nfsd.proc.rename = nfsd.proc2.rename,
+                         nfsd.proc3.rename
+{}
+
+probe nfsd.proc.rename.return = nfsd.proc2.rename.return,
+                         nfsd.proc3.rename.return
+{}
+
+probe nfsd.proc2.rename =  kernel.function("nfsd_proc_rename")?,
+                           module("nfsd").function("nfsd_proc_rename")?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV2"
+	fh = __get_fh($argp,12)
+	tfh = __get_fh($argp,13)
+
+	filename  = kernel_string($argp->fname) 
+	filelen = $argp->flen
+	tname = kernel_string($argp->tname)
+	tlen = $argp->tlen
+
+	name = "nfsd.proc2.rename"
+	argstr = sprintf("%s,%s",filename,tname)
+}
+
+probe nfsd.proc2.rename.return =  kernel.function("nfsd_proc_rename").return?,
+                           module("nfsd").function("nfsd_proc_rename").return?
+{
+	name = "nfsd.proc2.rename.return"
+	version = "NFSV2"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfsd.proc3.rename =  kernel.function("nfsd3_proc_rename")?,
+                           module("nfsd").function("nfsd3_proc_rename")?
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV3"
+	fh = __get_fh($argp,14)
+	tfh = __get_fh($argp,15)
+
+	filename  = kernel_string($argp->fname) 
+	filelen = $argp->flen
+	tname = kernel_string($argp->tname)
+	tlen = $argp->tlen
+
+	name = "nfsd.proc3.rename"
+	argstr = sprintf("%s,%s",filename,tname)
+}
+
+probe nfsd.proc3.rename.return =  kernel.function("nfsd3_proc_rename").return?,
+                           module("nfsd").function("nfsd3_proc_rename").return?
+{
+	name = "nfsd.proc3.rename.return"
+	version = "NFSV3"
+	retstr = sprintf("%d",$return)
+}
+/*
+*probe nfsd.proc.compound
+*   Fires when the server received a NFSV4 operation from client
+*
+*Arguments:
+*  client_ip : the ip address of client
+*  proto : transfer protocol
+*  version : nfs version
+*  num : number of file operation in this RPC operation 
+*  op : head of operation list in this compound execution
+*/
+probe nfsd.proc.compound = nfsd.proc4.compound
+{}
+
+probe nfsd.proc.compound.return = nfsd.proc4.compound.return
+{}
+
+probe nfsd.proc4.compound = kernel.function("nfsd4_proc_compound")?,
+                            module("nfsd").function("nfsd4_proc_compound")
+{
+	client_ip = $rqstp->rq_addr->sin_addr->s_addr
+	proto = $rqstp->rq_prot
+        version = "NFSV4"
+
+	num = $args->opcnt
+	op = $args->ops
+	
+	name = "nfsd.proc4.cmpound"
+	argstr = sprintf("%d",num)
+}
+
+probe nfsd.proc4.compound.return = kernel.function("nfsd4_proc_compound").return?,
+                            module("nfsd").function("nfsd4_proc_compound").return
+{
+	name = "nfsd.proc4.compound.return"
+	version = "NFSV4"
+	retstr = sprintf("%d",$return)
+}
+
+probe nfsd.entries = nfsd.open,
+	             nfsd.read,
+                     nfsd.write,
+                     nfsd.lookup,
+                     nfsd.commit,
+                     nfsd.create,
+                     nfsd.createv3,
+                     nfsd.unlink,
+                     nfsd.rename,
+                     nfsd.close
+{}
+
+probe nfsd.return= nfsd.open.return,
+	             nfsd.read.return,
+                     nfsd.write.return,
+                     nfsd.lookup.return,
+                     nfsd.commit.return,
+                     nfsd.create.return,
+                     nfsd.createv3.return,
+                     nfsd.unlink.return,
+                     nfsd.rename,return,
+                     nfsd.close.return
+{}
+/*probe nfsd.open
+*  Fires when server opens a file
+*
+* Arguments:
+*  fh  : file handle (the first part is the length of the file handle)
+*  access : indicates the type of open(read/write/commit/readdir...) 
+*  type : type of file(regular file or dir)
+*/
+probe nfsd.open = kernel.function("nfsd_open") ?,
+                  module("nfsd").function("nfsd_open")
+{
+	fh = __svc_fh($fhp)
+
+	access = $access
+	type = $type
+
+	name = "nfsd.open"
+	argstr = sprintf("%d",access)
+}
+
+probe nfsd.open.return = kernel.function("nfsd_open").return ?,
+                  module("nfsd").function("nfsd_open").return
+{
+	name = "nfsd.open.return"
+	retstr = sprintf("%d",$return)
+}
+
+/*probe nfsd.close
+*  Fires when server closes a file
+*
+* Arguments:
+* filename : file name
+*/
+probe nfsd.close = kernel.function("nfsd_close")?,
+                   module("nfsd").function("nfsd_close")?
+{
+	filename = kernel_string($filp->f_dentry->d_name->name)
+
+	name = "nfsd.close"
+	argstr = sprintf("%s",filename)
+}
+/*probe nfsd.read
+*  Fires when server reads data from a file
+*
+* Arguments:
+*  fh  : file handle (the first part is the length of the file handle)
+*  file : argument file,indicates if the file has been opened.
+*  size:
+*  count : read bytes
+*  offset : the offset of file 
+*  vec : struct kvec ,includes buf address in kernel address
+         and length of each buffer
+*  vlen : read blocks 
+*/
+probe nfsd.read = kernel.function("nfsd_read") ?,
+                  module("nfsd").function("nfsd_read")?
+{
+	fh = __svc_fh($fhp)
+
+	file = $file
+	count = p_long($count)
+	offset = $offset
+	vec = $vec
+	vlen = $vlen
+
+	name = "nfsd.read"
+	argstr = sprintf("%d,%d",count,offsee)
+
+	size = count
+	units = "bytes"
+} 
+
+probe nfsd.read.return = kernel.function("nfsd_read").return ?,
+                  module("nfsd").function("nfsd_read").return?
+{
+	name = "nfsd.read.return"
+	retstr = sprintf("%d",$return)
+}
+
+/*probe nfsd.write
+*  Fires when server writes data to a file
+*
+* Arguments:
+*  fh  : file handle (the first part is the length of the file handle)
+*  file : argument file,indicates if the file has been opened.
+*  size:
+*  count : read bytes
+*  offset : the offset of file 
+*  vec : struct kvec ,includes buf address in kernel address
+         and length of each buffer
+*  vlen : read blocks 
+*/
+probe nfsd.write = kernel.function("nfsd_write")?,
+                   module("nfsd").function("nfsd_write")?
+{
+	fh = __svc_fh($fhp)
+
+	file = $file
+	count = $cnt
+	offset = $offset
+	vec = $vec
+	vlen = $vlen
+
+	name = "nfsd.write"
+	argstr = sprintf("%d,%d",count,offsee)
+
+	size = count
+	units = "bytes"
+}
+
+probe nfsd.write.return = kernel.function("nfsd_write").return?,
+                   module("nfsd").function("nfsd_write").return?
+{
+	name = "nfsd.write.return"
+	retstr = sprintf("%d",$return)
+}
+
+/*probe nfsd.commit
+*  Fires when server commits all pending writes to stable storage.  
+*
+* Arguments:
+*  fh  : file handle (the first part is the length of the file handle)
+*  flag : indicates whether this execution is a sync operation
+*  size:
+*  count : read bytes
+*  offset : the offset of file
+*/
+probe nfsd.commit = kernel.function("nfsd_commit")?,
+                    module("nfsd").function("nfsd_commit")?
+{
+	fh = __svc_fh($fhp)
+
+	count = $count
+	offset = $offset
+	flag = $fhp->fh_export->ex_flags
+
+	name = "nfsd.commit"
+	argstr = sprintf("%d,%d",count,offset)
+
+	size = count 
+	units = "bytes"
+}
+
+probe nfsd.commit.return = kernel.function("nfsd_commit").return?,
+                    module("nfsd").function("nfsd_commit").return ?
+{
+	name = "nfsd.commit.return"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+*probe nfsd.lookup
+*  Fires when client opens/searchs file on server
+*
+*Arguments:
+*  fh  : file handle of parent dir(the first part is the length of the file handle)
+*  filename : file name 
+*  filelen  : the length of file name
+*/
+
+probe nfsd.lookup = kernel.function("nfsd_lookup")?,
+                    module("nfsd").function("nfsd_lookup")?
+{
+	fh = __svc_fh($fhp)
+
+	filename = kernel_string($name)
+	filelen = $len
+
+	name = "nfsd.lookup"
+	argstr = sprintf("%s",filename)
+}
+
+probe nfsd.lookup.return = kernel.function("nfsd_lookup").return?,
+                            module("nfsd").function("nfsd_lookup").return?
+{
+	name = "nfsd.lookup.return"
+	retstr = sprintf("%d",$return)
+}
+/*
+* probe nfsd.create
+*  Fires when client creates a file(regular,dir,device,fifo) on server side,
+*  sometimes nfsd will call nfsd_create_v3 instead of this function
+*
+* Arguments:
+*
+*  fh  : file handle (the first part is the length of the file handle)
+*  filename : file name 
+*  filelen  : the length of file name
+*  type : file type(regular,dir,device,fifo ...)
+*  iap: inode attributes 
+*/
+probe nfsd.create = kernel.function("nfsd_create")?,         
+                    module("nfsd").function("nfsd_create")?
+{
+	fh = __svc_fh($fhp)
+
+	filename = kernel_string($fname)
+	filelen = $flen
+	type = $type
+	iap = $iap
+
+	name = "nfsd.create"
+	argstr = sprintf("%s,%d",filename,iap)
+}
+
+probe nfsd.create.return = kernel.function("nfsd_create").return?,         
+                    module("nfsd").function("nfsd_create").return?
+{
+	name = "nfsd.create.return"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+* probe nfsd.createv3
+*  Fires when client creates a regular file or set file attributes on server side,
+*  only called by nfsd3_proc_create and nfsd4_open(op_claim_type is NFS4_OPEN_CLAIM_NULL)
+*
+* Arguments:
+*
+*  fh  : file handle (the first part is the length of the file handle)
+*  filename : file name 
+*  filelen  : the length of file name
+*  iap : inode attributes 
+*  createmode : create mode .The possible values could be:
+*	NFS3_CREATE_EXCLUSIVE,NFS3_CREATE_UNCHECKED,NFS3_CREATE_GUARDED
+*  truncp : trunp arguments, indicates if the file shouldbe truncate
+*  verfier :  file attributes (atime,mtime,mode).It's used to reset file
+              attributes for CREATE_EXCLUSIVE
+*/
+probe nfsd.createv3 = kernel.function("nfsd_create_v3")?,         
+                    module("nfsd").function("nfsd_create_v3")?
+{
+	fh = __svc_fh($fhp)
+
+	filename = kernel_string($fname)
+	filelen = $flen
+	ia_mode = $iap
+	truncp = $truncp
+	verfier = $verifier
+	createmode = $createmode
+
+	name = "nfsd.createv3"
+	argstr = sprintf("%s,%d",filename,createmode)
+}
+
+probe nfsd.createv3.return = kernel.function("nfsd_create_v3").return?,         
+                    module("nfsd").function("nfsd_create_v3").return?
+{
+	name = "nfsd.createv3.return"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+* probe nfsd.unlink
+*  Fires when client removes a file or a dir  on server side,
+*
+* Arguments:
+*
+*  fh  : file handle (the first part is the length of the file handle)
+*  filename : file name 
+*  filelen  : the length of file name
+*  type : file type(file or dir)
+*/
+probe nfsd.unlink = kernel.function("nfsd_unlink")?,         
+                    module("nfsd").function("nfsd_unlink")?
+{
+	fh = __svc_fh($fhp)
+
+	filename = kernel_string($fname)
+	filelen = $flen
+	type = $type
+
+	name = "nfsd.unlink"
+	argstr = sprintf("%s,%d",filename,iap)
+}
+
+probe nfsd.unlink.return = kernel.function("nfsd_unlink").return?,         
+                    module("nfsd").function("nfsd_unlink").return?
+{
+	name = "nfsd.unlink.return"
+	retstr = sprintf("%d",$return)
+}
+
+/*
+* probe nfsd.rename
+*  Fires when clients rename a file on server side
+*
+* Arguments:
+*   fh : file handler of old path
+*   tfh : file handler of new path
+*   filename : old file name 
+*   tname : new file name
+*   flen : length of old file name 
+*   tlen : length of new file name
+*/
+
+probe nfsd.rename =  kernel.function("nfsd_rename")?,
+                           module("nfsd").function("nfsd_rename")?
+{
+	fh = __svc_fh($ffhp)
+	tfh = __svc_fh($tfhp)
+
+	filename  = kernel_string($fname) 
+	filelen = $flen
+	tname = kernel_string($tname)
+	tlen = $tlen
+
+	name = "nfsd.rename"
+	argstr = sprintf("%s,%s",filename,tname)
+}
+
+probe nfsd.rename.return =  kernel.function("nfsd_rename").return?,
+                           module("nfsd").function("nfsd_rename").return?
+{
+	name = "nfsd.rename.return"
+	retstr = sprintf("%d",$return)
+}
diff --git a/tapset/vfs.stp b/tapset/vfs.stp
new file mode 100644
index 00000000..94535fe7
--- /dev/null
+++ b/tapset/vfs.stp
@@ -0,0 +1,592 @@
+/* generic vfs probes */
+
+/* helper functions */
+function __bdevname:string (bdev:long) %{ /* pure */
+	char b[BDEVNAME_SIZE];
+	struct block_device *bdev = (struct block_device *)(long)THIS->bdev;
+	if (bdev == NULL) {
+		strlcpy(THIS->__retvalue, "N/A", MAXSTRINGLEN);
+		return;
+	}
+
+	deref_string(THIS->__retvalue, bdevname(bdev,b), MAXSTRINGLEN);
+	if (0) {
+deref_fault:
+		CONTEXT->last_error = "pointer dereference fault";
+	}
+%}
+
+/*
+  We don't want to have to do a bdevname() call every time
+  we want a devname, so we'll hash them here.
+*/
+global __devnames
+function __find_bdevname(dev, bdev)
+{
+#	return ""
+
+	__devname = __devnames[dev]
+
+	if (__devname != null)
+		return __devname
+
+	__devname = __devnames[dev] = __bdevname(bdev)
+
+	return __devname
+}
+
+function ppos_pos:long (ppos:long) %{ /* pure */
+	loff_t *ppos = (loff_t *)(long)THIS->ppos;
+	THIS->__retvalue = (int64_t)*ppos;
+%}
+
+function __page_ino:long (page:long) %{ /* pure */
+	struct page *page = (struct page *)(long)THIS->page;
+	if ((page == NULL) || (page->mapping == NULL)) {
+		THIS->__retvalue = -1;
+		return;
+	}
+
+	THIS->__retvalue = deref(sizeof(page->mapping->host->i_ino),
+		&(page->mapping->host->i_ino));
+	if (0) {
+deref_fault:
+		CONTEXT->last_error = "pointer dereference fault";
+	}
+%}
+
+function __page_dev:long (page:long) %{ /* pure */
+	struct page *page = (struct page *)(long)THIS->page;
+	if ((page == NULL) || (page->mapping == NULL)) {
+		THIS->__retvalue = -1;
+		return;
+	}
+	THIS->__retvalue = deref(sizeof(page->mapping->host->i_sb->s_dev),
+		&(page->mapping->host->i_sb->s_dev));
+	if (0) {
+deref_fault:
+		CONTEXT->last_error = "pointer dereference fault";
+	}
+%}
+
+function __page_bdev:long (page:long) %{ /* pure */
+	struct page *page = (struct page *)(long)THIS->page;
+	if ((page == NULL) || (page->mapping == NULL)) {
+		THIS->__retvalue = -1;
+		return;
+	}
+	THIS->__retvalue = deref(sizeof(page->mapping->host->i_sb->s_bdev),
+		&(page->mapping->host->i_sb->s_dev));
+	if (0) {
+deref_fault:
+		CONTEXT->last_error = "pointer dereference fault";
+	}
+%}
+
+probe generic.fop.llseek = kernel.function ("generic_file_llseek")
+{
+	dev = $file->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $file->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $file->f_dentry->d_inode->i_ino
+
+	offset = $offset
+	origin = $origin
+        maxbyte = $file->f_dentry->d_inode->i_sb->s_maxbytes
+
+	name = "generic_file_llseek"
+	argstr = sprintf("%d, %d", offset, origin)
+}
+probe generic.fop.llseek.return = kernel.function ("generic_file_llseek").return
+{
+	name = "generic_file_llseek"
+	retstr = returnstr(1)
+}
+
+probe generic.fop.aio_read = kernel.function ("generic_file_aio_read")
+{
+	dev = $iocb->ki_filp->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $iocb->ki_filp->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $iocb->ki_filp->f_dentry->d_inode->i_ino
+
+	count = $count
+	pos = $pos
+        buf = $buf
+
+	name = "generic_file_aio_read"
+	argstr = sprintf("%d, %d, %p", count, pos,buf)
+
+	size = count
+	units = "bytes"
+}
+probe generic.fop.aio_read.return = kernel.function ("generic_file_aio_read").return
+{
+	name = "generic_file_aio_read"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.aio_write = kernel.function ("generic_file_aio_write")
+{
+	dev = $iocb->ki_filp->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $iocb->ki_filp->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $iocb->ki_filp->f_dentry->d_inode->i_ino
+
+	count = $count
+	pos = $pos
+
+	name = "generic_file_aio_write"
+	argstr = sprintf("%d, %d", count, pos)
+
+	size = count
+	units = "bytes"
+}
+probe generic.fop.aio_write.return = kernel.function ("generic_file_aio_write").return
+{
+	name = "generic_file_aio_write"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.readv = kernel.function ("generic_file_readv")
+{
+	dev = $filp->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $filp->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $filp->f_dentry->d_inode->i_ino
+
+	nr_segs = $nr_segs
+	pos = ppos_pos($ppos)
+
+	name = "generic_file_readv"
+	argstr = sprintf("%d, %d", nr_segs, pos)
+
+	size = nr_segs
+	units = "segs"
+}
+probe generic.fop.readv.return = kernel.function ("generic_file_readv").return
+{
+	name = "generic_file_readv"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+/* calls __generic_file_write_nolock */
+probe generic.fop.writev = kernel.function ("generic_file_writev")
+{
+	dev = $file->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $file->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $file->f_dentry->d_inode->i_ino
+
+	nr_segs = $nr_segs
+	pos = ppos_pos($ppos)
+
+	name = "generic_file_writev"
+	argstr = sprintf("%d, %d", nr_segs, pos)
+
+	size = nr_segs
+	units = "segs"
+}
+probe generic.fop.writev.return = kernel.function ("generic_file_writev").return
+{
+	name = "generic_file_writev"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+/* checks for aops->readpage, if not defined, return -ENOEXEC
+   else assigns generic_file_vm_ops to vma
+   add filemap_nopage, filemap_populate */
+probe generic.fop.mmap = kernel.function ("generic_file_mmap")
+{
+	dev = $file->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $file->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $file->f_dentry->d_inode->i_ino
+
+	vm_start = $vma->vm_start
+	vm_end = $vma->vm_end
+	vm_flags = $vma->vm_flags
+
+	name = "generic_file_mmap"
+	argstr = sprintf("0x%x, 0x%x, 0x%x", vm_start, vm_end, vm_flags)
+}
+probe generic.fop.mmap.return = kernel.function ("generic_file_mmap").return
+{
+	name = "generic_file_mmap"
+	retstr = sprintf("%d", $return)
+}
+
+probe generic.fop.open = kernel.function ("generic_file_open")
+{
+	dev = $filp->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $filp->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $inode->i_ino
+
+	filename = kernel_string($filp->f_dentry->d_name->name)
+        flag = $filp->f_flags
+        size = $inode->size
+
+	name = "generic_file_open"
+	argstr = sprintf("%d, %s", ino, flag, filename)
+}
+probe generic.fop.open.return = kernel.function ("generic_file_open").return
+{
+	name = "generic_file_open"
+	retstr = sprintf("%d", $return)
+}
+
+probe generic.fop.sendfile = kernel.function ("generic_file_sendfile")
+{
+	dev = $in_file->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $in_file->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $in_file->f_dentry->d_inode->i_ino
+
+	count = $count
+        ppos = $ppos
+
+	name = "generic_file_sendfile"
+	argstr = sprintf("%d", count)
+
+	size = count
+	units = "bytes"
+}
+probe generic.fop.sendfile.return = kernel.function ("generic_file_sendfile").return
+{
+	name = "generic_file_sendfile"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.splice_read = kernel.function ("generic_file_splice_read")
+{
+	dev = $in->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $in->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $in->f_dentry->d_inode->i_ino
+
+	len = $len
+	flags = $flags
+
+	name = "generic_file_splice_read"
+	argstr = sprintf("%d, %x", len, flags)
+
+	size = len
+	units = "bytes"
+}
+probe generic.fop.splice_read.return = kernel.function ("generic_file_splice_read").return
+{
+	name = "generic_file_splice_read"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.splice_write = kernel.function ("generic_file_splice_write")
+{
+	dev = $out->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $out->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $out->f_dentry->d_inode->i_ino
+
+	len = $len
+	flags = $flags
+
+	name = "generic_file_splice_write"
+	argstr = sprintf("%d, %x", len, flags)
+
+	size = len
+	units = "bytes"
+}
+probe generic.fop.splice_write.return = kernel.function ("generic_file_splice_write").return
+{
+	name = "generic_file_splice_write"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.read = kernel.function ("generic_file_read")
+{
+	dev = $filp->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $filp->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $filp->f_dentry->d_inode->i_ino
+
+	count = $count
+
+	name = "generic_file_read"
+	argstr = sprintf("%d", count)
+
+	size = count
+	units = "bytes"
+}
+probe generic.fop.read.return = kernel.function ("generic_file_read").return
+{
+	name = "generic_file_read"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe generic.fop.write = kernel.function ("generic_file_write")
+{
+	dev = $file->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $file->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $file->f_dentry->d_inode->i_ino
+
+	count = $count
+
+	name = "generic_file_write"
+	argstr = sprintf("%d", count)
+
+	size = count
+	units = "bytes"
+}
+probe generic.fop.write.return = kernel.function ("generic_file_write").return
+{
+	name = "generic_file_write"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+/* generic_writepages calls mpage_writepages(mapping, wbc, NULL) */
+probe generic.aop.writepages = kernel.function ("mpage_writepages")
+{
+	dev = $mapping->host->i_sb->s_dev
+	devname = __find_bdevname(dev, $mapping->host->i_sb->s_bdev)
+	ino = $mapping->host->i_ino
+
+	nr_to_write = $wbc->nr_to_write
+
+	name = "generic_writepages"
+	argstr = sprintf("%d", nr_to_write)
+
+	size = nr_to_write
+	units = "pages"
+}
+probe generic.aop.writepages.return = kernel.function ("mpage_writepages").return
+{
+	name = "generic_writepages"
+	retstr = sprintf("%d", $return)
+}
+
+probe vfs.do_sync_read = kernel.function ("do_sync_read")
+{
+	dev = $filp->f_dentry->d_inode->i_sb->s_dev
+	ino = $filp->f_dentry->d_inode->i_ino
+
+	len = $len
+	pos = ppos_pos($ppos)
+        buf = $buf
+
+	name = "do_sync_read"
+	argstr = sprintf("%d, %d , %p ", len, pos,buf)
+
+	size = len
+	units = "bytes"
+}
+probe vfs.do_sync_read.return = kernel.function ("do_sync_read").return
+{
+	name = "do_sync_read"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe vfs.do_sync_write = kernel.function ("do_sync_write")
+{
+	dev = $filp->f_dentry->d_inode->i_sb->s_dev
+	devname = __find_bdevname(dev, $filp->f_dentry->d_inode->i_sb->s_bdev)
+	ino = $filp->f_dentry->d_inode->i_ino
+
+	len = $len
+	pos = ppos_pos($ppos)
+
+	name = "do_sync_write"
+	argstr = sprintf("%d, %d", len, pos)
+
+	size = len
+	units = "bytes"
+}
+probe vfs.do_sync_write.return = kernel.function ("do_sync_write").return
+{
+	name = "do_sync_write"
+	retstr = sprintf("%d", $return)
+
+	if ($return > 0) {
+		size = $return
+		units = "bytes"
+	}
+}
+
+probe vfs.block_sync_page = kernel.function ("block_sync_page")
+{
+	__page = $page
+	dev = __page_dev(__page)
+	devname = __find_bdevname(dev, __page_bdev(__page))
+	ino = __page_ino(__page)
+
+	page_index = $page->index
+
+	name = "block_sync_page"
+	argstr = sprintf("%d", page_index)
+
+	size = 1
+	units = "pages"
+}
+probe vfs.block_sync_page.return = kernel.function ("block_sync_page").return
+{
+	name = "block_sync_page"
+	retstr = sprintf("N/A")
+
+	size = 1
+	units = "pages"
+}
+
+probe vfs.buffer_migrate_page = kernel.function ("buffer_migrate_page")
+{
+	dev = $page->mapping->host->i_sb->s_dev
+	devname = __find_bdevname(dev, $page->mapping->host->i_sb->s_dev)
+	ino = $page->mapping->host->i_ino
+
+	page_index = $page->index
+
+	name = "buffer_migrate_page"
+	argstr = sprintf("%d", page_index)
+
+	size = 1
+	units = "pages"
+}
+probe vfs.buffer_migrate_page.return = kernel.function ("buffer_migrate_page").return
+{
+	name = "buffer_migrate_page"
+	retstr = sprintf("%d", $return)
+
+	if ($return == 0) {
+		size = 1
+		units = "pages"
+	}
+}
+
+/* default if aop not set, __set_page_dirty_nobuffers usually used if set */
+probe vfs.__set_page_dirty_buffers = kernel.function ("__set_page_dirty_buffers")
+{
+	__page = $page
+	dev = __page_dev(__page)
+	devname = __find_bdevname(dev, __page_bdev(__page))
+	ino = __page_ino(__page)
+
+	index = $page->index
+
+	name = "__set_page_dirty_buffers"
+	argstr = sprintf("%d", page_index)
+
+	size = 1
+	units = "pages"
+}
+probe vfs.__set_page_dirty_buffers.return = kernel.function ("__set_page_dirty_buffers").return
+{
+	name = "__set_page_dirty_buffers"
+	retstr = sprintf("%d", $return)
+
+	if ($return == 1) {
+		size = 1
+		units = "pages"
+	}
+}
+
+probe vfs.do_mpage_readpage = kernel.function ("do_mpage_readpage")
+{
+	__page = $page
+	dev = __page_dev(__page)
+	devname = __find_bdevname(dev, __page_bdev(__page))
+	ino = __page_ino(__page)
+
+	index = $page->index
+
+	name = "do_mpage_readpage"
+	argstr = sprintf("%d", index)
+
+	size = 1
+	units = "pages"
+}
+probe vfs.do_mpage_readpage.return = kernel.function ("do_mpage_readpage").return
+{
+	name = "do_mpage_readpage"
+	retstr = sprintf("0x%x", $return)
+
+	size = 1
+	units = "pages"
+}
+
+probe vfs.add_to_page_cache = kernel.function ("add_to_page_cache")
+{
+	dev = $mapping->host->i_sb->s_dev
+	devname = __find_bdevname(dev, $mapping->host->i_sb->s_bdev)
+	ino = $mapping->host->i_ino
+
+	index = $offset
+	nrpages = $mapping->nrpages
+
+	name = "vfs.add_to_page_cache"
+	argstr = sprintf("%d, %d", ino, index)
+}
+probe vfs.add_to_page_cache.return = kernel.function ("add_to_page_cache").return
+{
+	name = "vfs.add_to_page_cache"
+	retstr = sprintf("%d", $return)
+
+	if ($return == 0) {
+		size = 1
+		units = "pages"
+	}
+}
+
+probe vfs.remove_from_page_cache = kernel.function ("__remove_from_page_cache")
+{
+	dev = __page_dev($page)
+	devname = __find_bdevname(dev, __page_bdev($page))
+	ino = __page_ino($page)
+
+	index = $page->index
+
+	name = "vfs.remove_from_page_cache"
+	argstr = sprintf("%d", ino)
+}
+probe vfs.remove_from_page_cache.return = kernel.function ("remove_from_page_cache").return
+{
+	name = "vfs.remove_from_page_cache"
+	retstr = sprintf("N/A")
+}
+