Removing LKET tapset files. (PR 4817: retiring LKET services)

19 files changed, 0 insertions, 7209 deletions

diff --git a/tapset/LKET/aio.stp b/tapset/LKET/aio.stp
deleted file mode 100755
index 09b3a3b8..00000000
--- a/tapset/LKET/aio.stp
+++ /dev/null
@@ -1,296 +0,0 @@
-// AIO tapset
-// 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.
-
-/*
- * the following aio related probes are used to probe those aio related
- * calls inside the kernel. They are: sys_io_setup, sys_io_submit, 
- * sys_io_getevents, sys_io_destroy, sys_io_cancel, io_submit_one
- */
-
-probe addevent.aio
-	= addevent.aio.entry, addevent.aio.return
-{}
-
-probe addevent.aio.entry
-	=
-	addevent.aio.io_setup.entry,
-	addevent.aio.io_submit.entry,
-	addevent.aio.io_submit_one.entry,
-	addevent.aio.io_destroy.entry,
-	addevent.aio.io_getevents.entry,
-	addevent.aio.io_cancel.entry
-{}
-
-probe addevent.aio.return
-	=
-	addevent.aio.io_setup.return,
-	addevent.aio.io_submit.return,
-	addevent.aio.io_submit_one.return,
-	addevent.aio.io_destroy.return,
-	addevent.aio.io_getevents.return,
-	addevent.aio.io_cancel.return
-{}
-
-/* 
- *  Fires by calling io_setup from user space. The corresponding
- *  system call is sys_io_setup, which will create an aio_context 
- *  capable of receiving at least maxevents.
- */
-probe addevent.aio.io_setup = 
-	addevent.aio.io_setup.entry, addevent.aio.io_setup.return
-{}
-
-probe addevent.aio.io_setup.entry
-	+= _addevent.aio.io_setup.entry
-{
-	update_record()
-}
-
-probe _addevent.aio.io_setup.entry
-	= syscall.io_setup
-{
-	log_aio_setup(maxevents, ctxp_uaddr)
-}
-
-function log_aio_setup(nr_events:long, ctxp_uaddr:long)
-%{
-	/* nr_events|ctxp_uaddr */
-	_lket_trace(_GROUP_AIO, _HOOKID_AIO_IO_SETUP_ENTRY, "%4b%8b", 
-		THIS->nr_events, THIS->ctxp_uaddr);
-%}
-
-probe addevent.aio.io_setup.return
-        += _addevent.aio.io_setup.return
-{
-        update_record()
-}
-
-probe _addevent.aio.io_setup.return
-        = kernel.function("sys_io_setup").return
-{
-        log_aio_return(HOOKID_AIO_IO_SETUP_RETURN, $return)
-}
-
-function log_aio_return(hookid:long, retval:long)
-%{
-	_lket_trace(_GROUP_AIO, THIS->hookid, "%8b", THIS->retval);
-%}
-
-/*
- * Fired by calling io_submit from user space. The corresponding  
- * system call is sys_io_submit which will queue the nr iocbs 
- * pointed to by iocbpp_uaddr for processing.
- */
-probe addevent.aio.io_submit =
-	addevent.aio.io_submit.entry, addevent.aio.io_submit.return
-{}
- 
-probe addevent.aio.io_submit.entry
-	+= _addevent.aio.io_submit.entry
-{
-	update_record()
-}
-
-probe _addevent.aio.io_submit.entry
-	= syscall.io_submit
-{
-	log_aio_submit(ctx_id, nr, iocbpp_uaddr)
-}
-
-function log_aio_submit(ctx_id:long, nr:long, iocbpp_uaddr:long)
-%{
-	/* ctx_id | no_iocbs | iocbpp */
-	_lket_trace(_GROUP_AIO, _HOOKID_AIO_IO_SUBMIT_ENTRY, "%8b%4b%8b", 
-		THIS->ctx_id, THIS->nr, THIS->iocbpp_uaddr);
-%}
-
-probe addevent.aio.io_submit.return
-	+= _addevent.aio.io_submit.return
-{
-	update_record()
-}
-
-probe _addevent.aio.io_submit.return
-	= syscall.io_submit.return
-{
-	log_aio_return(HOOKID_AIO_IO_SUBMIT_RETURN, $return)	
-}
-
-/* Called by sys_io_submit, will iterate iocbpp and process them
- * one by one
- */
-probe addevent.aio.io_submit_one
-	= addevent.aio.io_submit_one.entry, addevent.aio.io_submit_one.return
-{}
-
-probe addevent.aio.io_submit_one.entry
-	+= _addevent.aio.io_submit_one.entry
-{
-	update_record()
-}
-
-
-probe _addevent.aio.io_submit_one.entry
-	= kernel.function("io_submit_one")
-{
-	log_io_submit_one($ctx, $user_iocb, $user_iocb->aio_lio_opcode,
-		$user_iocb->aio_reqprio, $user_iocb->aio_fildes, 
-		$user_iocb->aio_buf, $user_iocb->aio_nbytes, 
-		$user_iocb->aio_offset )	
-}
-
-function log_io_submit_one(ctx:long, user_iocb_uaddr:long, aio_lio_opcode:long,
-		aio_reqprio:long, aio_fildes:long, aio_buf:long, aio_nbytes:long,
-		aio_offset:long)
-%{
-	/* ctx | user_iocb_addr | aio_lio_opcode | >aio_reqprio |
-		aio_fildes | aio_buf | aio_nbytes | >aio_offset */
-	_lket_trace(_GROUP_AIO, _HOOKID_AIO_IO_SUBMIT_ONE_ENTRY, 
-		"%8b%8b%2b%2b%4b%8b%8b%8b", 
-		THIS->ctx, THIS->user_iocb_uaddr, THIS->aio_lio_opcode, 
-		THIS->aio_reqprio, THIS->aio_fildes, 
-		THIS->aio_buf, THIS->aio_nbytes, 
-		THIS->aio_offset);
-%}
-
-probe addevent.aio.io_submit_one.return
-	+= _addevent.aio.io_submit_one.return
-{
-	update_record()
-}
-
-probe _addevent.aio.io_submit_one.return
-	= kernel.function("io_submit_one").return
-{
-	log_aio_return(HOOKID_AIO_IO_SUBMIT_ONE_RETURN, $return)
-}
-
-/*
- * Fired by calling io_destroy from user space. The corresponding 
- * system call is sys_io_destroy, which will destroy the aio_context 
- * specified.
- */
-probe addevent.aio.io_destroy =
-	addevent.aio.io_destroy.entry, addevent.aio.io_destroy.return
-{}
-
-probe addevent.aio.io_destroy.entry
-	+= _addevent.aio.io_destroy.entry
-{
-	update_record()
-}
-
-probe _addevent.aio.io_destroy.entry
-	= syscall.io_destroy
-{
-	log_io_destroy(ctx)
-}
-
-function log_io_destroy(ctx:long)
-%{
-	_lket_trace(_GROUP_AIO, _HOOKID_AIO_IO_DESTROY_ENTRY, "%8b", THIS->ctx);
-%}
-
-
-probe addevent.aio.io_destroy.return
-        += _addevent.aio.io_destroy.return
-{
-        update_record()
-}
-
-probe _addevent.aio.io_destroy.return
-        = syscall.io_destroy.return
-{
-        log_aio_return(HOOKID_AIO_IO_DESTROY_RETURN, $return)
-}
-
-/*
- * Fired by calling io_getevents from user space. The corresponding 
- * system call is sys_io_getevents, which will attempt to read at 
- * least min_nr events and up to nr events from the completion queue 
- * for the aio_context specified by ctx_id.
- */
-probe addevent.aio.io_getevents
-	= addevent.aio.io_getevents.entry, addevent.aio.io_getevents.return
-{}
-
-probe addevent.aio.io_getevents.entry
-        += _addevent.aio.io_getevents.entry
-{
-        update_record()
-}
-
-probe _addevent.aio.io_getevents.entry
-        = syscall.io_getevents
-{
-	log_io_getevents(ctx_id, min_nr, nr, events_uaddr, timeout_uaddr)
-}
-
-function log_io_getevents(ctx_id:long, min_nr:long, nr:long, 
-		events_uaddr:long, timeout:long)
-%{
-	struct timespec __user *timeout = (struct timespec *)((long)THIS->timeout);
-	struct timespec ts;
-
-	if (likely(0 == copy_from_user(&ts, timeout, sizeof(ts))))
-		_lket_trace(_GROUP_AIO, _HOOKID_AIO_IO_GETEVENTS_ENTRY,
-				"%8b%4b%4b%8b%4b%4b", THIS->ctx_id, THIS->min_nr,
-				THIS->nr, THIS->events_uaddr, (_FMT_)ts.tv_sec, 
-				(_FMT_)ts.tv_nsec);
-%}
-
-probe addevent.aio.io_getevents.return
-        += _addevent.aio.io_getevents.return
-{
-        update_record()
-}
-
-probe _addevent.aio.io_getevents.return
-        = syscall.io_getevents.return
-{
-        log_aio_return(HOOKID_AIO_IO_GETEVENTS_RETURN, $return)
-}
-
-/* 
- * Fired by calling io_cancel from user space. The corresponding
- * system call is sys_io_cancel, which will attempt to cancel 
- * an iocb previously passed to io_submit.
- */
-probe addevent.aio.io_cancel
-	= addevent.aio.io_cancel.entry, addevent.aio.io_cancel.return
-{}
-
-probe addevent.aio.io_cancel.entry
-	+= _addevent.aio.io_cancel.entry
-{
-	update_record()
-}
-
-probe _addevent.aio.io_cancel.entry
-	= syscall.io_cancel
-{
-	log_aio_cancel(ctx_id, iocb_uaddr, result_uaddr)
-}
-
-function log_aio_cancel(ctx_id:long, iocb_uaddr:long, result_uaddr:long)
-%{
-	_lket_trace(_GROUP_AIO, _HOOKID_AIO_IO_CANCEL_ENTRY, "%8b%8b%8b",
-		THIS->ctx_id, THIS->iocb_uaddr, THIS->result_uaddr);
-%}
-
-probe addevent.aio.io_cancel.return
-	+= _addevent.aio.io_cancel.return
-{
-	update_record()
-}
-
-probe _addevent.aio.io_cancel.return
-	= syscall.io_cancel.return
-{
-	log_aio_return(HOOKID_AIO_IO_CANCEL_RETURN, $return)
-}
diff --git a/tapset/LKET/hookid_defs.stp b/tapset/LKET/hookid_defs.stp
deleted file mode 100755
index e4ee0407..00000000
--- a/tapset/LKET/hookid_defs.stp
+++ /dev/null
@@ -1,905 +0,0 @@
-global 
-	/* register event */
-	GROUP_REGEVT,
-	HOOKID_REGSYSEVT,
-	HOOKID_REGUSREVT,
-	HOOKID_REGEVTDESC,
-
-	/* syscall */
-	GROUP_SYSCALL,
-	HOOKID_SYSCALL_ENTRY, HOOKID_SYSCALL_RETURN, 
-
-	/* process creation */
-	GROUP_PROCESS,
-	HOOKID_PROCESS_SNAPSHOT, HOOKID_PROCESS_FORK, 
-	HOOKID_PROCESS_EXECVE, HOOKID_PROCESS_EXIT_ENTRY,
-	stoptrace_exec, stoptrace_fork,
-
-	/* io scheduler */
-	GROUP_IOSCHED,
-	HOOKID_IOSCHED_ADD_REQ,
-	HOOKID_IOSCHED_NEXT_REQ_ENTRY, 
-	HOOKID_IOSCHED_NEXT_REQ_RETURN, 
-	HOOKID_IOSCHED_COMPLETE_REQ,
-
-	/* task dispatching */
-	GROUP_TASK,
-	HOOKID_TASK_CTXSWITCH, HOOKID_TASK_CPUIDLE,
-
-	/* scsi */
-	GROUP_SCSI,
-	HOOKID_SCSI_IOENTRY, HOOKID_SCSI_IO_TO_LLD,
-	HOOKID_SCSI_IODONE_BY_LLD, HOOKID_SCSI_IOCOMP_BY_MIDLEVEL,
-
-	/* page fault */
-	GROUP_PAGEFAULT,
-	HOOKID_PAGEFAULT,
-
-	/* network device */
-	GROUP_NETDEV,
-	HOOKID_NETDEV_RECEIVE, HOOKID_NETDEV_TRANSMIT,
-
-	/* io related syscall (not including AIO related calls) */
-	GROUP_IOSYSCALL,
-
-	HOOKID_IOSYSCALL_OPEN_ENTRY,
-	HOOKID_IOSYSCALL_OPEN_RETURN,
-
-	HOOKID_IOSYSCALL_CLOSE_ENTRY,
-	HOOKID_IOSYSCALL_CLOSE_RETURN,
-
-	HOOKID_IOSYSCALL_READ_ENTRY,
-	HOOKID_IOSYSCALL_READ_RETURN,
-
-	HOOKID_IOSYSCALL_WRITE_ENTRY, 
-	HOOKID_IOSYSCALL_WRITE_RETURN,
-
-	HOOKID_IOSYSCALL_READV_ENTRY,
-	HOOKID_IOSYSCALL_READV_RETURN,
-
-	HOOKID_IOSYSCALL_WRITEV_ENTRY, 
-	HOOKID_IOSYSCALL_WRITEV_RETURN,
-
-	HOOKID_IOSYSCALL_PREAD64_ENTRY, 
-	HOOKID_IOSYSCALL_PREAD64_RETURN,
-
-	HOOKID_IOSYSCALL_PWRITE64_ENTRY, 
-	HOOKID_IOSYSCALL_PWRITE64_RETURN,
-
-	HOOKID_IOSYSCALL_READAHEAD_ENTRY, 
-	HOOKID_IOSYSCALL_READAHEAD_RETURN,
-
-	HOOKID_IOSYSCALL_SENDFILE_ENTRY, 
-	HOOKID_IOSYSCALL_SENDFILE_RETURN,
-
-	HOOKID_IOSYSCALL_SENDFILE64_ENTRY, 
-	HOOKID_IOSYSCALL_SENDFILE64_RETURN,
-
-	HOOKID_IOSYSCALL_LSEEK_ENTRY,
-	HOOKID_IOSYSCALL_LSEEK_RETURN,
-
-	HOOKID_IOSYSCALL_LLSEEK_ENTRY,
-	HOOKID_IOSYSCALL_LLSEEK_RETURN,
-
-	HOOKID_IOSYSCALL_SYNC_ENTRY,
-	HOOKID_IOSYSCALL_SYNC_RETURN,
-
-	HOOKID_IOSYSCALL_FSYNC_ENTRY,
-	HOOKID_IOSYSCALL_FSYNC_RETURN,
-
-	HOOKID_IOSYSCALL_FDATASYNC_ENTRY,
-	HOOKID_IOSYSCALL_FDATASYNC_RETURN,
-
-	HOOKID_IOSYSCALL_FLOCK_ENTRY,
-	HOOKID_IOSYSCALL_FLOCK_RETURN,
-
-	/* AIO related calls */
-	GROUP_AIO,
-
-	HOOKID_AIO_IO_SETUP_ENTRY,
-	HOOKID_AIO_IO_SETUP_RETURN,
-	HOOKID_AIO_IO_SUBMIT_ENTRY,
-	HOOKID_AIO_IO_SUBMIT_RETURN,
-	HOOKID_AIO_IO_SUBMIT_ONE_ENTRY,
-	HOOKID_AIO_IO_SUBMIT_ONE_RETURN,
-	HOOKID_AIO_IO_GETEVENTS_ENTRY,
-	HOOKID_AIO_IO_GETEVENTS_RETURN,
-	HOOKID_AIO_IO_DESTROY_ENTRY,
-	HOOKID_AIO_IO_DESTROY_RETURN,
-	HOOKID_AIO_IO_CANCEL_ENTRY,
-	HOOKID_AIO_IO_CANCEL_RETURN,
-
-	/* signal */
-	GROUP_SIGNAL,
-
-	HOOKID_SIGNAL_SEND_ENTRY,
-	HOOKID_SIGNAL_SEND_RETURN,
-
-	HOOKID_SIGNAL_SYSKILL_ENTRY,
-	HOOKID_SIGNAL_SYSKILL_RETURN,
-
-	HOOKID_SIGNAL_SYSTGKILL_ENTRY,
-	HOOKID_SIGNAL_SYSTGKILL_RETURN,
-
-	HOOKID_SIGNAL_SYSTKILL_ENTRY,
-	HOOKID_SIGNAL_SYSTKILL_RETURN,
-
-	HOOKID_SIGNAL_PENDING_ENTRY,
-	HOOKID_SIGNAL_PENDING_RETURN,
-
-	HOOKID_SIGNAL_DOACTION_ENTRY,
-	HOOKID_SIGNAL_DOACTION_RETURN,
-
-	HOOKID_SIGNAL_PROC_MASK_ENTRY,
-	HOOKID_SIGNAL_PROC_MASK_RETURN,
-
-	HOOKID_SIGNAL_FLUSH_ENTRY,
-
-	/* RPC */
-	GROUP_SUNRPC,
-
-	HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY,
-	HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN,
-	HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY,
-	HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN,
-	HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY,
-	HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN,
-	HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY,
-	HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN,
-	HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY,
-	HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN,
-	HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY,
-	HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN,
-	HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY,
-	HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN,
-	
-	HOOKID_SUNRPC_SVC_REGISTER_ENTRY,
-	HOOKID_SUNRPC_SVC_REGISTER_RETURN,
-	HOOKID_SUNRPC_SVC_CREATE_ENTRY,
-	HOOKID_SUNRPC_SVC_CREATE_RETURN,
-	HOOKID_SUNRPC_SVC_DESTROY_ENTRY,
-	HOOKID_SUNRPC_SVC_DESTROY_RETURN,
-	HOOKID_SUNRPC_SVC_PROCESS_ENTRY,
-	HOOKID_SUNRPC_SVC_PROCESS_RETURN,
-	HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY,
-	HOOKID_SUNRPC_SVC_AUTHORISE_RETURN,
-	HOOKID_SUNRPC_SVC_RECV_ENTRY,
-	HOOKID_SUNRPC_SVC_RECV_RETURN,
-	HOOKID_SUNRPC_SVC_SEND_ENTRY,
-	HOOKID_SUNRPC_SVC_SEND_RETURN,
-	HOOKID_SUNRPC_SVC_DROP_ENTRY,
-	HOOKID_SUNRPC_SVC_DROP_RETURN,
-	
-	HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY,
-	HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN,
-	HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY,
-	HOOKID_SUNRPC_SCHED_EXECUTE_RETURN,
-	HOOKID_SUNRPC_SCHED_DELAY_ENTRY,
-	HOOKID_SUNRPC_SCHED_DELAY_RETURN,
-	HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY,
-	HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN,
-
-	/* CPU Frequency */
-	GROUP_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 */
-
-/* Group ID Definitions */
-int _GROUP_REGEVT = 1;
-int _GROUP_SYSCALL = 2;
-int _GROUP_PROCESS = 3;
-int _GROUP_IOSCHED = 4;
-int _GROUP_TASK = 5;
-int _GROUP_SCSI = 6;
-int _GROUP_PAGEFAULT = 7;
-int _GROUP_NETDEV = 8;
-int _GROUP_IOSYSCALL = 9;
-int _GROUP_AIO = 10;
-int _GROUP_SIGNAL = 11;
-int _GROUP_SUNRPC = 12;
-int _GROUP_CPUFREQ = 15;
-int _GROUP_NFS = 16;
-int _GROUP_NFSD = 17;
-
-/* hookIDs defined inside each group */
-int _HOOKID_REGSYSEVT = 1;
-int _HOOKID_REGUSREVT = 3;
-int _HOOKID_REGEVTDESC = 5;
-
-int _HOOKID_SYSCALL_ENTRY = 1;
-int _HOOKID_SYSCALL_RETURN = 2;
-
-int _HOOKID_PROCESS_SNAPSHOT = 1;
-int _HOOKID_PROCESS_EXECVE = 3;
-int _HOOKID_PROCESS_FORK = 5;
-int _HOOKID_PROCESS_EXIT_ENTRY = 7;
-
-int _HOOKID_IOSCHED_ADD_REQ = 1;
-int _HOOKID_IOSCHED_NEXT_REQ_ENTRY = 3;
-int _HOOKID_IOSCHED_NEXT_REQ_RETURN = 4;
-int _HOOKID_IOSCHED_COMPLETE_REQ = 5;
-
-int _HOOKID_TASK_CTXSWITCH = 1;
-int _HOOKID_TASK_CPUIDLE = 3;
-
-int _HOOKID_SCSI_IOENTRY = 1;
-int _HOOKID_SCSI_IO_TO_LLD = 3;
-int _HOOKID_SCSI_IODONE_BY_LLD = 5;
-int _HOOKID_SCSI_IOCOMP_BY_MIDLEVEL = 7;
-
-int _HOOKID_PAGEFAULT = 1;
-
-int _HOOKID_NETDEV_RECEIVE = 1;
-int _HOOKID_NETDEV_TRANSMIT = 3;
-
-int _HOOKID_IOSYSCALL_OPEN_ENTRY = 1;
-int _HOOKID_IOSYSCALL_OPEN_RETURN = 2;
-int _HOOKID_IOSYSCALL_CLOSE_ENTRY = 3;
-int _HOOKID_IOSYSCALL_CLOSE_RETURN = 4;
-int _HOOKID_IOSYSCALL_READ_ENTRY = 5;
-int _HOOKID_IOSYSCALL_READ_RETURN = 6;
-int _HOOKID_IOSYSCALL_WRITE_ENTRY = 7; 
-int _HOOKID_IOSYSCALL_WRITE_RETURN = 8;
-int _HOOKID_IOSYSCALL_READV_ENTRY = 9;
-int _HOOKID_IOSYSCALL_READV_RETURN = 10;
-int _HOOKID_IOSYSCALL_WRITEV_ENTRY = 11; 
-int _HOOKID_IOSYSCALL_WRITEV_RETURN = 12;
-int _HOOKID_IOSYSCALL_PREAD64_ENTRY = 13; 
-int _HOOKID_IOSYSCALL_PREAD64_RETURN = 14;
-int _HOOKID_IOSYSCALL_PWRITE64_ENTRY = 15; 
-int _HOOKID_IOSYSCALL_PWRITE64_RETURN = 16;
-int _HOOKID_IOSYSCALL_READAHEAD_ENTRY = 17; 
-int _HOOKID_IOSYSCALL_READAHEAD_RETURN = 18;
-int _HOOKID_IOSYSCALL_SENDFILE_ENTRY = 19; 
-int _HOOKID_IOSYSCALL_SENDFILE_RETURN = 20;
-int _HOOKID_IOSYSCALL_LSEEK_ENTRY = 21;
-int _HOOKID_IOSYSCALL_LSEEK_RETURN = 22;
-int _HOOKID_IOSYSCALL_LLSEEK_ENTRY = 23;
-int _HOOKID_IOSYSCALL_LLSEEK_RETURN = 24;
-int _HOOKID_IOSYSCALL_SYNC_ENTRY = 25;
-int _HOOKID_IOSYSCALL_SYNC_RETURN = 26;
-int _HOOKID_IOSYSCALL_FSYNC_ENTRY = 27;
-int _HOOKID_IOSYSCALL_FSYNC_RETURN = 28;
-int _HOOKID_IOSYSCALL_FDATASYNC_ENTRY = 29;
-int _HOOKID_IOSYSCALL_FDATASYNC_RETURN = 30;
-int _HOOKID_IOSYSCALL_FLOCK_ENTRY = 31;
-int _HOOKID_IOSYSCALL_FLOCK_RETURN = 32;
-
-int _HOOKID_AIO_IO_SETUP_ENTRY = 1;
-int _HOOKID_AIO_IO_SETUP_RETURN = 2;
-int _HOOKID_AIO_IO_SUBMIT_ENTRY = 3;
-int _HOOKID_AIO_IO_SUBMIT_RETURN = 4;
-int _HOOKID_AIO_IO_SUBMIT_ONE_ENTRY = 5;
-int _HOOKID_AIO_IO_SUBMIT_ONE_RETURN = 6;
-int _HOOKID_AIO_IO_GETEVENTS_ENTRY = 7;
-int _HOOKID_AIO_IO_GETEVENTS_RETURN = 8;
-int _HOOKID_AIO_IO_DESTROY_ENTRY = 9;
-int _HOOKID_AIO_IO_DESTROY_RETURN = 10;
-int _HOOKID_AIO_IO_CANCEL_ENTRY = 11;
-int _HOOKID_AIO_IO_CANCEL_RETURN = 12;
-
-int _HOOKID_SIGNAL_SEND_ENTRY = 1;
-int _HOOKID_SIGNAL_SEND_RETURN = 2;
-int _HOOKID_SIGNAL_SYSKILL_ENTRY = 3;
-int _HOOKID_SIGNAL_SYSKILL_RETURN = 4;
-int _HOOKID_SIGNAL_SYSTGKILL_ENTRY= 5; 
-int _HOOKID_SIGNAL_SYSTGKILL_RETURN = 6;
-int _HOOKID_SIGNAL_SYSTKILL_ENTRY = 7;
-int _HOOKID_SIGNAL_SYSTKILL_RETURN = 8;
-int _HOOKID_SIGNAL_PENDING_ENTRY = 9;
-int _HOOKID_SIGNAL_PENDING_RETURN = 10;
-int _HOOKID_SIGNAL_DOACTION_ENTRY = 11;
-int _HOOKID_SIGNAL_DOACTION_RETURN = 12;
-int _HOOKID_SIGNAL_PROC_MASK_ENTRY = 13;
-int _HOOKID_SIGNAL_PROC_MASK_RETURN = 14;
-int _HOOKID_SIGNAL_FLUSH_ENTRY = 15;
-
-int _HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY = 1;
-int _HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN = 2;
-int _HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY = 3;
-int _HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN = 4;
-int _HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY = 5;
-int _HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN = 6;
-int _HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY = 7;
-int _HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN = 8;
-int _HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY = 9;
-int _HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN = 10;
-int _HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY = 11;
-int _HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN = 12;
-int _HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY = 13;
-int _HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN = 14;
-
-int _HOOKID_SUNRPC_SVC_REGISTER_ENTRY = 33;
-int _HOOKID_SUNRPC_SVC_REGISTER_RETURN = 34;
-int _HOOKID_SUNRPC_SVC_CREATE_ENTRY = 35;
-int _HOOKID_SUNRPC_SVC_CREATE_RETURN = 36;
-int _HOOKID_SUNRPC_SVC_DESTROY_ENTRY = 37;
-int _HOOKID_SUNRPC_SVC_DESTROY_RETURN = 38;
-int _HOOKID_SUNRPC_SVC_PROCESS_ENTRY = 39;
-int _HOOKID_SUNRPC_SVC_PROCESS_RETURN = 40;
-int _HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY = 41;
-int _HOOKID_SUNRPC_SVC_AUTHORISE_RETURN = 42;
-int _HOOKID_SUNRPC_SVC_RECV_ENTRY = 43;
-int _HOOKID_SUNRPC_SVC_RECV_RETURN = 44;
-int _HOOKID_SUNRPC_SVC_SEND_ENTRY = 45;
-int _HOOKID_SUNRPC_SVC_SEND_RETURN = 46;
-int _HOOKID_SUNRPC_SVC_DROP_ENTRY = 47;
-int _HOOKID_SUNRPC_SVC_DROP_RETURN = 48;
-
-int _HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY = 65;
-int _HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN = 66;
-int _HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY = 67;
-int _HOOKID_SUNRPC_SCHED_EXECUTE_RETURN = 68;
-int _HOOKID_SUNRPC_SCHED_DELAY_ENTRY = 69;
-int _HOOKID_SUNRPC_SCHED_DELAY_RETURN = 70;
-int _HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY = 71;
-int _HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN = 72;
-
-
-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= 53;
-int _HOOKID_NFS_PROC_COMMITSETUP_ENTRY= 55;
-
-int _HOOKID_NFS_PROC_READDONE_ENTRY= 57;
-int _HOOKID_NFS_PROC_READDONE_RETURN= 58;
-int _HOOKID_NFS_PROC_WRITEDONE_ENTRY= 59;
-int _HOOKID_NFS_PROC_WRITEDONE_RETURN= 60;
-int _HOOKID_NFS_PROC_COMMITDONE_ENTRY= 61;
-int _HOOKID_NFS_PROC_COMMITDONE_RETURN= 62;
-int _HOOKID_NFS_PROC_OPEN_ENTRY= 63;
-int _HOOKID_NFS_PROC_OPEN_RETURN= 64;
-int _HOOKID_NFS_PROC_RELEASE_ENTRY= 65;
-int _HOOKID_NFS_PROC_RELEASE_RETURN= 66;
-int _HOOKID_NFS_PROC_CREATE_ENTRY= 67;
-int _HOOKID_NFS_PROC_CREATE_RETURN= 68;
-int _HOOKID_NFS_PROC_RENAME_ENTRY= 69;
-int _HOOKID_NFS_PROC_RENAME_RETURN= 70;
-int _HOOKID_NFS_PROC_REMOVE_ENTRY= 71;
-int _HOOKID_NFS_PROC_REMOVE_RETURN= 72;
-
-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()
-{
-/* Group ID Definitions */
-GROUP_REGEVT = 1;
-GROUP_SYSCALL = 2;
-GROUP_PROCESS = 3;
-GROUP_IOSCHED = 4;
-GROUP_TASK = 5;
-GROUP_SCSI = 6;
-GROUP_PAGEFAULT = 7;
-GROUP_NETDEV = 8;
-GROUP_IOSYSCALL = 9;
-GROUP_AIO = 10;
-GROUP_SIGNAL = 11;
-GROUP_SUNRPC = 12;
-GROUP_CPUFREQ = 15;
-GROUP_NFS = 16;
-GROUP_NFSD = 17;
-
-/* hookIDs defined inside each group */
-HOOKID_REGSYSEVT = 1;
-HOOKID_REGUSREVT = 3;
-HOOKID_REGEVTDESC = 5;
-
-HOOKID_SYSCALL_ENTRY = 1;
-HOOKID_SYSCALL_RETURN = 2;
-
-HOOKID_PROCESS_SNAPSHOT = 1;
-HOOKID_PROCESS_EXECVE = 3;
-HOOKID_PROCESS_FORK = 5;
-HOOKID_PROCESS_EXIT_ENTRY= 7;
-
-HOOKID_IOSCHED_ADD_REQ = 1;
-HOOKID_IOSCHED_NEXT_REQ_ENTRY = 3;
-HOOKID_IOSCHED_NEXT_REQ_RETURN = 4;
-HOOKID_IOSCHED_COMPLETE_REQ = 5;
-
-HOOKID_TASK_CTXSWITCH = 1;
-HOOKID_TASK_CPUIDLE = 3;
-
-HOOKID_SCSI_IOENTRY = 1;
-HOOKID_SCSI_IO_TO_LLD = 3;
-HOOKID_SCSI_IODONE_BY_LLD = 5;
-HOOKID_SCSI_IOCOMP_BY_MIDLEVEL = 7;
-
-HOOKID_PAGEFAULT = 1;
-
-HOOKID_NETDEV_RECEIVE = 1;
-HOOKID_NETDEV_TRANSMIT = 3;
-
-HOOKID_IOSYSCALL_OPEN_ENTRY = 1;
-HOOKID_IOSYSCALL_OPEN_RETURN = 2;
-HOOKID_IOSYSCALL_CLOSE_ENTRY = 3;
-HOOKID_IOSYSCALL_CLOSE_RETURN = 4;
-HOOKID_IOSYSCALL_READ_ENTRY = 5;
-HOOKID_IOSYSCALL_READ_RETURN = 6;
-HOOKID_IOSYSCALL_WRITE_ENTRY = 7; 
-HOOKID_IOSYSCALL_WRITE_RETURN = 8;
-HOOKID_IOSYSCALL_READV_ENTRY = 9;
-HOOKID_IOSYSCALL_READV_RETURN = 10;
-HOOKID_IOSYSCALL_WRITEV_ENTRY = 11; 
-HOOKID_IOSYSCALL_WRITEV_RETURN = 12;
-HOOKID_IOSYSCALL_PREAD64_ENTRY = 13; 
-HOOKID_IOSYSCALL_PREAD64_RETURN = 14;
-HOOKID_IOSYSCALL_PWRITE64_ENTRY = 15; 
-HOOKID_IOSYSCALL_PWRITE64_RETURN = 16;
-HOOKID_IOSYSCALL_READAHEAD_ENTRY = 17; 
-HOOKID_IOSYSCALL_READAHEAD_RETURN = 18;
-HOOKID_IOSYSCALL_SENDFILE_ENTRY = 19; 
-HOOKID_IOSYSCALL_SENDFILE_RETURN = 20;
-HOOKID_IOSYSCALL_LSEEK_ENTRY = 21;
-HOOKID_IOSYSCALL_LSEEK_RETURN = 22;
-HOOKID_IOSYSCALL_LLSEEK_ENTRY = 23;
-HOOKID_IOSYSCALL_LLSEEK_RETURN = 24;
-HOOKID_IOSYSCALL_SYNC_ENTRY = 25;
-HOOKID_IOSYSCALL_SYNC_RETURN = 26;
-HOOKID_IOSYSCALL_FSYNC_ENTRY = 27;
-HOOKID_IOSYSCALL_FSYNC_RETURN = 28;
-HOOKID_IOSYSCALL_FDATASYNC_ENTRY = 29;
-HOOKID_IOSYSCALL_FDATASYNC_RETURN = 30;
-HOOKID_IOSYSCALL_FLOCK_ENTRY = 31;
-HOOKID_IOSYSCALL_FLOCK_RETURN = 32;
-
-HOOKID_AIO_IO_SETUP_ENTRY = 1;
-HOOKID_AIO_IO_SETUP_RETURN = 2;
-HOOKID_AIO_IO_SUBMIT_ENTRY = 3;
-HOOKID_AIO_IO_SUBMIT_RETURN = 4;
-HOOKID_AIO_IO_SUBMIT_ONE_ENTRY = 5;
-HOOKID_AIO_IO_SUBMIT_ONE_RETURN = 6;
-HOOKID_AIO_IO_GETEVENTS_ENTRY = 7;
-HOOKID_AIO_IO_GETEVENTS_RETURN = 8;
-HOOKID_AIO_IO_DESTROY_ENTRY = 9;
-HOOKID_AIO_IO_DESTROY_RETURN = 10;
-HOOKID_AIO_IO_CANCEL_ENTRY = 11;
-HOOKID_AIO_IO_CANCEL_RETURN = 12;
-
-HOOKID_SIGNAL_SEND_ENTRY = 1;
-HOOKID_SIGNAL_SEND_RETURN = 2;
-HOOKID_SIGNAL_SYSKILL_ENTRY = 3;
-HOOKID_SIGNAL_SYSKILL_RETURN = 4;
-HOOKID_SIGNAL_SYSTGKILL_ENTRY= 5; 
-HOOKID_SIGNAL_SYSTGKILL_RETURN = 6;
-HOOKID_SIGNAL_SYSTKILL_ENTRY = 7;
-HOOKID_SIGNAL_SYSTKILL_RETURN = 8;
-HOOKID_SIGNAL_PENDING_ENTRY = 9;
-HOOKID_SIGNAL_PENDING_RETURN = 10;
-HOOKID_SIGNAL_DOACTION_ENTRY = 11;
-HOOKID_SIGNAL_DOACTION_RETURN = 12;
-HOOKID_SIGNAL_PROC_MASK_ENTRY = 13;
-HOOKID_SIGNAL_PROC_MASK_RETURN = 14;
-HOOKID_SIGNAL_FLUSH_ENTRY = 15;
-
-HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY = 1;
-HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN = 2;
-HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY = 3;
-HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN = 4;
-HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY = 5;
-HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN = 6;
-HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY = 7;
-HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN = 8;
-HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY = 9;
-HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN = 10;
-HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY = 11;
-HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN = 12;
-HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY = 13;
-HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN = 14;
-
-HOOKID_SUNRPC_SVC_REGISTER_ENTRY = 33;
-HOOKID_SUNRPC_SVC_REGISTER_RETURN = 34;
-HOOKID_SUNRPC_SVC_CREATE_ENTRY = 35;
-HOOKID_SUNRPC_SVC_CREATE_RETURN = 36;
-HOOKID_SUNRPC_SVC_DESTROY_ENTRY = 37;
-HOOKID_SUNRPC_SVC_DESTROY_RETURN = 38;
-HOOKID_SUNRPC_SVC_PROCESS_ENTRY = 39;
-HOOKID_SUNRPC_SVC_PROCESS_RETURN = 40;
-HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY = 41;
-HOOKID_SUNRPC_SVC_AUTHORISE_RETURN = 42;
-HOOKID_SUNRPC_SVC_RECV_ENTRY = 43;
-HOOKID_SUNRPC_SVC_RECV_RETURN = 44;
-HOOKID_SUNRPC_SVC_SEND_ENTRY = 45;
-HOOKID_SUNRPC_SVC_SEND_RETURN = 46;
-HOOKID_SUNRPC_SVC_DROP_ENTRY = 47;
-HOOKID_SUNRPC_SVC_DROP_RETURN = 48;
-
-HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY = 65;
-HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN = 66;
-HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY = 67;
-HOOKID_SUNRPC_SCHED_EXECUTE_RETURN = 68;
-HOOKID_SUNRPC_SCHED_DELAY_ENTRY = 69;
-HOOKID_SUNRPC_SCHED_DELAY_RETURN = 70;
-HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY = 71;
-HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN = 72;
-
-
-HOOKID_SWITCH_CPUFREQ = 1;
-
-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= 53;
-HOOKID_NFS_PROC_COMMITSETUP_ENTRY= 55;
-
-HOOKID_NFS_PROC_READDONE_ENTRY= 57;
-HOOKID_NFS_PROC_READDONE_RETURN= 58;
-HOOKID_NFS_PROC_WRITEDONE_ENTRY= 59;
-HOOKID_NFS_PROC_WRITEDONE_RETURN= 60;
-HOOKID_NFS_PROC_COMMITDONE_ENTRY= 61;
-HOOKID_NFS_PROC_COMMITDONE_RETURN= 62;
-HOOKID_NFS_PROC_OPEN_ENTRY= 63;
-HOOKID_NFS_PROC_OPEN_RETURN= 64;
-HOOKID_NFS_PROC_RELEASE_ENTRY= 65;
-HOOKID_NFS_PROC_RELEASE_RETURN= 66;
-HOOKID_NFS_PROC_CREATE_ENTRY= 67;
-HOOKID_NFS_PROC_CREATE_RETURN= 68;
-HOOKID_NFS_PROC_RENAME_ENTRY= 69;
-HOOKID_NFS_PROC_RENAME_RETURN= 70;
-HOOKID_NFS_PROC_REMOVE_ENTRY= 71;
-HOOKID_NFS_PROC_REMOVE_RETURN= 72;
-
-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;
-}
-
-
-probe begin
-{
-	hookid_init()
-	lket_trace_init()
-	lket_init_time()
-	register_sys_events()
-	write_events_desc()	
-	process_snapshot()
-}
-probe end
-{
-	lket_kill_time()
-}
diff --git a/tapset/LKET/ioscheduler.stp b/tapset/LKET/ioscheduler.stp
deleted file mode 100755
index 72957b45..00000000
--- a/tapset/LKET/ioscheduler.stp
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (C) 2005, 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.
-
-probe addevent.ioscheduler
-	= addevent.ioscheduler.elv_next_request,
-	addevent.ioscheduler.elv_add_request,
-	addevent.ioscheduler.elv_completed_request
-{}
-
-probe addevent.ioscheduler.elv_next_request
-	= addevent.ioscheduler.elv_next_request.entry,
-	addevent.ioscheduler.elv_next_request.return
-{}
-
-%{
-#include <linux/blkdev.h>
-#include <linux/elevator.h>
-%}
-
-/* when a request is retrieved from request queue */
-probe addevent.ioscheduler.elv_next_request.entry
-	+= _addevent.ioscheduler.elv_next_request.entry
-{
-	update_record()
-}
-
-probe _addevent.ioscheduler.elv_next_request.entry
-	=  ioscheduler.elv_next_request
-{
-	log_ioscheduler_tracedata_elv_next_entry(elevator_name)
-}
-
-probe addevent.ioscheduler.elv_next_request.return
-	+= _addevent.ioscheduler.elv_next_request.return
-{
-	update_record()
-}
-
-probe _addevent.ioscheduler.elv_next_request.return
-	= ioscheduler.elv_next_request.return
-{
-	log_ioscheduler_tracedata_elv_next_return(disk_major, disk_minor, req, req_flags)
-}
-
-
-/* when a request is added to the request queue */
-probe addevent.ioscheduler.elv_add_request
-	+= _addevent.ioscheduler.elv_add_request
-{
-	update_record()
-}
-
-probe _addevent.ioscheduler.elv_add_request
-	= ioscheduler.elv_add_request
-{
-	log_ioscheduler_tracedata_others(HOOKID_IOSCHED_ADD_REQ, 
-		elevator_name, disk_major, disk_minor, req, req_flags)
-}
-
-/* when a request is completed */
-probe addevent.ioscheduler.elv_completed_request
-	+= _addevent.ioscheduler.elv_completed_request
-{
-	update_record()
-}
-
-probe _addevent.ioscheduler.elv_completed_request
-	= ioscheduler.elv_completed_request
-{
-	log_ioscheduler_tracedata_others(HOOKID_IOSCHED_ADD_REQ, 
-		elevator_name, disk_major, disk_minor, req, req_flags)
-}
-
-function log_ioscheduler_tracedata_others(var_id:long, elv_name:string, major:long, 
-		minor:long, rq:long, flag:long)
-%{
-	/* elevator name|major|minor|request|request_flags  */
-
-	_lket_trace(_GROUP_IOSCHED, THIS->var_id, "%0s%1b%1b%8b%8b", 
-		THIS->elv_name, THIS->major, THIS->minor, THIS->rq, THIS->flag);
-
-%}
-
-/* log the data specific to elv_next_request */
-function log_ioscheduler_tracedata_elv_next_entry(elv_name:string)
-%{
-	_lket_trace(_GROUP_IOSCHED, _HOOKID_IOSCHED_NEXT_REQ_ENTRY, "%0s", THIS->elv_name);
-%}
-
-function log_ioscheduler_tracedata_elv_next_return(major:long, minor:long, req:long, req_flags:long)
-%{
-	_lket_trace(_GROUP_IOSCHED, _HOOKID_IOSCHED_NEXT_REQ_RETURN, "%1b%1b%8b%8b",
-		THIS->major, THIS->minor, THIS->req, THIS->req_flags);
-%}
-
diff --git a/tapset/LKET/iosyscall.stp b/tapset/LKET/iosyscall.stp
deleted file mode 100755
index 8fa8d794..00000000
--- a/tapset/LKET/iosyscall.stp
+++ /dev/null
@@ -1,679 +0,0 @@
-// 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.
-
-/*
- although addevent.syscall.* will trace all syscalls for you,
- but addevent.iosyscall* will log more detail about those
- io related syscalls instead of logging only the syscall name
-*/
- 
-probe addevent.iosyscall
-	= addevent.iosyscall.entry,
-	addevent.iosyscall.return
-{}
-
-probe addevent.iosyscall.entry
-	= 
-	addevent.iosyscall.open.entry,
-	addevent.iosyscall.close.entry,
-	addevent.iosyscall.read.entry,
-	addevent.iosyscall.write.entry,
-	addevent.iosyscall.readv.entry,
-	addevent.iosyscall.writev.entry,
-	addevent.iosyscall.pread64.entry,
-	addevent.iosyscall.pwrite64.entry,
-	addevent.iosyscall.readahead.entry,
-	addevent.iosyscall.sendfile.entry,
-	addevent.iosyscall.lseek.entry,
-	addevent.iosyscall.llseek.entry,
-	addevent.iosyscall.sync.entry,
-	addevent.iosyscall.fsync.entry,
-	addevent.iosyscall.fdatasync.entry,
-	addevent.iosyscall.flock.entry
-{}
-
-probe addevent.iosyscall.return
-	= 
-	addevent.iosyscall.open.return,
-	addevent.iosyscall.close.return,
-	addevent.iosyscall.read.return,
-	addevent.iosyscall.write.return,
-	addevent.iosyscall.readv.return,
-	addevent.iosyscall.writev.return,
-	addevent.iosyscall.pread64.return,
-	addevent.iosyscall.pwrite64.return,
-	addevent.iosyscall.readahead.return,
-	addevent.iosyscall.sendfile.return,
-	addevent.iosyscall.lseek.return,
-	addevent.iosyscall.llseek.return,
-	addevent.iosyscall.sync.return,
-	addevent.iosyscall.fsync.return,
-	addevent.iosyscall.fdatasync.return,
-	addevent.iosyscall.flock.return
-{}
-
-
-/*
-  addevent.iosyscall.open.{entry,return}
-*/
-probe addevent.iosyscall.open
-	= addevent.iosyscall.open.entry,
-	addevent.iosyscall.open.return
-{}
-
-probe addevent.iosyscall.open.entry
-	+= _addevent.iosyscall.open.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.open.entry 
-	= syscall.open
-{
-	log_iosyscall_open(filename, flags, mode)
-}
-
-probe addevent.iosyscall.open.return
-	+= _addevent.iosyscall.open.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.open.return 
-	= syscall.open.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_OPEN_RETURN, $return)
-}
-
-function log_iosyscall_open(filename:string, flags:long, mode:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_OPEN_ENTRY,
-		"%0s%4b%4b", THIS->filename, THIS->flags, THIS->mode);
-%}
-
-function log_iosyscall_return(hookid:long, ret_val:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, THIS->hookid, "%8b", THIS->ret_val);
-%}
-
-/*
-  addevent.iosyscall.close.{entry,return}
-*/ 	
-probe addevent.iosyscall.close
-	= addevent.iosyscall.close.entry, addevent.iosyscall.close.return
-{}
-
-probe addevent.iosyscall.close.entry
-	+= _addevent.iosyscall.close.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.close.entry 
-	= syscall.close
-{
-	log_iosyscall_close(fd)
-}
-
-probe addevent.iosyscall.close.return
-	+= _addevent.iosyscall.close.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.close.return 
-	= syscall.close.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_CLOSE_RETURN, $return)
-}
-
-function log_iosyscall_close(fd:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_CLOSE_ENTRY, "%8b", THIS->fd);
-%}
-
-/*
-  addevent.iosyscall.read.{entry,return}
-*/
-probe addevent.iosyscall.read
-	= addevent.iosyscall.read.entry, addevent.iosyscall.read.return
-{}
-
-probe addevent.iosyscall.read.entry
-	+= _addevent.iosyscall.read.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.read.entry
-	= syscall.read
-{
-	log_iosyscall_read(fd, buf_uaddr, count)
-}
-
-probe addevent.iosyscall.read.return
-	+= _addevent.iosyscall.read.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.read.return
-	= syscall.read.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_READ_RETURN, $return)
-}
-
-/*
-  addevent.iosyscall.write.{entry,return}
-*/	
-probe  addevent.iosyscall.write
-	= addevent.iosyscall.write.entry, addevent.iosyscall.write.return
-{}
-
-probe addevent.iosyscall.write.entry
-	+= _addevent.iosyscall.write.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.write.entry
-	= syscall.write
-{
-	log_iosyscall_write(fd, buf_uaddr, count)
-}
-
-probe addevent.iosyscall.write.return
-	+= _addevent.iosyscall.write.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.write.return
-	= syscall.write.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_WRITE_RETURN, $return)
-}
-	
-function log_iosyscall_read(fd:long, buf_uaddr:long, count:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_READ_ENTRY, "%8b%8b%8b",
-		THIS->fd, THIS->buf_uaddr, THIS->count);
-%}
-
-function log_iosyscall_write(fd:long, buf_uaddr:long, count:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_WRITE_ENTRY, "%8b%8b%8b",
-		THIS->fd, THIS->buf_uaddr, THIS->count);
-%}
-
-
-/*
-  addevent.iosyscall.readv.{entry,return}
-*/
-probe addevent.iosyscall.readv
-	= addevent.iosyscall.readv.entry, addevent.iosyscall.readv.return
-{}
-
-probe addevent.iosyscall.readv.entry
-	+= _addevent.iosyscall.readv.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.readv.entry
-	= syscall.readv
-{
-	log_iosyscall_readv_writev(HOOKID_IOSYSCALL_READV_ENTRY, fd, vector_uaddr, count)
-}
-
-probe addevent.iosyscall.readv.return
-	+= _addevent.iosyscall.readv.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.readv.return
-	= syscall.readv.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_READV_RETURN, $return)
-}
-	
-/*
-  addevent.iosyscall.writev.{entry,return}
-*/
-probe addevent.iosyscall.writev
-	= addevent.iosyscall.writev.entry, addevent.iosyscall.writev.return
-{}
-
-probe addevent.iosyscall.writev.entry
-	+= _addevent.iosyscall.writev.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.writev.entry
-	= syscall.writev
-{
-	log_iosyscall_readv_writev(HOOKID_IOSYSCALL_WRITEV_ENTRY, fd, vector_uaddr, count)
-}
-
-probe addevent.iosyscall.writev.return
-	+= _addevent.iosyscall.writev.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.writev.return
-	= syscall.writev.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_WRITEV_RETURN, $return)
-}
-	
-function log_iosyscall_readv_writev(hookid:long, fd:long, 
-		vector_uaddr:long, count:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, THIS->hookid, "%8b%8b%8b",
-		THIS->fd, THIS->vector_uaddr, THIS->count);
-%}
-
-/*
-  addevent.iosyscall.pread64.{entry,return}
-*/
-probe addevent.iosyscall.pread64
-	= addevent.iosyscall.pread64.entry, addevent.iosyscall.pread64.return
-{}
-
-probe addevent.iosyscall.pread64.entry
-	+= _addevent.iosyscall.pread64.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.pread64.entry
-	= syscall.pread64
-{
-	log_iosyscall_pread64_pwrite64(HOOKID_IOSYSCALL_PREAD64_ENTRY, 
-		fd, buf_uaddr, count, offset)
-}
-
-probe addevent.iosyscall.pread64.return
-	+= _addevent.iosyscall.pread64.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.pread64.return
-	= syscall.pread64.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_PREAD64_RETURN, $return)
-}
-
-/*
-  addevent.iosyscall.pwrite64.{entry,return}
-*/
-probe addevent.iosyscall.pwrite64
-	= addevent.iosyscall.pwrite64.entry, addevent.iosyscall.pwrite64.return
-{}
-
-probe addevent.iosyscall.pwrite64.entry
-	+= _addevent.iosyscall.pwrite64.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.pwrite64.entry
-	= syscall.pwrite64
-{
-	log_iosyscall_pread64_pwrite64(HOOKID_IOSYSCALL_PWRITE64_ENTRY,
-		fd, buf_uaddr, count, offset);
-}
-
-probe addevent.iosyscall.pwrite64.return
-	+= _addevent.iosyscall.pwrite64.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.pwrite64.return
-	= syscall.pwrite64.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_PWRITE64_RETURN, $return)
-}
-
-function log_iosyscall_pread64_pwrite64(hookid:long, fd:long, 
-		buf_uaddr:long, count:long, offset:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, THIS->hookid, "%8b%8b%8b%8b",
-		THIS->fd, THIS->buf_uaddr, THIS->count, THIS->offset);
-%}
-
-/*
-  addevent.iosyscall.readahead.{entry,return}
-*/
-probe addevent.iosyscall.readahead
-	= addevent.iosyscall.readahead.entry, addevent.iosyscall.readahead.return
-{}
-
-probe addevent.iosyscall.readahead.entry
-	+= _addevent.iosyscall.readahead.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.readahead.entry
-	= syscall.readahead
-{
-	log_iosyscall_readahead(fd, offset, count)
-}
-
-probe addevent.iosyscall.readahead.return
-	+= _addevent.iosyscall.readahead.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.readahead.return
-	= syscall.readahead.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_READAHEAD_RETURN, $return)
-}
-
-
-function log_iosyscall_readahead(fd:long, offset:long,count:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_READAHEAD_ENTRY,
-		"%8b%8b%8b", THIS->fd, THIS->offset, THIS->count);
-%}
-
-/*
-  addevent.iosyscall.sendfile.{entry,return}
-*/
-probe addevent.iosyscall.sendfile
-	= addevent.iosyscall.sendfile.entry, addevent.iosyscall.sendfile.return
-{}
-
-probe addevent.iosyscall.sendfile.entry
-	+= _addevent.iosyscall.sendfile.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.sendfile.entry
-	= syscall.sendfile
-{
-	log_iosyscall_sendfile(out_fd, in_fd, offset_uaddr, count)
-}
-
-probe addevent.iosyscall.sendfile.return
-	+= _addevent.iosyscall.sendfile.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.sendfile.return
-	= syscall.sendfile.return
-{
-	 log_iosyscall_return(HOOKID_IOSYSCALL_SENDFILE_RETURN, $return)
-}
-	
-function log_iosyscall_sendfile(out_fd:long, in_fd:long, offset_uaddr:long, count:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_SENDFILE_ENTRY, "%8b%8b%8b%8b",
-		THIS->out_fd, THIS->in_fd, THIS->offset_uaddr, THIS->count);
-%}
-
-/*
-  addevent.iosyscall.lseek.{entry,return}
-*/
-probe addevent.iosyscall.lseek
-	= addevent.iosyscall.lseek.entry, addevent.iosyscall.lseek.return
-{}
-
-probe addevent.iosyscall.lseek.entry
-	+= _addevent.iosyscall.lseek.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.lseek.entry
-	= syscall.lseek
-{
-	log_iosyscall_lseek(fildes, offset, whence)
-}
-
-probe addevent.iosyscall.lseek.return
-	+= _addevent.iosyscall.lseek.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.lseek.return
-	= syscall.lseek.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_LSEEK_RETURN, $return)
-}
-
-function log_iosyscall_lseek(fd:long, offset:long, whence:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_LSEEK_ENTRY,
-		"%8b%8b%1b", THIS->fd, THIS->offset, THIS->whence);
-%}
-
-/*
-  addevent.iosyscall.llseek.{entry,return}
-*/
-probe addevent.iosyscall.llseek
-	= addevent.iosyscall.llseek.entry, addevent.iosyscall.llseek.return
-{}
-
-probe addevent.iosyscall.llseek.entry
-	+= _addevent.iosyscall.llseek.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.llseek.entry
-	= syscall.llseek
-{
-	log_iosyscall_llseek(fd, offset_high, offset_low, result_uaddr, whence)
-}
-
-probe addevent.iosyscall.llseek.return
-	+= _addevent.iosyscall.llseek.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.llseek.return
-	= syscall.llseek.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_LLSEEK_RETURN, $return)
-}
-
-function log_iosyscall_llseek(fd:long, offset_high:long, 
-		offset_low:long, result_uaddr:long, whence:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_LLSEEK_ENTRY,
-		"%8b%8b%8b%8b%1b", THIS->fd, THIS->offset_high,
-		THIS->offset_low, THIS->result_uaddr, THIS->whence);
-%}
-
-/*
-  addevent.iosyscall.sync.{entry,return}
-*/
-probe addevent.iosyscall.sync
-	= addevent.iosyscall.sync.entry, addevent.iosyscall.sync.return
-{}
-
-probe addevent.iosyscall.sync.entry
-	+= _addevent.iosyscall.sync.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.sync.entry
-	= syscall.sync
-{
-	log_iosyscall_sync()
-}
-
-probe addevent.iosyscall.sync.return
-	+= _addevent.iosyscall.sync.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.sync.return
-	= syscall.sync.return
-{
-	 log_iosyscall_return(HOOKID_IOSYSCALL_SYNC_RETURN, $return)
-}
-
-function log_iosyscall_sync()
-%{
-	int GroupID = _GROUP_IOSYSCALL;
-	int hookID = _HOOKID_IOSYSCALL_SYNC_ENTRY;
-        struct timeval tv; 
-        do_gettimeofday(&tv); 
-#if defined(ASCII_TRACE)
-	_stp_printf("%d%d%d%d%d%d%d%d", _GROUP_IOSYSCALL,
-		_HOOKID_IOSYSCALL_SYNC_ENTRY, tv.tv_sec, tv.tv_usec,
-		current->tgid, current->parent->pid, current->pid,
-                current->thread_info->cpu);
-
-#else
-
-        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
-
-%}
-
-/*
-  addevent.iosyscall.fsync.{entry,return}
-*/
-probe addevent.iosyscall.fsync
-	= addevent.iosyscall.fsync.entry, addevent.iosyscall.fsync.return
-{}
-
-probe addevent.iosyscall.fsync.entry
-	+= _addevent.iosyscall.fsync.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.fsync.entry
-	= syscall.fsync
-{
-	log_iosyscall_fsync(HOOKID_IOSYSCALL_FSYNC_ENTRY, fd)
-}
-
-probe addevent.iosyscall.fsync.return
-	+= _addevent.iosyscall.fsync.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.fsync.return
-	= syscall.fsync.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_FSYNC_RETURN, $return)
-}
-	
-/*
-  addevent.iosyscall.fdatasync.{entry,return}
-*/
-probe addevent.iosyscall.fdatasync
-	= addevent.iosyscall.fdatasync.entry, addevent.iosyscall.fdatasync.return
-{}
-
-probe addevent.iosyscall.fdatasync.entry
-	+= _addevent.iosyscall.fdatasync.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.fdatasync.entry
-	= syscall.fdatasync
-{
-	log_iosyscall_fsync(HOOKID_IOSYSCALL_FDATASYNC_ENTRY, fd)
-}
-
-probe addevent.iosyscall.fdatasync.return
-	+= _addevent.iosyscall.fdatasync.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.fdatasync.return
-	= syscall.fdatasync.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_FDATASYNC_RETURN, $return)
-}
-
-function log_iosyscall_fsync(hookid:long, fd:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, THIS->hookid, "%8b", THIS->fd);
-%}
-
-/*
-  addevent.iosyscall.flock.{entry,return}
-*/
-probe addevent.iosyscall.flock
-	= addevent.iosyscall.flock.entry, addevent.iosyscall.flock.return
-{}
-
-probe addevent.iosyscall.flock.entry
-	+= _addevent.iosyscall.flock.entry
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.flock.entry
-	= syscall.flock
-{
-	log_iosyscall_flock(fd, operation)
-}
-
-probe addevent.iosyscall.flock.return
-	+= _addevent.iosyscall.flock.return
-{
-	update_record()
-}
-
-probe _addevent.iosyscall.flock.return
-	= syscall.flock.return
-{
-	log_iosyscall_return(HOOKID_IOSYSCALL_FLOCK_RETURN, $return)
-}
-
-function log_iosyscall_flock(fd:long, operation:long)
-%{
-	_lket_trace(_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_FLOCK_ENTRY,
-		"%8b%4b", THIS->fd, THIS->operation);
-%}
diff --git a/tapset/LKET/lket_trace.stp b/tapset/LKET/lket_trace.stp
deleted file mode 100755
index 81d47dd6..00000000
--- a/tapset/LKET/lket_trace.stp
+++ /dev/null
@@ -1,216 +0,0 @@
-// Copyright (C) 2005, 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/cpufreq.h>
-
-#if defined(ASCII_TRACE)
-#ifndef _FMT_
-#define _FMT_ unsigned int
-#endif
-#else
-#ifndef _FMT_
-#define _FMT_ int64_t
-#endif
-#endif
-
-#ifndef TIMING_GETCYCLES
-#define TIMING_GETCYCLES 0x01
-#endif
-#ifndef TIMING_GETTIMEOFDAY
-#define TIMING_GETTIMEOFDAY 0x02
-#endif
-#ifndef TIMING_SCHEDCLOCK
-#define TIMING_SCHEDCLOCK 0x03
-#endif
-
-extern int _GROUP_CPUFREQ;
-extern int _HOOKID_SWITCH_CPUFREQ;
-
-extern long timing_method;
-
-#ifndef _PFN_SCHEDCLOCK_TYPE
-#define _PFN_SCHEDCLOCK_TYPE
-typedef unsigned long long (* pfn_schedclock_type)(void);
-#endif
-
-extern pfn_schedclock_type pfn_schedclock;
-%}
-
-function lket_trace_header_init()
-%{
-
-/* header info for binary format*/
-#if !defined(ASCII_TRACE) 
-
-#define MAGIC_NUMBER           0xAEFCDB6B
-#define LKET_TRACE_VER_MAJOR   0x01
-#define LKET_TRACE_VER_MINOR   0x01 /* used for user customization */
-#define LITTLE_ENDIAN          0x01
-#define BIG_ENDIAN             0x02
-#define BITS_WIDTH             64     /* 32-bit or 64-bit environment*/
-
-	_stp_printf("%4b%2n%1b%1b%1b%1b%1b%4b", (_FMT_)MAGIC_NUMBER,
-		(_FMT_)LKET_TRACE_VER_MAJOR, (_FMT_)LKET_TRACE_VER_MINOR, 
-		(_FMT_)BIG_ENDIAN, (_FMT_)timing_method, 
-		(_FMT_)BITS_WIDTH, (_FMT_)__stp_estimate_cpufreq());
-	_stp_print_flush();
-#endif
-%}
-
-function lket_trace_init() 
-{
-	lket_trace_header_init()
-}
-
-%{
-#ifndef __LKET_TRACE__
-#define __LKET_TRACE__
-
-#define LKET_PKT_BT 2
-
-#define MAX_FMT_LEN 128
-char new_sysfmt[MAX_FMT_LEN] = "\n%d|%d|%d|%d|%d|%d|%d|%d";
-#define NEW_SYSFMT_START 24 
-
-void fmt_change(char *oldfmt, char *newfmt, int newfmt_start)
-{
-	char *old_ptr, *new_ptr;
-
-	old_ptr = oldfmt;
-	new_ptr = newfmt + newfmt_start;
-
-	while(*old_ptr != 0 && (new_ptr - newfmt) < MAX_FMT_LEN)  {
-		if(*old_ptr != '%')  {
-			*new_ptr++ = *old_ptr++;
-			continue;
-		}  else  {
-			*new_ptr++ = '|'; /* delimier to make it readable */ 
-			*new_ptr++ = *old_ptr++;
-			while( *old_ptr == 'L' || *old_ptr == 'l'
-				|| isdigit(*old_ptr) )  {
-				*new_ptr++ = *old_ptr++;
-			}
-			if( *old_ptr == 'b') {
-				if(isdigit(*(old_ptr-1))) {
-					if(*(old_ptr-1) == '1' ||
-					   *(old_ptr-1) == '2' ||
-					   *(old_ptr-1) == '3' ||
-					   *(old_ptr-1) == '4')  {
-						new_ptr--;
-					} else if(*(old_ptr-1) == '8')  {
-						*--new_ptr='l';
-						*++new_ptr='l';
-						new_ptr++;
-					}
-				}
-				*new_ptr++ = 'd';
-				old_ptr++;
-			}
-			else if ( *old_ptr == 's') {
-				if(isdigit(*(old_ptr-1)) && *(old_ptr-1)=='0')
-					new_ptr--;
-				*new_ptr++ = 's';
-				old_ptr++;
-			} else
-				*new_ptr++ = *old_ptr++;
-		}
-	}
-	*new_ptr=0;
-}
-
-/* trace data in ASCII format 
-   Format of the common prefix of the trace data:
-  groupid|subhookid|sec|usec|tgid|ppid|pid|cpuid|
-*/
-#if defined(ASCII_TRACE)
-
-#define _lket_trace(GroupID, hookID, fmt, args...) do { \
-	struct timeval tv; \
-	do_gettimeofday (&tv); \
-	fmt_change(fmt, new_sysfmt, NEW_SYSFMT_START); \
-	_stp_printf(new_sysfmt, \
-		(_FMT_)GroupID, (_FMT_)hookID, (_FMT_)tv.tv_sec, (_FMT_)tv.tv_usec,\
-		(_FMT_)current->tgid, (_FMT_)current->parent->tgid,\
-		(_FMT_)current->pid, (_FMT_)current->thread_info->cpu, args);\
-} while(0)
-
-#else //binary trace
-
-static inline int this_event_len(void)
-{
-	return 0;
-}
-
-/* we use 2 bytes to store the length. */
-#define _lket_trace(GroupID, hookID, fmt, args...) do { \
-	if(timing_method == TIMING_GETCYCLES) { \
-        	_stp_printf("%2b%2n%8b%8b%8b"fmt, (_FMT_)0, \
-			(_FMT_)get_cycles(), \
-			(_FMT_)((int64_t)current->pid << 32 | (int32_t)current->tgid),\
-			(_FMT_)((int64_t)current->parent->tgid << 32 | \
-				(int32_t)GroupID << 24 | (int32_t)hookID << 16 | \
-			       	(int16_t)current->thread_info->cpu << 8), \
-			args); \
-	} \
-	else if(timing_method == TIMING_GETTIMEOFDAY) { \
-		struct timeval tv; \
-		do_gettimeofday (&tv); \
-		_stp_printf("%2b%2n%8b%8b%8b"fmt, (_FMT_)0, \
-			(_FMT_)(tv.tv_sec*1000000LL + tv.tv_usec), \
-			(_FMT_)((int64_t)current->pid << 32 | (int32_t)current->tgid),\
-			(_FMT_)((int64_t)current->parent->tgid << 32 | \
-				(int32_t)GroupID << 24 | (int32_t)hookID << 16 | \
-			       	(int16_t)current->thread_info->cpu << 8), \
-			args); \
-	} \
-	else { \
-		_stp_printf("%2b%2n%8b%8b%8b"fmt, (_FMT_)0, \
-			(_FMT_)pfn_schedclock(), \
-			(_FMT_)((int64_t)current->pid << 32 | (int32_t)current->tgid),\
-			(_FMT_)((int64_t)current->parent->tgid << 32 | \
-				(int32_t)GroupID << 24 | (int32_t)hookID << 16 | \
-				(int16_t)current->thread_info->cpu << 8), \
-			args); \
-	} \
-} while(0)
-#endif
-
-#endif
-%}
-
-function update_record()
-%{
-#if !defined(ASCII_TRACE)
-	_stp_pbuf *pb = per_cpu_ptr(Stp_pbuf, smp_processor_id());
-	char *total_length = &(pb->buf[0]);
-	*(int16_t *)total_length = pb->len - 4;
-#endif
-%}
-
-%{
-#ifdef CONFIG_CPU_FREQ
-static int __lket_time_cpufreq_callback(struct notifier_block *self,
-        unsigned long state, void *vfreqs)
-{
-	int cpu;
-	unsigned long flags;
-	struct cpufreq_freqs *freqs;
-	unsigned int freq_mhz;
-	stp_time_t *time;
-
-	switch (state) {
-        	case CPUFREQ_POSTCHANGE:
-        	case CPUFREQ_RESUMECHANGE:
-			_lket_trace(_GROUP_CPUFREQ, _HOOKID_SWITCH_CPUFREQ, 
-				"%8b", __stp_estimate_cpufreq());
-		break;
-	}
-	return NOTIFY_OK;
-}
-#endif
-%}
diff --git a/tapset/LKET/netdev.stp b/tapset/LKET/netdev.stp
deleted file mode 100755
index 2f7bfc74..00000000
--- a/tapset/LKET/netdev.stp
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (C) 2005, 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/netdevice.h>
-%}
-
-probe addevent.netdev
-	= addevent.netdev.receive,
-	addevent.netdev.transmit
-{}
-
-/* Main device receive routine, be called when packet arrives on network device */
-probe addevent.netdev.receive
-	+= _addevent.netdev.receive
-{
-	update_record()
-}
-
-probe _addevent.netdev.receive
-	=  netdev.receive
-{
-	/* no need to filter by pid */
-	log_netdev_extra(HOOKID_NETDEV_RECEIVE, dev_name, length, protocol, truesize)
-}
-
-/* Queue a buffer for transmission to a network device */
-probe addevent.netdev.transmit
-	+= _addevent.netdev.transmit
-{
-	update_record()
-}
-
-probe _addevent.netdev.transmit
-	=  netdev.transmit
-{
-	log_netdev_extra(HOOKID_NETDEV_TRANSMIT, dev_name, length, protocol, truesize)
-}
-
-function log_netdev_extra(var_id:long, dev_name:string, len:long, 
-			protocol:long, truesize:long)
-%{
-
-	/* dev_name | Length of actual data | protocol | Buffer size 
-
-	    skb->protocol is:
-		0800    IP
-		8100    802.1Q VLAN
-		0001    802.3
-		0002    AX.25
-		0004    802.2
-		8035    RARP
-		0005    SNAP
-		0805    X.25
-		0806    ARP
-		8137    IPX
-		0009    Localtalk
-		86DD    IPv6
-	*/
-
-	_lket_trace(_GROUP_NETDEV, THIS->var_id, "%0s%4b%2b%4b", THIS->dev_name,
-		THIS->len, THIS->protocol, THIS->truesize);
-%}
diff --git a/tapset/LKET/nfs.stp b/tapset/LKET/nfs.stp
deleted file mode 100755
index 63852d61..00000000
--- a/tapset/LKET/nfs.stp
+++ /dev/null
@@ -1,771 +0,0 @@
-/* Helper functions */
-function __file_fsname:string (file:long) %{ /* pure */
-	struct file *file = (struct file *)(long)THIS->file;
-	struct dentry *dentry = file? kread(&(file->f_dentry)) : NULL;
-	struct inode *d_inode = dentry? kread(&(dentry->d_inode)) : NULL;
-	if (d_inode == NULL)
-		strlcpy(THIS->__retvalue, "NULL", MAXSTRINGLEN);
-	else {
-		struct super_block *i_sb = kread(&(d_inode->i_sb));
-		struct file_system_type *s_type = kread(&(i_sb->s_type));
-		const char *name = kread(&(s_type->name));
-		deref_string(THIS->__retvalue, name, MAXSTRINGLEN);
-	}
-	CATCH_DEREF_FAULT();
-%}
-
-probe never
-{
-	printf("%d",GROUP_NFS)
-}
-probe addevent.nfs
-       = addevent.nfs.entry,
-         addevent.nfs.return
-{}
-
-probe addevent.nfs.entry
-	= addevent.nfs.fop.entry,
-	  addevent.nfs.aop.entry,
-	  addevent.nfs.proc.entry
-{}
-
-probe addevent.nfs.return
-	= addevent.nfs.fop.return,
-	  addevent.nfs.aop.return,
-	  addevent.nfs.proc.return
-{}
-
-probe addevent.nfs.fop
-      = addevent.nfs.fop.entry,
-        addevent.nfs.fop.return
-{}
-
-probe addevent.nfs.fop.entry
-       =
-	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,
-	addevent.nfs.fop.check_flags.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
-//	addevent.nfs.fop.check_flags.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 *)((long)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 = __file_fsname($filp)
-
-	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 *)((long)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 = __file_fsname($filp)
-
-	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 *)((long)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 *)((long)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 *)((long)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 *)((long)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 *)((long)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 *)((long)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 *)((long)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);
-%}
-
-///FIXME: unable to resovle $return
-/*
-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.entry
-       =
-       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
deleted file mode 100755
index 418f6c21..00000000
--- a/tapset/LKET/nfs_proc.stp
+++ /dev/null
@@ -1,681 +0,0 @@
-// 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)
-{
-	/* FIXME: deref hazard! */
-	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.entry,
-       addevent.nfs.proc.return
-{}
-
-probe addevent.nfs.proc.entry
-     = 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 * )((long)THIS->dir);
-	struct super_block *sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->filename);
-	CATCH_DEREF_FAULT();
-%}
-
-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* )((long)THIS->rdata);
-	struct inode *inode = kread(&(rdata->inode));
-	struct super_block * sb = kread(&(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",
-		(_FMT_)major_device,(_FMT_)minor_device,
-		NFS_FILEID(inode) /* FIXME: deref hazard! */,
-		THIS->version,THIS->count,THIS->offset);
-	CATCH_DEREF_FAULT();
-%}
-
-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* )((long)THIS->wdata);
-	struct inode *inode = kread(&(wdata->inode));
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->count,THIS->offset);
-	CATCH_DEREF_FAULT();
-%}
-
-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* )((long)THIS->cdata);
-	struct inode *inode = kread(&(cdata->inode));
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->count,THIS->offset);
-	CATCH_DEREF_FAULT();
-%}
-
-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* )((long)THIS->data);
-	struct inode *inode = kread(&(data->inode));
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->count,THIS->offset);
-	CATCH_DEREF_FAULT();
-%}
-
-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* )((long)THIS->data);
-	struct inode *inode = kread(&(data->inode));
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->how,THIS->count,THIS->offset);
-	CATCH_DEREF_FAULT();
-%}
-
-
-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* )((long)THIS->data);
-	struct inode *inode = kread(&(data->inode));
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->count,THIS->offset);
-	CATCH_DEREF_FAULT();
-%}
-
-
-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
-{
-%( kernel_v >= "2.6.10" %?
-	log_proc_read_done(version,$data,count,status)
-%:
-	log_proc_read_done(version,$task->tk_calldata,count,status)
-%)
-}
-
-function log_proc_read_done(version:long,data:long,count:long,status:long)
-%{
-	struct nfs_read_data* data =  (struct nfs_read_data* )((long)THIS->data);
-	struct inode *inode = kread(&(data->inode));
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->status,THIS->count);
-	CATCH_DEREF_FAULT();
-%}
-
-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
-{
-%( kernel_v >= "2.6.10" %?
- 	log_nfs_return(HOOKID_NFS_PROC_READDONE_RETURN,$return)
-%:
-	log_nfs_return(HOOKID_NFS_PROC_READDONE_RETURN,0)
-%)
-}
-
-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
-{
-%( kernel_v >= "2.6.10" %?
- 	log_proc_write_done(version,$data,count,status)
-%:
-	log_proc_write_done(version,$task->tk_calldata,count,status)
-%)
-}
-
-function log_proc_write_done(version:long,data:long,count:long,status:long)
-%{
-	struct nfs_write_data* data =  (struct nfs_write_data* )((long)THIS->data);
-	struct inode *inode = kread(&(data->inode));
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->status,THIS->count);
-	CATCH_DEREF_FAULT();
-%}
-
-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
-{
-%( kernel_v >= "2.6.10" %?
- 	log_nfs_return(HOOKID_NFS_PROC_WRITEDONE_RETURN,$return)
-%:
-	log_nfs_return(HOOKID_NFS_PROC_WRITEDONE_RETURN,0)
-%)
-}
-
-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
-{
-%( kernel_v >= "2.6.10" %?
- 	log_proc_commit_done(version,$data,count,status)
-%:
-	log_proc_commit_done(version,$task->tk_calldata,count,status)
-%)
-}
-
-function log_proc_commit_done(version:long,data:long,count:long,status:long)
-%{
-	struct nfs_write_data* data =  (struct nfs_write_data* )((long)THIS->data);
-	struct inode *inode = kread(&(data->inode));
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->status,THIS->count);
-	CATCH_DEREF_FAULT();
-%}
-
-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
-{
-%( kernel_v >= "2.6.10" %?
- 	log_nfs_return(HOOKID_NFS_PROC_COMMITDONE_RETURN,$return)
-%:
-	log_nfs_return(HOOKID_NFS_PROC_COMMITDONE_RETURN,0)
-%)
-}
-
-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 *)((long)THIS->inode);
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->filename,THIS->flag,THIS->mode);
-	CATCH_DEREF_FAULT();
-%}
-
-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 *)((long)THIS->inode);
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->filename,THIS->flag,THIS->mode);
-	CATCH_DEREF_FAULT();
-%}
-
-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 *)((long)THIS->inode);
-	struct super_block * sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->version,THIS->filename,THIS->mode);
-	CATCH_DEREF_FAULT();
-%}
-
-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 *)((long)THIS->inode);
-	struct super_block * sb = kread(&(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",
-		(_FMT_)major_device,(_FMT_)minor_device,
-		NFS_FILEID(inode) /* FIXME: deref hazard! */,
-		THIS->version,THIS->filename);
-	CATCH_DEREF_FAULT();
-%}
-
-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 *)((long)THIS->old_dir);
-	struct inode *new_dir= (struct inode *)((long)THIS->new_dir);
-	struct super_block * old_sb = kread(&(old_dir->i_sb));
-	struct super_block * new_sb = kread(&(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) /* FIXME: deref hazard! */,
-		THIS->old_name,(_FMT_)major_new,(_FMT_)minor_new,
-		NFS_FILEID(new_dir) /* FIXME: deref hazard! */,
-		THIS->new_name);
-	CATCH_DEREF_FAULT();
-%}
-
-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
deleted file mode 100755
index 2e42d194..00000000
--- a/tapset/LKET/nfsd.stp
+++ /dev/null
@@ -1,792 +0,0 @@
-%{
-	#include <linux/sunrpc/svc.h>
-	#include <linux/nfsd/nfsfh.h>
-%}
-%{
-	void decode_fh(struct knfsd_fh *fh,__u64 * i_ino)
-	{
-		/* FIXME: deref hazard! */
-		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\n", GROUP_PROCESS)
-}
-
-
-probe addevent.nfsd
-               = addevent.nfsd.entry,
-                 addevent.nfsd.return
-{}
-
-probe addevent.nfsd.entry
-               = addevent.nfsd.op.entry,
-                 addevent.nfsd.proc.entry
-{}
-probe addevent.nfsd.return
-               = addevent.nfsd.op.return,
-                 addevent.nfsd.proc.return
-{}
-probe addevent.nfsd.op
-	= addevent.nfsd.op.entry,
-	  addevent.nfsd.op.return
-{}
-
-probe addevent.nfsd.op.entry = 
-             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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],THIS->filename);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],THIS->filename,
-		THIS->type,THIS->iap_valid,THIS->iap_mode);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],THIS->filename,
-		THIS->createmode,THIS->iap_valid,THIS->iap_mode);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],
-		THIS->filename,THIS->type);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)THIS->fhp);
-	struct svc_fh * tfhp = (struct svc_fh*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		old_ino[0],old_ino[1],old_ino[2], THIS->filename,
-		(_FMT_)kread(&(tfhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2], THIS->tname);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],
-		THIS->type,THIS->access);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)THIS->fhp);
-	struct kvec * vec = (struct kvec *)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2], THIS->count,THIS->offset,
-		(_FMT_)kread(&(vec->iov_len)), THIS->vlen);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)THIS->fhp);
-	struct kvec * vec = (struct kvec *)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2], THIS->count,THIS->offset,
-		(_FMT_)kread(&(vec->iov_len)), THIS->vlen);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2], THIS->count,THIS->offset);
-	CATCH_DEREF_FAULT();
-%}
-
-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.entry,
-		     addevent.nfsd.proc.return
-{}
-
-probe addevent.nfsd.proc.entry =
-                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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2], THIS->version,THIS->filename);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)THIS->fhp);
-	struct kvec * vec = (struct kvec *)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],THIS->version,
-		THIS->count,THIS->offset,(_FMT_)kread(&(vec->iov_len)), THIS->vlen);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)THIS->fhp);
-	struct kvec * vec = (struct kvec *)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],THIS->version,
-		THIS->count,THIS->offset,(_FMT_)kread(&(vec->iov_len)), THIS->vlen);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],THIS->version,
-		THIS->count,THIS->offset);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],THIS->version,
-		THIS->filename);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)THIS->fhp);
-	struct svc_fh * tfhp = (struct svc_fh*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		o_ino[0],o_ino[1],o_ino[2], THIS->filename,
-		(_FMT_)kread(&(tfhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2], THIS->tname);
-	CATCH_DEREF_FAULT();
-%}
-
-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*)((long)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_)kread(&(fhp->fh_handle.fh_size)),
-		i_ino[0],i_ino[1],i_ino[2],
-		THIS->version,THIS->filename);
-	CATCH_DEREF_FAULT();
-%}
-
-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/pagefault.stp b/tapset/LKET/pagefault.stp
deleted file mode 100755
index 214855fb..00000000
--- a/tapset/LKET/pagefault.stp
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (C) 2005, 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.
-
-function log_pagefault_tracedata(var_addr:long, var_rwflag:long)
-%{
-	_lket_trace(_GROUP_PAGEFAULT, _HOOKID_PAGEFAULT, "%8b%1b", 
-		THIS->var_addr, (_FMT_)((THIS->var_rwflag)?1:0)); 
-%}
-
-
-/* Record the page fault event */
-probe addevent.pagefault
-	+= _addevent.pagefault
-{
-	update_record()
-}
-
-probe _addevent.pagefault
-	=  vm.pagefault
-{
-	log_pagefault_tracedata($address, $write_access)
-}
diff --git a/tapset/LKET/process.stp b/tapset/LKET/process.stp
deleted file mode 100755
index 41f6d3f1..00000000
--- a/tapset/LKET/process.stp
+++ /dev/null
@@ -1,126 +0,0 @@
-// Copyright (C) 2005, 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.
-
-/* the trace hooks defined here are used by lket internally and they
-   will be turned on by default */
-
-/* record the newly created process name */
-function log_execve_tracedata(var:long)
-%{
-	long tmp=(long)THIS->var;
-	_lket_trace(_GROUP_PROCESS, _HOOKID_PROCESS_EXECVE, "%4b%4b%4b%0s", 
-		(_FMT_)current->pid, (_FMT_)current->tgid, 
-		(_FMT_)current->parent->tgid,
-		(char *)tmp /* FIXME: deref hazard! */); 
-%}
-
-
-/* record the newly forked process id */
-function log_fork_tracedata(task:long)
-%{
-	/*
-	pid_t pid = (pid_t)THIS->var;	
-	_lket_trace(_GROUP_PROCESS, THIS->var_id, "%4b", (_FMT_)pid); 
-	*/
-	struct task_struct *task = (struct task_struct *)((long)THIS->task);
-	struct task_struct *parent = kread(&(task->parent));
-	_lket_trace(_GROUP_PROCESS, _HOOKID_PROCESS_FORK, "%4b%4b%4b",
-		(_FMT_)kread(&(task->pid)),
-		(_FMT_)kread(&(task->tgid)),
-		(_FMT_)kread(&(parent->tgid))); 
-	CATCH_DEREF_FAULT();
-%}
-
-
-/************************************************************
-* This function could be used to take a snapshot of all the *
-* processes. It's not a probe, so the data format doesn't   *
-* follow the format used by probe handlers                  *
-************************************************************/
-function process_snapshot()
-%{
-	struct task_struct *tsk;
-	struct list_head *cur, *head;
-	_stp_pbuf *pb;
-	int cpu = smp_processor_id();
-	char *total_length;
-	head = &(current->tasks);
-
-	/* iterate all the processes, and record the pid and process
-	name for each entry */
-	/* FIXME: need some sort of lock before doing this! */
-	for_each_process(tsk)  {
-		_lket_trace(_GROUP_PROCESS, _HOOKID_PROCESS_SNAPSHOT, "%4b%4b%4b%0s", 
-			(_FMT_)tsk->pid, (_FMT_)tsk->tgid, (_FMT_)tsk->parent->tgid, tsk->comm);
-#if !defined(ASCII_TRACE)
-		pb = per_cpu_ptr(Stp_pbuf, smp_processor_id());
-		total_length = &(pb->buf[0]);
-		*(int16_t *)total_length = pb->len - 4;
-#endif
-		_stp_print_flush();
-	}
-%}
-
-probe addevent.process = addevent.process.exit {}
-probe addevent.process.exit = addevent.process.exit.entry {}
-
-probe addevent.process.exit.entry
-	+= _addevent.process.exit.entry
-{
-	update_record()
-}
-
-probe _addevent.process.exit.entry
-	= process.exit
-{
-	log_process_exit(code)
-}
-
-function log_process_exit(code:long)
-%{
-	_lket_trace(_GROUP_PROCESS, _HOOKID_PROCESS_EXIT_ENTRY,
-		"%8b", THIS->code);
-%}
-
-probe lket_internal.process { }
-
-probe lket_internal.process
-	= lket_internal.process.execve,
-	lket_internal.process.fork
-{}
-
-/* 
-  we should capture both do_execve for 64-bit app
-  and compat_do_execve for 32-bit app           
-*/
-probe lket_internal.process.execve
-	+= _lket_internal.process.execve
-{
-	update_record()
-}
-
-probe _lket_internal.process.execve
-	=  process.exec
-{
-	if(stoptrace_exec==1) next;
-	log_execve_tracedata($filename)
-}
-
-probe lket_internal.process.fork
-	+= _lket_internal.process.fork
-{
-	update_record()
-}
-
-probe _lket_internal.process.fork
-	= process.create
-{
-	if(stoptrace_fork==1) next;
-	log_fork_tracedata($return)
-}
-
-
diff --git a/tapset/LKET/register_event.stp b/tapset/LKET/register_event.stp
deleted file mode 100755
index 98999355..00000000
--- a/tapset/LKET/register_event.stp
+++ /dev/null
@@ -1,1023 +0,0 @@
-// 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.
-
-global usr_field_name, usr_evt_fmt
-global have_userevent
-
-%{
-
-#define _MAXGROUPID  0xFF
-#define _MAXHOOKID   0xFF
-
-int get_fmtcode(char *fmt)
-{
-	if(strncmp(fmt, "INT8", 4) != 0 &&
-		strncmp(fmt, "INT16", 5) != 0 &&
-		strncmp(fmt, "INT32", 5) != 0 &&
-		strncmp(fmt, "INT64", 5) != 0 &&
-		strncmp(fmt, "STRING", 6) != 0)  
-		return -1;
-	else
-		return 0;
-}
-
-void _register_event(int grpid, int hookid, int evt_type, char *fmt, char *names)
-{
-	char in_fmt[512], in_name[512];
-	char *p_in_fmt, *p_in_name;
-	char *_fmt, *name;
-	_stp_pbuf * pb;
-        int cpu = smp_processor_id();
-	char *total_length;
-	p_in_fmt = in_fmt;
-	p_in_name = in_name;
-
-	if(!strncmp(fmt,"",1) && !strncmp(names,"",1)) {
-		_lket_trace(_GROUP_REGEVT,evt_type,"%1b%1b",(_FMT_)grpid, (_FMT_)hookid); 
-		goto reg_epilogue;
-	}
-
-	if( grpid <= 0 || grpid > _MAXGROUPID ||
-		hookid <= 0 || hookid > _MAXHOOKID)  {
-		_stp_warn("register_event: wrong groupid/hookid, type: %d, grp:%d, hkid:%d\n", 
-			evt_type, grpid, hookid);
-		_stp_exit();
-	}
-
-	strncpy(in_fmt, fmt, 512);
-	strncpy(in_name, names, 512);
-
-	_fmt = strsep(&p_in_fmt, ":");
-	name = strsep(&p_in_name, ":");
-
-	while(_fmt!=NULL && name!=NULL)  {
-		if(get_fmtcode(_fmt) == -1)  {
-			_stp_warn("error in fmt string\n");
-			_stp_exit();
-		}
-		_fmt = strsep(&p_in_fmt, ":");
-		name = strsep(&p_in_name, ":");
-	}
-
-	if(_fmt!=NULL || name != NULL)  {
-		_stp_warn("unpaired types/names, grpid:%d, hookid:%d\n",
-			grpid, hookid);
-		_stp_exit();
-	}
-
-	_lket_trace(_GROUP_REGEVT, evt_type, "%1b%1b%0s%0s", (_FMT_)grpid,
-		(_FMT_)hookid, fmt, names); 
-
-reg_epilogue:
-
-#if !defined(ASCII_TRACE)
-        pb = per_cpu_ptr(Stp_pbuf, smp_processor_id());
-	total_length = &(pb->buf[0]);
-	*(int16_t *)total_length = pb->len - 4;
-#endif
-	_stp_print_flush();
-
-}
-
-void _register_evt_desc(int grpid, int hookid, int evt_type, char *desc)
-{
-	_stp_pbuf * pb;
-	char *total_length;
-        int cpu = smp_processor_id();
-
-	if(!strncmp(desc,"",1))  {
-		_stp_warn("empty event description for grpid:%d, hookid:%d\n",
-			grpid, hookid);
-		_stp_exit();
-	}
-
-	if( grpid <= 0 || grpid > _MAXGROUPID ||
-		hookid <= 0 || hookid > _MAXHOOKID)  {
-		_stp_warn("_register_evt_desc: wrong groupid/hookid, type: %d, event: %s, grp:%d, hkid:%d\n", 
-			evt_type, desc, grpid, hookid);
-		_stp_exit();
-		_stp_exit();
-	}
-
-	_lket_trace(_GROUP_REGEVT, evt_type, "%1b%1b%0s", (_FMT_)grpid, (_FMT_)hookid, desc); 
-
-#if !defined(ASCII_TRACE)
-        pb = per_cpu_ptr(Stp_pbuf, smp_processor_id());
-	total_length = &(pb->buf[0]);
-	*(int16_t *)total_length = pb->len - 4;
-#endif
-	_stp_print_flush();
-}
-
-void _register_sys_event (char *event_desc, int grpid, int hookid, char *fmt, char *field_name)
-{
-	_register_evt_desc(grpid, hookid, _HOOKID_REGEVTDESC, event_desc);
-	_register_event(grpid, hookid, _HOOKID_REGSYSEVT, fmt, field_name);
-}
-
-%}
-
-function dummy_c_function()
-%{
-%}
-
-function register_user_event(grpid:long, hookid:long,fmt:string, field_name:string) 
-{
-	usr_evt_fmt[grpid, hookid] = fmt
-	usr_field_name[grpid, hookid] = field_name
-	dummy_c_function() /* ensure register_user_event won't be compiled away */
-}
-
-function write_events_desc()
-{
-	if(have_userevent == 1)
-	{
-		foreach([grpid, hookid] in usr_evt_fmt)
-		{
-			register_event(grpid, hookid, HOOKID_REGUSREVT,
-				usr_evt_fmt[grpid, hookid], 
-				usr_field_name[grpid, hookid])
-		}
-		delete usr_field_name
-		delete usr_evt_fmt
-	}
-
-}	
-
-
-function register_event(grpid:long, hookid:long, evt_type:long, fmt:string, names:string)
-%{
-	_register_event(THIS->grpid, THIS->hookid, THIS->evt_type, THIS->fmt, THIS->names);
-%}
-
-function register_sys_events()
-%{
-	_register_sys_event("syscall.entry", _GROUP_SYSCALL, _HOOKID_SYSCALL_ENTRY, 
-		"STRING", "syscall");
-	_register_sys_event("syscall.return", _GROUP_SYSCALL, _HOOKID_SYSCALL_RETURN,
-		"STRING", "syscall");
-		
-	_register_sys_event("process_snapshot", _GROUP_PROCESS, _HOOKID_PROCESS_SNAPSHOT,
-		"INT32:INT32:INT32:STRING", "tid:pid:ppid:pname");
-	_register_sys_event("process.execve", _GROUP_PROCESS, _HOOKID_PROCESS_EXECVE,
-		"INT32:INT32:INT32:STRING", "tid:pid:ppid:pname");
-	_register_sys_event("process.fork", _GROUP_PROCESS, _HOOKID_PROCESS_FORK,
-		"INT32:INT32:INT32", "tid:pid:ppid");
-	_register_sys_event("process.exit.entry", _GROUP_PROCESS, _HOOKID_PROCESS_EXIT_ENTRY,
-		"INT64", "code");
-
-	_register_sys_event("ioscheduler.elv_next_request.entry",
-		_GROUP_IOSCHED, _HOOKID_IOSCHED_NEXT_REQ_ENTRY,
-		"STRING", "elv_name");
-	_register_sys_event("ioscheduler.elv_next_request.return",
-		_GROUP_IOSCHED, _HOOKID_IOSCHED_NEXT_REQ_RETURN,
-		"INT8:INT8:INT64:INT64", "major:minor:req_addr:req_flags");
-
-
-	_register_sys_event("ioscheduler.elv_add_request",
-		_GROUP_IOSCHED, _HOOKID_IOSCHED_ADD_REQ,
-		"STRING:INT8:INT8:INT64:INT64", "elv_name:major:minor:request:req_flags");
-	_register_sys_event("ioscheduler.elv_completed_request",
-		_GROUP_IOSCHED, _HOOKID_IOSCHED_COMPLETE_REQ,
-		"STRING:INT8:INT8:INT64:INT64", "elv_name:major:minor:request:req_flags");
-
-	_register_sys_event("tskdispatch.ctxswitch",
-		_GROUP_TASK, _HOOKID_TASK_CTXSWITCH,
-		"INT32:INT32:INT8", "prev_pid:next_pid:prev_state");
-	_register_sys_event("tskdispatch.cpuidle", _GROUP_TASK, _HOOKID_TASK_CPUIDLE,
-		"INT32", "cur_pid");
-
-	_register_sys_event("scsi.ioentry", _GROUP_SCSI, _HOOKID_SCSI_IOENTRY,
-		"INT8:INT8:INT8:INT64", "major:minor:sdev_state:request_addr");
-
-	_register_sys_event("scsi.iodispatching", _GROUP_SCSI, _HOOKID_SCSI_IO_TO_LLD,
-		"INT8:INT8:INT8:INT8:INT8:INT8:INT64:INT32:INT64",
-		"host:channel:lun:dev_id:dev_state:data_dir:reqbuf_addr:reqbuf_len:request_addr");
-
-	_register_sys_event("scsi.iodone", _GROUP_SCSI, _HOOKID_SCSI_IODONE_BY_LLD,
-		"INT8:INT8:INT8:INT8:INT8:INT8:INT64", 
-		"host:channel:lun:dev_id:dev_state:data_dir:request_addr");
-
-	_register_sys_event("scsi.iocompleted", 
-		_GROUP_SCSI, _HOOKID_SCSI_IOCOMP_BY_MIDLEVEL,
-		"INT8:INT8:INT8:INT8:INT8:INT8:INT64:INT32", 
-		"host:channel:lun:dev_id:dev_state:data_dir:request_addr:done_bytes");
-
-	_register_sys_event("pagefault", _GROUP_PAGEFAULT, _HOOKID_PAGEFAULT,
-		"INT64:INT8", "addr:write");
-
-	_register_sys_event("netdev.receive", _GROUP_NETDEV, _HOOKID_NETDEV_RECEIVE,
-		"STRING:INT32:INT16:INT32", "dev_name:data_len:protocol:buff_size");
-
-	_register_sys_event("netdev.transmit", _GROUP_NETDEV, _HOOKID_NETDEV_TRANSMIT,
-		"STRING:INT32:INT16:INT32", "dev_name:data_len:protocol:buff_size");
-
-	_register_sys_event("iosyscall.open.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_OPEN_ENTRY,
-		"STRING:INT32:INT32", "filename:flags:mode");
-	_register_sys_event("iosyscall.open.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_OPEN_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.close.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_CLOSE_ENTRY,
-		"INT64", "fd");
-	_register_sys_event("iosyscall.close.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_CLOSE_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.read.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_READ_ENTRY,
-		"INT64:INT64:INT64", "fd:buff_addr:count");
-	_register_sys_event("iosyscall.read.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_READ_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.write.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_WRITE_ENTRY,
-		"INT64:INT64:INT64", "fd:buff_addr:count");
-	_register_sys_event("iosyscall.write.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_WRITE_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.readv.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_READV_ENTRY,
-		"INT64:INT64:INT64", "fd:vector_uaddr:count");
-	_register_sys_event("iosyscall.readv.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_READV_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.writev.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_WRITEV_ENTRY,
-		"INT64:INT64:INT64", "fd:vector_uaddr:count");
-	_register_sys_event("iosyscall.writev.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_WRITEV_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.pread64.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_PREAD64_ENTRY,
-		"INT64:INT64:INT64:INT64", "fd:buff_uaddr:count:offset");
-	_register_sys_event("iosyscall.pread64.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_PREAD64_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.pwrite64.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_PWRITE64_ENTRY,
-		"INT64:INT64:INT64:INT64", "fd:buff_uaddr:count:offset");
-	_register_sys_event("iosyscall.pwrite64.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_PWRITE64_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.readahead.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_READAHEAD_ENTRY,
-		"INT64:INT64:INT64", "fd:offset:count");
-	_register_sys_event("iosyscall.readahead.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_READAHEAD_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.sendfile.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_SENDFILE_ENTRY,
-		"INT64:INT64:INT64:INT64", "out_fd:in_fd:offset_uaddr:count");
-	_register_sys_event("iosyscall.sendfile.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_SENDFILE_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.lseek.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_LSEEK_ENTRY,
-		"INT64:INT64:INT8", "fd:offset:whence");
-	_register_sys_event("iosyscall.lseek.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_LSEEK_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.llseek.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_LLSEEK_ENTRY,
-		"INT64:INT64:INT64:INT64:INT8b", 
-		"fd:offset_high:offset_low:result_uaddr:whence");
-	_register_sys_event("iosyscall.llseek.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_LLSEEK_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.sync.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_SYNC_ENTRY,
-		"", "");
-
-	_register_sys_event("iosyscall.sync.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_SYNC_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.fsync.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_FSYNC_ENTRY,
-		"INT64", "fd");
-	_register_sys_event("iosyscall.fsync.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_FSYNC_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.fdatasync.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_FDATASYNC_ENTRY,
-		"INT64", "fd");
-	_register_sys_event("iosyscall.fdatasync.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_FDATASYNC_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("iosyscall.flock.entry",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_FLOCK_ENTRY,
-		"INT64:INT32", "fd:operation");
-	_register_sys_event("iosyscall.flock.return",
-		_GROUP_IOSYSCALL, _HOOKID_IOSYSCALL_FLOCK_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("aio.io_setup.entry",
-		_GROUP_AIO, _HOOKID_AIO_IO_SETUP_ENTRY,
-		"INT32:INT64", "nr_events:ctxp_uaddr");
-	_register_sys_event("aio.io_setup.return",
-		_GROUP_AIO, _HOOKID_AIO_IO_SETUP_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("aio.io_submit.entry",
-		_GROUP_AIO, _HOOKID_AIO_IO_SUBMIT_ENTRY,
-		"INT64:INT32:INT64", "ctx_id:nr:iocbpp_uaddr");
-	_register_sys_event("aio.io_submit.return",
-		_GROUP_AIO, _HOOKID_AIO_IO_SUBMIT_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("aio.io_submit_one.entry",
-		_GROUP_AIO, _HOOKID_AIO_IO_SUBMIT_ONE_ENTRY,
-		"INT64:INT64:INT16:INT16:INT32:INT64:INT64:INT64", 
-		"ctx:user_iocb_uaddr:aio_lio_opcode:aio_reqprio:aio_fildes:aio_buf:aio_nbytes:aio_offset");
-	_register_sys_event("aio.io_submit_one.return",
-		_GROUP_AIO, _HOOKID_AIO_IO_SUBMIT_ONE_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("aio.io_destroy.entry",
-		_GROUP_AIO, _HOOKID_AIO_IO_DESTROY_ENTRY,
-		"INT64", "ctx");
-	_register_sys_event("aio.io_destroy.return",
-		_GROUP_AIO, _HOOKID_AIO_IO_DESTROY_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("aio.io_getevents.entry",
-		_GROUP_AIO, _HOOKID_AIO_IO_GETEVENTS_ENTRY,
-		"INT64:INT32:INT32:INT64:INT32:INT32", 
-		"ctx_id:min_nr:nr:events_uaddr:tv_sec:tv_nsec");
-	_register_sys_event("aio.io_getevents.return",
-		_GROUP_AIO, _HOOKID_AIO_IO_GETEVENTS_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("aio.io_cancel.entry",
-		_GROUP_AIO, _HOOKID_AIO_IO_CANCEL_ENTRY,
-		"INT64:INT64:INT64", 
-		"ctx_id:iocb_uaddr:result_uaddr");
-	_register_sys_event("aio.io_cancel.return",
-		_GROUP_AIO, _HOOKID_AIO_IO_CANCEL_RETURN,
-		"INT64", "return");
-
-
-	_register_sys_event("signal.send.entry",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_SEND_ENTRY,
-		"INT8:INT8:INT8:INT32", "sig:shared:send2queue:pid");
-	_register_sys_event("signal.send.return",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_SEND_RETURN,
-		"INT8", "return");
-
-	_register_sys_event("signal.syskill.entry",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSKILL_ENTRY,
-		"INT32:INT8", "pid:sig");
-	_register_sys_event("signal.syskill.return",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSKILL_RETURN,
-		"INT8", "return");
-
-	_register_sys_event("signal.systgkill.entry",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTGKILL_ENTRY,
-		"INT32:INT32:INT8", "tid:pid:sig");
-	_register_sys_event("signal.systgkill.return",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTGKILL_RETURN,
-		"INT8", "return");
-
-	_register_sys_event("signal.systkill.entry",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTKILL_ENTRY,
-		"INT32:INT8", "pid:sig");
-	_register_sys_event("signal.systkill.return",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTKILL_RETURN,
-		"INT8", "return");
-
-	_register_sys_event("signal.pending.entry",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_PENDING_ENTRY,
-		"INT32:INT32", "sigset_addr:setsize");;
-	_register_sys_event("signal.pending.return",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_PENDING_RETURN,
-		"INT8", "return");
-
-	_register_sys_event("signal.do_action.entry",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_DOACTION_ENTRY,
-		"INT8:INT64", "sig:handler");
-	_register_sys_event("signal.do_action.return",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_DOACTION_RETURN,
-		"INT16", "return");
-
-	_register_sys_event("signal.procmask.entry",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_PROC_MASK_ENTRY,
-		"INT8:INT64", "how:sigset");
-	_register_sys_event("signal.procmask.return",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_PROC_MASK_RETURN,
-		"INT8", "return");
-
-	_register_sys_event("signal.flush.entry",
-		_GROUP_SIGNAL, _HOOKID_SIGNAL_FLUSH_ENTRY,
-		"INT32", "pid");
-
-	_register_sys_event("sunrpc.clnt.create_client.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY, 
-		"STRING:INT64:INT8:INT16:INT16:INT8",
-		"server:prog:vers:prot:port:authflavor");
-	_register_sys_event("sunrpc.clnt.create_client.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN, 
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.clnt.clone_client.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY, 
-		"STRING:INT64:INT8:INT16:INT16:INT8",
-		"server:prog:vers:prot:port:authflavor");
-	_register_sys_event("sunrpc.clnt.clone_client.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.clnt.shutdown_client.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY, 
-		"STRING:INT64:INT16:INT16:INT32",
-		"server:prog:clones:tasks:rpccount");
-	_register_sys_event("sunrpc.clnt.shutdown_client.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN,
-		"INT8", "void");
-
-	_register_sys_event("sunrpc.clnt.bind_new_program.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY,
-		"STRING:INT64:INT8:INT64:INT8",
-		"server:old_prog:old_vers:new_prog:new_vers");
-	_register_sys_event("sunrpc.clnt.bind_new_program.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.clnt.call_sync.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY,
-		"STRING:INT64:INT8:INT64:INT64",
-		"server:prog:vers:proc:flags");
-	_register_sys_event("sunrpc.clnt.call_sync.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.clnt.call_async.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY,
-		"STRING:INT64:INT8:INT64:INT64",
-		"server:prog:vers:proc:flags");
-	_register_sys_event("sunrpc.clnt.call_async.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.clnt.restart_call.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY,
-		"INT64:INT64", "tk_pid:tk_flags");
-	
-	_register_sys_event("sunrpc.clnt.restart_call.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN,
-		"INT8", "void");
-
-	_register_sys_event("sunrpc.svc.register.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_REGISTER_ENTRY,
-		"STRING:INT64:INT16:INT32",
-		"service:program:protocol:prot");
-	_register_sys_event("sunrpc.svc.register.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_REGISTER_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.svc.create.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_CREATE_ENTRY,
-		"INT64:INT8:INT32",
-		"prog:nvers:bufsize");
-	_register_sys_event("sunrpc.svc.create.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_CREATE_RETURN,
-		"INT64", "return");
-			
-	_register_sys_event("sunrpc.svc.destroy.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_DESTROY_ENTRY,
-		"STRING:INT64:INT32",
-		"service:program:num_threads");
-
-	_register_sys_event("sunrpc.svc.destroy.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_DESTROY_RETURN,
-		"INT8", "void");
-			
-	_register_sys_event("sunrpc.svc.process.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_PROCESS_ENTRY,
-		"STRING:INT64:INT64:INT64:INT64:INT8:INT8",
-		"service:sv_prog:peer_ip:rq_xid:rq_prog:rq_vers:rq_proc");
-	_register_sys_event("sunrpc.svc.process.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_PROCESS_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.svc.authorise.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY,
-		"STRING:INT64:INT64:INT64:INT8:INT64",
-		"service:peer_ip:xid:prog:vers:proc");
-	_register_sys_event("sunrpc.svc.authorise.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_AUTHORISE_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.svc.send.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_SEND_ENTRY,
-		"STRING:INT64:INT64:INT64:INT8:INT64",
-		"sv_name:peer_ip:xid:prog:vers:proc");
-	_register_sys_event("sunrpc.svc.send.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_SEND_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.svc.recv.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_RECV_ENTRY,
-		"STRING:INT64", "sv_name:timeout");
-	
-	_register_sys_event("sunrpc.svc.recv.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_RECV_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.svc.drop.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_DROP_ENTRY,
-		"STRING:INT64:INT64:INT64:INT8:INT64",
-		"sv_name:peer_ip:xid:prog:vers:proc");
-	
-	_register_sys_event("sunrpc.svc.drop.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SVC_DROP_RETURN,
-		"INT8", "void");
-
-	_register_sys_event("sunrpc.sched.new_task.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY,
-		"INT64:INT64:INT8:INT64:INT64",
-		"xid:prog:vers:prot:flags");
-	_register_sys_event("sunrpc.sched.new_task.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.sched.release_task.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY,
-		"INT64:INT64:INT8:INT64:INT64",
-		"xid:prog:vers:prot:flags");
-	_register_sys_event("sunrpc.sched.release_task.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN,
-		"INT8", "void");
-
-	_register_sys_event("sunrpc.sched.execute.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY,
-		"INT64:INT64:INT8:INT64:INT64:INT64",
-		"xid:prog:vers:prot:tk_pid:tk_flags");
-	_register_sys_event("sunrpc.sched.execute.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SCHED_EXECUTE_RETURN,
-		"INT64", "return");
-
-	_register_sys_event("sunrpc.sched.delay.entry",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SCHED_DELAY_ENTRY,
-		"INT64:INT64:INT64:INT64:INT64",
-		"xid:prog:tk_pid:tk_flags:delay");
-	_register_sys_event("sunrpc.sched.delay.return",
-		_GROUP_SUNRPC, _HOOKID_SUNRPC_SCHED_DELAY_RETURN,
-		"INT8", "void");
-
-	_register_sys_event("cpu_freq",
-		_GROUP_CPUFREQ, _HOOKID_SWITCH_CPUFREQ,
-		"INT64", "cpufreq");		
-
-	_register_sys_event("nfs.fop.llseek.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_LLSEEK_ENTRY,
-                "INT8:INT8:INT64:INT64:INT8",
-		"major:minor:ino:offset:origin");
-	_register_sys_event("nfs.fop.llseek.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_LLSEEK_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.fop.read.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_READ_ENTRY,
-                "INT8:INT8:INT64:INT64:INT64:INT64",
-		"major:minor:ino:buf:len:pos");		
-	_register_sys_event("nfs.fop.read.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_READ_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfs.fop.write.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_WRITE_ENTRY,
-                "INT8:INT8:INT64:INT64:INT64:INT64",
-		"major:minor:ino:buf:len:pos");		
-	_register_sys_event("nfs.fop.write.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_WRITE_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfs.fop.aio_read.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_AIOREAD_ENTRY,
-                "INT8:INT8:INT64:INT64:INT64:INT64",
-		"major:minor:ino:buf:len:pos");		
-	_register_sys_event("nfs.fop.aio_read.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_AIOREAD_RETURN,
-                "INT32","return");
-	
-	_register_sys_event("nfs.fop.aio_write.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_AIOWRITE_ENTRY,
-                "INT8:INT8:INT64:INT64:INT64:INT64",
-		"major:minor:ino:buf:len:pos");		
-	_register_sys_event("nfs.fop.aio_write.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_AIOWRITE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.fop.mmap.entry",
-		_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("nfs.fop.mmap.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_MMAP_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.fop.open.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_OPEN_ENTRY,
-                "INT8:INT8:INT64:INT32:STRING",
-		"major:minor:ino:flag:filename");		
-	_register_sys_event("nfs.fop.open.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_OPEN_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.fop.flush.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_FLUSH_ENTRY,
-                "INT8:INT8:INT64:INT32",
-		"major:minor:ino:ndirty");		
-	_register_sys_event("nfs.fop.flush.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_FLUSH_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.fop.release.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_RELEASE_ENTRY,
-                "INT8:INT8:INT64:INT16",
-		"major:minor:ino:mode");		
-	_register_sys_event("nfs.fop.release.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_RELEASE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.fop.fsync.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_FSYNC_ENTRY,
-                "INT8:INT8:INT64:INT32",
-		"major:minor:ino:ndirty");		
-	_register_sys_event("nfs.fop.fsync.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_FSYNC_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.fop.lock.entry",
-		_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("nfs.fop.lock.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_LOCK_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.fop.sendfile.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_SENDFILE_ENTRY,
-                "INT8:INT8:INT64:INT64:INT64",
-		"major:minor:ino:count:pos");		
-	_register_sys_event("nfs.fop.sendfile.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_SENDFILE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.fop.check_flags.entry",
-		_GROUP_NFS, _HOOKID_NFS_FOP_CHECKFLAGS_ENTRY,
-                "INT32","flag");		
-	////TODO unable to resovle $return
-	_register_sys_event("nfs.fop.check_flags.return",
-		_GROUP_NFS, _HOOKID_NFS_FOP_CHECKFLAGS_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.aop.readpage.entry",
-		_GROUP_NFS, _HOOKID_NFS_AOP_READPAGE_ENTRY,
-                "INT64:INT32:INT64:INT64",
-		"ino:rsize:__page:page_index");		
-	_register_sys_event("nfs.aop.readpage.return",
-		_GROUP_NFS, _HOOKID_NFS_AOP_READPAGE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.aop.readpages.entry",
-		_GROUP_NFS, _HOOKID_NFS_AOP_READPAGES_ENTRY,
-                "INT64:INT32:INT32",
-		"ino:rpages:nr_pages");		
-	_register_sys_event("nfs.aop.readpages.return",
-		_GROUP_NFS, _HOOKID_NFS_AOP_READPAGES_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.aop.writepage.entry",
-		_GROUP_NFS, _HOOKID_NFS_AOP_WRITEPAGE_ENTRY,
-                "INT64:INT32:INT64:INT64",
-		"ino:wsize:__page:page_index");		
-	_register_sys_event("nfs.aop.writepage.return",
-		_GROUP_NFS, _HOOKID_NFS_AOP_WRITEPAGE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.aop.writepages.entry",
-		_GROUP_NFS, _HOOKID_NFS_AOP_WRITEPAGES_ENTRY,
-                "INT64:INT32:INT64",
-		"ino:wpages:nr_to_write");		
-	_register_sys_event("nfs.aop.writepages.return",
-		_GROUP_NFS, _HOOKID_NFS_AOP_WRITEPAGES_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.aop.prepare_write.entry",
-		_GROUP_NFS, _HOOKID_NFS_AOP_PREPAREWRITE_ENTRY,
-                "INT64:INT64:INT64",
-		"ino:__page:page_index");		
-	_register_sys_event("nfs.aop.prepare_write.return",
-		_GROUP_NFS, _HOOKID_NFS_AOP_PREPAREWRITE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.aop.commit_write.entry",
-		_GROUP_NFS, _HOOKID_NFS_AOP_COMMITWRITE_ENTRY,
-                "INT64:INT64:INT64:INT32:INT32",
-		"ino:__page:page_index:offset:count");		
-	_register_sys_event("nfs.aop.commit_write.return",
-		_GROUP_NFS, _HOOKID_NFS_AOP_COMMITWRITE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.aop.set_page_dirty.entry",
-		_GROUP_NFS, _HOOKID_NFS_AOP_SETPAGEDIRTY_ENTRY,
-                "INT64:INT8",
-		"__page:page_flag");		
-	_register_sys_event("nfs.aop.set_page_dirty.return",
-		_GROUP_NFS, _HOOKID_NFS_AOP_SETPAGEDIRTY_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.aop.release_page.entry",
-		_GROUP_NFS, _HOOKID_NFS_AOP_RELEASEPAGE_ENTRY,
-                "INT64:INT64",
-		"__page:page_index");		
-	_register_sys_event("nfs.aop.release_page.return",
-		_GROUP_NFS, _HOOKID_NFS_AOP_RELEASEPAGE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.lookup.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_LOOKUP_ENTRY,
-                "INT8:INT8:INT64:INT8:STRING",
-		"major_device:minor_device:fileid:version:filename");		
-	_register_sys_event("nfs.proc.lookup.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_LOOKUP_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.read.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_READ_ENTRY,
-                "INT8:INT8:INT64:INT8:INT32:INT64",
-		"major_device:minor_device:fileid:version:count:offset");	
-	_register_sys_event("nfs.proc.read.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_READ_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.write.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_WRITE_ENTRY,
-                "INT8:INT8:INT64:INT8:INT32:INT64",
-		"major_device:minor_device:fileid:version:count:offset");	
-	_register_sys_event("nfs.proc.write.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_WRITE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.commit.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_COMMIT_ENTRY,
-                "INT8:INT8:INT64:INT8:INT32:INT64",
-		"major_device:minor_device:fileid:version:count:offset");	
-	_register_sys_event("nfs.proc.commit.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_COMMIT_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.read_setup.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_READSETUP_ENTRY,
-                "INT8:INT8:INT64:INT8:INT32:INT64",
-		"major_device:minor_device:fileid:version:count:offset");	
-	_register_sys_event("nfs.proc.write_setup.entry",
-		_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("nfs.proc.commit_setup.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_COMMITSETUP_ENTRY,
-                "INT8:INT8:INT64:INT8:INT32:INT64",
-		"major_device:minor_device:fileid:version:count:offset");	
-
-	_register_sys_event("nfs.proc.read_done.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_READDONE_ENTRY,
-                "INT8:INT8:INT64:INT8:INT32:INT32",
-		"major_device:minor_device:fileid:version:status:count");	
-	_register_sys_event("nfs.proc.read_done.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_READDONE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.write_done.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_WRITEDONE_ENTRY,
-                "INT8:INT8:INT64:INT8:INT32:INT32",
-		"major_device:minor_device:fileid:version:status:count");	
-	_register_sys_event("nfs.proc.write_done.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_WRITEDONE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.commit_done.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_COMMITDONE_ENTRY,
-                "INT8:INT8:INT64:INT8:INT32:INT32",
-		"major_device:minor_device:fileid:version:status:count");	
-	_register_sys_event("nfs.proc.commit_done.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_COMMITDONE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.open.entry",
-		_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("nfs.proc.open.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_OPEN_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.release.entry",
-		_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("nfs.proc.release.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_RELEASE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.create.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_CREATE_ENTRY,
-                "INT8:INT8:INT64:INT8:STRING:INT32",
-		"major_device:minor_device:fileid:version:filename:mode");	
-	_register_sys_event("nfs.proc.create.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_CREATE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.rename.entry",
-		_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("nfs.proc.rename.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_RENAME_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfs.proc.remove.entry",
-		_GROUP_NFS, _HOOKID_NFS_PROC_REMOVE_ENTRY,
-		"INT8:INT8:INT64:INT8:STRING",
-		"major_dev:minor_dev:field_id:version:filename");;
-	_register_sys_event("nfs.proc.remove.return",
-		_GROUP_NFS, _HOOKID_NFS_PROC_REMOVE_RETURN,
-		"INT32", "return");;
-
-	_register_sys_event("nfsd.dispatch.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_DISPATCH_ENTRY,
-                "INT8:INT8:INT32:INT32:INT32",
-		"proto:version:xid:proc:client_ip");	
-	_register_sys_event("nfsd.dispatch.return",
-		_GROUP_NFSD, _HOOKID_NFSD_DISPATCH_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.open.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_OPEN_ENTRY,
-                "INT8:INT64:INT64:INT64:INT32:INT8",
-		"size:ino0:ino1:ino2:type:access");	
-	_register_sys_event("nfsd.open.return",
-		_GROUP_NFSD, _HOOKID_NFSD_OPEN_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.read.entry",
-		_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("nfsd.read.return",
-		_GROUP_NFSD, _HOOKID_NFSD_READ_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.write.entry",
-		_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("nfsd.write.return",
-		_GROUP_NFSD, _HOOKID_NFSD_WRITE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfsd.lookup.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_LOOKUP_ENTRY,
-                "INT8:INT64:INT64:INT64:STRING",
-		"size:ino0:ino1:ino2:filename");	
-	_register_sys_event("nfsd.lookup.return",
-		_GROUP_NFSD, _HOOKID_NFSD_LOOKUP_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.commit.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_COMMIT_ENTRY,
-                "INT8:INT64:INT64:INT64:INT64:INT64",
-		"size:ino0:ino1:ino2:count:offset");	
-	_register_sys_event("nfsd.commit.return",
-		_GROUP_NFSD, _HOOKID_NFSD_COMMIT_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.create.entry",
-		_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("nfsd.create.return",
-		_GROUP_NFSD, _HOOKID_NFSD_CREATE_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.createv3.entry",
-		_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("nfsd.createv3.return",
-		_GROUP_NFSD, _HOOKID_NFSD_CREATEV3_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.unlink.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_UNLINK_ENTRY,
-                "INT8:INT64:INT64:INT64:STRING:INT32",
-		"size:ino0:ino1:ino2:filename:type");	
-	_register_sys_event("nfsd.unlink.return",
-		_GROUP_NFSD, _HOOKID_NFSD_UNLINK_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.rename.entry",
-		_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("nfsd.rename.return",
-		_GROUP_NFSD, _HOOKID_NFSD_RENAME_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.close.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_CLOSE_ENTRY,
-                "STRING", "filename");	
-	_register_sys_event("nfsd.close.return",
-		_GROUP_NFSD, _HOOKID_NFSD_CLOSE_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.proc.lookup.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_LOOKUP_ENTRY,
-                "INT8:INT64:INT64:INT64:INT8:STRING",
-		"size:ino0:ino1:ino2:version:filename");	
-	_register_sys_event("nfsd.proc.lookup.return",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_LOOKUP_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.proc.read.entry",
-		_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("nfsd.proc.read.return",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_READ_RETURN,
-                "INT32","return");
-	
-	_register_sys_event("nfsd.proc.write.entry",
-		_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("nfsd.proc.write.return",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_WRITE_RETURN,
-                "INT32","return");
-	
-	_register_sys_event("nfsd.proc.commit.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_COMMIT_ENTRY,
-                "INT8:INT64:INT64:INT64:INT8:INT64:INT64",
-		"size:ino0:ino1:ino2:version:count:offset");	
-	_register_sys_event("nfsd.proc.commit.return",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_COMMIT_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfsd.proc.compound.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_COMPOUND_ENTRY,
-                "INT32","num");	
-	_register_sys_event("nfsd.proc.compound.return",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_COMPOUND_RETURN,
-                "INT32","return");	
-
-	_register_sys_event("nfsd.proc.remove.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_REMOVE_ENTRY,
-                "INT8:INT64:INT64:INT64:INT8:STRING",
-		"size:ino0:ino1:ino2:version:filename");	
-	_register_sys_event("nfsd.proc.remove.return",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_REMOVE_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfsd.proc.rename.entry",
-		_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("nfsd.proc.rename.return",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_RENAME_RETURN,
-                "INT32","return");
-
-	_register_sys_event("nfsd.proc.create.entry",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_CREATE_ENTRY,
-                "INT8:INT64:INT64:INT64:INT8:STRING",
-		"size:ino0:ino1:ino2:version:filename");	
-	_register_sys_event("nfsd.proc.create.return",
-		_GROUP_NFSD, _HOOKID_NFSD_PROC_CREATE_RETURN,
-                "INT32","return");
-%}
-
-probe register_event = begin
-{
-	have_userevent = 1
-	hookid_init()
-}
diff --git a/tapset/LKET/rpc.stp b/tapset/LKET/rpc.stp
deleted file mode 100755
index b9c8ca60..00000000
--- a/tapset/LKET/rpc.stp
+++ /dev/null
@@ -1,800 +0,0 @@
-# SunRPC 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.
-#
-probe never 
-{
-	printf("%d\n", GROUP_SUNRPC) 
-}
-
-probe addevent.sunrpc
-	= addevent.sunrpc.entry, addevent.sunrpc.return
-{}
-
-probe addevent.sunrpc.entry
-	=
-	addevent.sunrpc.clnt.entry,
-	addevent.sunrpc.svc.entry,
-	addevent.sunrpc.sched.entry
-{}
-
-probe addevent.sunrpc.return
-	=
-	addevent.sunrpc.clnt.return,
-	addevent.sunrpc.svc.return,
-	addevent.sunrpc.sched.return
-{}
-
-/******************************************************************
- *        trace hooks on high level RPC client functions          *  
- ******************************************************************/
-probe addevent.sunrpc.clnt 
-	= addevent.sunrpc.clnt.entry, addevent.sunrpc.clnt.return
-{}
-
-probe addevent.sunrpc.clnt.entry
-	= 
-	addevent.sunrpc.clnt.create_client.entry,
-	addevent.sunrpc.clnt.clone_client.entry,
-	addevent.sunrpc.clnt.bind_new_program.entry,
-	addevent.sunrpc.clnt.shutdown_client.entry,
-	addevent.sunrpc.clnt.call_sync.entry,
-	addevent.sunrpc.clnt.call_async.entry,
-	addevent.sunrpc.clnt.restart_call.entry
-{}
-
-probe addevent.sunrpc.clnt.return
-	= 
-	addevent.sunrpc.clnt.create_client.return,
-	addevent.sunrpc.clnt.clone_client.return,
-	addevent.sunrpc.clnt.bind_new_program.return,
-	addevent.sunrpc.clnt.shutdown_client.return,
-	addevent.sunrpc.clnt.call_sync.return,
-	addevent.sunrpc.clnt.call_async.return,
-	addevent.sunrpc.clnt.restart_call.return
-{}
-
-// Fires when an RPC client is to be created
-probe addevent.sunrpc.clnt.create_client.entry
-	+= _addevent.sunrpc.clnt.create_client.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.create_client.entry
-	= sunrpc.clnt.create_client
-{
-	log_sunrpc_client_info(HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY,
-			servername, prog, vers, prot, port, authflavor)
-}
-
-probe addevent.sunrpc.clnt.create_client.return
-	+= _addevent.sunrpc.clnt.create_client.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.create_client.return
-	= sunrpc.clnt.create_client.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN, 
-			$return)
-}
-
-// Fires when the RPC client structure is to be cloned
-probe addevent.sunrpc.clnt.clone_client.entry
-	+= _addevent.sunrpc.clnt.clone_client.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.clone_client.entry
-	= sunrpc.clnt.clone_client
-{
-	log_sunrpc_client_info(HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY, 
-			servername, prog, vers, prot, port, authflavor)
-}
-
-probe addevent.sunrpc.clnt.clone_client.return
-	+= _addevent.sunrpc.clnt.clone_client.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.clone_client.return
-	= sunrpc.clnt.clone_client.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN, 
-			$return)
-}
-
-// Fires when an RPC client is to be shut down.
-probe addevent.sunrpc.clnt.shutdown_client.entry
-	+= _addevent.sunrpc.clnt.shutdown_client.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.shutdown_client.entry
-	= sunrpc.clnt.shutdown_client
-{
-	log_sunrpc_shutdown_client(HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY,
-			servername, prog, clones, tasks, rpccnt)
-}
-
-probe addevent.sunrpc.clnt.shutdown_client.return
-	+= _addevent.sunrpc.clnt.shutdown_client.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.shutdown_client.return
-	= sunrpc.clnt.shutdown_client.return
-{
-	log_sunrpc_return_void(HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN)
-}
-
-function log_sunrpc_shutdown_client(hookid:long, servername:string, 
-		prog:long, clones:long, tasks:long, rpccnt:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%2b%2b%4b", 
-			THIS->servername, (_FMT_)THIS->prog, 
-			(_FMT_)THIS->clones, (_FMT_)THIS->tasks, 
-			(_FMT_)THIS->rpccnt);
-%}
-
-// Fires when a new RPC program is to be bound an existing client
-probe addevent.sunrpc.clnt.bind_new_program.entry
-	+= _addevent.sunrpc.clnt.bind_new_program.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.bind_new_program.entry
-	= sunrpc.clnt.bind_new_program
-{
-	log_sunrpc_bind_new_program(HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY, 
-			servername, old_prog, old_vers, prog, vers)
-}
-
-probe addevent.sunrpc.clnt.bind_new_program.return
-	+= _addevent.sunrpc.clnt.bind_new_program.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.bind_new_program.return
-	= sunrpc.clnt.bind_new_program.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN, 
-			$return)
-}
-
-function log_sunrpc_bind_new_program(hookid:long, servername:string, 
-		old_prog:long, old_vers:long, prog:long, vers:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%1b%8b%1b",
-			THIS->servername, (_FMT_)THIS->old_prog, 
-			(_FMT_)THIS->old_vers, (_FMT_)THIS->prog, 
-			(_FMT_)THIS->vers);
-%}
-
-// rpc_call_sync
-probe addevent.sunrpc.clnt.call_sync.entry
-	+= _addevent.sunrpc.clnt.call_sync.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.call_sync.entry
-	= sunrpc.clnt.call_sync
-{
-	 log_sunrpc_call_sync(HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY, servername, 
-			prog, vers, proc, flags)
-}
-
-probe addevent.sunrpc.clnt.call_sync.return
-	+= _addevent.sunrpc.clnt.call_sync.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.call_sync.return
-	= sunrpc.clnt.call_sync.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN, $return)
-}
-
-function log_sunrpc_call_sync(hookid:long, servername:string, prog:long, 
-		vers:long, proc:long, flags:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%1b%8b%8b",
-			THIS->servername, (_FMT_)THIS->prog, 
-			(_FMT_)THIS->vers, (_FMT_)THIS->proc, 
-			(_FMT_)THIS->flags);
-%}
-
-// rpc_call_async
-probe addevent.sunrpc.clnt.call_async.entry
-	+= _addevent.sunrpc.clnt.call_async.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.call_async.entry
-	= sunrpc.clnt.call_async
-{
-	 log_sunrpc_call_async(HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY, servername, 
-			 prog, vers, proc, flags)
-}
-
-probe addevent.sunrpc.clnt.call_async.return
-	+= _addevent.sunrpc.clnt.call_async.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.call_async.return
-	= sunrpc.clnt.call_async.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN, $return)
-}
-
-function log_sunrpc_call_async(hookid:long, servername:string, prog:long, 
-		vers:long, proc:long, flags:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%1b%8b%8b",
-			THIS->servername, (_FMT_)THIS->prog, 
-			(_FMT_)THIS->vers, (_FMT_)THIS->proc, 
-			(_FMT_)THIS->flags);
-%}
-
-// Fires when want to restart a task
-probe addevent.sunrpc.clnt.restart_call.entry
-	+= _addevent.sunrpc.clnt.restart_call.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.restart_call.entry
-	= sunrpc.clnt.restart_call
-{
-	log_sunrpc_restart_call(HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY, tk_pid, 
-			tk_flags)
-} 
-
-probe addevent.sunrpc.clnt.restart_call.return
-	+= _addevent.sunrpc.clnt.restart_call.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.clnt.restart_call.return
-	= sunrpc.clnt.restart_call.return
-{
-	log_sunrpc_return_void(HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN) //void
-}
-
-function log_sunrpc_restart_call(hookid:long, tk_pid:long, tk_flags:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b", 
-			(_FMT_)THIS->tk_pid, (_FMT_)THIS->tk_flags);
-%}
-
-/*********************************************
- *    Probe points on RPC server interface   *
- ********************************************/
-probe addevent.sunrpc.svc
-	= addevent.sunrpc.svc.entry, addevent.sunrpc.svc.return
-{}
-
-probe addevent.sunrpc.svc.entry
-	=
-	addevent.sunrpc.svc.register.entry,
-	addevent.sunrpc.svc.create.entry,
-	addevent.sunrpc.svc.destroy.entry,
-	addevent.sunrpc.svc.process.entry,
-	addevent.sunrpc.svc.authorise.entry,
-	addevent.sunrpc.svc.recv.entry,
-	addevent.sunrpc.svc.send.entry,
-	addevent.sunrpc.svc.drop.entry
-{}
-
-probe addevent.sunrpc.svc.return
-	=
-	addevent.sunrpc.svc.register.return,
-	addevent.sunrpc.svc.create.return,
-	addevent.sunrpc.svc.destroy.return,
-	addevent.sunrpc.svc.process.return,
-	addevent.sunrpc.svc.authorise.return,
-	addevent.sunrpc.svc.recv.return,
-	addevent.sunrpc.svc.send.return,
-	addevent.sunrpc.svc.drop.return
-{}
-
-// Fires when an RPC service is to be registered with the local portmapper.
-probe addevent.sunrpc.svc.register.entry
-	+= _addevent.sunrpc.svc.register.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.register.entry
-	= sunrpc.svc.register
-{
-	log_sunrpc_svc_register(HOOKID_SUNRPC_SVC_REGISTER_ENTRY, sv_name, 
-			prog, prot, port)
-}
-
-probe addevent.sunrpc.svc.register.return
-	+= _addevent.sunrpc.svc.register.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.register.return
-	= sunrpc.svc.register.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_REGISTER_RETURN, 
-			$return) 
-}
-
-function log_sunrpc_svc_register(hookid:long, sv_name:string,
-		prog:long, prot:long, port:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%2b%4b", 
-			THIS->sv_name, (_FMT_)THIS->prog, 
-			(_FMT_)THIS->prot, (_FMT_)THIS->port);
-%}
-
-// Fires when an RPC service is to be created
-probe addevent.sunrpc.svc.create.entry
-	+= _addevent.sunrpc.svc.create.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.create.entry
-	= sunrpc.svc.create
-{
-	log_sunrpc_svc_create(HOOKID_SUNRPC_SVC_CREATE_ENTRY, prog, 
-			pg_nvers, bufsize)
-}
-
-probe addevent.sunrpc.svc.create.return
-	+= _addevent.sunrpc.svc.create.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.create.return
-	= sunrpc.svc.create.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_CREATE_RETURN, $return)
-}
-
-function log_sunrpc_svc_create(hookid:long, prog:long, 
-		pg_nvers:long, bufsize:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%1b%4b", 
-			(_FMT_)THIS->prog, (_FMT_)THIS->pg_nvers,
-			(_FMT_)THIS->bufsize);
-%}
-
-// Fires when an RPC service is to be destroyed
-probe addevent.sunrpc.svc.destroy.entry
-	+= _addevent.sunrpc.svc.destroy.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.destroy.entry
-	= sunrpc.svc.destroy
-{
-	log_sunrpc_svc_destroy(HOOKID_SUNRPC_SVC_DESTROY_ENTRY, 
-			sv_name, sv_prog, sv_nrthreads)
-}
-
-probe addevent.sunrpc.svc.destroy.return
-	+= _addevent.sunrpc.svc.destroy.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.destroy.return
-	= sunrpc.svc.destroy.return
-{
-	log_sunrpc_return_void(HOOKID_SUNRPC_SVC_DESTROY_RETURN)
-}
-
-function log_sunrpc_svc_destroy(hookid:long, sv_name:string, 
-		sv_prog:long, sv_nrthreads:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%4b", THIS->sv_name, 
-			(_FMT_)THIS->sv_prog, (_FMT_)THIS->sv_nrthreads);
-%}
-
-// Fires when an RPC request is to be processed
-probe addevent.sunrpc.svc.process.entry
-	+= _addevent.sunrpc.svc.process.entry
-{
-	update_record()
-}
-probe _addevent.sunrpc.svc.process.entry
-	= sunrpc.svc.process
-{
-	log_sunrpc_task_info(HOOKID_SUNRPC_SVC_PROCESS_ENTRY, sv_name, 
-			sv_prog, peer_ip, rq_xid, rq_prog, rq_vers, rq_proc)
-}
-
-probe addevent.sunrpc.svc.process.return
-	+= _addevent.sunrpc.svc.process.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.process.return
-	= sunrpc.svc.process.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_PROCESS_RETURN, $return)
-}
-
-// Fires when an RPC request is to be authorised
-probe addevent.sunrpc.svc.authorise.entry
-	+= _addevent.sunrpc.svc.authorise.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.authorise.entry
-	= sunrpc.svc.authorise
-{
-	log_sunrpc_svc_authorise(HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY, sv_name, 
-			peer_ip, rq_xid, rq_prog, rq_vers, rq_proc)
-}
-
-probe addevent.sunrpc.svc.authorise.return
-	+= _addevent.sunrpc.svc.authorise.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.authorise.return
-	= sunrpc.svc.authorise.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_AUTHORISE_RETURN, $return)
-}
-
-function log_sunrpc_svc_authorise(hookid:long, sv_name:string, peer_ip:long, 
-		rq_xid:long, rq_prog:long, rq_vers:long, rq_proc:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%8b%8b%1b%8b",
-			THIS->sv_name, (_FMT_)THIS->peer_ip, 
-			(_FMT_)THIS->rq_xid, (_FMT_)THIS->rq_prog, 
-			(_FMT_)THIS->rq_vers, (_FMT_)THIS->rq_proc);
-%}
-
-/*
- * Fires when receiving the next request on any socket.
- */
-probe addevent.sunrpc.svc.recv.entry
-	+= _addevent.sunrpc.svc.recv.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.recv.entry
-	= sunrpc.svc.recv
-{
-	log_sunrpc_svc_recv(HOOKID_SUNRPC_SVC_RECV_ENTRY, sv_name, timeout)
-}
-
-probe addevent.sunrpc.svc.recv.return
-	+= _addevent.sunrpc.svc.recv.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.recv.return
-	= sunrpc.svc.recv.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_RECV_RETURN, $return)
-}
-
-function log_sunrpc_svc_recv(hookid:long, sv_name:string, timeout:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b", THIS->sv_name, 
-			(_FMT_)THIS->timeout);
-%}
-
-// Fires when want to return reply to client.
-probe addevent.sunrpc.svc.send.entry
-	+= _addevent.sunrpc.svc.send.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.send.entry
-	= sunrpc.svc.send
-{
-	log_sunrpc_svc_send(HOOKID_SUNRPC_SVC_SEND_ENTRY, sv_name, peer_ip, 
-			rq_xid, rq_prog, rq_vers, rq_proc)
-}
-
-probe addevent.sunrpc.svc.send.return
-	+= _addevent.sunrpc.svc.send.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.send.return
-	= sunrpc.svc.send.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_SEND_RETURN, $return)
-}
-
-function log_sunrpc_svc_send(hookid:long, sv_name:string, peer_ip:long,
-		rq_xid:long, rq_prog:long, rq_vers:long, rq_proc:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%8b%8b%1b%8b", 
-			THIS->sv_name, (_FMT_)THIS->peer_ip, 
-			(_FMT_)THIS->rq_xid, (_FMT_)THIS->rq_prog, 
-			(_FMT_)THIS->rq_vers, (_FMT_)THIS->rq_proc);
-%}
-
-// Fires when a request is to be dropped
-probe addevent.sunrpc.svc.drop.entry
-	+= _addevent.sunrpc.svc.drop.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.drop.entry
-	= sunrpc.svc.drop
-{
-	log_sunrpc_svc_drop(HOOKID_SUNRPC_SVC_DROP_ENTRY, sv_name, peer_ip, 
-			rq_xid, rq_prog, rq_vers, rq_proc)
-}
-
-probe addevent.sunrpc.svc.drop.return
-	+= _addevent.sunrpc.svc.drop.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.svc.drop.return
-	= sunrpc.svc.drop.return
-{
-	log_sunrpc_return_void(HOOKID_SUNRPC_SVC_DROP_RETURN)
-}
-
-function log_sunrpc_svc_drop(hookid:long, sv_name:string, peer_ip:long,
-		rq_xid:long, rq_prog:long, rq_vers:long, rq_proc:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%8b%8b%1b%8b", 
-			THIS->sv_name, (_FMT_)THIS->peer_ip, 
-			(_FMT_)THIS->rq_xid, (_FMT_)THIS->rq_prog, 
-			(_FMT_)THIS->rq_vers, (_FMT_)THIS->rq_proc);
-%}
-
-/*******************************************************************
- *                  Probe points on RPC scheduler                  *
- ******************************************************************/
-probe addevent.sunrpc.sched
-	= addevent.sunrpc.sched.entry, addevent.sunrpc.sched.return
-{}
-
-probe addevent.sunrpc.sched.entry
-	= 
-	addevent.sunrpc.sched.new_task.entry,
-	addevent.sunrpc.sched.execute.entry,
-	addevent.sunrpc.sched.delay.entry,
-	addevent.sunrpc.sched.release_task.entry
-{}
-
-probe addevent.sunrpc.sched.return
-	= 
-	addevent.sunrpc.sched.new_task.return,
-	addevent.sunrpc.sched.execute.return,
-	addevent.sunrpc.sched.delay.return,
-	addevent.sunrpc.sched.release_task.return
-{}
-
-// Fires when creating a new task for the specified client
-probe addevent.sunrpc.sched.new_task.entry
-	+= _addevent.sunrpc.sched.new_task.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.sched.new_task.entry
-	= sunrpc.sched.new_task
-{
-	log_sunrpc_new_task(HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY, xid, prog, 
-			vers, prot, flags)
-}
-
-probe addevent.sunrpc.sched.new_task.return
-	+= _addevent.sunrpc.sched.new_task.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.sched.new_task.return
-	= sunrpc.sched.new_task.return
-{
-	log_sunrpc_return_int64(HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN, $return)
-}
-
-function log_sunrpc_new_task(hookid:long, xid:long, prog:long, vers:long,
-		prot:long, flags:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b%1b%8b%8b",
-			(_FMT_)THIS->xid, (_FMT_)THIS->prog,
-			(_FMT_)THIS->vers, (_FMT_)THIS->prot,
-			(_FMT_)THIS->flags);
-%}
-
-// Fires when releasing a task
-probe addevent.sunrpc.sched.release_task.entry
-	+= _addevent.sunrpc.sched.release_task.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.sched.release_task.entry
-	= sunrpc.sched.release_task
-{
-	log_sunrpc_release_task(HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY,	
-			xid, prog, vers, prot, tk_flags)
-}
-
-probe addevent.sunrpc.sched.release_task.return
-	+= _addevent.sunrpc.sched.release_task.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.sched.release_task.return
-	= sunrpc.sched.release_task.return
-{
-	log_sunrpc_return_void(HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN)
-}
-
-function log_sunrpc_release_task(hookid:long, xid:long, prog:long, vers:long,
-		prot:long, flags:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b%1b%8b%8b",
-			(_FMT_)THIS->xid, (_FMT_)THIS->prog,
-			(_FMT_)THIS->vers, (_FMT_)THIS->prot,
-			(_FMT_)THIS->flags);
-%}
-
-// Fires when an RPC request is to be executed
-probe addevent.sunrpc.sched.execute.entry
-	+= _addevent.sunrpc.sched.execute.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.sched.execute.entry
-	= sunrpc.sched.execute
-{
-	log_sunrpc_execute(HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY, xid, prog, 
-			vers, prot, tk_pid, tk_flags)
-}
-
-probe addevent.sunrpc.sched.execute.return
-	+= _addevent.sunrpc.sched.execute.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.sched.execute.return
-	= sunrpc.sched.execute.return
-{
-%( kernel_v <= "2.6.20" %?
-	log_sunrpc_return_int64(HOOKID_SUNRPC_SCHED_EXECUTE_RETURN, $return)
-%:
-	log_sunrpc_return_void(HOOKID_SUNRPC_SCHED_EXECUTE_RETURN)
-%)
-}
-
-function log_sunrpc_execute(hookid:long, xid:long, prog:long, vers:long,
-		prot:long, tk_pid:long, tk_flags:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b%1b%8b%8b%8b",
-			(_FMT_)THIS->xid, (_FMT_)THIS->prog,
-			(_FMT_)THIS->vers, (_FMT_)THIS->prot,
-			(_FMT_)THIS->tk_pid, (_FMT_)THIS->tk_flags);
-%}
-
-// Fires when want to delay an RPC request
-probe addevent.sunrpc.sched.delay.entry
-	+= _addevent.sunrpc.sched.delay.entry
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.sched.delay.entry
-	= sunrpc.sched.delay
-{
-	log_sunrpc_delay(HOOKID_SUNRPC_SCHED_DELAY_ENTRY, xid, prog, 
-			tk_pid, tk_flags, delay)
-}
-
-probe addevent.sunrpc.sched.delay.return
-	+= _addevent.sunrpc.sched.delay.return
-{
-	update_record()
-}
-
-probe _addevent.sunrpc.sched.delay.return
-	= sunrpc.sched.delay.return
-{
-	log_sunrpc_return_void(HOOKID_SUNRPC_SCHED_DELAY_RETURN)
-}
-
-function log_sunrpc_delay(hookid:long, xid:long, prog:long, tk_pid:long, 
-		tk_flags:long, delay:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b%8b%8b%8b",
-			(_FMT_)THIS->xid, (_FMT_)THIS->prog,
-			(_FMT_)THIS->tk_pid, (_FMT_)THIS->tk_flags,
-			(_FMT_)THIS->delay);
-%}
-
-/******************************************************************
- *                       Helper functions                        *
- *****************************************************************/
-function log_sunrpc_client_info(hookid:long, servername:string, 
-		prog:long, vers:long, prot:long,
-		port:long, authflavor:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%1b%2b%2b%1b", 
-			THIS->servername, (_FMT_)THIS->prog, 
-			(_FMT_)THIS->vers, (_FMT_)THIS->prot, 
-			(_FMT_)THIS->port, (_FMT_)THIS->authflavor);
-%}
-
-function log_sunrpc_task_info(hookid:long, sv_name:string,
-		sv_prog:long, peer_ip:long, rq_xid:long,
-		rq_prog:long, rq_vers:long, rq_proc:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%8b%8b%8b%1b%1b",
-			THIS->sv_name, (_FMT_)THIS->sv_prog, 
-			(_FMT_)THIS->peer_ip, (_FMT_)THIS->rq_xid, 
-			(_FMT_)THIS->rq_prog, (_FMT_)THIS->rq_vers,
-			(_FMT_)THIS->rq_proc);
-%}
-
-function log_sunrpc_return_int64(hookid:long, ret:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b", (_FMT_)THIS->ret);
-%}
-
-function log_sunrpc_return_int32(hookid:long, ret:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%4b", (_FMT_)THIS->ret);
-%}
-
-function log_sunrpc_return_int16(hookid:long, ret:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%2b", (_FMT_)THIS->ret);
-%}
-
-function log_sunrpc_return_int8(hookid:long, ret:long)
-%{
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%1b", (_FMT_)THIS->ret);
-%}
-
-function log_sunrpc_return_void(hookid:long)
-%{
-#define VOIDRETURN	0
-	_lket_trace(_GROUP_SUNRPC, THIS->hookid, "%1b", (_FMT_)VOIDRETURN);
-%}
-
diff --git a/tapset/LKET/scsi.stp b/tapset/LKET/scsi.stp
deleted file mode 100755
index a1b76102..00000000
--- a/tapset/LKET/scsi.stp
+++ /dev/null
@@ -1,139 +0,0 @@
-// Copyright (C) 2005, 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
-
-/***********************************************************
-* Trace the following activities of scsi layer:            *
-*  1. I/O Entry                                            *
-*  2. Issuing I/O to LLD                                   *
-*  3. I/O done by LLD                                      *
-*  4. I/O Complete                                         *
-*                                                          *
-***********************************************************/
-
-%{
-#include <linux/types.h>
-#include <scsi/scsi_cmnd.h>
-#include <scsi/scsi_device.h>
-#include <scsi/scsi_host.h>
-#include <linux/timer.h>
-#include <linux/blkdev.h>
-%}
-
-probe addevent.scsi
-	= addevent.scsi.ioentry,
-	addevent.scsi.iodispatching,
-	addevent.scsi.iodone,
-	addevent.scsi.iocompleted
-{}
-
-/* mid-layer prepare a IO request */
-probe addevent.scsi.ioentry
-	+= _addevent.scsi.ioentry
-{
-	update_record()
-}
-
-probe _addevent.scsi.ioentry
-	= scsi.ioentry
-{
-	log_scsi_ioentry(disk_major, disk_minor, device_state, req_addr)
-}
-
-/* Dispatch a command to the low-level driver. */
-probe addevent.scsi.iodispatching
-	+= _addevent.scsi.iodispatching
-{
-	update_record()
-}
-
-probe _addevent.scsi.iodispatching
-	= scsi.iodispatching
-{
-	log_scsi_dispatch(host_no, channel, lun, dev_id, device_state, 
-		data_direction, request_buffer, request_bufflen, req_addr)
-}
-
-/* I/O is done by low-level driver*/
-probe addevent.scsi.iodone
-	+= _addevent.scsi.iodone
-{
-	update_record()
-}
-
-probe _addevent.scsi.iodone
-	= scsi.iodone
-{
-	/* scsi timer check. We should record the hook only
-	 * when the timer is inactive. But there's a gap between 
-	 * the checking and the actual calling of scsi_delete_timer.
-	 */
-	if( scsi_timer_pending == 1) {
-		log_scsi_iodone_extra(host_no, channel, lun,
-			dev_id, device_state, data_direction, req_addr)
-	}
-}
-
-/* mid-layer processes the completed IO */
-probe addevent.scsi.iocompleted
-	+= _addevent.scsi.iocompleted
-{
-	update_record()
-}
-
-probe _addevent.scsi.iocompleted
-	= scsi.iocompleted
-{
-	log_scsi_iocompleted(host_no, channel, lun, dev_id, device_state,
-		data_direction, req_addr, goodbytes)
-}
-
-/* log the info about scsi io entry */
-function log_scsi_ioentry(major:long, minor:long, dev_state:long, req_addr:long)
-%{
-	/* 
-	major|minor|scsi_device_state|request_addr
-	*/
-	_lket_trace(_GROUP_SCSI, _HOOKID_SCSI_IOENTRY, "%1b%1b%1b%8b", 
-		THIS->major, THIS->minor, THIS->dev_state, THIS->req_addr);
-%}
-
-/* log the info about scsi_dispatching_cmd */
-
-function log_scsi_dispatch(host_no:long, channel:long, lun:long, dev_id:long, 
-		device_state:long, data_direction:long, request_buffer:long, 
-		request_bufflen:long, req_addr:long)
-%{
-	_lket_trace(_GROUP_SCSI, _HOOKID_SCSI_IO_TO_LLD, "%1b%1b%1b%1b%1b%1b%8b%4b%8b",
-		THIS->host_no, THIS->channel, THIS->lun, THIS->dev_id, 
-		THIS->device_state, THIS->data_direction, THIS->request_buffer,
-		THIS->request_bufflen, THIS->req_addr);
-%}
-
-/* log the info about scsi_done */
-function log_scsi_iodone_extra(host_no:long, channel:long, lun:long,
-		dev_id:long, device_state:long, data_direction:long,
-		req_addr:long)
-%{
-	_lket_trace(_GROUP_SCSI, _HOOKID_SCSI_IODONE_BY_LLD, "%1b%1b%1b%1b%1b%1b%8b", 
-		THIS->host_no, THIS->channel, THIS->lun, THIS->dev_id,
-		THIS->device_state, THIS->data_direction, THIS->req_addr);
-%}
-
-/* log the info about scsi_dispatching_cmd */
-function log_scsi_iocompleted(host_no:long, channel:long, lun:long, dev_id:long,
-		device_state:long, data_direction:long, req_addr:long, goodbytes:long)
-%{
-	_lket_trace(_GROUP_SCSI, _HOOKID_SCSI_IOCOMP_BY_MIDLEVEL, 
-		"%1b%1b%1b%1b%1b%1b%8b%4b", THIS->host_no, THIS->channel, 
-		THIS->lun, THIS->dev_id, THIS->device_state, THIS->data_direction, 
-		THIS->req_addr, THIS->goodbytes);		
-%}
-
-probe never
-{
-	printf("%d\n", GROUP_SCSI)
-}
diff --git a/tapset/LKET/signal.stp b/tapset/LKET/signal.stp
deleted file mode 100755
index 1de4da1f..00000000
--- a/tapset/LKET/signal.stp
+++ /dev/null
@@ -1,357 +0,0 @@
-// signal 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.
-
-probe never 
-{
-	printf("%d", GROUP_SIGNAL)
-}
-
-probe addevent.signal
-	= addevent.signal.entry,
-	addevent.signal.return
-{}
-
-probe addevent.signal.entry
-	=
-	addevent.signal.send.entry,
-	addevent.signal.syskill.entry,
-	addevent.signal.systgkill.entry,
-	addevent.signal.systkill.entry,
-	addevent.signal.pending.entry,
-	addevent.signal.do_action.entry,
-	addevent.signal.procmask.entry,
-	addevent.signal.flush.entry
-{}
-
-probe addevent.signal.return
-	=
-	addevent.signal.send.return,
-	addevent.signal.syskill.return,
-	addevent.signal.systgkill.return,
-	addevent.signal.systkill.return,
-	addevent.signal.pending.return,
-	addevent.signal.do_action.return,
-	addevent.signal.procmask.return
-{}
-
-/* Fires when a signal is sent to a process */
-probe addevent.signal.send.entry
-	+= _addevent.signal.send.entry
-{
-	update_record()
-}
-
-probe _addevent.signal.send.entry
-	= signal.send
-{
-	log_signal_send(sig, sig_pid, shared, send2queue)
-}
-
-function log_signal_send(sig:long, pid:long, shared:long, send2queue:long)
-%{
-	/* sig | shared | send2queue | pid 
-		shared: indicate whether the signal is send to a process
-			group or to a single process
-		send2queue: indicate whether the event is triggered by 
-			send_group_sigqueue or send_sigqueue
-	*/
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SEND_ENTRY, "%1b%1b%1b%4b", 
-		THIS->sig, THIS->shared, THIS->send2queue, THIS->pid);
-%}
-
-probe addevent.signal.send.return
-	+= _addevent.signal.send.return
-{
-	update_record()
-}
-probe _addevent.signal.send.return
-	= signal.send.return
-{
-	log_signal_send_return($return)
-}
-
-function log_signal_send_return(ret:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SEND_RETURN, "%1b", THIS->ret);
-%}
-
-
-/* Triggered by calling kill() from user app */
-probe addevent.signal.syskill.entry
-	+= _addevent.signal.syskill.entry
-{
-	update_record()
-}
-
-probe _addevent.signal.syskill.entry = signal.syskill
-{
-	log_signal_syskill(pid, sig)
-}
-
-function log_signal_syskill(pid:long, sig:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSKILL_ENTRY,
-		"%4b%1b", THIS->pid, THIS->sig);
-%}
-
-probe addevent.signal.syskill.return
-	+= _addevent.signal.syskill.return
-{
-	update_record()
-}
-
-probe _addevent.signal.syskill.return 
-	= signal.syskill.return
-{
-	log_signal_syskill_return($return)
-}
-
-function log_signal_syskill_return(ret:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSKILL_RETURN,
-		"%1b", THIS->ret);
-%}
-
-/* triggered by calling sys_tgkill() from user app */
-probe addevent.signal.systgkill.entry
-	+= _addevent.signal.systgkill.entry
-{
-	update_record()
-}
-
-probe _addevent.signal.systgkill.entry = signal.systgkill
-{
-	log_signal_systgkill(pid, tgid, sig)
-}
-
-function log_signal_systgkill(pid:long, tgid:long, sig:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTGKILL_ENTRY,
-		"%4b%4b%1b", THIS->pid, THIS->tgid, THIS->sig);
-%}
-
-probe addevent.signal.systgkill.return
-	+= _addevent.signal.systgkill.return
-{
-	update_record()
-}
-
-probe _addevent.signal.systgkill.return 
-	= signal.systgkill.return
-{
-	log_signal_systgkill_return($return)
-}
-
-function log_signal_systgkill_return(ret:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTGKILL_RETURN,
-		"%1b", THIS->ret);
-%}
-
-/* Triggered by calling tkill() from user app */
-probe addevent.signal.systkill.entry
-	+= _addevent.signal.systkill.entry
-{
-	update_record()
-}
-
-probe _addevent.signal.systkill.entry = signal.systkill
-{
-	log_signal_systkill(pid, sig)
-}
-
-function log_signal_systkill(pid:long, sig:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTKILL_ENTRY,
-		"%4b%1b", THIS->pid, THIS->sig);
-%}
-
-probe addevent.signal.systkill.return
-	+= _addevent.signal.systkill.return
-{
-	update_record()
-}
-
-probe _addevent.signal.systkill.return 
-	= signal.systkill.return
-{
-	log_signal_systkill_return($return)
-}
-
-function log_signal_systkill_return(ret:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_SYSTKILL_RETURN,
-		"%1b", THIS->ret);
-%}
-
-/* Fires when examining current pending signals */
-probe addevent.signal.pending.entry
-	+= _addevent.signal.pending.entry
-{
-	update_record()
-}
-
-probe _addevent.signal.pending.entry = signal.pending
-{
-	log_signal_pending(sigset_add, sigset_size)
-}
-
-function log_signal_pending(sigset_addr:long, setsize:long)
-%{
-	/* sigset_addr | setsize */
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_PENDING_ENTRY,
-		"%8b%8b", THIS->sigset_addr, THIS->setsize);
-%}
-
-probe addevent.signal.pending.return
-	+= _addevent.signal.pending.return
-{
-	update_record()
-}
-
-probe _addevent.signal.pending.return = signal.pending.return
-{
-	log_signal_pending_return($return)
-}
-
-function log_signal_pending_return(ret:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_PENDING_RETURN,
-		"%1b", THIS->ret);
-%}
-
-/* probe signal.handle
- *
- * Used to invoke signals
- *
- * static int handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
- *					sigset_t *oldset, struct pt_regs * regs)
- * Argument :-
- *  sig    : Signal number
- *  info   : address of siginfo table.
- *  ka     : Address of the k_sigaction table associated with the signal
- *  oldset : Address of a bit mask array of blocked signals
- *  regs   : Address in the Kernel Mode stack area 
- *  
- */
-/*
-probe signal.handle = kernel.function("handle_signal")
-{
-    sig = $sig
-    sig_name = _signal_name($sig)
-    sinfo_addr = $info
-    sig_code = $info->si_code
-    sig_stack_add=$ka
-    bitmask_add=$oldset
-    kernmode_stack_add=$regs
-
-    // Check whether the signal is a User Mode or Kernel mode Signal.
-    
-    if (sinfo_addr == 0 && sig_code <= 0)
-        sig_mode = "User Mode Signal"
-    else if (sinfo_addr >=  1)
-        sig_mode = "Kernel Mode Signal"
-}
-
-probe signal.handle.return = kernel.function("handle_signal").return
-{
-    retstr = returnstr(1)
-}
-*/
-
-/* Fires when examing and change a signal action */
-probe addevent.signal.do_action.entry
-	+= _addevent.signal.do_action.entry
-{
-	update_record()
-}
-
-probe _addevent.signal.do_action.entry = signal.do_action
-{
-	log_signal_doaction(sig, sa_handler)
-}
-
-function log_signal_doaction(sig:long, handler:long)
-%{
-	/* sig | sa_handler | sa_mask */
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_DOACTION_ENTRY,
-		"%1b%8b", THIS->sig, THIS->handler);
-%}
-
-
-probe addevent.signal.do_action.return
-	+= _addevent.signal.do_action.return
-{
-	update_record()
-}
-
-probe _addevent.signal.do_action.return = signal.do_action.return
-{
-	log_signal_doaction_return($return)
-}
-
-function log_signal_doaction_return(ret:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_DOACTION_RETURN,
-		"%2b", THIS->ret);
-%}
-
-/* Fires when examine and change blocked signals */
-
-probe addevent.signal.procmask.entry
-	+= _addevent.signal.procmask.entry
-{
-	update_record()
-}
-
-probe _addevent.signal.procmask.entry = signal.procmask
-{
-	log_signal_procmask($how, sigset)
-}
-
-function log_signal_procmask(how:long, set:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_PROC_MASK_ENTRY,
-		"%1b%8b", THIS->how, THIS->set);
-%}
-	
-probe addevent.signal.procmask.return
-	+= _addevent.signal.procmask.return
-{
-	update_record()
-}
-
-probe _addevent.signal.procmask.return = signal.procmask.return
-{
-	log_signal_procmask_return($return)
-}
-
-function log_signal_procmask_return(ret:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_PROC_MASK_RETURN,
-		"%1b", THIS->ret);
-%}
-
-/* Flush all pending signals for a task */
-probe addevent.signal.flush.entry
-	+= _addevent.signal.flush.entry
-{
-	update_record()
-}
-
-probe _addevent.signal.flush.entry = signal.flush
-{
-	log_signal_flush(sig_pid)
-}
-
-function log_signal_flush(pid:long)
-%{
-	_lket_trace(_GROUP_SIGNAL, _HOOKID_SIGNAL_FLUSH_ENTRY,
-		"%4b", THIS->pid);
-%}
-
diff --git a/tapset/LKET/syscalls.stp b/tapset/LKET/syscalls.stp
deleted file mode 100755
index 189bc5c4..00000000
--- a/tapset/LKET/syscalls.stp
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright (C) 2005, 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.
-
-probe never
-{
-        printf("%d", GROUP_SIGNAL)
-}
-
-probe addevent.syscall
-	= addevent.syscall.entry,
-	addevent.syscall.return
-{}
-
-probe addevent.syscall.entry
-	+= _addevent.syscall.entry
-{
-	update_record()
-}
-
-probe _addevent.syscall.entry
-	= syscall.*
-{
-	log_syscall_tracedata(1, name)
-}
-
-probe addevent.syscall.return
-	+= _addevent.syscall.return
-{
-	update_record()
-}
-
-probe _addevent.syscall.return
-	= syscall.*.return
-{
-	log_syscall_tracedata(2, name)
-}
-
-/* log the system call name */
-function log_syscall_tracedata(var_id:long, name:string)
-%{
-	_lket_trace(_GROUP_SYSCALL, THIS->var_id, "%0s", THIS->name); 
-%}
-
-
diff --git a/tapset/LKET/timestamp.stp b/tapset/LKET/timestamp.stp
deleted file mode 100755
index b450bd67..00000000
--- a/tapset/LKET/timestamp.stp
+++ /dev/null
@@ -1,66 +0,0 @@
-%{
-#ifndef TIMING_GETCYCLES
-#define TIMING_GETCYCLES 0x01
-#endif
-#ifndef TIMING_GETTIMEOFDAY
-#define TIMING_GETTIMEOFDAY 0x02
-#endif
-#ifndef TIMING_SCHEDCLOCK
-#define TIMING_SCHEDCLOCK 0x03
-#endif
-
-#define MAX_TIMING_METHOD TIMING_SCHEDCLOCK
-
-long timing_method = TIMING_GETTIMEOFDAY;
-
-#ifndef _PFN_SCHEDCLOCK_TYPE
-#define _PFN_SCHEDCLOCK_TYPE
-typedef unsigned long long (* pfn_schedclock_type)(void);
-#endif
-
-pfn_schedclock_type pfn_schedclock = NULL;
-%}
-
-%{
-#ifdef CONFIG_CPU_FREQ
-static int __lket_time_cpufreq_callback(struct notifier_block *self,
-		unsigned long state, void *vfreqs);
-
-struct notifier_block __lket_time_notifier = {
-	.notifier_call = __lket_time_cpufreq_callback,
-};
-
-#endif
-%}
-
-function set_timing_method(method:long)
-%{
-	if(THIS->method == TIMING_SCHEDCLOCK) {
-		pfn_schedclock = (pfn_schedclock_type)kallsyms_lookup_name("sched_clock");
-		if(!pfn_schedclock)
-			_stp_warn("Failed to lookup specified timing method sched_clock()\n");
-		else
-			timing_method = THIS->method;
-	} else if(THIS->method > 0 && THIS->method <= MAX_TIMING_METHOD)
-		timing_method = THIS->method;
-%}
-
-function lket_init_time:long()
-%{
-	int ret = 0;
-#ifdef CONFIG_CPU_FREQ
-	if(timing_method == TIMING_GETCYCLES)
-		ret = cpufreq_register_notifier(&__lket_time_notifier,
-			CPUFREQ_TRANSITION_NOTIFIER);
-#endif
-	THIS->__retvalue = ret;
-%}
-
-function lket_kill_time()
-%{
-#ifdef CONFIG_CPU_FREQ
-	if(timing_method == TIMING_GETCYCLES)
-		cpufreq_unregister_notifier(&__lket_time_notifier, 
-			CPUFREQ_TRANSITION_NOTIFIER);
-#endif
-%}
diff --git a/tapset/LKET/tskdispatch.stp b/tapset/LKET/tskdispatch.stp
deleted file mode 100755
index 05103f96..00000000
--- a/tapset/LKET/tskdispatch.stp
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (C) 2005, 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.
-
-/**********************************************************
-* Dispatching when the cpu is idle or when a new process  * 
-* is chosen to run.                                       *
-*                                                         *
-* The actual locations for these two kinds of events are  *
-* the labels go_idle and switch_tasks inside the function *
-* schedule. But currently SystemTap doesn't support       *
-* specifying probe points by label.                       *
-*                                                         *
-**********************************************************/
-
-probe addevent.tskdispatch
-	= addevent.tskdispatch.cpuidle,
-	addevent.tskdispatch.ctxswitch
-{}
-
-/* Only applicable to SMP systems */
-probe addevent.tskdispatch.cpuidle
-	+= _addevent.tskdispatch.cpuidle
-{
-	update_record()
-}
-
-probe _addevent.tskdispatch.cpuidle
-	= scheduler.balance
-{
-	/* we didn't call filter_by_pid() here,
-	 so that we can get all the idle events
-	 despite how the cpu enters idle */
-	log_cpuidle_tracedata(HOOKID_TASK_CPUIDLE)
-}
-
-probe addevent.tskdispatch.ctxswitch
-	+= _addevent.tskdispatch.ctxswitch
-{
-	update_record()
-}
-
-probe _addevent.tskdispatch.ctxswitch
-	= scheduler.ctxswitch
-{
-	target_pid = target()
-	cur_pid = pid()
-	if( stp_pid() != cur_pid ) {  /* skip staprun itself */
-		if(target_pid == 0 || (target_pid !=0 && (prev_pid == target_pid 
-			|| next_pid == target_pid)))  {
-			log_ctxswitch_tracedata(HOOKID_TASK_CTXSWITCH, prev_task, next_task)
-		}
-	}
-}
-
-function log_ctxswitch_tracedata(var_id:long, prev:long, next_pid:long)
-%{
-	struct task_struct *prev_tsk, *next_tsk;
-
-	prev_tsk = (struct task_struct *)((long)THIS->prev);
-	next_tsk = (struct task_struct *)((long)THIS->next_pid);
-
-	_lket_trace(_GROUP_TASK, THIS->var_id, "%4b%4b%1b",
-		(_FMT_)kread(&(prev_tsk->pid)),
-		(_FMT_)kread(&(next_tsk->pid)),
-		(_FMT_)kread(&(prev_tsk->state))); 
-	CATCH_DEREF_FAULT();
-%}
-
-function log_cpuidle_tracedata(var_id:long)
-%{
-	struct task_struct *cur = current;
-
-	_lket_trace(_GROUP_TASK, THIS->var_id, "%4b", (_FMT_)cur->pid); 
-%}
diff --git a/tapset/LKET/utils.stp b/tapset/LKET/utils.stp
deleted file mode 100755
index 8edab81e..00000000
--- a/tapset/LKET/utils.stp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright (C) 2005, 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.
-
-/* data tracing filter by pid
-   return:
-	1 - if continue to log the raw data
-	0 - return without logging the raw data
- */
-function filter_by_pid:long()
-%{
-	struct task_struct *cur = current;
-
-	if(cur->tgid != _stp_pid)  {
-		/* to trace a specific process if we explicitly specify
-		   which process we want to trace by:
-		    1. stap -c "process_to_trace" ...
-		    2. stap -x pid_to_trace ...
-		   else we will trace all the processes
-		 */ 
-		if( _stp_target != 0 && cur->tgid != _stp_target) {
-			THIS->__retvalue = 0;
-		} else
-			THIS->__retvalue = 1;
-	} else  /*skip the events generated by stap itself*/
-		THIS->__retvalue = 0;
-%}
-
-function reset_maxaction()
-%{
-	struct context* c;
-	int cpu;
-	for_each_online_cpu(cpu) {
-		c = per_cpu_ptr (contexts, cpu);
-		c->actioncount = 0;
-	}
-%}