aio.stp: new event hooks for AIO

register_events.stp, hookid_defs.stp: changes for aio.stp.
register_events.stp, process.stp: bugfix for ascii tracing

7 files changed, 433 insertions, 11 deletions

diff --git a/runtime/lket/b2a/lket_b2a.c b/runtime/lket/b2a/lket_b2a.c
index 461a553e..f744ccb9 100644
--- a/runtime/lket/b2a/lket_b2a.c
+++ b/runtime/lket/b2a/lket_b2a.c
@@ -379,7 +379,7 @@ char *get_fmtstr(char *fmt)
 	return "";
 }
 
-void ascii_print(lket_pkt_header header, FILE *infp, FILE *outfile, int evt_type)
+int ascii_print(lket_pkt_header header, FILE *infp, FILE *outfile, int evt_type)
 {
 	int i, c;
 	int16_t stemp;
@@ -399,19 +399,19 @@ void ascii_print(lket_pkt_header header, FILE *infp, FILE *outfile, int evt_type
 		size = header.total_size - header.sys_size;
 
 	if(events_des[evt_type][grpid] == NULL)
-		return;
+		return -1;
 	if(events_des[evt_type][grpid][hookid] == NULL)
-		return;
+		return -1;
 
 	if(events_des[evt_type][grpid][hookid]->count <= 0 || !outfile)
-		return;
+		return -1;
 
 	if(events_des[evt_type][grpid][hookid]->evt_fmt[0][0] == '\0')  {
 		//no format is provided, dump in hex
 		buffer = malloc(size);
 		fread(buffer, size, 1, infp);
 		fwrite(buffer, size, 1, outfile);
-		return;
+		return -1;
 	}
 
 	for(i=0; i<events_des[evt_type][grpid][hookid]->count; i++)  {
@@ -448,7 +448,8 @@ void ascii_print(lket_pkt_header header, FILE *infp, FILE *outfile, int evt_type
 				continue;
 			}
 			else
-				return;
+				return -1;
 		}
 	}
+	return readbytes;
 }
diff --git a/runtime/lket/b2a/lket_b2a.h b/runtime/lket/b2a/lket_b2a.h
index 1dbfae53..8db5adb2 100644
--- a/runtime/lket/b2a/lket_b2a.h
+++ b/runtime/lket/b2a/lket_b2a.h
@@ -29,6 +29,8 @@ int _GROUP_TASK = 5;
 int _GROUP_SCSI = 6;
 int _GROUP_PAGEFAULT = 7;
 int _GROUP_NETDEV = 8;
+int _GROUP_IOSYSCALL = 9;
+int _GROUP_AIO = 10;
 
 /* hookIDs defined inside each group */
 int _HOOKID_REGSYSEVT = 1;
@@ -58,6 +60,67 @@ int _HOOKID_PAGEFAULT = 1;
 int _HOOKID_NETDEV_RECEIVE = 1;
 int _HOOKID_NETDEV_TRANSMIT = 2;
 
+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;
+
 typedef struct _lket_pkt_header {
 	int16_t	total_size;
 	int16_t	sys_size;
@@ -111,6 +174,6 @@ gint compareFunc(gconstpointer a, gconstpointer b, gpointer user_data);
 void destroyAppName(gpointer data);
 
 void register_events(int evt_type, FILE *infp, size_t size);
-void ascii_print(lket_pkt_header header, FILE *infp, FILE *outfile, int evt_type);
+int ascii_print(lket_pkt_header header, FILE *infp, FILE *outfile, int evt_type);
 char *get_fmtstr(char *fmt);
 #endif
diff --git a/tapset/LKET/Changelog b/tapset/LKET/Changelog
index 2c766ab8..965cbf36 100644
--- a/tapset/LKET/Changelog
+++ b/tapset/LKET/Changelog
@@ -1,3 +1,9 @@
+2006-06-26  Li Guanglei <guanglei@cn.ibm.com>
+	
+	* aio.stp: new event hooks for AIO
+	* register_events.stp, hookid_defs.stp: changes for aio.stp. 
+	* register_events.stp, process.stp: bugfix for ascii tracing
+	
 2006-06-24  Li Guanglei <guanglei@cn.ibm.com>
 	
 	* iosyscall.stp, register_events.stp: change the return type from string to int64_t
diff --git a/tapset/LKET/aio.stp b/tapset/LKET/aio.stp
new file mode 100755
index 00000000..efcaa6e3
--- /dev/null
+++ b/tapset/LKET/aio.stp
@@ -0,0 +1,264 @@
+// 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.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);
+%}
+
+/*
+ * Fires by calling io_submit from user space. sys_io_submit will
+ * queue the nr iocbs pointed to by iocbpp_uaddr for processing.
+ */
+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.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)	
+}
+
+function log_io_submit_one(ctx:long, user_iocb_uaddr:long)
+%{
+	struct iocb *user_iocb = (struct iocb *)THIS->user_iocb_uaddr;
+
+	/* 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, (_FMT_)user_iocb->aio_lio_opcode, 
+		(_FMT_)user_iocb->aio_reqprio, (_FMT_)user_iocb->aio_fildes, 
+		(_FMT_)user_iocb->aio_buf, (_FMT_)user_iocb->aio_nbytes, 
+		(_FMT_)user_iocb->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)
+}
+
+/*
+ * Fires by calling io_destroy from user space. It will destroy 
+ * the aio_context specified.
+ */
+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)
+}
+
+/*
+ * Fires by calling io_getevents from user space. It 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.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 *)THIS->timeout;
+	struct timespec ts;
+
+	if (unlikely(copy_from_user(&ts, timeout, sizeof(ts))))
+		return;
+
+	_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)
+}
+
+
+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
index 567e3ed9..36ddeb33 100755
--- a/tapset/LKET/hookid_defs.stp
+++ b/tapset/LKET/hookid_defs.stp
@@ -36,7 +36,7 @@ global
 	GROUP_NETDEV,
 	HOOKID_NETDEV_RECEIVE, HOOKID_NETDEV_TRANSMIT,
 
-	/* io related syscall */
+	/* io related syscall (not including AIO related calls) */
 	GROUP_IOSYSCALL,
 
 	HOOKID_IOSYSCALL_OPEN_ENTRY,
@@ -88,7 +88,25 @@ global
 	HOOKID_IOSYSCALL_FDATASYNC_RETURN,
 
 	HOOKID_IOSYSCALL_FLOCK_ENTRY,
-	HOOKID_IOSYSCALL_FLOCK_RETURN
+	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
+
+	
 %{
 /* used in embedded c codes */
 
@@ -102,6 +120,7 @@ int _GROUP_SCSI = 6;
 int _GROUP_PAGEFAULT = 7;
 int _GROUP_NETDEV = 8;
 int _GROUP_IOSYSCALL = 9;
+int _GROUP_AIO = 10;
 
 /* hookIDs defined inside each group */
 int _HOOKID_REGSYSEVT = 1;
@@ -179,6 +198,19 @@ 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;
+
 %}
 
 function hookid_init()
@@ -267,6 +299,26 @@ function hookid_init()
 
 	HOOKID_IOSYSCALL_FLOCK_ENTRY = 31
 	HOOKID_IOSYSCALL_FLOCK_RETURN = 32
+
+	GROUP_AIO = 10
+
+	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
 }
 
 
diff --git a/tapset/LKET/process.stp b/tapset/LKET/process.stp
index 3155e5dc..f09e97ba 100755
--- a/tapset/LKET/process.stp
+++ b/tapset/LKET/process.stp
@@ -40,9 +40,10 @@ function process_snapshot()
 		tsk = (struct task_struct *)(list_entry(cur, struct task_struct, tasks));
 		_lket_trace(_GROUP_PROCESS, _HOOKID_PROCESS_SNAPSHOT, "%4b%0s", 
 			(_FMT_)tsk->pid, tsk->comm);
-
+#if !defined(ASCII_TRACE)
 		total_length = &_stp_pbuf[cpu][STP_PRINT_BUF_START];
 		*(int16_t *)total_length = _stp_pbuf_len[cpu] - 4;
+#endif
 		_stp_print_flush();
 	}
 %}
diff --git a/tapset/LKET/register_event.stp b/tapset/LKET/register_event.stp
index 9bc4eecf..38598603 100755
--- a/tapset/LKET/register_event.stp
+++ b/tapset/LKET/register_event.stp
@@ -111,10 +111,12 @@ function register_event(grpid:long, hookid:long, evt_type:long, fmt:string, name
 	_lket_trace(_GROUP_REGEVT, THIS->evt_type, "%1b%1b%0s%0s", THIS->grpid,
 		THIS->hookid, THIS->fmt, THIS->names); 
 
+#if !defined(ASCII_TRACE)
         total_length = &_stp_pbuf[cpu][STP_PRINT_BUF_START];
         *(int16_t *)total_length = _stp_pbuf_len[cpu] - 4;
-
+#endif
 	_stp_print_flush();
+
 %}
 
 function register_sys_events()
@@ -244,6 +246,39 @@ function register_sys_events()
 		"INT64:INT32", "fd:operation")
 	register_sys_event(GROUP_IOSYSCALL, HOOKID_IOSYSCALL_FLOCK_RETURN,
 		"INT64", "return")
+
+	register_sys_event(GROUP_AIO, HOOKID_AIO_IO_SETUP_ENTRY,
+		"INT32:INT64", "nr_events:ctxp_uaddr")
+	register_sys_event(GROUP_AIO, HOOKID_AIO_IO_SETUP_RETURN,
+		"INT64", "return")
+
+	register_sys_event(GROUP_AIO, HOOKID_AIO_IO_SUBMIT_ENTRY,
+		"INT64:INT32:INT64", "ctx_id:nr:iocbpp_uaddr")
+	register_sys_event(GROUP_AIO, HOOKID_AIO_IO_SUBMIT_RETURN,
+		"INT64", "return")
+
+	register_sys_event(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(GROUP_AIO, HOOKID_AIO_IO_SUBMIT_ONE_RETURN,
+		"INT64", "return")
+
+	register_sys_event(GROUP_AIO, HOOKID_AIO_IO_DESTROY_ENTRY,
+		"INT64", "ctx")
+	register_sys_event(GROUP_AIO, HOOKID_AIO_IO_DESTROY_RETURN,
+		"INT64", "return")
+
+	register_sys_event(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(GROUP_AIO, HOOKID_AIO_IO_GETEVENTS_RETURN,
+		"INT64", "return")
+
+	register_sys_event(GROUP_AIO, HOOKID_AIO_IO_CANCEL_ENTRY,
+		"INT64:INT64:INT64", 
+		"ctx_id:iocb_uaddr:result_uaddr")
+	register_sys_event(GROUP_AIO, HOOKID_AIO_IO_CANCEL_RETURN,
+		"INT64", "return")
 }