diff options
| -rw-r--r-- | tapset/ChangeLog | 12 | ||||
| -rw-r--r-- | tapset/nfs.stp | 999 | ||||
| -rw-r--r-- | tapset/nfs_proc.stp | 1443 | ||||
| -rw-r--r-- | tapset/nfsd.stp | 1059 | ||||
| -rw-r--r-- | tapset/vfs.stp | 592 |
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") +} + |