diff options
| -rw-r--r-- | ChangeLog | 5 | ||||
| -rw-r--r-- | lket.5.in | 533 | ||||
| -rw-r--r-- | tapset/ChangeLog | 9 | ||||
| -rw-r--r-- | tapset/LKET/Changelog | 16 | ||||
| -rwxr-xr-x | tapset/LKET/hookid_defs.stp | 402 | ||||
| -rwxr-xr-x | tapset/LKET/iosyscall.stp | 29 | ||||
| -rwxr-xr-x | tapset/LKET/nfs.stp | 741 | ||||
| -rwxr-xr-x | tapset/LKET/nfs_proc.stp | 611 | ||||
| -rwxr-xr-x | tapset/LKET/nfsd.stp | 755 | ||||
| -rwxr-xr-x | tapset/LKET/register_event.stp | 331 | ||||
| -rwxr-xr-x | tapset/LKET/utils.stp | 10 | ||||
| -rw-r--r-- | tapset/nfs.stp | 45 | ||||
| -rw-r--r-- | tapset/nfs_proc.stp | 258 | ||||
| -rw-r--r-- | tapset/nfsd.stp | 109 |
14 files changed, 3688 insertions, 166 deletions
@@ -1,3 +1,8 @@ +2006-09-12 Li Guanglei <guanglei@cn.ibm.com> + + From Li Xuepeng <xuepengl@cn.ibm.com> + * lket.5.in: document nfs trace hooks + 2006-09-08 David Smith <dsmith@redhat.com> * elaborate.h (struct derived_probe): Replace emit_registrations() @@ -479,6 +479,539 @@ Data format is: .I common_data, ctx_id(INT64), iocb_uaddr(INT64), result_uaddr(INT64) +.SS NFS (GROUPID=16) +You could use +.I addevent.nfs +to trace the detail activities of nfs on client side. +It divided into three groups: nfs file operation event hooks(addevent.nfs.fop), +nfs address space operation event hooks(addevent.nfs.aop), nfs proc event hooks(addevent.nfs.proc). +It contains 36 entry hooks and 33 corresponding return hooks + +All the return hooks will only log the common_data and +the return value. So in the following subsections, only the entry +hooks will be listed: + +.P +.TP +.B addevent.nfs.fop.llseek.entry (HOOKID=1) +the entry of nfs_file_llseek + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I offset(INT32), origin(INR8) + +.TP +.B addevent.nfs.fop.read.entry (HOOKID=3) +the entry of do_sync_read + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I buf_addr(INT64), count(INT64) , offset(INT64) + +.TP +.B addevent.nfs.fop.write.entry (HOOKID=5) +the entry of do_sync_write + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I buf_addr(INT64), count(INT64) , offset(INT64) + +.TP +.B addevent.nfs.fop.aio_read.entry (HOOKID=7) +the entry of nfs_file_read + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I buf_addr(INT64), count(INT64) , offset(INT64) + +.TP +.B addevent.nfs.fop.aio_write.entry (HOOKID=9) +the entry of nfs_file_read + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I buf_addr(INT64), count(INT64) , offset(INT64) + +.TP +.B addevent.nfs.fop.mmap.entry (HOOKID=11) +the entry of nfs_file_mmap + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I vm_start(INT64), vm_end(INT64) , vm_flags(INT32) + +.TP +.B addevent.nfs.fop.open.entry (HOOKID=13) +the entry of nfs_file_open + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I flag(INT32), filename(STRING) + +.TP +.B addevent.nfs.fop.flush.entry (HOOKID=15) +the entry of nfs_file_flush + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I ndirty(INT32) + +.TP +.B addevent.nfs.fop.release.entry (HOOKID=17) +the entry of nfs_file_release + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I mode(INT16) + +.TP +.B addevent.nfs.fop.fsync.entry (HOOKID=19) +the entry of nfs_fsync + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I ndirty(INT32) + +.TP +.B addevent.nfs.fop.lock.entry (HOOKID= 21) +the entry of nfs_lock + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I fl_start(INT64), fl_end(INT64), fl_type(INT8), fl_flag(INT8), cmd(INT32) + +.TP +.B addevent.nfs.fop.sendfile.entry (HOOKID= 23) +the entry of nfs_file_sendfile + +Data format is: + +.I common_data, major_device(INT8), minor_devide(INT8), fileid(INT32), +.I count(INT64), ppos(INT64) + +.TP +.B addevent.nfs.fop.checkflags.entry (HOOKID= 25) +the entry of nfs_check_flags + +Data format is: + +.I flag(INT32) + +.TP +.B addevent.nfs.aop.readpage.entry (HOOKID= 27) +the entry of nfs_readpage + +Data format is: + +.I fileid(INT64), rsize(INT32), page_address(INT64), page_index(INT64) + +.TP +.B addevent.nfs.aop.readpages.entry (HOOKID= 29) +the entry of nfs_readpages + +Data format is: + +.I fileid(INT64), rpages(INT32), nr_pages(INT32) + +.TP +.B addevent.nfs.aop.writepage.entry (HOOKID= 31) +the entry of nfs_writepage + +Data format is: + +.I fileid(INT64), wsize(INT32), page_address(INT64), page_index(INT64) + +.TP +.B addevent.nfs.aop.writepages.entry (HOOKID= 33) +the entry of nfs_writepages + +Data format is: + +.I fileid(INT64), wpages(INT32), nr_to_write(INT64) + +.TP +.B addevent.nfs.aop.prepare_write.entry (HOOKID= 35) +the entry of nfs_prepare_write + +Data format is: + +.I fileid(INT64), page_address(INT64), page_index(INT64) + +.TP +.B addevent.nfs.aop.commit_write.entry (HOOKID= 37) +the entry of nfs_commit_write + +Data format is: + +.I fileid(INT64), page_address(INT64), page_index(INT64),offset(INT32),count(INT32) + +.TP +.B addevent.nfs.aop.set_page_dirty.entry (HOOKID= 39) +the entry of __set_page_dirty_nobuffers + +Data format is: + +.I page_address(INT64), page_flag(INT8) + +.TP +.B addevent.nfs.aop.release_page.entry (HOOKID= 41) +the entry of nfs_release_page + +Data format is: + +.I page_address(INT64), page_index(INT64) + +.TP +.B addevent.nfs.proc.lookup.entry (HOOKID= 43) +the entry of nfs_proc_lookup , nfs3_proc_lookup and nfs4_proc_lookup + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I filename(STRING) + +.TP +.B addevent.nfs.proc.read.entry (HOOKID= 45) +the entry of nfs_proc_read, nfs3_proc_read and nfs4_proc_read + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I count(INT32),offset(INT64) + +.TP +.B addevent.nfs.proc.write.entry (HOOKID= 47) +the entry of nfs_proc_write, nfs3_proc_write and nfs4_proc_write + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I count(INT32),offset(INT64) + +.TP +.B addevent.nfs.proc.commit.entry (HOOKID= 49) +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 + +the entry of nfs3_proc_commit and nfs4_proc_commit + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I count(INT32),offset(INT64) + +.TP +.B addevent.nfs.proc.read_setup.entry (HOOKID= 51) +The read_setup function is used to setup a read rpc task,not do a real read operation + +the entry of nfs_proc_read_setup, nfs3_proc_read_setup and nfs4_proc_read_setup + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I count(INT32),offset(INT64) + +.TP +.B addevent.nfs.proc.write_setup.entry (HOOKID= 52) +The write_setup function is used to setup a write rpc task,not do a real write operation + +the entry of nfs_proc_write_setup, nfs3_proc_write_setup and nfs4_proc_write_setup + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I how(INT8), count(INT32),offset(INT64) + +.TP +.B addevent.nfs.proc.commit_setup.entry (HOOKID= 53) +The commit_setup function is used to setup a commit rpc task,not do a real commit operation.It is not exist in NFSV2 + +the entry of nfs3_proc_commit_setup and nfs4_proc_commit_setup + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I how(INT8), count(INT32),offset(INT64) + +.TP +.B addevent.nfs.proc.read_done.entry (HOOKID= 54) +Fires when a read reply is received or some read error occur (timeout or socket shutdown) + +the entry of nfs_read_done, nfs3_read_done and nfs4_read_done + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I status(INT32), count(INT32) + +.TP +.B addevent.nfs.proc.write_done.entry (HOOKID= 56) +Fires when a write reply is received or some write error occur (timeout or socket shutdown) + +the entry of nfs_write_done, nfs3_write_done and nfs4_write_done + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I status(INT32), count(INT32) + +.TP +.B addevent.nfs.proc.commit_done.entry (HOOKID= 58) +Fires when a commit reply is received or some commit operation error occur (timeout or socket shutdown) + +the entry of nfs_commit_done, nfs3_commit_done and nfs4_commit_done + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I status(INT32), count(INT32) + +.TP +.B addevent.nfs.proc.open.entry (HOOKID= 60) +the entry of nfs_open + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I filename(STRING), flag(INT32), mode(INT32) + +.TP +.B addevent.nfs.proc.release.entry (HOOKID= 62) +the entry of nfs_release + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I filename(STRING), flag(INT32), mode(INT32) + +.TP +.B addevent.nfs.proc.create.entry (HOOKID= 64) +the entry of nfs_proc_create, nfs3_proc_create, nfs4_proc_create + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I filename(STRING), mode(INT32) + +.TP +.B addevent.nfs.proc.rename.entry (HOOKID= 66) +the entry of nfs_proc_rename, nfs3_proc_rename, nfs4_proc_rename + +Data format is: + +.I version(INT8), major_old(INT8), minor_old(INT8), old_fileid(INT64), old_name(STRING), +.I major_new(INT8), minor_new(INT8), new_fileid(INT64), new_name(STRING) + +.TP +.B addevent.nfs.proc.remove.entry (HOOKID= 68) +the entry of nfs_proc_remove, nfs3_proc_remove, nfs4_proc_remove + +Data format is: + +.I major_dev(INT8), minor_dev(INT8), fileid(INT64), version(INT8), +.I filename(STRING) + +.SS NFSD (GROUPID=17) +You could use +.I addevent.nfsd +to trace the detail activities of nfs on server side. +It divided into two groups: nfsd operation event hooks(addevent.nfsd.op), +nfsd proc event hooks(addevent.nfsd.proc). +It contains 19 entry hooks and 19 corresponding return hooks + +All the return hooks will only log the common_data and +the return value. So in the following subsections, only the entry +hooks will be listed: + +.P +.TP +.B addevent.nfsd.dispatch.entry (HOOKID= 1) +Fires when server receives a NFS operation from client + +the entry of nfsd_dispatch + +Data format is: + +.I proto(INT8), version(INT8), xid(INT32), proc(INT32),client_ip(INT32) + +.TP +.B addevent.nfsd.open.entry (HOOKID= 3) +the entry of nfsd_open + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), +.I type(INT32), access(INT32) + +.TP +.B addevent.nfsd.read.entry (HOOKID= 5) +the entry of nfsd_read + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), +.I count(INT64), offset(INT64), iov_len(INT64), vlen(INT64) + +.TP +.B addevent.nfsd.write.entry (HOOKID= 7) +the entry of nfsd_write + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), +.I count(INT64), offset(INT64), iov_len(INT64), vlen(INT64) + +.TP +.B addevent.nfsd.lookup.entry (HOOKID= 9) +the entry of nfsd_lookup + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), +.I filename(STRING) + +.TP +.B addevent.nfsd.commit.entry (HOOKID= 11) +the entry of nfsd_commit + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), +.I count(INT64), offset(INT64) + +.TP +.B addevent.nfsd.create.entry (HOOKID= 13) +Fires when client creates a file(regular,dir,device,fifo) on server side, +sometimes nfsd will call nfsd_create_v3 instead of this function + +the entry of nfsd_create + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), +.I filename(STRING), type(INT32), iap_valid(INT16), iap_mode(INT32) + +.TP +.B addevent.nfsd.createv3.entry (HOOKID= 15) +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) + +the entry of nfsd_create_v3 + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), +.I filename(STRING), createmode(INT8), iap_valid(INT16), iap_mode(INT32) + +.TP +.B addevent.nfsd.unlink.entry (HOOKID= 17) +the entry of nfsd_unlink + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), +.I filename(STRING), type(INT32) + +.TP +.B addevent.nfsd.rename.entry (HOOKID= 19) +the entry of nfsd_rename + +Data format is: + +.I old_fhsize(INT8), old_fh0(INT64), old_fh1(INT64), old_fh2(INT64), old_name(STRING) +.I new_fhsize(INT8), new_fh0(INT64), new_fh1(INT64), new_fh2(INT64), new_name(STRING) + +.TP +.B addevent.nfsd.close.entry (HOOKID= 21) +the entry of nfsd_close + +Data format is: + +.I filename(STRING) + +.TP +.B addevent.nfsd.proc.lookup.entry (HOOKID= 23) +the entry of nfsd_proc_lookup, nfsd3_proc_lookup + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), version(INT8) +.I filename(STRING) + +.TP +.B addevent.nfsd.proc.read.entry (HOOKID= 25) +the entry of nfsd_proc_read, nfsd3_proc_read + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), version(INT8) +.I count(INT64), offset(INT64), iov_len(INT64), vlen(INT64) + +.TP +.B addevent.nfsd.proc.write.entry (HOOKID= 27) +the entry of nfsd_proc_write, nfsd3_proc_write + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), version(INT8) +.I count(INT64), offset(INT64), iov_len(INT64), vlen(INT64) + +.TP +.B addevent.nfsd.proc.commit.entry (HOOKID= 29) +the entry of nfsd_proc_commit, nfsd3_proc_commit + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), version(INT8) +.I count(INT64), offset(INT64) + +.TP +.B addevent.nfsd.proc.commit.entry (HOOKID= 31) +the entry of nfsd4_proc_compound + +Data format is: + +.I number(INT32) + +.TP +.B addevent.nfsd.proc.remove.entry (HOOKID= 33) +the entry of nfsd4_proc_compound + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), version(INT8) +.I filename(STRING) + +.TP +.B addevent.nfsd.proc.rename.entry (HOOKID= 35) +the entry of nfsd_proc_rename, nfsd3_proc_rename + +Data format is: + +.I old_fhsize(INT8), old_fh0(INT64), old_fh1(INT64), old_fh2(INT64), old_name(STRING) +.I new_fhsize(INT8), new_fh0(INT64), new_fh1(INT64), new_fh2(INT64), new_name(STRING) + +.TP +.B addevent.nfsd.proc.create.entry (HOOKID= 37) +the entry of nfsd_proc_create, nfsd3_proc_create + +Data format is: + +.I fh_size(INT8), fhandle0(INT64), fhandle1(INT64), fhandle2(INT64), version(INT8) +.I filename(STRING) + +.TP .SH TRACE DATA FORMAT By default, LKET will log the trace data in binary format. diff --git a/tapset/ChangeLog b/tapset/ChangeLog index 77384a53..8c85e648 100644 --- a/tapset/ChangeLog +++ b/tapset/ChangeLog @@ -1,3 +1,12 @@ +2006-09-12 Li Guanglei <guanglei@cn.ibm.com> + + From Li Xuepeng <xuepengl@cn.ibm.com> + + * nfsd.stp, nfs_proc.stp, nfs.stp: + Change NFS file identifier. Change NFS version data type + from String to INT. Add version variable to nfs_open + and nfs_release. + 2006-09-11 Li Guanglei <guanglei@cn.ibm.com> From Gui Jian(guijian@cn.ibm.com> diff --git a/tapset/LKET/Changelog b/tapset/LKET/Changelog index e569bce5..ef175aef 100644 --- a/tapset/LKET/Changelog +++ b/tapset/LKET/Changelog @@ -1,3 +1,19 @@ +2006-09-12 Li Guanglei <guanglei@cn.ibm.com> + + * iosyscall.stp: change log_iosyscall_sync() be sync + with different timing methods. + * utils.stp: add reset_maxaction() since there are too + many functions called inside "probe begin". + +2006-09-12 Li Guanglei <guanglei@cn.ibm.com> + + From Li Xuepeng <xuepengl@cn.ibm.com> + + * nfsd.stp, nfs_proc.stp, nfs.stp: New trace hooks for + NFS, including both NFS client and server side activities. + * register_event.stp: Add the register event calls for NFS + trace hooks. + 2006-08-29 Li Guanglei <guanglei@cn.ibm.com> From Gui Jian <guijian@cn.ibm.com> diff --git a/tapset/LKET/hookid_defs.stp b/tapset/LKET/hookid_defs.stp index d3c09db7..71684425 100755 --- a/tapset/LKET/hookid_defs.stp +++ b/tapset/LKET/hookid_defs.stp @@ -135,8 +135,175 @@ global /* CPU Frequency */ GROUP_CPUFREQ, - HOOKID_SWITCH_CPUFREQ - + HOOKID_SWITCH_CPUFREQ, + + /*NFS*/ + GROUP_NFS, + + HOOKID_NFS_FOP_LLSEEK_ENTRY, + HOOKID_NFS_FOP_LLSEEK_RETURN, + + HOOKID_NFS_FOP_READ_ENTRY, + HOOKID_NFS_FOP_READ_RETURN, + + HOOKID_NFS_FOP_WRITE_ENTRY, + HOOKID_NFS_FOP_WRITE_RETURN, + + HOOKID_NFS_FOP_AIOREAD_ENTRY, + HOOKID_NFS_FOP_AIOREAD_RETURN, + + HOOKID_NFS_FOP_AIOWRITE_ENTRY, + HOOKID_NFS_FOP_AIOWRITE_RETURN, + + HOOKID_NFS_FOP_MMAP_ENTRY, + HOOKID_NFS_FOP_MMAP_RETURN, + + HOOKID_NFS_FOP_OPEN_ENTRY, + HOOKID_NFS_FOP_OPEN_RETURN, + + HOOKID_NFS_FOP_FLUSH_ENTRY, + HOOKID_NFS_FOP_FLUSH_RETURN, + + HOOKID_NFS_FOP_RELEASE_ENTRY, + HOOKID_NFS_FOP_RELEASE_RETURN, + + HOOKID_NFS_FOP_FSYNC_ENTRY, + HOOKID_NFS_FOP_FSYNC_RETURN, + + HOOKID_NFS_FOP_LOCK_ENTRY, + HOOKID_NFS_FOP_LOCK_RETURN, + + HOOKID_NFS_FOP_SENDFILE_ENTRY, + HOOKID_NFS_FOP_SENDFILE_RETURN, + + HOOKID_NFS_FOP_CHECKFLAGS_ENTRY, + HOOKID_NFS_FOP_CHECKFLAGS_RETURN, + + HOOKID_NFS_AOP_READPAGE_ENTRY, + HOOKID_NFS_AOP_READPAGE_RETURN, + + HOOKID_NFS_AOP_READPAGES_ENTRY, + HOOKID_NFS_AOP_READPAGES_RETURN, + + HOOKID_NFS_AOP_WRITEPAGES_ENTRY, + HOOKID_NFS_AOP_WRITEPAGES_RETURN, + + HOOKID_NFS_AOP_WRITEPAGE_ENTRY, + HOOKID_NFS_AOP_WRITEPAGE_RETURN, + + HOOKID_NFS_AOP_RELEASEPAGE_ENTRY, + HOOKID_NFS_AOP_RELEASEPAGE_RETURN, + + HOOKID_NFS_AOP_SETPAGEDIRTY_ENTRY, + HOOKID_NFS_AOP_SETPAGEDIRTY_RETURN, + + HOOKID_NFS_AOP_PREPAREWRITE_ENTRY, + HOOKID_NFS_AOP_PREPAREWRITE_RETURN, + + HOOKID_NFS_AOP_COMMITWRITE_ENTRY, + HOOKID_NFS_AOP_COMMITWRITE_RETURN, + + HOOKID_NFS_PROC_LOOKUP_ENTRY, + HOOKID_NFS_PROC_LOOKUP_RETURN, + + HOOKID_NFS_PROC_READ_ENTRY, + HOOKID_NFS_PROC_READ_RETURN, + + HOOKID_NFS_PROC_WRITE_ENTRY, + HOOKID_NFS_PROC_WRITE_RETURN, + + HOOKID_NFS_PROC_COMMIT_ENTRY, + HOOKID_NFS_PROC_COMMIT_RETURN, + + HOOKID_NFS_PROC_READSETUP_ENTRY, + + HOOKID_NFS_PROC_WRITESETUP_ENTRY, + + HOOKID_NFS_PROC_COMMITSETUP_ENTRY, + + HOOKID_NFS_PROC_READDONE_ENTRY, + HOOKID_NFS_PROC_READDONE_RETURN, + + HOOKID_NFS_PROC_WRITEDONE_ENTRY, + HOOKID_NFS_PROC_WRITEDONE_RETURN, + + HOOKID_NFS_PROC_COMMITDONE_ENTRY, + HOOKID_NFS_PROC_COMMITDONE_RETURN, + + HOOKID_NFS_PROC_OPEN_ENTRY, + HOOKID_NFS_PROC_OPEN_RETURN, + + HOOKID_NFS_PROC_RELEASE_ENTRY, + HOOKID_NFS_PROC_RELEASE_RETURN, + + HOOKID_NFS_PROC_CREATE_ENTRY, + HOOKID_NFS_PROC_CREATE_RETURN, + + HOOKID_NFS_PROC_RENAME_ENTRY, + HOOKID_NFS_PROC_RENAME_RETURN, + + HOOKID_NFS_PROC_REMOVE_ENTRY, + HOOKID_NFS_PROC_REMOVE_RETURN, + + /*NFSD*/ + GROUP_NFSD, + + HOOKID_NFSD_DISPATCH_ENTRY, + HOOKID_NFSD_DISPATCH_RETURN, + + HOOKID_NFSD_OPEN_ENTRY, + HOOKID_NFSD_OPEN_RETURN, + + HOOKID_NFSD_READ_ENTRY, + HOOKID_NFSD_READ_RETURN, + + HOOKID_NFSD_WRITE_ENTRY, + HOOKID_NFSD_WRITE_RETURN, + + HOOKID_NFSD_LOOKUP_ENTRY, + HOOKID_NFSD_LOOKUP_RETURN, + + HOOKID_NFSD_COMMIT_ENTRY, + HOOKID_NFSD_COMMIT_RETURN, + + HOOKID_NFSD_CREATE_ENTRY, + HOOKID_NFSD_CREATE_RETURN, + + HOOKID_NFSD_CREATEV3_ENTRY, + HOOKID_NFSD_CREATEV3_RETURN, + + HOOKID_NFSD_UNLINK_ENTRY, + HOOKID_NFSD_UNLINK_RETURN, + + HOOKID_NFSD_RENAME_ENTRY, + HOOKID_NFSD_RENAME_RETURN, + + HOOKID_NFSD_CLOSE_ENTRY, + HOOKID_NFSD_CLOSE_RETURN, + + HOOKID_NFSD_PROC_LOOKUP_ENTRY, + HOOKID_NFSD_PROC_LOOKUP_RETURN, + + HOOKID_NFSD_PROC_READ_ENTRY, + HOOKID_NFSD_PROC_READ_RETURN, + + HOOKID_NFSD_PROC_WRITE_ENTRY, + HOOKID_NFSD_PROC_WRITE_RETURN, + + HOOKID_NFSD_PROC_COMMIT_ENTRY, + HOOKID_NFSD_PROC_COMMIT_RETURN, + + HOOKID_NFSD_PROC_COMPOUND_ENTRY, + HOOKID_NFSD_PROC_COMPOUND_RETURN, + + HOOKID_NFSD_PROC_REMOVE_ENTRY, + HOOKID_NFSD_PROC_REMOVE_RETURN, + + HOOKID_NFSD_PROC_RENAME_ENTRY, + HOOKID_NFSD_PROC_RENAME_RETURN, + + HOOKID_NFSD_PROC_CREATE_ENTRY, + HOOKID_NFSD_PROC_CREATE_RETURN %{ /* used in embedded c codes */ @@ -153,6 +320,8 @@ int _GROUP_IOSYSCALL = 9; int _GROUP_AIO = 10; int _GROUP_SIGNAL = 11; int _GROUP_CPUFREQ = 15; +int _GROUP_NFS = 16; +int _GROUP_NFSD = 17; /* hookIDs defined inside each group */ int _HOOKID_REGSYSEVT = 1; @@ -261,6 +430,117 @@ int _HOOKID_SIGNAL_FLUSH_ENTRY = 15; int _HOOKID_SWITCH_CPUFREQ = 1; +int _HOOKID_NFS_FOP_LLSEEK_ENTRY= 1; +int _HOOKID_NFS_FOP_LLSEEK_RETURN= 2; +int _HOOKID_NFS_FOP_READ_ENTRY= 3; +int _HOOKID_NFS_FOP_READ_RETURN= 4; +int _HOOKID_NFS_FOP_WRITE_ENTRY= 5; +int _HOOKID_NFS_FOP_WRITE_RETURN= 6; +int _HOOKID_NFS_FOP_AIOREAD_ENTRY= 7; +int _HOOKID_NFS_FOP_AIOREAD_RETURN= 8; +int _HOOKID_NFS_FOP_AIOWRITE_ENTRY= 9; +int _HOOKID_NFS_FOP_AIOWRITE_RETURN= 10; +int _HOOKID_NFS_FOP_MMAP_ENTRY= 11; +int _HOOKID_NFS_FOP_MMAP_RETURN= 12; +int _HOOKID_NFS_FOP_OPEN_ENTRY= 13; +int _HOOKID_NFS_FOP_OPEN_RETURN= 14; +int _HOOKID_NFS_FOP_FLUSH_ENTRY= 15; +int _HOOKID_NFS_FOP_FLUSH_RETURN= 16; +int _HOOKID_NFS_FOP_RELEASE_ENTRY= 17; +int _HOOKID_NFS_FOP_RELEASE_RETURN= 18; +int _HOOKID_NFS_FOP_FSYNC_ENTRY= 19; +int _HOOKID_NFS_FOP_FSYNC_RETURN= 20; +int _HOOKID_NFS_FOP_LOCK_ENTRY= 21; +int _HOOKID_NFS_FOP_LOCK_RETURN= 22; +int _HOOKID_NFS_FOP_SENDFILE_ENTRY= 23; +int _HOOKID_NFS_FOP_SENDFILE_RETURN= 24; +int _HOOKID_NFS_FOP_CHECKFLAGS_ENTRY= 25; +int _HOOKID_NFS_FOP_CHECKFLAGS_RETURN= 26; + +int _HOOKID_NFS_AOP_READPAGE_ENTRY= 27; +int _HOOKID_NFS_AOP_READPAGE_RETURN= 28; +int _HOOKID_NFS_AOP_READPAGES_ENTRY= 29; +int _HOOKID_NFS_AOP_READPAGES_RETURN= 30; +int _HOOKID_NFS_AOP_WRITEPAGE_ENTRY= 31; +int _HOOKID_NFS_AOP_WRITEPAGE_RETURN= 32; +int _HOOKID_NFS_AOP_WRITEPAGES_ENTRY= 33; +int _HOOKID_NFS_AOP_WRITEPAGES_RETURN= 34; +int _HOOKID_NFS_AOP_RELEASEPAGE_ENTRY= 35; +int _HOOKID_NFS_AOP_RELEASEPAGE_RETURN= 36; +int _HOOKID_NFS_AOP_SETPAGEDIRTY_ENTRY= 37; +int _HOOKID_NFS_AOP_SETPAGEDIRTY_RETURN= 38; +int _HOOKID_NFS_AOP_PREPAREWRITE_ENTRY= 39; +int _HOOKID_NFS_AOP_PREPAREWRITE_RETURN= 40; +int _HOOKID_NFS_AOP_COMMITWRITE_ENTRY= 41; +int _HOOKID_NFS_AOP_COMMITWRITE_RETURN= 42; + +int _HOOKID_NFS_PROC_LOOKUP_ENTRY = 43; +int _HOOKID_NFS_PROC_LOOKUP_RETURN= 44; +int _HOOKID_NFS_PROC_READ_ENTRY= 45; +int _HOOKID_NFS_PROC_READ_RETURN= 46; +int _HOOKID_NFS_PROC_WRITE_ENTRY= 47; +int _HOOKID_NFS_PROC_WRITE_RETURN= 48; +int _HOOKID_NFS_PROC_COMMIT_ENTRY= 49; +int _HOOKID_NFS_PROC_COMMIT_RETURN= 50; +int _HOOKID_NFS_PROC_READSETUP_ENTRY= 51; +int _HOOKID_NFS_PROC_WRITESETUP_ENTRY= 52; +int _HOOKID_NFS_PROC_COMMITSETUP_ENTRY= 53; +int _HOOKID_NFS_PROC_READDONE_ENTRY= 54; +int _HOOKID_NFS_PROC_READDONE_RETURN= 55; +int _HOOKID_NFS_PROC_WRITEDONE_ENTRY= 56; +int _HOOKID_NFS_PROC_WRITEDONE_RETURN= 57; +int _HOOKID_NFS_PROC_COMMITDONE_ENTRY= 58; +int _HOOKID_NFS_PROC_COMMITDONE_RETURN= 59; +int _HOOKID_NFS_PROC_OPEN_ENTRY= 60; +int _HOOKID_NFS_PROC_OPEN_RETURN= 61; +int _HOOKID_NFS_PROC_RELEASE_ENTRY= 62; +int _HOOKID_NFS_PROC_RELEASE_RETURN= 63; +int _HOOKID_NFS_PROC_CREATE_ENTRY= 64; +int _HOOKID_NFS_PROC_CREATE_RETURN= 65; +int _HOOKID_NFS_PROC_RENAME_ENTRY= 66; +int _HOOKID_NFS_PROC_RENAME_RETURN= 67; +int _HOOKID_NFS_PROC_REMOVE_ENTRY= 68; +int _HOOKID_NFS_PROC_REMOVE_RETURN= 69; + +int _HOOKID_NFSD_DISPATCH_ENTRY= 1; +int _HOOKID_NFSD_DISPATCH_RETURN= 2; +int _HOOKID_NFSD_OPEN_ENTRY= 3; +int _HOOKID_NFSD_OPEN_RETURN= 4; +int _HOOKID_NFSD_READ_ENTRY= 5; +int _HOOKID_NFSD_READ_RETURN= 6; +int _HOOKID_NFSD_WRITE_ENTRY= 7; +int _HOOKID_NFSD_WRITE_RETURN= 8; +int _HOOKID_NFSD_LOOKUP_ENTRY= 9; +int _HOOKID_NFSD_LOOKUP_RETURN= 10; +int _HOOKID_NFSD_COMMIT_ENTRY= 11; +int _HOOKID_NFSD_COMMIT_RETURN= 12; +int _HOOKID_NFSD_CREATE_ENTRY= 13; +int _HOOKID_NFSD_CREATE_RETURN= 14; +int _HOOKID_NFSD_CREATEV3_ENTRY= 15; +int _HOOKID_NFSD_CREATEV3_RETURN= 16; +int _HOOKID_NFSD_UNLINK_ENTRY= 17; +int _HOOKID_NFSD_UNLINK_RETURN= 18; +int _HOOKID_NFSD_RENAME_ENTRY= 19; +int _HOOKID_NFSD_RENAME_RETURN= 20; +int _HOOKID_NFSD_CLOSE_ENTRY= 21; +int _HOOKID_NFSD_CLOSE_RETURN = 22; +int _HOOKID_NFSD_PROC_LOOKUP_ENTRY = 23; +int _HOOKID_NFSD_PROC_LOOKUP_RETURN= 24; +int _HOOKID_NFSD_PROC_READ_ENTRY= 25; +int _HOOKID_NFSD_PROC_READ_RETURN= 26; +int _HOOKID_NFSD_PROC_WRITE_ENTRY= 27; +int _HOOKID_NFSD_PROC_WRITE_RETURN= 28; +int _HOOKID_NFSD_PROC_COMMIT_ENTRY= 29; +int _HOOKID_NFSD_PROC_COMMIT_RETURN= 30; +int _HOOKID_NFSD_PROC_COMPOUND_ENTRY= 31; +int _HOOKID_NFSD_PROC_COMPOUND_RETURN= 32; +int _HOOKID_NFSD_PROC_REMOVE_ENTRY= 33; +int _HOOKID_NFSD_PROC_REMOVE_RETURN= 34; +int _HOOKID_NFSD_PROC_RENAME_ENTRY= 35; +int _HOOKID_NFSD_PROC_RENAME_RETURN= 36; +int _HOOKID_NFSD_PROC_CREATE_ENTRY= 37; +int _HOOKID_NFSD_PROC_CREATE_RETURN= 38; + %} function hookid_init() @@ -391,6 +671,123 @@ function hookid_init() GROUP_CPUFREQ = 15 HOOKID_SWITCH_CPUFREQ = 2 + + GROUP_NFS = 16 + + HOOKID_NFS_FOP_LLSEEK_ENTRY= 1 + HOOKID_NFS_FOP_LLSEEK_RETURN= 2 + HOOKID_NFS_FOP_READ_ENTRY= 3 + HOOKID_NFS_FOP_READ_RETURN= 4 + HOOKID_NFS_FOP_WRITE_ENTRY= 5 + HOOKID_NFS_FOP_WRITE_RETURN= 6 + HOOKID_NFS_FOP_AIOREAD_ENTRY= 7 + HOOKID_NFS_FOP_AIOREAD_RETURN= 8 + HOOKID_NFS_FOP_AIOWRITE_ENTRY= 9 + HOOKID_NFS_FOP_AIOWRITE_RETURN= 10 + HOOKID_NFS_FOP_MMAP_ENTRY= 11 + HOOKID_NFS_FOP_MMAP_RETURN= 12 + HOOKID_NFS_FOP_OPEN_ENTRY= 13 + HOOKID_NFS_FOP_OPEN_RETURN= 14 + HOOKID_NFS_FOP_FLUSH_ENTRY= 15 + HOOKID_NFS_FOP_FLUSH_RETURN= 16 + HOOKID_NFS_FOP_RELEASE_ENTRY= 17 + HOOKID_NFS_FOP_RELEASE_RETURN= 18 + HOOKID_NFS_FOP_FSYNC_ENTRY= 19 + HOOKID_NFS_FOP_FSYNC_RETURN= 20 + HOOKID_NFS_FOP_LOCK_ENTRY= 21 + HOOKID_NFS_FOP_LOCK_RETURN= 22 + HOOKID_NFS_FOP_SENDFILE_ENTRY= 23 + HOOKID_NFS_FOP_SENDFILE_RETURN= 24 + HOOKID_NFS_FOP_CHECKFLAGS_ENTRY= 25 + HOOKID_NFS_FOP_CHECKFLAGS_RETURN= 26 + + HOOKID_NFS_AOP_READPAGE_ENTRY= 27 + HOOKID_NFS_AOP_READPAGE_RETURN= 28 + HOOKID_NFS_AOP_READPAGES_ENTRY= 29 + HOOKID_NFS_AOP_READPAGES_RETURN= 30 + HOOKID_NFS_AOP_WRITEPAGE_ENTRY= 31 + HOOKID_NFS_AOP_WRITEPAGE_RETURN= 32 + HOOKID_NFS_AOP_WRITEPAGES_ENTRY= 33 + HOOKID_NFS_AOP_WRITEPAGES_RETURN= 34 + HOOKID_NFS_AOP_RELEASEPAGE_ENTRY= 35 + HOOKID_NFS_AOP_RELEASEPAGE_RETURN= 36 + HOOKID_NFS_AOP_SETPAGEDIRTY_ENTRY= 37 + HOOKID_NFS_AOP_SETPAGEDIRTY_RETURN= 38 + HOOKID_NFS_AOP_PREPAREWRITE_ENTRY= 39 + HOOKID_NFS_AOP_PREPAREWRITE_RETURN= 40 + HOOKID_NFS_AOP_COMMITWRITE_ENTRY= 41 + HOOKID_NFS_AOP_COMMITWRITE_RETURN= 42 + + HOOKID_NFS_PROC_LOOKUP_ENTRY = 43 + HOOKID_NFS_PROC_LOOKUP_RETURN= 44 + HOOKID_NFS_PROC_READ_ENTRY= 45 + HOOKID_NFS_PROC_READ_RETURN= 46 + HOOKID_NFS_PROC_WRITE_ENTRY= 47 + HOOKID_NFS_PROC_WRITE_RETURN= 48 + HOOKID_NFS_PROC_COMMIT_ENTRY= 49 + HOOKID_NFS_PROC_COMMIT_RETURN= 50 + HOOKID_NFS_PROC_READSETUP_ENTRY= 51 + HOOKID_NFS_PROC_WRITESETUP_ENTRY= 52 + HOOKID_NFS_PROC_COMMITSETUP_ENTRY= 53 + HOOKID_NFS_PROC_READDONE_ENTRY= 54 + HOOKID_NFS_PROC_READDONE_RETURN= 55 + HOOKID_NFS_PROC_WRITEDONE_ENTRY= 56 + HOOKID_NFS_PROC_WRITEDONE_RETURN= 57 + HOOKID_NFS_PROC_COMMITDONE_ENTRY= 58 + HOOKID_NFS_PROC_COMMITDONE_RETURN= 59 + HOOKID_NFS_PROC_OPEN_ENTRY= 60 + HOOKID_NFS_PROC_OPEN_RETURN= 61 + HOOKID_NFS_PROC_RELEASE_ENTRY= 62 + HOOKID_NFS_PROC_RELEASE_RETURN= 63 + HOOKID_NFS_PROC_CREATE_ENTRY= 64 + HOOKID_NFS_PROC_CREATE_RETURN= 65 + HOOKID_NFS_PROC_RENAME_ENTRY= 66 + HOOKID_NFS_PROC_RENAME_RETURN= 67 + HOOKID_NFS_PROC_REMOVE_ENTRY= 68 + HOOKID_NFS_PROC_REMOVE_RETURN= 69 + + GROUP_NFSD = 17 + + HOOKID_NFSD_DISPATCH_ENTRY= 1 + HOOKID_NFSD_DISPATCH_RETURN= 2 + HOOKID_NFSD_OPEN_ENTRY= 3 + HOOKID_NFSD_OPEN_RETURN= 4 + HOOKID_NFSD_READ_ENTRY= 5 + HOOKID_NFSD_READ_RETURN= 6 + HOOKID_NFSD_WRITE_ENTRY= 7 + HOOKID_NFSD_WRITE_RETURN= 8 + HOOKID_NFSD_LOOKUP_ENTRY= 9 + HOOKID_NFSD_LOOKUP_RETURN= 10 + HOOKID_NFSD_COMMIT_ENTRY= 11 + HOOKID_NFSD_COMMIT_RETURN= 12 + HOOKID_NFSD_CREATE_ENTRY= 13 + HOOKID_NFSD_CREATE_RETURN= 14 + HOOKID_NFSD_CREATEV3_ENTRY= 15 + HOOKID_NFSD_CREATEV3_RETURN= 16 + HOOKID_NFSD_UNLINK_ENTRY= 17 + HOOKID_NFSD_UNLINK_RETURN= 18 + HOOKID_NFSD_RENAME_ENTRY= 19 + HOOKID_NFSD_RENAME_RETURN= 20 + HOOKID_NFSD_CLOSE_ENTRY= 21 + HOOKID_NFSD_CLOSE_RETURN = 22 + + HOOKID_NFSD_PROC_LOOKUP_ENTRY = 23 + HOOKID_NFSD_PROC_LOOKUP_RETURN= 24 + HOOKID_NFSD_PROC_READ_ENTRY= 25 + HOOKID_NFSD_PROC_READ_RETURN= 26 + HOOKID_NFSD_PROC_WRITE_ENTRY= 27 + HOOKID_NFSD_PROC_WRITE_RETURN= 28 + HOOKID_NFSD_PROC_COMMIT_ENTRY= 29 + HOOKID_NFSD_PROC_COMMIT_RETURN= 30 + HOOKID_NFSD_PROC_COMPOUND_ENTRY= 31 + HOOKID_NFSD_PROC_COMPOUND_RETURN= 32 + HOOKID_NFSD_PROC_REMOVE_ENTRY= 33 + HOOKID_NFSD_PROC_REMOVE_RETURN= 34 + HOOKID_NFSD_PROC_RENAME_ENTRY= 35 + HOOKID_NFSD_PROC_RENAME_RETURN= 36 + HOOKID_NFSD_PROC_CREATE_ENTRY= 37 + HOOKID_NFSD_PROC_CREATE_RETURN= 38 + } @@ -403,7 +800,6 @@ probe begin write_events_desc() process_snapshot() } - probe end { lket_kill_time() diff --git a/tapset/LKET/iosyscall.stp b/tapset/LKET/iosyscall.stp index 494acbaa..480c51a1 100755 --- a/tapset/LKET/iosyscall.stp +++ b/tapset/LKET/iosyscall.stp @@ -524,11 +524,30 @@ function log_iosyscall_sync(hookid:long) current->thread_info->cpu); #else - _stp_printf("%2b%2n%1b%1b%4b%4b%4b%4b%4b%1b", 0, - _GROUP_IOSYSCALL, THIS->hookid, - tv.tv_sec, tv.tv_usec, current->tgid, - current->parent->pid, current->pid, - current->thread_info->cpu); + + if(timing_method == TIMING_GETCYCLES) { + _stp_printf("%2b%2n%8b%8b", (_FMT_)0, + (_FMT_)get_cycles(), + (_FMT_)((int64_t)current->pid << 32 | + (int32_t)GroupID << 24 | (int32_t)hookID << 16 | + (int16_t)current->thread_info->cpu << 8)); + } + else if(timing_method == TIMING_GETTIMEOFDAY) { + struct timeval tv; + do_gettimeofday (&tv); + _stp_printf("%2b%2n%8b%8b", (_FMT_)0, + (_FMT_)(tv.tv_sec*1000000LL + tv.tv_usec), + (_FMT_)((int64_t)current->pid << 32 | + (int32_t)GroupID << 24 | (int32_t)hookID << 16 | + (int16_t)current->thread_info->cpu << 8)); + } + else { + _stp_printf("%2b%2n%8b%8b", (_FMT_)0, + (_FMT_)pfn_schedclock(), + (_FMT_)((int64_t)current->pid << 32 | + (int32_t)GroupID << 24 | (int32_t)hookID << 16 | + (int16_t)current->thread_info->cpu << 8)); + } #endif %} diff --git a/tapset/LKET/nfs.stp b/tapset/LKET/nfs.stp new file mode 100755 index 00000000..924b2c28 --- /dev/null +++ b/tapset/LKET/nfs.stp @@ -0,0 +1,741 @@ +probe never +{ + printf("%d",GROUP_NFS) +} +probe addevent.nfs + = addevent.nfs.entries, + addevent.nfs.return +{} + +probe addevent.nfs.entries + = addevent.nfs.fop.entries, + addevent.nfs.aop.entries, + addevent.nfs.proc.entries +{} + +probe addevent.nfs.return + = addevent.nfs.fop.return, + addevent.nfs.aop.return, + addevent.nfs.proc.return +{} + +probe addevent.nfs.fop + = addevent.nfs.fop.entries, + addevent.nfs.fop.return +{} + +probe addevent.nfs.fop.entries + = + addevent.nfs.fop.llseek.entry, + addevent.nfs.fop.read.entry, + addevent.nfs.fop.write.entry, + addevent.nfs.fop.aio_read.entry, + addevent.nfs.fop.aio_write.entry, + addevent.nfs.fop.mmap.entry, + addevent.nfs.fop.open.entry, + addevent.nfs.fop.flush.entry, + addevent.nfs.fop.release.entry, + addevent.nfs.fop.fsync.entry, + addevent.nfs.fop.lock.entry, + addevent.nfs.fop.sendfile.entry +{} + +probe addevent.nfs.fop.return + = + addevent.nfs.fop.llseek.return, + addevent.nfs.fop.read.return, + addevent.nfs.fop.write.return, + addevent.nfs.fop.aio_read.return, + addevent.nfs.fop.aio_write.return, + addevent.nfs.fop.mmap.return, + addevent.nfs.fop.open.return, + addevent.nfs.fop.flush.return, + addevent.nfs.fop.release.return, + addevent.nfs.fop.fsync.return, + addevent.nfs.fop.lock.return, + addevent.nfs.fop.sendfile.return +{} + +%{ + void getdevice(char * ,int * ,int *); +%} +function log_nfs_return (hookid:long,ret_val:long) +%{ + _lket_trace(_GROUP_NFS,THIS->hookid,"%4b",THIS->ret_val); +%} + +probe addevent.nfs.fop.llseek.entry + += _addevent.nfs.fop.llseek.entry +{ + update_record() +} + +probe _addevent.nfs.fop.llseek.entry + = nfs.fop.llseek +{ + log_fop_llseek(s_id,fileid,offset,origin) +} + +function log_fop_llseek(s_id:long,ino:long,offset:long,origin:long)%{ /*pure*/ + char * s_id = (char *)THIS->s_id; + int major,minor; + + getdevice(s_id,&major,&minor); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_LLSEEK_ENTRY,"%1b%1b%8b%8b%1b",(_FMT_)major,(_FMT_)minor, + THIS->ino,THIS->offset,THIS->origin); +%} + +probe addevent.nfs.fop.llseek.return + += _addevent.nfs.fop.llseek.return +{ + update_record() +} + +probe _addevent.nfs.fop.llseek.return + = nfs.fop.llseek.return +{ + log_nfs_return(HOOKID_NFS_FOP_LLSEEK_RETURN,$return) +} + +probe addevent.nfs.fop.read.entry + += _addevent.nfs.fop.read.entry +{ + update_record() +} + +probe _addevent.nfs.fop.read.entry + = nfs.fop.read +{ + filesystem = kernel_string($filp->f_dentry->d_inode->i_sb->s_type->name) + + if(filesystem == "nfs") + log_fop_rw(HOOKID_NFS_FOP_READ_ENTRY,s_id,fileid,buf,len,pos) +} + +function log_fop_rw(hookid:long,s_id:long,ino:long,buf:long,len:long,pos:long) %{ /*pure*/ + char * s_id = (char *)THIS->s_id; + int major,minor; + + getdevice(s_id,&major,&minor); + _lket_trace(_GROUP_NFS,THIS->hookid,"%1b%1b%8b%8b%8b%8b",(_FMT_)major,(_FMT_)minor, + THIS->ino,THIS->buf,THIS->len,THIS->pos); +%} + +probe addevent.nfs.fop.read.return + += _addevent.nfs.fop.read.return +{ + update_record() +} + +probe _addevent.nfs.fop.read.return + = nfs.fop.read.return +{ +// log_nfs_return(HOOKID_NFS_FOP_READ_RETURN,$return) +} + +probe addevent.nfs.fop.write.entry + += _addevent.nfs.fop.write.entry +{ + update_record() +} + +probe _addevent.nfs.fop.write.entry + = nfs.fop.write +{ + filesystem = kernel_string($filp->f_dentry->d_inode->i_sb->s_type->name) + + if(filesystem == "nfs") + log_fop_rw(HOOKID_NFS_FOP_WRITE_ENTRY,s_id,fileid,buf,len,pos) +} + +probe addevent.nfs.fop.write.return + += _addevent.nfs.fop.write.return +{ + update_record() +} + +probe _addevent.nfs.fop.write.return + = nfs.fop.write.return +{ +// log_nfs_return(HOOKID_NFS_FOP_WRITE_RETURN,$return) +} + +probe addevent.nfs.fop.aio_read.entry + += _addevent.nfs.fop.aio_read.entry +{ + update_record() +} + +probe _addevent.nfs.fop.aio_read.entry + = nfs.fop.aio_read +{ + log_fop_rw(HOOKID_NFS_FOP_AIOREAD_ENTRY,s_id,fileid,buf,len,pos) +} + +probe addevent.nfs.fop.aio_read.return + += _addevent.nfs.fop.aio_read.return +{ + update_record() +} + +probe _addevent.nfs.fop.aio_read.return + = nfs.fop.aio_read.return +{ + log_nfs_return(HOOKID_NFS_FOP_AIOREAD_RETURN,$return) +} + +probe addevent.nfs.fop.aio_write.entry + += _addevent.nfs.fop.aio_write.entry +{ + update_record() +} + +probe _addevent.nfs.fop.aio_write.entry + = nfs.fop.aio_write +{ + log_fop_rw(HOOKID_NFS_FOP_AIOWRITE,s_id,fileid,buf,len,pos) +} + +probe addevent.nfs.fop.aio_write.return + += _addevent.nfs.fop.aio_write.return +{ + update_record() +} + +probe _addevent.nfs.fop.aio_write.return + = nfs.fop.aio_write.return +{ + log_nfs_return(HOOKID_NFS_FOP_AIOWRITE_RETURN,$return) +} + +probe addevent.nfs.fop.mmap.entry + += _addevent.nfs.fop.mmap.entry +{ + update_record() +} + +probe _addevent.nfs.fop.mmap.entry + = nfs.fop.mmap +{ + log_fop_mmap(s_id,fileid,vm_start,vm_end,vm_flags) +} + +function log_fop_mmap(s_id:long,ino:long,vm_start:long, + vm_end:long,vm_flags:long) +%{/*pure*/ + char * s_id = (char *)THIS->s_id; + int major,minor; + + getdevice(s_id,&major,&minor); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_MMAP_ENTRY,"%1b%1b%8b%8b%8b%4b",(_FMT_)major,(_FMT_)minor, + THIS->ino,THIS->vm_start,THIS->vm_end,THIS->vm_flags); +%} + +probe addevent.nfs.fop.mmap.return + += _addevent.nfs.fop.mmap.return +{ + update_record() +} + +probe _addevent.nfs.fop.mmap.return + = nfs.fop.mmap.return +{ + log_nfs_return(HOOKID_NFS_FOP_MMAP_RETURN,$return) +} + +probe addevent.nfs.fop.open.entry + += _addevent.nfs.fop.open.entry +{ + update_record() +} + +probe _addevent.nfs.fop.open.entry + = nfs.fop.open +{ + log_fop_open(s_id,fileid,flag,filename) +} + +function log_fop_open(s_id:long,ino:long,flag :long , filename:string) +%{/*pure*/ + char * s_id = (char *)THIS->s_id; + int major,minor; + + getdevice(s_id,&major,&minor); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_OPEN_ENTRY,"%1b%1b%8b%4b%0s",(_FMT_)major,(_FMT_)minor, + THIS->ino,THIS->flag,THIS->filename); +%} + +probe addevent.nfs.fop.open.return + += _addevent.nfs.fop.open.return +{ + update_record() +} + +probe _addevent.nfs.fop.open.return + = nfs.fop.open.return +{ + log_nfs_return(HOOKID_NFS_FOP_OPEN_RETURN,$return) +} + +probe addevent.nfs.fop.flush.entry + += _addevent.nfs.fop.flush.entry +{ + update_record() +} + +probe _addevent.nfs.fop.flush.entry + = nfs.fop.flush +{ + log_fop_flush(s_id,fileid,ndirty) +} + +function log_fop_flush(s_id:long,ino:long,ndirty:long) +%{/*pure*/ + char * s_id = (char *)THIS->s_id; + int major,minor; + + getdevice(s_id,&major,&minor); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_FLUSH_ENTRY,"%1b%1b%8b%4b",(_FMT_)major,(_FMT_)minor, + THIS->ino,THIS->ndirty); +%} + +probe addevent.nfs.fop.flush.return + += _addevent.nfs.fop.flush.return +{ + update_record() +} + +probe _addevent.nfs.fop.flush.return + = nfs.fop.flush.return +{ + log_nfs_return(HOOKID_NFS_FOP_FLUSH_RETURN,$return) +} + +probe addevent.nfs.fop.release.entry + += _addevent.nfs.fop.release.entry +{ + update_record() +} + +probe _addevent.nfs.fop.release.entry + = nfs.fop.release +{ + log_fop_release(s_id,fileid,mode) +} + +function log_fop_release(s_id:long,ino:long,mode:long) +%{/*pure*/ + char * s_id = (char *)THIS->s_id; + int major,minor; + + getdevice(s_id,&major,&minor); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_RELEASE_ENTRY,"%1b%1b%8b%2b",(_FMT_)major,(_FMT_)minor, + THIS->ino,THIS->mode); +%} + +probe addevent.nfs.fop.release.return + += _addevent.nfs.fop.release.return +{ + update_record() +} + +probe _addevent.nfs.fop.release.return + = nfs.fop.release.return +{ + log_nfs_return(HOOKID_NFS_FOP_RELEASE_RETURN,$return) +} + +probe addevent.nfs.fop.fsync.entry + += _addevent.nfs.fop.fsync.entry +{ + update_record() +} + +probe _addevent.nfs.fop.fsync.entry + = nfs.fop.fsync +{ + log_fop_fsync(s_id,fileid,ndirty) +} + +function log_fop_fsync(s_id:long,ino:long,ndirty:long) +%{/*pure*/ + char * s_id = (char *)THIS->s_id; + int major,minor; + + getdevice(s_id,&major,&minor); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_FSYNC_ENTRY,"%1b%1b%8b%4b",(_FMT_)major,(_FMT_)minor, + THIS->ino,THIS->ndirty); +%} + +probe addevent.nfs.fop.fsync.return + += _addevent.nfs.fop.fsync.return +{ + update_record() +} + +probe _addevent.nfs.fop.fsync.return + = nfs.fop.fsync.return +{ + log_nfs_return(HOOKID_NFS_FOP_FSYNC_RETURN,$return) +} + +probe addevent.nfs.fop.lock.entry + += _addevent.nfs.fop.lock.entry +{ + update_record() +} + +probe _addevent.nfs.fop.lock.entry + = nfs.fop.lock +{ + log_fop_lock(s_id,fileid,fl_start,fl_end,fl_type,fl_flag,cmd) +} + +function log_fop_lock(s_id:long,ino:long,fl_start:long,fl_end:long,fl_type:long,fl_flag:long,cmd:long) +%{/*pure*/ + char * s_id = (char *)THIS->s_id; + int major,minor; + + getdevice(s_id,&major,&minor); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_LOCK_ENTRY,"%1b%1b%8b%8b%8b%1b%1b%4b",(_FMT_)major,(_FMT_)minor, + THIS->ino,THIS->fl_start,THIS->fl_end, + THIS->fl_type,THIS->fl_flag,THIS->cmd); +%} + +probe addevent.nfs.fop.lock.return + += _addevent.nfs.fop.lock.return +{ + update_record() +} + +probe _addevent.nfs.fop.lock.return + = nfs.fop.lock.return +{ + log_nfs_return(HOOKID_NFS_FOP_LOCK_RETURN,$return) +} + +probe addevent.nfs.fop.sendfile.entry + += _addevent.nfs.fop.sendfile.entry +{ + update_record() +} + +probe _addevent.nfs.fop.sendfile.entry + = nfs.fop.sendfile +{ + log_fop_sendfile(s_id,fileid,count,ppos) +} + +function log_fop_sendfile(s_id:long,ino:long,count:long,ppos:long) +%{/*pure*/ + char * s_id = (char *)THIS->s_id; + int major,minor; + + getdevice(s_id,&major,&minor); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_SENDFILE_ENTRY,"%1b%1b%8b%8b%8b",(_FMT_)major,(_FMT_)minor, + THIS->ino,THIS->count,THIS->ppos); +%} + +probe addevent.nfs.fop.sendfile.return + += _addevent.nfs.fop.sendfile.return +{ + update_record() +} + +probe _addevent.nfs.fop.sendfile.return + = nfs.fop.sendfile.return +{ + log_nfs_return(HOOKID_NFS_FOP_SENDFILE_RETURN,$return) +} + +probe addevent.nfs.fop.check_flags.entry + += _addevent.nfs.fop.check_flags.entry +{ + update_record() +} + +probe _addevent.nfs.fop.check_flags.entry + = nfs.fop.check_flags +{ + log_fop_check_flags(flag) +} + +function log_fop_check_flags(flag:long) +%{/*pure*/ + _lket_trace(_GROUP_NFS,_HOOKID_NFS_FOP_CHECKFLAGS_ENTRY,"%4b",THIS->flag); +%} + +probe addevent.nfs.fop.check_flags.return + += _addevent.nfs.fop.check_flags.return +{ + update_record() +} + +probe _addevent.nfs.fop.check_flags.return + = nfs.fop.check_flags.return +{ + log_nfs_return(HOOKID_NFS_FOP_CHECKFLAGS_RETURN,$return) +} + + +probe addevent.nfs.aop + = addevent.nfs.aop.entry, + addevent.nfs.aop.return +{} + +probe addevent.nfs.aop.entries + = + addevent.nfs.aop.readpage.entry, + addevent.nfs.aop.readpages.entry, + addevent.nfs.aop.writepage.entry, + addevent.nfs.aop.writepages.entry, + addevent.nfs.aop.release_page.entry, + addevent.nfs.aop.set_page_dirty.entry, + addevent.nfs.aop.prepare_write.entry, + addevent.nfs.aop.commit_write.entry +{} + +probe addevent.nfs.aop.return + = + addevent.nfs.aop.readpage.return, + addevent.nfs.aop.readpages.return, + addevent.nfs.aop.writepage.return, + addevent.nfs.aop.writepages.return, + addevent.nfs.aop.release_page.return, + addevent.nfs.aop.set_page_dirty.return, + addevent.nfs.aop.prepare_write.return, + addevent.nfs.aop.commit_write.return +{} + +probe addevent.nfs.aop.readpages.entry + += _addevent.nfs.aop.readpages.entry +{ + update_record() +} + +probe _addevent.nfs.aop.readpages.entry + = nfs.aop.readpages +{ + log_aop_readpages(fileid,rpages,nr_pages) +} + +function log_aop_readpages(ino:long,rpages:long,nr_pages:long) +%{/*pure*/ + _lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_READPAGES_ENTRY,"%8b%4b%4b",THIS->ino,THIS->rpages,THIS->nr_pages); +%} + +probe addevent.nfs.aop.readpages.return + += _addevent.nfs.aop.readpages.return +{ + update_record() +} + +probe _addevent.nfs.aop.readpages.return + = nfs.aop.readpages.return +{ + log_nfs_return(HOOKID_NFS_AOP_READPAGES_RETURN,$return) +} + +probe addevent.nfs.aop.readpage.entry + += _addevent.nfs.aop.readpage.entry +{ + update_record() +} + +probe _addevent.nfs.aop.readpage.entry + = nfs.aop.readpage +{ + log_aop_readpage(fileid,rsize,__page,page_index) +} + +function log_aop_readpage(ino:long,rsize:long,__page:long,page_index:long) +%{/*pure*/ + _lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_READPAGE_ENTRY,"%8b%4b%8b%8b",THIS->ino,THIS->rsize,THIS->__page,THIS->page_index); +%} + +probe addevent.nfs.aop.readpage.return + += _addevent.nfs.aop.readpage.return +{ + update_record() +} + +probe _addevent.nfs.aop.readpage.return + = nfs.aop.readpage.return +{ + log_nfs_return(HOOKID_NFS_AOP_READPAGE_RETURN,$return) +} + +probe addevent.nfs.aop.writepage.entry + += _addevent.nfs.aop.writepage.entry +{ + update_record() +} + +probe _addevent.nfs.aop.writepage.entry + = nfs.aop.writepage +{ + log_aop_writepage(fileid,wsize,__page,page_index) +} + +function log_aop_writepage(ino:long,wsize:long,__page:long,page_index:long) +%{/*pure*/ + _lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_WRITEPAGE_ENTRY,"%8b%4b%8b%8b",THIS->ino,THIS->wsize,THIS->__page,THIS->page_index); +%} + +probe addevent.nfs.aop.writepage.return + += _addevent.nfs.aop.writepage.return +{ + update_record() +} + +probe _addevent.nfs.aop.writepage.return + = nfs.aop.writepage.return +{ + log_nfs_return(HOOKID_NFS_AOP_WRITEPAGE_RETURN,$return) +} + +probe addevent.nfs.aop.writepages.entry + += _addevent.nfs.aop.writepages.entry +{ + update_record() +} + +probe _addevent.nfs.aop.writepages.entry + = nfs.aop.writepages +{ + log_aop_writepages(fileid,wpages,nr_to_write) +} + +function log_aop_writepages(ino:long,wpages:long,nr_to_write:long) +%{/*pure*/ + _lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_WRITEPAGES_ENTRY,"%8b%4b%8b",THIS->ino,THIS->wpages,THIS->nr_to_write); +%} + +probe addevent.nfs.aop.writepages.return + += _addevent.nfs.aop.writepages.return +{ + update_record() +} + +probe _addevent.nfs.aop.writepages.return + = nfs.aop.writepages.return +{ + log_nfs_return(HOOKID_NFS_AOP_WRITEPAGES_RETURN,$return) +} + +probe addevent.nfs.aop.prepare_write.entry + += _addevent.nfs.aop.prepare_write.entry +{ + update_record() +} + +probe _addevent.nfs.aop.prepare_write.entry + = nfs.aop.prepare_write +{ + log_aop_prepare_write(fileid,__page,page_index) +} + +function log_aop_prepare_write(ino:long,__page:long,page_index:long) +%{/*pure*/ + _lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_PREPAREWRITE_ENTRY,"%8b%8b%8b",THIS->ino,THIS->__page,THIS->page_index); +%} + +probe addevent.nfs.aop.prepare_write.return + += _addevent.nfs.aop.prepare_write.return +{ + update_record() +} + +probe _addevent.nfs.aop.prepare_write.return + = nfs.aop.prepare_write.return +{ + log_nfs_return(HOOKID_NFS_AOP_PREPAREWRITE_RETURN,$return) +} + +probe addevent.nfs.aop.commit_write.entry + += _addevent.nfs.aop.commit_write.entry +{ + update_record() +} + +probe _addevent.nfs.aop.commit_write.entry + = nfs.aop.commit_write +{ + log_aop_commit_write(fileid,__page,page_index,offset,count) +} + +function log_aop_commit_write(ino:long,__page:long,page_index:long,offset:long,count:long) +%{/*pure*/ + _lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_COMMITWRITE_ENTRY,"%8b%8b%8b%4b%4b",THIS->ino,THIS->__page, + THIS->page_index,THIS->offset,THIS->count); +%} + +probe addevent.nfs.aop.commit_write.return + += _addevent.nfs.aop.commit_write.return +{ + update_record() +} + +probe _addevent.nfs.aop.commit_write.return + = nfs.aop.commit_write.return +{ + log_nfs_return(HOOKID_NFS_AOP_COMMITWRITE_RETURN,$return) +} + +probe addevent.nfs.aop.set_page_dirty.entry + += _addevent.nfs.aop.set_page_dirty.entry +{ + update_record() +} + +probe _addevent.nfs.aop.set_page_dirty.entry + = nfs.aop.set_page_dirty +{ +// log_aop_set_page_dirty(__page,page_flag) +} + +function log_aop_set_page_dirty(__page:long,page_flag:long) +%{/*pure*/ + _lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_SETPAGEDIRTY_ENTRY,"%8b%1b",THIS->__page,THIS->page_flag); +%} + +probe addevent.nfs.aop.set_page_dirty.return + += _addevent.nfs.aop.set_page_dirty.return +{ + update_record() +} + +probe _addevent.nfs.aop.set_page_dirty.return + = nfs.aop.set_page_dirty.return +{ + //log_nfs_return(HOOKID_NFS_AOP_SETPAGEDIRTY_RETURN,$return) +} + +probe addevent.nfs.aop.release_page.entry + += _addevent.nfs.aop.release_page.entry +{ + update_record() +} + +probe _addevent.nfs.aop.release_page.entry + = nfs.aop.release_page +{ + log_aop_release_page(__page,page_index) +} + +function log_aop_release_page(__page:long,page_index:long) +%{/*pure*/ + _lket_trace(_GROUP_NFS,_HOOKID_NFS_AOP_RELEASEPAGE_ENTRY,"%8b%8b",THIS->__page,THIS->page_index); +%} + +probe addevent.nfs.aop.release_page.return + += _addevent.nfs.aop.release_page.return +{ + update_record() +} + +probe _addevent.nfs.aop.release_page.return + = nfs.aop.release_page.return +{ + log_nfs_return(HOOKID_NFS_AOP_RELEASEPAGE_RETURN,$return) +} diff --git a/tapset/LKET/nfs_proc.stp b/tapset/LKET/nfs_proc.stp new file mode 100755 index 00000000..82623bc5 --- /dev/null +++ b/tapset/LKET/nfs_proc.stp @@ -0,0 +1,611 @@ +// nfs trace hooks +// Copyright (C) 2006 IBM Corp. +// +// This file is part of systemtap, and is free software. You can +// redistribute it and/or modify it under the terms of the GNU General +// Public License (GPL); either version 2, or (at your option) any +// later version. +%{ + #include <linux/nfs_fs.h> +%} +%{ + void getdevice(char *sid,int * major,int* min) + { + char c; + char * minor, *p; + int i = 0; + + c = ':'; + minor = strchr(sid,c); + minor++; + + p = sid; + c = *p; + p++; + while(c != ':') + { + if(c > '0' || c < '9') + i = i << 4 | (c - 48); + else if (c > 'a' || c < 'f') + i = i<< 4 | (c-87); + c = *p; + p++; + } + *major = i; + + p = minor; + c = *minor; + p++; + while(c != 0) + { + if(c > '0' || c < '9') + i = i << 4 | (c - 48); + else if (c > 'a' || c < 'f') + i = i<< 4 | (c-87); + c = *p; + p++; + } + *min = i; + } +%} + +probe never +{ + printf("%d",GROUP_NFS) +} +probe addevent.nfs.proc + = addevent.nfs.proc.entries, + addevent.nfs.proc.return +{} + +probe addevent.nfs.proc.entries + = addevent.nfs.proc.lookup.entry, + addevent.nfs.proc.read.entry, + addevent.nfs.proc.write.entry, + addevent.nfs.proc.commit.entry, + addevent.nfs.proc.read_setup.entry, + addevent.nfs.proc.write_setup.entry, + addevent.nfs.proc.commit_setup.entry, + addevent.nfs.proc.read_done.entry, + addevent.nfs.proc.write_done.entry, + addevent.nfs.proc.commit_done.entry, + addevent.nfs.proc.open.entry, + addevent.nfs.proc.release.entry, + addevent.nfs.proc.create.entry, + addevent.nfs.proc.rename.entry, + addevent.nfs.proc.remove.entry +{} + +probe addevent.nfs.proc.return + = addevent.nfs.proc.lookup.return, + addevent.nfs.proc.read.return, + addevent.nfs.proc.write.return, + addevent.nfs.proc.commit.return, + addevent.nfs.proc.read_done.return, + addevent.nfs.proc.write_done.return, + addevent.nfs.proc.commit_done.return, + addevent.nfs.proc.open.return, + addevent.nfs.proc.release.return, + addevent.nfs.proc.create.return, + addevent.nfs.proc.rename.return, + addevent.nfs.proc.remove.return +{} + +probe addevent.nfs.proc.lookup.entry + += _addevent.nfs.proc.lookup.entry +{ + update_record() +} + +probe _addevent.nfs.proc.lookup.entry + = nfs.proc.lookup +{ + log_proc_lookup(version,$dir,filename) +} + +function log_proc_lookup(version:long,dir:long,filename:string) +%{ + struct inode * dir = (struct inode * )THIS->dir; + struct super_block * sb = dir->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_LOOKUP_ENTRY,"%1b%1b%8b%1b%0s",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(dir),THIS->version,THIS->filename); +%} + +probe addevent.nfs.proc.lookup.return + += _addevent.nfs.proc.lookup.return +{ + update_record() +} + +probe _addevent.nfs.proc.lookup.return + = nfs.proc.lookup.return +{ + log_nfs_return(HOOKID_NFS_PROC_LOOKUP_RETURN,$return) +} + +probe addevent.nfs.proc.read.entry + += _addevent.nfs.proc.read.entry +{ + update_record() +} + +probe _addevent.nfs.proc.read.entry + = nfs.proc.read +{ + log_proc_read(version,$rdata,count,offset) +} + +function log_proc_read(version:long,rdata:long,count:long,offset:long) +%{ + struct nfs_read_data* rdata = (struct nfs_read_data* )THIS->rdata; + struct inode *inode = rdata->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_READ_ENTRY,"%1b%1b%8b%1b%4b%8b",major_device,minor_device, + NFS_FILEID(inode),THIS->version,THIS->count,THIS->offset); +%} + +probe addevent.nfs.proc.read.return + += _addevent.nfs.proc.read.return +{ + update_record() +} + +probe _addevent.nfs.proc.read.return + = nfs.proc.read.return +{ + log_nfs_return(HOOKID_NFS_PROC_READ_RETURN,$return) +} + +probe addevent.nfs.proc.write.entry + += _addevent.nfs.proc.write.entry +{ + update_record() +} + +probe _addevent.nfs.proc.write.entry + = nfs.proc.write +{ + log_proc_write(version,$wdata,count,offset) +} + +function log_proc_write(version:long,wdata:long,count:long,offset:long) +%{ + struct nfs_write_data* wdata = (struct nfs_write_data* )THIS->wdata; + struct inode *inode = wdata->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_WRITE_ENTRY,"%1b%1b%8b%1b%4b%8b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->count,THIS->offset); +%} + +probe addevent.nfs.proc.write.return + += _addevent.nfs.proc.write.return +{ + update_record() +} + +probe _addevent.nfs.proc.write.return + = nfs.proc.write.return +{ + log_nfs_return(HOOKID_NFS_PROC_WRITE_RETURN,$return) +} + +probe addevent.nfs.proc.commit.entry + += _addevent.nfs.proc.commit.entry +{ + update_record() +} + +probe _addevent.nfs.proc.commit.entry + = nfs.proc.commit +{ + log_proc_commit(version,$cdata,count,offset) +} + +function log_proc_commit(version:long,cdata:long,count:long,offset:long) +%{ + struct nfs_write_data* cdata = (struct nfs_write_data* )THIS->cdata; + struct inode *inode = cdata->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_COMMIT_ENTRY,"%1b%1b%8b%1b%4b%8b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->count,THIS->offset); +%} + +probe addevent.nfs.proc.commit.return + += _addevent.nfs.proc.commit.return +{ + update_record() +} + +probe _addevent.nfs.proc.commit.return + = nfs.proc.commit.return +{ + log_nfs_return(HOOKID_NFS_PROC_COMMIT_RETURN,$return) +} + +probe addevent.nfs.proc.read_setup.entry + += _addevent.nfs.proc.read_setup.entry +{ + update_record() +} + +probe _addevent.nfs.proc.read_setup.entry + = nfs.proc.read_setup +{ + log_proc_read_setup(version,$data,count,offset) +} + +function log_proc_read_setup(version:long,data:long,count:long,offset:long) +%{ + struct nfs_read_data* data = (struct nfs_read_data* )THIS->data; + struct inode *inode = data->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_READSETUP_ENTRY,"%1b%1b%8b%1b%4b%8b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->count,THIS->offset); +%} + +probe addevent.nfs.proc.write_setup.entry + += _addevent.nfs.proc.write_setup.entry +{ + update_record() +} + +probe _addevent.nfs.proc.write_setup.entry + = nfs.proc.write_setup +{ + log_proc_write_setup(version,$data,count,offset,how) +} + +function log_proc_write_setup(version:long,data:long,count:long,offset:long,how:long) +%{ + struct nfs_write_data* data = (struct nfs_write_data* )THIS->data; + struct inode *inode = data->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_WRITESETUP_ENTRY,"%1b%1b%8b%1b%1b%4b%8b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->how,THIS->count,THIS->offset); +%} + + +probe addevent.nfs.proc.commit_setup.entry + += _addevent.nfs.proc.commit_setup.entry +{ + update_record() +} + +probe _addevent.nfs.proc.commit_setup.entry + = nfs.proc.commit_setup +{ + log_proc_commit_setup(version,$data,count,offset) +} + +function log_proc_commit_setup(version:long,data:long,count:long,offset:long) +%{ + struct nfs_write_data* data = (struct nfs_write_data* )THIS->data; + struct inode *inode = data->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_COMMITSETUP_ENTRY,"%1b%1b%8b%1b%4b%8b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->count,THIS->offset); +%} + + +probe addevent.nfs.proc.read_done.entry + += _addevent.nfs.proc.read_done.entry +{ + update_record() +} + +probe _addevent.nfs.proc.read_done.entry + = nfs.proc.read_done +{ + log_proc_read_done(version,$data,count,status) +} + +function log_proc_read_done(version:long,data:long,count:long,status:long) +%{ + struct nfs_read_data* data = (struct nfs_read_data* )THIS->data; + struct inode *inode = data->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_READDONE_ENTRY,"%1b%1b%8b%1b%4b%4b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->status,THIS->count); +%} + +probe addevent.nfs.proc.read_done.return + += _addevent.nfs.proc.read_done.return +{ + update_record() +} + +probe _addevent.nfs.proc.read_done.return + = nfs.proc.read_done.return +{ + log_nfs_return(HOOKID_NFS_PROC_READDONE_RETURN,$return) +} + +probe addevent.nfs.proc.write_done.entry + += _addevent.nfs.proc.write_done.entry +{ + update_record() +} + +probe _addevent.nfs.proc.write_done.entry + = nfs.proc.write_done +{ + log_proc_write_done(version,$data,count,status) +} + +function log_proc_write_done(version:long,data:long,count:long,status:long) +%{ + struct nfs_write_data* data = (struct nfs_write_data* )THIS->data; + struct inode *inode = data->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_WRITEDONE_ENTRY,"%1b%1b%8b%1b%4b%4b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->status,THIS->count); +%} + +probe addevent.nfs.proc.write_done.return + += _addevent.nfs.proc.write_done.return +{ + update_record() +} + +probe _addevent.nfs.proc.write_done.return + = nfs.proc.write_done.return +{ + log_nfs_return(HOOKID_NFS_PROC_WRITEDONE_RETURN,$return) +} + +probe addevent.nfs.proc.commit_done.entry + += _addevent.nfs.proc.commit_done.entry +{ + update_record() +} + +probe _addevent.nfs.proc.commit_done.entry + = nfs.proc.commit_done +{ + log_proc_commit_done(version,$data,count,status) +} + +function log_proc_commit_done(version:long,data:long,count:long,status:long) +%{ + struct nfs_write_data* data = (struct nfs_write_data* )THIS->data; + struct inode *inode = data->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_COMMITDONE_ENTRY,"%1b%1b%8b%1b%4b%4b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->status,THIS->count); +%} + +probe addevent.nfs.proc.commit_done.return + += _addevent.nfs.proc.commit_done.return +{ + update_record() +} + +probe _addevent.nfs.proc.commit_done.return + = nfs.proc.commit_done.return +{ + log_nfs_return(HOOKID_NFS_PROC_COMMITDONE_RETURN,$return) +} + +probe addevent.nfs.proc.open.entry + += _addevent.nfs.proc.open.entry +{ + update_record() +} + +probe _addevent.nfs.proc.open.entry + = nfs.proc.open +{ + log_proc_open(version,$inode,filename,flag,mode) +} + +function log_proc_open(version:long,inode:long, + filename:string,flag:long,mode:long) +%{ + struct inode *inode = (struct inode *)THIS->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_OPEN_ENTRY,"%1b%1b%8b%1b%0s%4b%4b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->filename,THIS->flag,THIS->mode); +%} + +probe addevent.nfs.proc.open.return + += _addevent.nfs.proc.open.return +{ + update_record() +} + +probe _addevent.nfs.proc.open.return + = nfs.proc.open.return +{ + log_nfs_return(HOOKID_NFS_PROC_OPEN_RETURN,$return) +} + +probe addevent.nfs.proc.release.entry + += _addevent.nfs.proc.release.entry +{ + update_record() +} + +probe _addevent.nfs.proc.release.entry + = nfs.proc.release +{ + log_proc_release(version,$inode,filename,flag,mode) +} + +function log_proc_release(version:long,inode:long, + filename:string,flag:long,mode:long) +%{ + struct inode *inode = (struct inode *)THIS->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_RELEASE_ENTRY,"%1b%1b%8b%1b%0s%4b%4b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->filename,THIS->flag,THIS->mode); +%} + +probe addevent.nfs.proc.release.return + += _addevent.nfs.proc.release.return +{ + update_record() +} + +probe _addevent.nfs.proc.release.return + = nfs.proc.release.return +{ + log_nfs_return(HOOKID_NFS_PROC_RELEASE_RETURN,$return) +} + +probe addevent.nfs.proc.create.entry + += _addevent.nfs.proc.create.entry +{ + update_record() +} + +probe _addevent.nfs.proc.create.entry + = nfs.proc.create +{ + log_proc_create(version,$dir,filename,mode) +} + +function log_proc_create(version:long,inode:long,filename:string,mode:long) +%{ + struct inode *inode = (struct inode *)THIS->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_CREATE_ENTRY,"%1b%1b%8b%1b%0s%4b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->filename,THIS->mode); +%} + +probe addevent.nfs.proc.create.return + += _addevent.nfs.proc.create.return +{ + update_record() +} + +probe _addevent.nfs.proc.create.return + = nfs.proc.create.return +{ + log_nfs_return(HOOKID_NFS_PROC_CREATE_RETURN,$return) +} + +probe addevent.nfs.proc.remove.entry + += _addevent.nfs.proc.remove.entry +{ + update_record() +} + +probe _addevent.nfs.proc.remove.entry + = nfs.proc.remove +{ + log_proc_remove(version,$dir,filename) +} + +function log_proc_remove(version:long,inode:long, + filename:string) +%{ + struct inode *inode = (struct inode *)THIS->inode; + struct super_block * sb = inode->i_sb; + int major_device,minor_device; + + getdevice(sb->s_id,&major_device,&minor_device); + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_REMOVE_ENTRY,"%1b%1b%8b%1b%0s%4b",(_FMT_)major_device,(_FMT_)minor_device, + NFS_FILEID(inode),THIS->version,THIS->filename); +%} + +probe addevent.nfs.proc.remove.return + += _addevent.nfs.proc.remove.return +{ + update_record() +} + +probe _addevent.nfs.proc.remove.return + = nfs.proc.remove.return +{ + log_nfs_return(HOOKID_NFS_PROC_REMOVE_RETURN,$return) +} + +probe addevent.nfs.proc.rename.entry + += _addevent.nfs.proc.rename.entry +{ + update_record() +} + +probe _addevent.nfs.proc.rename.entry + = nfs.proc.rename +{ + log_proc_rename(version,$old_dir,old_name,$new_dir,new_name) +} + +function log_proc_rename(version:long,old_dir:long,old_name:string, + new_dir:long,new_name:string) +%{ + struct inode *old_dir= (struct inode *)THIS->old_dir; + struct inode *new_dir= (struct inode *)THIS->new_dir; + struct super_block * old_sb = old_dir->i_sb; + struct super_block * new_sb = new_dir->i_sb; + int major_old,minor_old,major_new,minor_new; + + getdevice(old_sb->s_id,&major_old,&minor_old); + getdevice(new_sb->s_id,&major_new,&minor_new); + + _lket_trace(_GROUP_NFS,_HOOKID_NFS_PROC_RENAME_ENTRY,"%1b%1b%1b%8b%0s%1b%1b%8b%0s",THIS->version, + (_FMT_)major_old,(_FMT_)minor_old,NFS_FILEID(old_dir),THIS->old_name, + (_FMT_)major_new,(_FMT_)minor_new,NFS_FILEID(new_dir),THIS->new_name); +%} + +probe addevent.nfs.proc.rename.return + += _addevent.nfs.proc.rename.return +{ + update_record() +} + +probe _addevent.nfs.proc.rename.return + = nfs.proc.rename.return +{ + log_nfs_return(HOOKID_NFS_PROC_RENAME_RETURN,$return) +} + diff --git a/tapset/LKET/nfsd.stp b/tapset/LKET/nfsd.stp new file mode 100755 index 00000000..5154b95a --- /dev/null +++ b/tapset/LKET/nfsd.stp @@ -0,0 +1,755 @@ +%{ + #include <linux/sunrpc/svc.h> + #include <linux/nfsd/nfsfh.h> +%} +%{ + void decode_fh(struct knfsd_fh *fh,__u64 * i_ino) + { + int i; + + for(i = 0;i < 3;i++) + { + i_ino[i] = fh->fh_base.fh_pad[2*i]; + i_ino[i] = i_ino[i] << 32 |fh->fh_base.fh_pad[2*i + 1 ]; + } + } +%} +probe never +{ + printf("%d",GROUP_NFSD) +} + +probe addevent.nfsd + = addevent.nfsd.entries, + addevent.nfsd.return +{} + +probe addevent.nfsd.entries + = addevent.nfsd.op.entries, + addevent.nfsd.proc.entries +{} +probe addevent.nfsd.return + = addevent.nfsd.op.return, + addevent.nfsd.proc.return +{} +probe addevent.nfsd.op + = addevent.nfsd.op.entries, + addevent.nfsd.op.return +{} + +probe addevent.nfsd.op.entries = + addevent.nfsd.dispatch.entry, + addevent.nfsd.open.entry, + addevent.nfsd.read.entry, + addevent.nfsd.write.entry, + addevent.nfsd.lookup.entry, + addevent.nfsd.commit.entry, + addevent.nfsd.create.entry, + addevent.nfsd.createv3.entry, + addevent.nfsd.unlink.entry, + addevent.nfsd.rename.entry, + addevent.nfsd.close.entry +{} + +probe addevent.nfsd.op.return = + addevent.nfsd.dispatch.return, + addevent.nfsd.open.return, + addevent.nfsd.read.return, + addevent.nfsd.write.return, + addevent.nfsd.lookup.return, + addevent.nfsd.commit.return, + addevent.nfsd.create.return, + addevent.nfsd.createv3.return, + addevent.nfsd.unlink.return, + addevent.nfsd.rename.return, + addevent.nfsd.close.return +{} + +probe addevent.nfsd.dispatch.entry + += _addevent.nfsd.dispatch.entry +{ + update_record() +} + +probe _addevent.nfsd.dispatch.entry + = nfsd.dispatch +{ + log_nfsd_dispatch(client_ip,proto,version,xid,prog,proc) +} + +function log_nfsd_dispatch(client_ip:long,proto:long,version:long,xid:long, + prog:long,proc:long) +%{ + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_DISPATCH_ENTRY,"%1b%1b%4b%4b%4b", + THIS->proto,THIS->version,THIS->xid,THIS->proc,THIS->client_ip); +%} + +probe addevent.nfsd.dispatch.return + += _addevent.nfs.dispatch.return +{ + update_record() +} + +probe _addevent.nfs.dispatch.return + = nfsd.dispatch.return +{ + log_nfs_return(HOOKID_NFSD_DISPATCH_RETURN,$return) +} + +probe addevent.nfsd.lookup.entry + += _addevent.nfsd.lookup.entry +{ + update_record() +} + +probe _addevent.nfsd.lookup.entry + = nfsd.lookup +{ + log_nfsd_lookup($fhp,filename) +} + +function log_nfsd_lookup(fhp:long,filename:string)%{ /*pure*/ + + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_LOOKUP_ENTRY,"%1b%8b%8b%8b%0s", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->filename); +%} + +probe addevent.nfsd.lookup.return + += _addevent.nfsd.lookup.return +{ + update_record() +} + +probe _addevent.nfsd.lookup.return + = nfsd.lookup.return +{ + log_nfs_return(HOOKID_NFSD_LOOKUP_RETURN,$return) +} + +probe addevent.nfsd.create.entry + += _addevent.nfsd.create.entry +{ + update_record() +} + +probe _addevent.nfsd.create.entry + = nfsd.create +{ + log_nfsd_create($fhp,filename,type,iap_valid,iap_mode) +} + +function log_nfsd_create(fhp:long,filename:string,type:long, + iap_valid:long,iap_mode:long)%{ /*pure*/ + + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_CREATE_ENTRY,"%1b%8b%8b%8b%0s%4b%2b%4b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->filename, + THIS->type,THIS->iap_valid,THIS->iap_mode); +%} + +probe addevent.nfsd.create.return + += _addevent.nfsd.create.return +{ + update_record() +} + +probe _addevent.nfsd.create.return + = nfsd.create.return +{ + log_nfs_return(HOOKID_NFSD_CREATE_RETURN,$return) +} + + +probe addevent.nfsd.createv3.entry + += _addevent.nfsd.createv3.entry +{ + update_record() +} + +probe _addevent.nfsd.createv3.entry + = nfsd.createv3 +{ + log_nfsd_createv3($fhp,filename,createmode,iap_valid,iap_mode) +} + +function log_nfsd_createv3(fhp:long,filename:string,createmode:long, + iap_valid:long,iap_mode:long)%{ /*pure*/ + + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_CREATEV3_ENTRY,"%1b%8b%8b%8b%0s%1b%2b%4b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->filename, + THIS->createmode,THIS->iap_valid,THIS->iap_mode); +%} + +probe addevent.nfsd.createv3.return + += _addevent.nfsd.createv3.return +{ + update_record() +} + +probe _addevent.nfsd.createv3.return + = nfsd.createv3.return +{ + log_nfs_return(HOOKID_NFSD_CREATEV3_RETURN,$return) +} + +probe addevent.nfsd.unlink.entry + += _addevent.nfsd.unlink.entry +{ + update_record() +} + +probe _addevent.nfsd.unlink.entry + = nfsd.unlink +{ + log_nfsd_unlink($fhp,filename,type) +} + +function log_nfsd_unlink(fhp:long,filename:string,type:long)%{ /*pure*/ + + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_UNLINK_ENTRY,"%1b%8b%8b%8b%0s%4b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->filename,THIS->type); +%} + +probe addevent.nfsd.unlink.return + += _addevent.nfsd.unlink.return +{ + update_record() +} + +probe _addevent.nfsd.unlink.return + = nfsd.unlink.return +{ + log_nfs_return(HOOKID_NFSD_UNLINK_RETURN,$return) +} + +probe addevent.nfsd.rename.entry + += _addevent.nfsd.rename.entry +{ + update_record() +} + +probe _addevent.nfsd.rename.entry + = nfsd.rename +{ + log_nfsd_rename($ffhp,filename,$tfhp,tname) +} + +function log_nfsd_rename(fhp:long,filename:string,tfhp:long,tname:string)%{ /*pure*/ + + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + struct svc_fh * tfhp = (struct svc_fh*)(THIS->tfhp); + __u64 old_ino[3],i_ino[3]; + + decode_fh(&fhp->fh_handle,old_ino); + decode_fh(&tfhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_RENAME_ENTRY,"%1b%8b%8b%8b%0s%1b%8b%8b%8b%0s", + (_FMT_)fhp->fh_handle.fh_size,old_ino[0],old_ino[1],old_ino[2],THIS->filename, + (_FMT_)tfhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->tname); +%} + +probe addevent.nfsd.rename.return + += _addevent.nfsd.rename.return +{ + update_record() +} + +probe _addevent.nfsd.rename.return + = nfsd.rename.return +{ + log_nfs_return(HOOKID_NFSD_RENAME_RETURN,$return) +} + +probe addevent.nfsd.open.entry + += _addevent.nfsd.open.entry +{ + update_record() +} + +probe _addevent.nfsd.open.entry + = nfsd.open +{ + log_nfsd_open($fhp,type,access) +} + +function log_nfsd_open(fhp:long,type:long,access:long)%{ /*pure*/ + + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_OPEN_ENTRY,"%1b%8b%8b%8b%4b%1b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->type,THIS->access); +%} + +probe addevent.nfsd.open.return + += _addevent.nfsd.open.return +{ + update_record() +} + +probe _addevent.nfsd.open.return + = nfsd.open.return +{ + log_nfs_return(HOOKID_NFSD_OPEN_RETURN,$return) +} + +probe addevent.nfsd.close.entry + += _addevent.nfsd.close.entry +{ + update_record() +} + +probe _addevent.nfsd.close.entry + = nfsd.close +{ + log_nfsd_close(filename) +} + +function log_nfsd_close(filename:string)%{ /*pure*/ + + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_CLOSE_ENTRY,"%0s",THIS->filename); +%} + +probe addevent.nfsd.close.return + += _addevent.nfsd.close.return +{ + update_record() +} + +probe _addevent.nfsd.close.return + = nfsd.close.return +{ +} + +probe addevent.nfsd.read.entry + += _addevent.nfsd.read.entry +{ + update_record() +} + +probe _addevent.nfsd.read.entry + = nfsd.read +{ + log_nfsd_read($fhp,count,offset,$vec,vlen) +} + +function log_nfsd_read(fhp:long,count:long,offset:long, + vec:long,vlen:long)%{ /*pure*/ + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + struct kvec * vec = (struct kvec *)THIS->vec; + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_READ_ENTRY,"%1b%8b%8b%8b%8b%8b%8b%8b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2], + THIS->count,THIS->offset,vec->iov_len,THIS->vlen); +%} + +probe addevent.nfsd.read.return + += _addevent.nfsd.read.return +{ + update_record() +} + +probe _addevent.nfsd.read.return + = nfsd.read.return +{ + log_nfs_return(HOOKID_NFSD_READ_RETURN,$return) +} + +probe addevent.nfsd.write.entry + += _addevent.nfsd.write.entry +{ + update_record() +} + +probe _addevent.nfsd.write.entry + = nfsd.write +{ + log_nfsd_write($fhp,count,offset,$vec,vlen) +} + +function log_nfsd_write(fhp:long,count:long,offset:long, + vec:long,vlen:long)%{ /*pure*/ + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + struct kvec * vec = (struct kvec *)THIS->vec; + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_WRITE_ENTRY,"%1b%8b%8b%8b%8b%8b%8b%8b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2], + THIS->count,THIS->offset,vec->iov_len,THIS->vlen); +%} + +probe addevent.nfsd.write.return + += _addevent.nfsd.write.return +{ + update_record() +} + +probe _addevent.nfsd.write.return + = nfsd.write.return +{ + log_nfs_return(HOOKID_NFSD_WRITE_RETURN,$return) +} + +probe addevent.nfsd.commit.entry + += _addevent.nfsd.commit.entry +{ + update_record() +} + +probe _addevent.nfsd.commit.entry + = nfsd.commit +{ + log_nfsd_commit($fhp,count,offset) +} + +function log_nfsd_commit(fhp:long,count:long,offset:long)%{ /*pure*/ + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_COMMIT_ENTRY,"%1b%8b%8b%8b%8b%8b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2], + THIS->count,THIS->offset); +%} + +probe addevent.nfsd.commit.return + += _addevent.nfsd.commit.return +{ + update_record() +} + +probe _addevent.nfsd.commit.return + = nfsd.commit.return +{ + log_nfs_return(HOOKID_NFSD_COMMIT_RETURN,$return) +} + +probe addevent.nfsd.proc = addevent.nfsd.proc.entries, + addevent.nfsd.proc.return +{} + +probe addevent.nfsd.proc.entries = + addevent.nfsd.proc.lookup.entry, + addevent.nfsd.proc.read.entry, + addevent.nfsd.proc.write.entry, + addevent.nfsd.proc.commit.entry, + addevent.nfsd.proc.compound.entry, + addevent.nfsd.proc.remove.entry, + addevent.nfsd.proc.rename.entry, + addevent.nfsd.proc.create.entry +{} + +probe addevent.nfsd.proc.return = + addevent.nfsd.proc.lookup.return, + addevent.nfsd.proc.read.return, + addevent.nfsd.proc.write.return, + addevent.nfsd.proc.commit.return, + addevent.nfsd.proc.compound.return, + addevent.nfsd.proc.remove.return, + addevent.nfsd.proc.rename.return, + addevent.nfsd.proc.create.return +{} + +probe addevent.nfsd.proc.lookup.entry + += _addevent.nfsd.proc.lookup.entry +{ + update_record() +} + +probe _addevent.nfsd.proc.lookup.entry + = nfsd.proc.lookup +{ + log_nfsd_proc_lookup(fh,version,filename) +} + +function log_nfsd_proc_lookup(fh:long,version:long,filename:string)%{ /*pure*/ + struct svc_fh * fhp = (struct svc_fh*)(THIS->fh); + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_PROC_LOOKUP_ENTRY,"%1b%8b%8b%8b%1b%0s", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2], + THIS->version,THIS->filename); +%} + +probe addevent.nfsd.proc.lookup.return + += _addevent.nfsd.proc.lookup.return +{ + update_record() +} + +probe _addevent.nfsd.proc.lookup.return + = nfsd.proc.lookup.return +{ + log_nfs_return(HOOKID_NFSD_PROC_LOOKUP_RETURN,$return) +} + +probe addevent.nfsd.proc.read.entry + += _addevent.nfsd.proc.read.entry +{ + update_record() +} + +probe _addevent.nfsd.proc.read.entry + = nfsd.proc.read +{ + log_nfsd_proc_read(fh,version,count,offset,vec,vlen) +} + +function log_nfsd_proc_read(fhp:long,version:long,count:long,offset:long, + vec:long,vlen:long)%{ /*pure*/ + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + struct kvec * vec = (struct kvec *)THIS->vec; + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_PROC_READ_ENTRY,"%1b%8b%8b%8b%1b%8b%8b%8b%8b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->version, + THIS->count,THIS->offset,vec->iov_len,THIS->vlen); +%} + +probe addevent.nfsd.proc.read.return + += _addevent.nfsd.proc.read.return +{ + update_record() +} + +probe _addevent.nfsd.proc.read.return + = nfsd.proc.read.return +{ + log_nfs_return(HOOKID_NFSD_PROC_READ_RETURN,$return) +} + +probe addevent.nfsd.proc.write.entry + += _addevent.nfsd.proc.write.entry +{ + update_record() +} + +probe _addevent.nfsd.proc.write.entry + = nfsd.proc.write +{ + log_nfsd_proc_write(fh,version,count,offset,vec,vlen) +} + +function log_nfsd_proc_write(fhp:long,version:long,count:long,offset:long, + vec:long,vlen:long)%{ /*pure*/ + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + struct kvec * vec = (struct kvec *)THIS->vec; + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_PROC_WRITE_ENTRY,"%1b%8b%8b%8b%1b%8b%8b%8b%8b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->version, + THIS->count,THIS->offset,vec->iov_len,THIS->vlen); +%} + +probe addevent.nfsd.proc.write.return + += _addevent.nfsd.proc.write.return +{ + update_record() +} + +probe _addevent.nfsd.proc.write.return + = nfsd.proc.write.return +{ + log_nfs_return(HOOKID_NFSD_PROC_WRITE_RETURN,$return) +} + +probe addevent.nfsd.proc.commit.entry + += _addevent.nfsd.proc.commit.entry +{ + update_record() +} + +probe _addevent.nfsd.proc.commit.entry + = nfsd.proc.commit +{ + log_nfsd_proc_commit(fh,version,count,offset) +} + +function log_nfsd_proc_commit(fhp:long,version:long,count:long,offset:long)%{ /*pure*/ + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_PROC_COMMIT_ENTRY,"%1b%8b%8b%8b%1b%8b%8b", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->version, + THIS->count,THIS->offset); +%} + +probe addevent.nfsd.proc.commit.return + += _addevent.nfsd.proc.commit.return +{ + update_record() +} + +probe _addevent.nfsd.proc.commit.return + = nfsd.proc.commit.return +{ + log_nfs_return(HOOKID_NFSD_PROC_COMMIT_RETURN,$return) +} + +probe addevent.nfsd.proc.compound.entry + += _addevent.nfsd.proc.compound.entry +{ + update_record() +} + +probe _addevent.nfsd.proc.compound.entry + = nfsd.proc.compound +{ + log_nfsd_proc_compound(num) +} + +function log_nfsd_proc_compound(num:long)%{ /*pure*/ + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_PROC_COMPOUND_ENTRY,"%4b", + THIS->num); +%} + +probe addevent.nfsd.proc.compound.return + += _addevent.nfsd.proc.compound.return +{ + update_record() +} + +probe _addevent.nfsd.proc.compound.return + = nfsd.proc.compound.return +{ + log_nfs_return(HOOKID_NFSD_PROC_COMPOUND_RETURN,$return) +} + +probe addevent.nfsd.proc.remove.entry + += _addevent.nfsd.proc.remove.entry +{ + update_record() +} + +probe _addevent.nfsd.proc.remove.entry + = nfsd.proc.remove +{ + log_nfsd_proc_remove(fh,version,filename) +} + +function log_nfsd_proc_remove(fhp:long,version:long,filename:string)%{ /*pure*/ + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_PROC_REMOVE_ENTRY,"%1b%8b%8b%8b%1b%0s", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->version, + THIS->filename); +%} + +probe addevent.nfsd.proc.remove.return + += _addevent.nfsd.proc.remove.return +{ + update_record() +} + +probe _addevent.nfsd.proc.remove.return + = nfsd.proc.remove.return +{ + log_nfs_return(HOOKID_NFSD_PROC_REMOVE_RETURN,$return) +} + +probe addevent.nfsd.proc.rename.entry + += _addevent.nfsd.proc.rename.entry +{ + update_record() +} + +probe _addevent.nfsd.proc.rename.entry + = nfsd.proc.rename +{ + log_nfsd_proc_rename(fh,version,filename,tfh,tname) +} + +function log_nfsd_proc_rename(fhp:long,version:long,filename:string, + tfh:long,tname:string)%{ /*pure*/ + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + struct svc_fh * tfhp = (struct svc_fh*)(THIS->tfh); + __u64 i_ino[3],o_ino[3]; + + decode_fh(&fhp->fh_handle,o_ino); + decode_fh(&tfhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_PROC_RENAME_ENTRY,"%1b%1b%8b%8b%8b%0s%1b%8b%8b%8b%0s", + THIS->version,(_FMT_)fhp->fh_handle.fh_size,o_ino[0],o_ino[1],o_ino[2],THIS->filename, + (_FMT_)tfhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->tname); +%} + +probe addevent.nfsd.proc.rename.return + += _addevent.nfsd.proc.rename.return +{ + update_record() +} + +probe _addevent.nfsd.proc.rename.return + = nfsd.proc.rename.return +{ + log_nfs_return(HOOKID_NFSD_PROC_RENAME_RETURN,$return) +} + +probe addevent.nfsd.proc.create.entry + += _addevent.nfsd.proc.create.entry +{ + update_record() +} + +probe _addevent.nfsd.proc.create.entry + = nfsd.proc.create +{ + log_nfsd_proc_create(fh,version,filename) +} + +function log_nfsd_proc_create(fhp:long,version:long,filename:string)%{ /*pure*/ + + struct svc_fh * fhp = (struct svc_fh*)(THIS->fhp); + __u64 i_ino[3]; + + decode_fh(&fhp->fh_handle,i_ino); + _lket_trace(_GROUP_NFSD,_HOOKID_NFSD_PROC_CREATE_ENTRY,"%1b%8b%8b%8b%1b%0s", + (_FMT_)fhp->fh_handle.fh_size,i_ino[0],i_ino[1],i_ino[2],THIS->version,THIS->filename); +%} + +probe addevent.nfsd.proc.create.return + += _addevent.nfsd.proc.create.return +{ + update_record() +} + +probe _addevent.nfsd.proc.create.return + = nfsd.proc.create.return +{ + log_nfs_return(HOOKID_NFSD_PROC_CREATE_RETURN,$return) +} diff --git a/tapset/LKET/register_event.stp b/tapset/LKET/register_event.stp index e743c2ca..0809146f 100755 --- a/tapset/LKET/register_event.stp +++ b/tapset/LKET/register_event.stp @@ -11,7 +11,7 @@ global usr_evt_name, usr_evt_fmt %{ #define _MAXGROUPID 20 -#define _MAXHOOKID 40 +#define _MAXHOOKID 80 int get_fmtcode(char *fmt) { @@ -121,6 +121,7 @@ function register_event(grpid:long, hookid:long, evt_type:long, fmt:string, name function register_sys_events() { + reset_maxaction() register_sys_event(GROUP_SYSCALL, HOOKID_SYSCALL_ENTRY, "STRING", "syscall") register_sys_event(GROUP_SYSCALL, HOOKID_SYSCALL_RETURN, "STRING", "syscall") @@ -280,6 +281,8 @@ function register_sys_events() register_sys_event(GROUP_AIO, HOOKID_AIO_IO_CANCEL_RETURN, "INT64", "return") + reset_maxaction() + register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SEND_ENTRY, "INT8:INT8:INT8:INT32", "sig:shared:send2queue:pid") register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_SEND_RETURN, @@ -320,6 +323,332 @@ function register_sys_events() register_sys_event(GROUP_CPUFREQ, HOOKID_SWITCH_CPUFREQ, "INT64", "cpufreq") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_LLSEEK_ENTRY, + "INT8:INT8:INT64:INT64:INT8", + "major:minor:ino:offset:origin") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_LLSEEK_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_READ_ENTRY, + "INT8:INT8:INT64:INT64:INT64:INT64", + "major:minor:ino:buf:len:pos") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_READ_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_WRITE_ENTRY, + "INT8:INT8:INT64:INT64:INT64:INT64", + "major:minor:ino:buf:len:pos") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_WRITE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_AIOREAD_ENTRY, + "INT8:INT8:INT64:INT64:INT64:INT64", + "major:minor:ino:buf:len:pos") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_AIOREAD_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_AIOWRITE_ENTRY, + "INT8:INT8:INT64:INT64:INT64:INT64", + "major:minor:ino:buf:len:pos") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_AIOWRITE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_MMAP_ENTRY, + "INT8:INT8:INT64:INT64:INT64:INT32", + "major:minor:ino:vm_start:vm_end:vm_flags") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_MMAP_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_OPEN_ENTRY, + "INT8:INT8:INT64:INT32:STRING", + "major:minor:ino:flag:filename") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_OPEN_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_FLUSH_ENTRY, + "INT8:INT8:INT64:INT32", + "major:minor:ino:ndirty") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_FLUSH_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_RELEASE_ENTRY, + "INT8:INT8:INT64:INT16", + "major:minor:ino:mode") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_RELEASE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_FSYNC_ENTRY, + "INT8:INT8:INT64:INT32", + "major:minor:ino:ndirty") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_FSYNC_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_LOCK_ENTRY, + "INT8:INT8:INT64:INT64:INT64:INT8:INT8:INT32", + "major:minor:ino:fl_start:fl_end:fl_type:fl_flag:cmd") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_LOCK_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_SENDFILE_ENTRY, + "INT8:INT8:INT64:INT64:INT64", + "major:minor:ino:count:pos") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_SENDFILE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_CHECKFLAGS_ENTRY, + "INT32","flag") + register_sys_event(GROUP_NFS, HOOKID_NFS_FOP_CHECKFLAGS_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_READPAGE_ENTRY, + "INT64:INT32:INT64:INT64", + "ino:rsize:__page:page_index") + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_READPAGE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_READPAGES_ENTRY, + "INT64:INT32:INT32", + "ino:rpages:nr_pages") + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_READPAGES_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_WRITEPAGE_ENTRY, + "INT64:INT32:INT64:INT64", + "ino:wsize:__page:page_index") + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_WRITEPAGE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_WRITEPAGES_ENTRY, + "INT64:INT32:INT64", + "ino:wpages:nr_to_write") + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_WRITEPAGES_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_PREPAREWRITE_ENTRY, + "INT64:INT64:INT64", + "ino:__page:page_index") + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_PREPAREWRITE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_COMMITWRITE_ENTRY, + "INT64:INT64:INT64:INT32:INT32", + "ino:__page:page_index:offset:count") + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_COMMITWRITE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_SETPAGEDIRTY_ENTRY, + "INT64:INT8", + "__page:page_flag") + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_SETPAGEDIRTY_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_RELEASEPAGE_ENTRY, + "INT64:INT64", + "__page:page_index") + register_sys_event(GROUP_NFS, HOOKID_NFS_AOP_RELEASEPAGE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_LOOKUP_ENTRY, + "INT8:INT8:INT64:INT8:STRING", + "major_device:minor_device:fileid:version:filename") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_LOOKUP_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_READ_ENTRY, + "INT8:INT8:INT64:INT8:INT32:INT64", + "major_device:minor_device:fileid:version:count:offset") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_READ_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_WRITE_ENTRY, + "INT8:INT8:INT64:INT8:INT32:INT64", + "major_device:minor_device:fileid:version:count:offset") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_WRITE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_COMMIT_ENTRY, + "INT8:INT8:INT64:INT8:INT32:INT64", + "major_device:minor_device:fileid:version:count:offset") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_COMMIT_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_READSETUP_ENTRY, + "INT8:INT8:INT64:INT8:INT32:INT64", + "major_device:minor_device:fileid:version:count:offset") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_WRITESETUP_ENTRY, + "INT8:INT8:INT64:INT8:INT8:INT32:INT64", + "major_device:minor_device:fileid:version:how:count:offset") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_COMMITSETUP_ENTRY, + "INT8:INT8:INT64:INT8:INT32:INT64", + "major_device:minor_device:fileid:version:count:offset") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_READDONE_ENTRY, + "INT8:INT8:INT64:INT8:INT32:INT32", + "major_device:minor_device:fileid:version:status:count") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_READDONE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_WRITEDONE_ENTRY, + "INT8:INT8:INT64:INT8:INT32:INT32", + "major_device:minor_device:fileid:version:status:count") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_WRITEDONE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_COMMITDONE_ENTRY, + "INT8:INT8:INT64:INT8:INT32:INT32", + "major_device:minor_device:fileid:version:status:count") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_COMMITDONE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_OPEN_ENTRY, + "INT8:INT8:INT64:INT8:STRING:INT32:INT32", + "major_device:minor_device:fileid:version:filename:flag:mode") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_OPEN_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_RELEASE_ENTRY, + "INT8:INT8:INT64:INT8:STRING:INT32:INT32", + "major_device:minor_device:fileid:version:filename:flag:mode") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_RELEASE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_CREATE_ENTRY, + "INT8:INT8:INT64:INT8:STRING:INT32", + "major_device:minor_device:fileid:version:filename:mode") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_CREATE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_RENAME_ENTRY, + "INT8:INT8:INT8:INT64:STRING:INT8:INT8:INT64:STRING", + "version:major_old:minor_old:fileid_old:filename_old:major_new:minor_new:fileid_new:filename_new") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_RENAME_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_CREATE_ENTRY, + "INT8:INT8:INT64:INT8:STRING", + "major_device:minor_device:fileid:version:filename") + register_sys_event(GROUP_NFS, HOOKID_NFS_PROC_CREATE_RETURN, + "INT32","return") + + reset_maxaction() + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_DISPATCH_ENTRY, + "INT8:INT8:INT32:INT32:INT32:INT32", + "proto:version:xid:proc:prog:client_ip") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_DISPATCH_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_OPEN_ENTRY, + "INT8:INT64:INT64:INT64:INT32:INT8", + "size:ino0:ino1:ino2:type:access") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_OPEN_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_READ_ENTRY, + "INT8:INT64:INT64:INT64:INT64:INT64:INT64:INT64", + "size:ino0:ino1:ino2:count:offset:iov_len:vlen") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_READ_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_WRITE_ENTRY, + "INT8:INT64:INT64:INT64:INT64:INT64:INT64:INT64", + "size:ino0:ino1:ino2:count:offset:iov_len:vlen") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_WRITE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_LOOKUP_ENTRY, + "INT8:INT64:INT64:INT64:STRING", + "size:ino0:ino1:ino2:filename") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_LOOKUP_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_COMMIT_ENTRY, + "INT8:INT64:INT64:INT64:INT64:INT64", + "size:ino0:ino1:ino2:count:offset") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_COMMIT_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_CREATE_ENTRY, + "INT8:INT64:INT64:INT64:STRING:INT32:INT16:INT32", + "size:ino0:ino1:ino2:filename:type:iap_valid:iap_mode") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_CREATE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_CREATEV3_ENTRY, + "INT8:INT64:INT64:INT64:STRING:INT8:INT16:INT32", + "size:ino0:ino1:ino2:filename:createmode:iap_valid:iap_mode") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_CREATEV3_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_UNLINK_ENTRY, + "INT8:INT64:INT64:INT64:STRING:INT32", + "size:ino0:ino1:ino2:filename:type") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_UNLINK_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_RENAME_ENTRY, + "INT8:INT64:INT64:INT64:STRING:INT8:INT64:INT64:INT64:STRING", + "old_size:old_ino0:old_ino1:old_ino2:old_filename:size:ino0:ino1:ino2:filename") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_RENAME_RETURN, + "INT32","return") + + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_CLOSE_ENTRY, + "STRING", + "filename") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_CLOSE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_LOOKUP_ENTRY, + "INT8:INT64:INT64:INT64:INT8:STRING", + "size:ino0:ino1:ino2:version:filename") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_LOOKUP_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_READ_ENTRY, + "INT8:INT64:INT64:INT64:INT8:INT64:INT64:INT64:INT64", + "size:ino0:ino1:ino2:version:count:offset:iov_len:vlen") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_READ_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_WRITE_ENTRY, + "INT8:INT64:INT64:INT64:INT8:INT64:INT64:INT64:INT64", + "size:ino0:ino1:ino2:version:count:offset:iov_len:vlen") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_WRITE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_COMMIT_ENTRY, + "INT8:INT64:INT64:INT64:INT8:INT64:INT64", + "size:ino0:ino1:ino2:version:count:offset") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_COMMIT_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_COMPOUND_ENTRY, + "INT32","num") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_COMPOUND_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_REMOVE_ENTRY, + "INT8:INT64:INT64:INT64:INT8:STRING", + "size:ino0:ino1:ino2:version:filename") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_REMOVE_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_RENAME_ENTRY, + "INT8:INT8:INT64:INT64:INT64:STRING:INT8:INT64:INT64:INT64:STRING", + "version:old_size:old_ino0:old_ino1:old_ino2:old_filename:size:ino0:ino1:ino2:filename") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_RENAME_RETURN, + "INT32","return") + + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_CREATE_ENTRY, + "INT8:INT64:INT64:INT64:INT8:STRING", + "size:ino0:ino1:ino2:version:filename") + register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_CREATE_RETURN, + "INT32","return") + reset_maxaction() } diff --git a/tapset/LKET/utils.stp b/tapset/LKET/utils.stp index 0006246e..5bff6a9f 100755 --- a/tapset/LKET/utils.stp +++ b/tapset/LKET/utils.stp @@ -31,3 +31,13 @@ function filter_by_pid:long() THIS->__retvalue = 0; return; %} + +function reset_maxaction() +%{ + struct context* c; + int cpu; + for_each_online_cpu(cpu) { + c = per_cpu_ptr (contexts, cpu); + c->actioncount = 0; + } +%} diff --git a/tapset/nfs.stp b/tapset/nfs.stp index 56054851..2bdd170f 100644 --- a/tapset/nfs.stp +++ b/tapset/nfs.stp @@ -84,6 +84,18 @@ function __nfs_server_rsize:long (inode:long) %{ /* pure */ THIS->__retvalue = NFS_SERVER(inode)->rsize; %} +/*Get version from struct inode*/ +function __nfs_version:long (inode:long) %{ /* pure */ + struct inode * inode = (struct inode *)(THIS->inode); + + if(inode == NULL) + { + THIS->__retvalue = -1; + return; + } + THIS->__retvalue = NFS_PROTO(inode)->version; +%} + /*Get wsize from struct inode*/ function __nfs_server_wsize:long (inode:long) %{ /* pure */ struct inode * inode = (struct inode *)(THIS->inode); @@ -273,6 +285,9 @@ probe nfs.fop.llseek = kernel.function ("nfs_file_llseek") ?, { dev = $filp->f_dentry->d_inode->i_sb->s_dev ino = $filp->f_dentry->d_inode->i_ino + s_id = $filp->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) + maxbyte = $filp->f_dentry->d_inode->i_sb->s_maxbytes offset = $offset origin = $origin @@ -298,6 +313,8 @@ probe nfs.fop.llseek.return = kernel.function ("nfs_file_llseek").return ?, */ probe nfs.fop.read = vfs.do_sync_read { + s_id = $filp->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) name = "nfs.fop.read" } @@ -318,6 +335,8 @@ probe nfs.fop.read.return = vfs.do_sync_read.return probe nfs.fop.write = vfs.do_sync_write { + s_id = $filp->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) name = "nfs.fop.write" } @@ -351,6 +370,8 @@ probe nfs.fop.aio_read = kernel.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 + s_id = $iocb->ki_filp->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) count = $count pos = $pos @@ -404,6 +425,8 @@ probe nfs.fop.aio_write = kernel.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 + s_id = $iocb->ki_filp->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) count = $count pos = $pos @@ -458,6 +481,8 @@ probe nfs.fop.mmap = kernel.function("nfs_file_mmap") ?, { dev = $file->f_dentry->d_inode->i_sb->s_dev ino = $file->f_dentry->d_inode->i_ino + s_id = $file->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) vm_start = $vma->vm_start vm_end = $vma->vm_end @@ -498,6 +523,8 @@ probe nfs.fop.open = kernel.function("nfs_file_open") ?, { dev = $filp->f_dentry->d_inode->i_sb->s_dev ino = $inode->i_ino + s_id = $inode->i_sb->s_id + devname = kernel_string(s_id) filename = kernel_string($filp->f_dentry->d_name->name) flag = $filp->f_flags @@ -531,6 +558,8 @@ probe nfs.fop.flush = kernel.function("nfs_file_flush") ?, { dev = $file->f_dentry->d_inode->i_sb->s_dev ino = $file->f_dentry->d_inode->i_ino; + s_id = $file->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) mode = $file->f_mode ndirty = __nfsi_ndirty($file->f_dentry->d_inode) @@ -561,6 +590,8 @@ probe nfs.fop.release = kernel.function("nfs_file_release") ?, { dev = $filp->f_dentry->d_inode->i_sb->s_dev ino = $inode->i_ino + s_id = $inode->i_sb->s_id + devname = kernel_string(s_id) mode = $filp->f_mode @@ -590,6 +621,8 @@ probe nfs.fop.fsync = kernel.function("nfs_fsync") ?, { dev = $file->f_dentry->d_inode->i_sb->s_dev ino = $file->f_dentry->d_inode->i_ino + s_id = $file->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) ndirty = __nfsi_ndirty($file->f_dentry->d_inode) @@ -624,6 +657,8 @@ probe nfs.fop.lock = kernel.function("nfs_lock") ?, { dev = $filp->f_dentry->d_inode->i_sb->s_dev ino = $filp->f_dentry->d_inode->i_ino + s_id = $filp->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) i_mode = $filp->f_dentry->d_inode->i_mode cmd = $cmd @@ -669,6 +704,8 @@ probe nfs.fop.sendfile = kernel.function("nfs_file_sendfile") ?, dev = $filp->f_dentry->d_inode->i_sb->s_dev ino = $filp->f_dentry->d_inode->i_ino + s_id = $filp->f_dentry->d_inode->i_sb->s_id + devname = kernel_string(s_id) count = $count ppos = __d_loff_t($ppos) @@ -801,11 +838,11 @@ probe nfs.aop.readpage.return = kernel.function ("nfs_readpage").return ?, * Arguments: * dev : device identifier * ino : inode number - * nr_pages : number of pages to be read in this execution + * nr_pages : number of pages attempted to 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 + * size : number of pages attempted to read in this execution */ probe nfs.aop.readpages = kernel.function ("nfs_readpages") ?, module("nfs").function ("nfs_readpages") ? @@ -939,8 +976,8 @@ probe nfs.aop.writepage.return = kernel.function ("nfs_writepage").return ?, * 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 + * nr_to_write : number of pages attempted to be written in this execution + * size : number of pages attempted to be written in this execution */ probe nfs.aop.writepages = kernel.function ("nfs_writepages") ?, module("nfs").function ("nfs_writepages") ? diff --git a/tapset/nfs_proc.stp b/tapset/nfs_proc.stp index 292b5af7..fbfd6ab8 100644 --- a/tapset/nfs_proc.stp +++ b/tapset/nfs_proc.stp @@ -98,6 +98,9 @@ probe nfs.proc.return = nfs.proc.lookup.return, nfs.proc.read.return, nfs.proc.write.return, nfs.proc.commit.return, + nfs.proc.read_setup.return, + nfs.proc.write_setup.return, + nfs.proc.commit_setup.return, nfs.proc.read_done.return, nfs.proc.write_done.return, nfs.proc.commit_done.return, @@ -141,7 +144,7 @@ probe nfs.proc2.lookup = kernel.function("nfs_proc_lookup")?, { server_ip = __i2n_ip_proto($dir,0) prot = __i2n_ip_proto($dir,1) - version = "NFSV2" + version =2 filename = kernel_string($name->name) name_len = $name->len @@ -153,7 +156,7 @@ probe nfs.proc2.lookup = kernel.function("nfs_proc_lookup")?, probe nfs.proc2.lookup.return = kernel.function("nfs_proc_lookup").return?, module("nfs").function("nfs_proc_lookup").return? { - version = "NFSV2" + version =2 name = "nfs.proc2.lookup.return" retstr = sprintf("%d", $return) } @@ -164,7 +167,7 @@ probe nfs.proc3.lookup = kernel.function("nfs3_proc_lookup")?, server_ip = __i2n_ip_proto($dir,0) prot = __i2n_ip_proto($dir,1) - version = "NFSV3" + version =3 filename = kernel_string($name->name) name_len = $name->len @@ -177,7 +180,7 @@ probe nfs.proc3.lookup = kernel.function("nfs3_proc_lookup")?, probe nfs.proc3.lookup.return = kernel.function("nfs3_proc_lookup").return?, module("nfs").function("nfs3_proc_lookup").return? { - version = "NFSV3" + version =3 name = "nfs.proc3.lookup.return" retstr = sprintf("%d", $return) } @@ -188,7 +191,7 @@ probe nfs.proc4.lookup = kernel.function("nfs4_proc_lookup")?, server_ip = __i2n_ip_proto($dir,0) prot = __i2n_ip_proto($dir,1) - version = "NFSV4" + version =4 filename = kernel_string($name->name) name_len = $name->len @@ -202,7 +205,7 @@ probe nfs.proc4.lookup = kernel.function("nfs4_proc_lookup")?, probe nfs.proc4.lookup.return = kernel.function("nfs4_proc_lookup").return?, module("nfs").function("nfs4_proc_lookup").return? { - version = "NFSV4" + version =4 name = "nfs.proc4.lookup.return" retstr = sprintf("%d", $return) } @@ -239,7 +242,7 @@ probe nfs.proc2.read = kernel.function("nfs_proc_read") ?, { server_ip = __nfs_data_ip_proto($rdata,0) prot = __nfs_data_ip_proto($rdata,1) - version = "NFSV2" + version =2 flags = $rdata->flags count = $rdata->args->count @@ -255,7 +258,7 @@ probe nfs.proc2.read = kernel.function("nfs_proc_read") ?, probe nfs.proc2.read.return = kernel.function("nfs_proc_read").return ?, module("nfs").function("nfs_proc_read").return? { - version = "NFSV2" + version =2 name = "nfs.proc2.read.return" retstr = sprintf("%d", $return) @@ -271,7 +274,7 @@ probe nfs.proc3.read = kernel.function("nfs3_proc_read") ?, { server_ip = __nfs_data_ip_proto($rdata,0) prot = __nfs_data_ip_proto($rdata,1) - version = "NFSV3" + version =3 flags = $rdata->flags count = $rdata->args->count @@ -288,7 +291,7 @@ probe nfs.proc3.read = kernel.function("nfs3_proc_read") ?, probe nfs.proc3.read.return = kernel.function("nfs3_proc_read").return ?, module("nfs").function("nfs3_proc_read").return? { - version = "NFSV3" + version =3 name = "nfs.proc3.read.return" retstr = sprintf("%d", $return) @@ -305,7 +308,7 @@ probe nfs.proc4.read = kernel.function("nfs4_proc_read") ?, { server_ip = __nfs_data_ip_proto($rdata,0) prot = __nfs_data_ip_proto($rdata,1) - version = "NFSV4" + version =4 flags = $rdata->flags count = $rdata->args->count @@ -322,7 +325,7 @@ probe nfs.proc4.read = kernel.function("nfs4_proc_read") ?, probe nfs.proc4.read.return = kernel.function("nfs4_proc_read").return ?, module("nfs").function("nfs4_proc_read").return? { - version = "NFSV4" + version =4 name = "nfs.proc4.read.return" retstr = sprintf("%d", $return) @@ -349,7 +352,7 @@ probe nfs.proc4.read.return = kernel.function("nfs4_proc_read").return ?, * offset : the file offset * bitmask0: * bitmask1 :V4 bitmask representing the set of attributes -* supported on this filesystem (only in probe nfs.proc4.lookup) +* supported on this filesystem (only in probe nfs.proc4.write) */ probe nfs.proc.write = nfs.proc2.write , @@ -364,12 +367,12 @@ probe nfs.proc.write.return = nfs.proc2.write.return , {} probe nfs.proc2.write = kernel.function("nfs_proc_write")?, - module("nfs").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" + version =2 flags = $wdata->flags count = $wdata->args->count @@ -386,7 +389,7 @@ probe nfs.proc2.write = kernel.function("nfs_proc_write")?, probe nfs.proc2.write.return = kernel.function("nfs_proc_write").return ?, module("nfs").function("nfs_proc_write").return? { - version = "NFSV2" + version =2 name = "nfs.proc2.write.return" retstr = sprintf("%d", $return) @@ -399,12 +402,12 @@ probe nfs.proc2.write.return = kernel.function("nfs_proc_write").return ?, probe nfs.proc3.write = kernel.function("nfs3_proc_write")?, - module("nfs").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" + version =3 flags = $wdata->flags count = $wdata->args->count @@ -421,7 +424,7 @@ probe nfs.proc3.write = kernel.function("nfs3_proc_write")?, probe nfs.proc3.write.return = kernel.function("nfs3_proc_write").return ?, module("nfs").function("nfs3_proc_write").return? { - version = "NFSV3" + version =3 name = "nfs.proc3.write.return" retstr = sprintf("%d", $return) @@ -434,12 +437,12 @@ probe nfs.proc3.write.return = kernel.function("nfs3_proc_write").return ?, probe nfs.proc4.write = kernel.function("nfs4_proc_write")?, - module("nfs").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" + version =4 flags = $wdata->flags count = $wdata->args->count @@ -458,7 +461,7 @@ probe nfs.proc4.write = kernel.function("nfs4_proc_write")?, probe nfs.proc4.write.return = kernel.function("nfs4_proc_write").return ?, module("nfs").function("nfs4_proc_write").return? { - version = "NFSV4" + version =4 name = "nfs.proc4.write.return" retstr = sprintf("%d", $return) @@ -480,13 +483,12 @@ probe nfs.proc4.write.return = kernel.function("nfs4_proc_write").return ?, * 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) +* supported on this filesystem (only in probe nfs.proc4.commit) */ probe nfs.proc.commit = nfs.proc3.commit, nfs.proc4.commit @@ -501,7 +503,7 @@ probe nfs.proc3.commit = kernel.function ("nfs3_proc_commit")?, { server_ip = __nfs_data_ip_proto($cdata,0) prot = __nfs_data_ip_proto($cdata,1) - version = "NFSV3" + version =3 count = $cdata->args->count offset = $cdata->args->offset @@ -516,7 +518,7 @@ probe nfs.proc3.commit = kernel.function ("nfs3_proc_commit")?, probe nfs.proc3.commit.return = kernel.function ("nfs3_proc_commit").return?, module("nfs").function("nfs3_proc_commit").return? { - version = "NFSV3" + version =3 name = "nfs.proc3.commit.return" retstr = sprintf("%d", $return) @@ -533,7 +535,7 @@ probe nfs.proc4.commit = kernel.function ("nfs4_proc_commit")?, { server_ip = __nfs_data_ip_proto($cdata,0) prot = __nfs_data_ip_proto($cdata,1) - version = "NFSV4" + version =4 count = $cdata->args->count offset = $cdata->args->offset @@ -550,7 +552,7 @@ probe nfs.proc4.commit = kernel.function ("nfs4_proc_commit")?, probe nfs.proc4.commit.return = kernel.function ("nfs4_proc_commit").return?, module("nfs").function("nfs4_proc_commit").return? { - version = "NFSV4" + version =4 name = "nfs.proc4.commit.return" retstr = sprintf("%d", $return) @@ -580,6 +582,11 @@ probe nfs.proc.read_setup = nfs.proc2.read_setup , nfs.proc4.read_setup {} +probe nfs.proc.read_setup.return = nfs.proc2.read_setup.return , + nfs.proc3.read_setup.return , + nfs.proc4.read_setup.return +{} + probe nfs.proc2.read_setup = kernel.function("nfs_proc_read_setup") ?, @@ -587,7 +594,7 @@ probe nfs.proc2.read_setup = kernel.function("nfs_proc_read_setup") ?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV2" + version =2 count = $data->args->count offset = $data->args->offset @@ -599,13 +606,19 @@ probe nfs.proc2.read_setup = kernel.function("nfs_proc_read_setup") ?, units = "bytes" } +probe nfs.proc2.read_setup.return = kernel.function("nfs_proc_read_setup").return ?, + module("nfs").function("nfs_proc_read_setup").return? +{ + name = "nfs.proc2.read_setup.return" + retvalue = 0; +} 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" + version =3 fh = count = $data->args->count @@ -618,15 +631,19 @@ probe nfs.proc3.read_setup = kernel.function("nfs3_proc_read_setup") ?, units = "bytes" } - - +probe nfs.proc3.read_setup.return = kernel.function("nfs3_proc_read_setup").return ?, + module("nfs").function("nfs3_proc_read_setup").return? +{ + name = "nfs.proc3.read_setup.return" + retvalue = 0; +} 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" + version =4 count = $data->args->count offset = $data->args->offset @@ -638,7 +655,12 @@ probe nfs.proc4.read_setup = kernel.function("nfs4_proc_read_setup") ?, size = count units = "bytes" } - +probe nfs.proc4.read_setup.return = kernel.function("nfs4_proc_read_setup").return ?, + module("nfs").function("nfs4_proc_read_setup").return? +{ + name = "nfs.proc4.read_setup.return" + retvalue = 0; +} /*probe nfs.proc.read_done * @@ -650,8 +672,7 @@ probe nfs.proc4.read_setup = kernel.function("nfs4_proc_read_setup") ?, * prot : transfer protocol * version : nfs version * status : result of last operation -* count : read size of last operation -* offset : the file offset of last operation +* count : number of bytes read * timestamp : time stamp ,which is used for lease renewal (only in nfs.proc4.read_done) */ @@ -670,11 +691,10 @@ probe nfs.proc2.read_done = kernel.function("nfs_read_done")?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV2" + version =2 status = $task->tk_status - offset = $data->args->offset - count = $data->args->count + count = $data->res->count name = "nfs.proc2.read_done" argstr = sprintf("%d",status) @@ -684,7 +704,7 @@ probe nfs.proc2.read_done = kernel.function("nfs_read_done")?, probe nfs.proc2.read_done.return = kernel.function("nfs_read_done").return?, module("nfs").function("nfs_read_done").return? { - version = "NFSV2" + version =2 name = "nfs.proc2.read_done.return" retstr = sprintf("%d", $return) } @@ -695,11 +715,10 @@ probe nfs.proc3.read_done = kernel.function("nfs3_read_done")?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV3" + version =3 status = $task->tk_status - offset = $data->args->offset - count = $data->args->count + count = $data->res->count name = "nfs.proc3.read_done" argstr = sprintf("%d",status) @@ -709,7 +728,7 @@ probe nfs.proc3.read_done = kernel.function("nfs3_read_done")?, probe nfs.proc3.read_done.return = kernel.function("nfs3_read_done").return?, module("nfs").function("nfs3_read_done").return? { - version = "NFSV3" + version =3 name = "nfs.proc3.read_done.return" retstr = sprintf("%d", $return) } @@ -720,11 +739,10 @@ probe nfs.proc4.read_done = kernel.function("nfs4_read_done")?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV4" + version =4 status = $task->tk_status - offset = $data->args->offset - count = $data->args->count + count = $data->res->count timestamp = $data->timestamp name = "nfs.proc4.read_done" @@ -735,7 +753,7 @@ probe nfs.proc4.read_done = kernel.function("nfs4_read_done")?, probe nfs.proc4.read_done.return = kernel.function("nfs4_read_done").return?, module("nfs").function("nfs4_read_done").return? { - version = "NFSV4" + version =4 name = "nfs.proc4.read_done.return" retstr = sprintf("%d", $return) } @@ -757,13 +775,17 @@ probe nfs.proc4.read_done.return = kernel.function("nfs4_read_done").return?, * 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) +* supported on this filesystem (only in probe nfs.proc4.write_setup) */ probe nfs.proc.write_setup = nfs.proc2.write_setup, nfs.proc3.write_setup, nfs.proc4.write_setup {} +probe nfs.proc.write_setup.return = nfs.proc2.write_setup.return, + nfs.proc3.write_setup.return, + nfs.proc4.write_setup.return +{} probe nfs.proc2.write_setup = kernel.function("nfs_proc_write_setup") ?, @@ -771,7 +793,7 @@ probe nfs.proc2.write_setup = kernel.function("nfs_proc_write_setup") ?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV2" + version =2 count = $data->args->count offset = $data->args->offset @@ -782,6 +804,12 @@ probe nfs.proc2.write_setup = kernel.function("nfs_proc_write_setup") ?, size = count units = "bytes" } +probe nfs.proc2.write_setup.return = kernel.function("nfs_proc_write_setup").return ?, + module("nfs").function("nfs_proc_write_setup").return ? +{ + name = "nfs.proc2.write_setup.return" + retvalue = 0 +} probe nfs.proc3.write_setup = kernel.function("nfs3_proc_write_setup") ?, @@ -789,7 +817,7 @@ probe nfs.proc3.write_setup = kernel.function("nfs3_proc_write_setup") ?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV3" + version =3 count = $data->args->count offset = $data->args->offset @@ -801,13 +829,19 @@ probe nfs.proc3.write_setup = kernel.function("nfs3_proc_write_setup") ?, size = count units = "bytes" } +probe nfs.proc3.write_setup.return = kernel.function("nfs3_proc_write_setup").return ?, + module("nfs").function("nfs3_proc_write_setup").return ? +{ + name = "nfs.proc3.write_setup.return" + retvalue = 0 +} 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" + version =4 count = $data->args->count offset = $data->args->offset @@ -822,6 +856,12 @@ probe nfs.proc4.write_setup = kernel.function("nfs4_proc_write_setup") ?, size = count units = "bytes" } +probe nfs.proc4.write_setup.return = kernel.function("nfs4_proc_write_setup").return ?, + module("nfs").function("nfs4_proc_write_setup").return ? +{ + name = "nfs.proc4.write_setup.return" + retvalue = 0 +} /*probe nfs.proc.write_done @@ -835,8 +875,7 @@ probe nfs.proc4.write_setup = kernel.function("nfs4_proc_write_setup") ?, * 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 +* count : number of bytes written * timestamp : time stamp ,which is used for lease renewal (only in nfs.proc4.write_done) */ @@ -855,12 +894,11 @@ probe nfs.proc2.write_done = kernel.function("nfs_write_done") ?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV2" + version =2 status = $task->tk_status valid = $data->res->fattr->valid - offset = $data->args->offset - count = $data->args->count + count = $data->res->count name = "nfs.proc2.write_done" argstr = sprintf("%d",status) @@ -869,7 +907,7 @@ probe nfs.proc2.write_done = kernel.function("nfs_write_done") ?, probe nfs.proc2.write_done.return = kernel.function("nfs_write_done").return ?, module("nfs").function("nfs_write_done").return ? { - version = "NFSV2" + version =2 name = "nfs.proc2.write_done.return" retstr = sprintf("%d", $return) } @@ -879,12 +917,11 @@ probe nfs.proc3.write_done = kernel.function("nfs3_write_done") ?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV3" + version =3 status = $task->tk_status valid = $data->res->fattr->valid - offset = $data->args->offset - count = $data->args->count + count = $data->res->count name = "nfs.proc3.write_done" argstr = sprintf("%d",status) @@ -893,7 +930,7 @@ probe nfs.proc3.write_done = kernel.function("nfs3_write_done") ?, probe nfs.proc3.write_done.return = kernel.function("nfs3_write_done").return ?, module("nfs").function("nfs3_write_done").return ? { - version = "NFSV3" + version =3 name = "nfs.proc3.write_done.return" retstr = sprintf("%d", $return) } @@ -903,12 +940,11 @@ probe nfs.proc4.write_done = kernel.function("nfs4_write_done") ?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV4" + version =4 status = $task->tk_status valid = $data->res->fattr->valid - offset = $data->args->offset - count = $data->args->count + count = $data->res->count timestamp = $data->timestamp name = "nfs.proc4.write_done" @@ -918,7 +954,7 @@ probe nfs.proc4.write_done = kernel.function("nfs4_write_done") ?, probe nfs.proc4.write_done.return = kernel.function("nfs4_write_done").return ?, module("nfs").function("nfs4_write_done").return ? { - version = "NFSV4" + version =4 name = "nfs.proc4.write_done.return" retstr = sprintf("%d", $return) } @@ -938,12 +974,16 @@ probe nfs.proc4.write_done.return = kernel.function("nfs4_write_done").return ?, * offset : the file offset * bitmask0: * bitmask1 :V4 bitmask representing the set of attributes -* supported on this filesystem (only in probe nfs.proc4.lookup) +* supported on this filesystem (only in probe nfs.proc4.commit_setup) */ probe nfs.proc.commit_setup =nfs.proc3.commit_setup, nfs.proc4.commit_setup {} +probe nfs.proc.commit_setup.return =nfs.proc3.commit_setup.return, + nfs.proc4.commit_setup.return +{} + probe nfs.proc3.commit_setup = kernel.function("nfs3_proc_commit_setup") ?, @@ -951,24 +991,30 @@ probe nfs.proc3.commit_setup = kernel.function("nfs3_proc_commit_setup") ?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV3" + version =3 count = $data->args->count offset = $data->args->offset name = "nfs.proc3.commit_setup" - argstr = sprintf("%d,%d,%d",count,offset,how) + argstr = sprintf("%d,%d",count,offset) size = count units = "bytes" } +probe nfs.proc3.commit_setup.return = kernel.function("nfs3_proc_commit_setup") .return?, + module("nfs").function("nfs3_proc_commit_setup").return ? +{ + name = "nfs.proc3.commit_setup.return" + retvalue = 0 +} 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" + version =4 count = $data->args->count offset = $data->args->offset @@ -977,11 +1023,17 @@ probe nfs.proc4.commit_setup = kernel.function("nfs4_proc_commit_setup") ?, //timestamp = $jiffies name = "nfs.proc4.commit_setup" - argstr = sprintf("%d,%d,%d",count,offset,how) + argstr = sprintf("%d,%d",count,offset) size = count units = "bytes" } +probe nfs.proc4.commit_setup.return = kernel.function("nfs4_proc_commit_setup") .return?, + module("nfs").function("nfs4_proc_commit_setup").return ? +{ + name = "nfs.proc4.commit_setup.return" + retvalue = 0 +} /*probe nfs.proc.commit_done @@ -995,8 +1047,7 @@ probe nfs.proc4.commit_setup = kernel.function("nfs4_proc_commit_setup") ?, * 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 +* count : number of bytes commited * timestamp : time stamp ,which is used for lease renewal (only in nfs.proc4.commit_done) */ @@ -1016,11 +1067,10 @@ probe nfs.proc3.commit_done = kernel.function("nfs3_commit_done") ?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV3" + version =3 status = $task->tk_status - count = $data->args->count - offset = $data->args->offset + count = $data->res->count valid = $data->res->fattr->valid name = "nfs.proc3.commit_done" @@ -1030,7 +1080,7 @@ probe nfs.proc3.commit_done = kernel.function("nfs3_commit_done") ?, probe nfs.proc3.commit_done.return = kernel.function("nfs3_commit_done").return ?, module("nfs").function("nfs3_commit_done").return ? { - version = "NFSV3" + version =3 name = "nfs.proc3.commit_done.return" retstr = sprintf("%d", $return) } @@ -1040,11 +1090,10 @@ probe nfs.proc4.commit_done = kernel.function("nfs4_commit_done") ?, { server_ip = __nfs_data_ip_proto($data,0) prot = __nfs_data_ip_proto($data,1) - version = "NFSV4" + version =4 status = $task->tk_status - count = $data->args->count - offset = $data->args->offset + count = $data->res->count valid = $data->res->fattr->valid timestamp = $data->timestamp @@ -1055,7 +1104,7 @@ probe nfs.proc4.commit_done = kernel.function("nfs4_commit_done") ?, probe nfs.proc4.commit_done.return = kernel.function("nfs4_commit_done").return ?, module("nfs").function("nfs4_commit_done").return ? { - version = "NFSV4" + version =4 name = "nfs.proc4.commit_done.return" retstr = sprintf("%d", $return) } @@ -1077,7 +1126,7 @@ probe nfs.proc.open = kernel.function("nfs_open") ?, { server_ip = __i2n_ip_proto($inode,0) prot = __i2n_ip_proto($inode,1) - version = "NFS" + version = __nfs_version($inode) filename = kernel_string($filp->f_dentry->d_name->name) flag = $filp->f_flags @@ -1090,7 +1139,6 @@ probe nfs.proc.open = kernel.function("nfs_open") ?, 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) } @@ -1112,7 +1160,7 @@ probe nfs.proc.release= kernel.function("nfs_release") ?, { server_ip = __i2n_ip_proto($inode,0) prot = __i2n_ip_proto($inode,1) - version = "NFS" + version = __nfs_version($inode) filename = kernel_string($filp->f_dentry->d_name->name) flag = $filp->f_flags @@ -1125,7 +1173,6 @@ probe nfs.proc.release= kernel.function("nfs_release") ?, 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) } @@ -1139,7 +1186,7 @@ probe nfs.proc.release.return = kernel.function("nfs_release").return ?, probe nfs.proc4.handle_exception = kernel.function("nfs4_handle_exception") ?, module("nfs").function("nfs4_handle_exception")? { - version = "NFSV4" + version =4 errorcode = $errorcode @@ -1182,11 +1229,12 @@ probe nfs.proc2.create = kernel.function("nfs_proc_create")?, { server_ip = __i2n_ip_proto($dir,0) prot = __i2n_ip_proto($dir,1) - version = "NFSv2" + version =2 fh = __getfh_inode($dir) filename = kernel_string($dentry->d_name->name) filelen = $dentry->d_name->len + mode = $sattr->ia_mode name = "nfs.proc2.create" argstr = sprintf("%s",filename) @@ -1196,7 +1244,7 @@ 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" + version =2 retstr = sprintf("%d",$return) } @@ -1205,12 +1253,13 @@ probe nfs.proc3.create = kernel.function("nfs3_proc_create")?, { server_ip = __i2n_ip_proto($dir,0) prot = __i2n_ip_proto($dir,1) - version = "NFSv3" + version =3 fh = __getfh_inode($dir) filename = kernel_string($dentry->d_name->name) filelen = $dentry->d_name->len flag = $flags + mode = $sattr->ia_mode name = "nfs.proc3.create" argstr = sprintf("%s",filename) @@ -1220,7 +1269,7 @@ 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" + version =3 retstr = sprintf("%d",$return) } @@ -1229,12 +1278,13 @@ probe nfs.proc4.create = kernel.function("nfs4_proc_create")?, { server_ip = __i2n_ip_proto($dir,0) prot = __i2n_ip_proto($dir,1) - version = "NFSv4" + version =4 fh = __getfh_inode($dir) filename = kernel_string($dentry->d_name->name) filelen = $dentry->d_name->len flag = $flags + mode = $sattr->ia_mode name = "nfs.proc4.create" argstr = sprintf("%s",filename) @@ -1244,7 +1294,7 @@ 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" + version =4 retstr = sprintf("%d",$return) } @@ -1275,7 +1325,7 @@ probe nfs.proc2.remove = kernel.function("nfs_proc_remove")?, { server_ip = __i2n_ip_proto($dir,0) prot = __i2n_ip_proto($dir,1) - version = "NFSv2" + version =2 fh = __getfh_inode($dir) filename = kernel_string($name->name) @@ -1289,7 +1339,7 @@ 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" + version =2 retstr = sprintf("%d",$return) } @@ -1298,7 +1348,7 @@ probe nfs.proc3.remove = kernel.function("nfs3_proc_remove")?, { server_ip = __i2n_ip_proto($dir,0) prot = __i2n_ip_proto($dir,1) - version = "NFSv3" + version =3 fh = __getfh_inode($dir) filename = kernel_string($name->name) @@ -1312,7 +1362,7 @@ 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" + version =3 retstr = sprintf("%d",$return) } @@ -1321,7 +1371,7 @@ probe nfs.proc4.remove = kernel.function("nfs4_proc_remove")?, { server_ip = __i2n_ip_proto($dir,0) prot = __i2n_ip_proto($dir,1) - version = "NFSv4" + version =4 fh = __getfh_inode($dir) filename = kernel_string($name->name) @@ -1335,7 +1385,7 @@ 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" + version =4 retstr = sprintf("%d",$return) } @@ -1369,7 +1419,7 @@ probe nfs.proc2.rename = kernel.function("nfs_proc_rename")?, { server_ip = __i2n_ip_proto($old_dir,0) prot = __i2n_ip_proto($old_dir,1) - version = "NFSv2" + version =2 old_fh = __getfh_inode($old_dir) old_name = kernel_string($old_name->name) @@ -1386,7 +1436,7 @@ 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" + version =2 retstr = sprintf("%d",$return) } @@ -1395,7 +1445,7 @@ probe nfs.proc3.rename = kernel.function("nfs3_proc_rename")?, { server_ip = __i2n_ip_proto($old_dir,0) prot = __i2n_ip_proto($old_dir,1) - version = "NFSv3" + version =3 old_fh = __getfh_inode($old_dir) old_name = kernel_string($old_name->name) @@ -1412,7 +1462,7 @@ 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" + version =3 retstr = sprintf("%d",$return) } @@ -1421,7 +1471,7 @@ probe nfs.proc4.rename = kernel.function("nfs4_proc_rename")?, { server_ip = __i2n_ip_proto($old_dir,0) prot = __i2n_ip_proto($old_dir,1) - version = "NFSv4" + version =4 old_fh = __getfh_inode($old_dir) old_name = kernel_string($old_name->name) @@ -1438,6 +1488,6 @@ 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" + version =4 retstr = sprintf("%d",$return) } diff --git a/tapset/nfsd.stp b/tapset/nfsd.stp index 9c7947ed..cfff8005 100644 --- a/tapset/nfsd.stp +++ b/tapset/nfsd.stp @@ -45,7 +45,7 @@ char * fh_fmt(struct svc_fh * fhp) */ /*Get file handler from argp,the index indicates the type of argp*/ -function __get_fh:string (argp:long,index:long) %{ /* pure */ +function __get_fh:long(argp:long,index:long) %{ /* pure */ int index = (int)(THIS->index); struct nfsd_diropargs * argp = NULL ; struct nfsd3_diropargs * argp3 = NULL ; @@ -115,12 +115,13 @@ function __get_fh:string (argp:long,index:long) %{ /* pure */ if(fhp == NULL) { _stp_printf("the fhp is NULL"); + return; } else { - buf = fh_fmt(fhp); -// _stp_printf("%s:\n",buf); - strlcpy (THIS->__retvalue,buf,80); + /* buf = fh_fmt(fhp); + strlcpy (THIS->__retvalue,buf,80);*/ + THIS->__retvalue = (long)fhp; } %} /*Get file handler from struct svc_fh , it will call @@ -177,6 +178,7 @@ probe nfsd.proc.entries = nfsd.proc.lookup, nfsd.proc.write, nfsd.proc.commit, nfsd.proc.compound, + nfsd.proc.remove, nfsd.proc.rename, nfsd.proc.create {} @@ -186,6 +188,7 @@ probe nfsd.proc.return = nfsd.proc.lookup.return, nfsd.proc.write.return, nfsd.proc.commit.return, nfsd.proc.compound.return, + nfsd.proc.remove.return, nfsd.proc.rename.return, nfsd.proc.create.return {} @@ -215,7 +218,7 @@ probe nfsd.proc2.lookup = kernel.function("nfsd_proc_lookup") ?, { client_ip = $rqstp->rq_addr->sin_addr->s_addr proto = $rqstp->rq_prot - version = "NFSV2" + version = 2 fh = __get_fh($argp,1) filename = kernel_string($argp->name) @@ -230,7 +233,7 @@ 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" + version = 2 retstr = sprintf("%d",$return) } @@ -239,7 +242,7 @@ probe nfsd.proc3.lookup = kernel.function("nfsd3_proc_lookup") ?, { client_ip = $rqstp->rq_addr->sin_addr->s_addr proto = $rqstp->rq_prot - version = "NFSV3" + version = 3 fh = __get_fh($argp,1) filename = kernel_string($argp->name) @@ -253,7 +256,7 @@ 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" + version = 3 retstr = sprintf("%d",$return) } @@ -289,7 +292,7 @@ probe nfsd.proc2.read = kernel.function("nfsd_proc_read")?, { client_ip = $rqstp->rq_addr->sin_addr->s_addr proto = $rqstp->rq_prot - version = "NFSV2" + version = 2 fh = __get_fh($argp,3) count = $argp->count @@ -309,7 +312,7 @@ 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" + version = 2 retstr = sprintf("%d",$return) } @@ -318,7 +321,7 @@ probe nfsd.proc3.read = kernel.function("nfsd3_proc_read")?, { client_ip = $rqstp->rq_addr->sin_addr->s_addr proto = $rqstp->rq_prot - version = "NFSV3" + version = 3 fh = __get_fh($argp,4) count = $argp->count @@ -338,7 +341,7 @@ 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" + version = 3 retstr = sprintf("%d",$return) } @@ -374,7 +377,7 @@ probe nfsd.proc2.write = kernel.function("nfsd_proc_write")?, { client_ip = $rqstp->rq_addr->sin_addr->s_addr proto = $rqstp->rq_prot - version = "NFSV2" + version = 2 fh = __get_fh($argp,5) count = $argp->len @@ -394,7 +397,7 @@ 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" + version = 2 retstr = sprintf("%d",$return) } @@ -403,7 +406,7 @@ probe nfsd.proc3.write = kernel.function("nfsd3_proc_write")?, { client_ip = $rqstp->rq_addr->sin_addr->s_addr proto = $rqstp->rq_prot - version = "NFSV3" + version = 3 fh = __get_fh($argp,6) count = $argp->count @@ -424,7 +427,7 @@ 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" + version = 3 retstr = sprintf("%d",$return) } @@ -456,7 +459,7 @@ probe nfsd.proc3.commit = kernel.function("nfsd3_proc_commit")?, { client_ip = $rqstp->rq_addr->sin_addr->s_addr proto = $rqstp->rq_prot - version = "NFSV3" + version = 3 fh = __get_fh($argp,7) count = $argp->count @@ -473,7 +476,7 @@ 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" + version = 3 retstr = sprintf("%d",$return) } @@ -497,11 +500,11 @@ probe nfsd.proc.create.return = nfsd.proc2.create.return, {} probe nfsd.proc2.create = kernel.function("nfsd_proc_create")?, - module("nfsd").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" + version = 2 fh = __get_fh($argp,8) filename = kernel_string($argp->name) @@ -512,19 +515,19 @@ probe nfsd.proc2.create = kernel.function("nfsd_proc_create")?, } probe nfsd.proc2.create.return = kernel.function("nfsd_proc_create").return?, - module("nfsd").function("nfsd_proc_create").return + module("nfsd").function("nfsd_proc_create").return? { name = "nfsd.proc2.create.return" - version = "NFSV2" + version = 2 retstr = sprintf("%d",$return) } probe nfsd.proc3.create = kernel.function("nfsd3_proc_create")?, - module("nfsd").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" + version = 3 fh = __get_fh($argp,9) filename = kernel_string($argp->name) @@ -535,10 +538,10 @@ probe nfsd.proc3.create = kernel.function("nfsd3_proc_create")?, } probe nfsd.proc3.create.return = kernel.function("nfsd3_proc_create").return?, - module("nfsd").function("nfsd3_proc_create").return + module("nfsd").function("nfsd3_proc_create").return? { name = "nfsd.proc3.create.return" - version = "NFSV3" + version = 3 retstr = sprintf("%d",$return) } @@ -562,11 +565,11 @@ probe nfsd.proc.remove.return = nfsd.proc2.remove.return, {} probe nfsd.proc2.remove = kernel.function("nfsd_proc_remove")?, - module("nfsd").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" + version = 2 fh = __get_fh($argp,10) filename = kernel_string($argp->name) @@ -577,19 +580,19 @@ probe nfsd.proc2.remove = kernel.function("nfsd_proc_remove")?, } probe nfsd.proc2.remove.return = kernel.function("nfsd_proc_remove").return?, - module("nfsd").function("nfsd_proc_remove").return + module("nfsd").function("nfsd_proc_remove").return? { name = "nfsd.proc2.remove.return" - version = "NFSV2" + version = 2 retstr = sprintf("%d",$return) } probe nfsd.proc3.remove = kernel.function("nfsd3_proc_remove")?, - module("nfsd").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" + version = 3 fh = __get_fh($argp,11) filename = kernel_string($argp->name) @@ -603,7 +606,7 @@ 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" + version = 3 retstr = sprintf("%d",$return) } @@ -632,7 +635,7 @@ probe nfsd.proc2.rename = kernel.function("nfsd_proc_rename")?, { client_ip = $rqstp->rq_addr->sin_addr->s_addr proto = $rqstp->rq_prot - version = "NFSV2" + version = 2 fh = __get_fh($argp,12) tfh = __get_fh($argp,13) @@ -649,7 +652,7 @@ 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" + version = 2 retstr = sprintf("%d",$return) } @@ -658,7 +661,7 @@ probe nfsd.proc3.rename = kernel.function("nfsd3_proc_rename")?, { client_ip = $rqstp->rq_addr->sin_addr->s_addr proto = $rqstp->rq_prot - version = "NFSV3" + version = 3 fh = __get_fh($argp,14) tfh = __get_fh($argp,15) @@ -675,7 +678,7 @@ 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" + version = 3 retstr = sprintf("%d",$return) } /* @@ -696,11 +699,11 @@ probe nfsd.proc.compound.return = nfsd.proc4.compound.return {} probe nfsd.proc4.compound = kernel.function("nfsd4_proc_compound")?, - module("nfsd").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" + version = 4 num = $args->opcnt op = $args->ops @@ -710,10 +713,10 @@ probe nfsd.proc4.compound = kernel.function("nfsd4_proc_compound")?, } probe nfsd.proc4.compound.return = kernel.function("nfsd4_proc_compound").return?, - module("nfsd").function("nfsd4_proc_compound").return + module("nfsd").function("nfsd4_proc_compound").return? { name = "nfsd.proc4.compound.return" - version = "NFSV4" + version = 4 retstr = sprintf("%d",$return) } @@ -729,7 +732,7 @@ probe nfsd.entries = nfsd.open, nfsd.close {} -probe nfsd.return= nfsd.open.return, +probe nfsd.return = nfsd.open.return, nfsd.read.return, nfsd.write.return, nfsd.lookup.return, @@ -748,7 +751,7 @@ probe nfsd.return= nfsd.open.return, * type : type of file(regular file or dir) */ probe nfsd.open = kernel.function("nfsd_open") ?, - module("nfsd").function("nfsd_open") + module("nfsd").function("nfsd_open")? { fh = __svc_fh($fhp) @@ -760,7 +763,7 @@ probe nfsd.open = kernel.function("nfsd_open") ?, } probe nfsd.open.return = kernel.function("nfsd_open").return ?, - module("nfsd").function("nfsd_open").return + module("nfsd").function("nfsd_open").return? { name = "nfsd.open.return" retstr = sprintf("%d",$return) @@ -780,6 +783,10 @@ probe nfsd.close = kernel.function("nfsd_close")?, name = "nfsd.close" argstr = sprintf("%s",filename) } + +probe nfsd.close.return = kernel.function("nfsd_close").return?, + module("nfsd").function("nfsd_close").return? +{} /*probe nfsd.read * Fires when server reads data from a file * @@ -928,7 +935,8 @@ probe nfsd.lookup.return = kernel.function("nfsd_lookup").return?, * filename : file name * filelen : the length of file name * type : file type(regular,dir,device,fifo ...) -* iap: inode attributes +* iap_valid: Attribute flags +* iap_mode : file access mode */ probe nfsd.create = kernel.function("nfsd_create")?, module("nfsd").function("nfsd_create")? @@ -938,10 +946,11 @@ probe nfsd.create = kernel.function("nfsd_create")?, filename = kernel_string($fname) filelen = $flen type = $type - iap = $iap + iap_valid = $iap->ia_valid + iap_mode = $iap->ia_mode name = "nfsd.create" - argstr = sprintf("%s,%d",filename,iap) + argstr = sprintf("%s,%d",filename,type) } probe nfsd.create.return = kernel.function("nfsd_create").return?, @@ -961,7 +970,8 @@ probe nfsd.create.return = kernel.function("nfsd_create").return?, * 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 +* iap_valid: Attribute flags +* iap_mode : file access mode * 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 @@ -975,7 +985,8 @@ probe nfsd.createv3 = kernel.function("nfsd_create_v3")?, filename = kernel_string($fname) filelen = $flen - ia_mode = $iap + iap_valid = $iap->ia_valid + iap_mode = $iap->ia_mode truncp = $truncp verfier = $verifier createmode = $createmode |