src/lket.5.in:

document nfs trace hooks

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

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

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

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

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

8 files changed, 2886 insertions, 9 deletions

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;
+	}
+%}