*** empty log message ***

8 files changed, 1010 insertions, 1203 deletions

diff --git a/tapset/aux_syscalls.stp b/tapset/aux_syscalls.stp
index cfbe3192..e50bb89e 100644
--- a/tapset/aux_syscalls.stp
+++ b/tapset/aux_syscalls.stp
@@ -531,7 +531,7 @@ function __get_argv:string(a:long)
 		if (vstr == NULL)
 			break;
 
-		rc = _stp_strncpy_from_user(buf, vstr, 80);
+		rc = _stp_strncpy_from_user(buf, vstr, 79);
 		if (rc <= 0)
 			break;
 
@@ -584,8 +584,8 @@ function __string:string (a:long)
  * Return a integer member value of struct
  * timezone user  space pointer  parameter
  * CALLERS:
- *    kernel.syscall.gettimeofday
- *    kernel.syscall.settimeofday
+ *    syscall.gettimeofday
+ *    syscall.settimeofday
  */
 /*
 function __uget_tz_m:long(u_addr:long,member:long)
@@ -606,7 +606,7 @@ function __uget_tz_m:long(u_addr:long,member:long)
  * Return integer member value of struct
  * timex user  space  pointer  parameter
  * CALLERS:
- *    kernel.syscall.adjtimex
+ *    syscall.adjtimex
  */
 /*
 function __uget_timex_m:long(u_addr:long,member:long)
@@ -652,7 +652,7 @@ function __uget_timex_m:long(u_addr:long,member:long)
  * Return the clock_t member  value of the
  * struct tms user space pointer parameter
  * CALLERS:
- *    kernel.syscall.times
+ *    syscall.times
  */
 /*
 %{ #include <linux/times.h> %}
@@ -681,7 +681,7 @@ function __uget_tms_m:long(u_addr:long,member:long)
  * Return a time_t / long  member  value of the
  * struct timespec user space pointer parameter
  * CALLERS:
- *    kernel.syscall.nanosleep
+ *    syscall.nanosleep
  */
 /*
 function __uget_ts_m:long(u_addr:long,member:long)
@@ -704,7 +704,7 @@ function __uget_ts_m:long(u_addr:long,member:long)
  * of the struct timex.mode member of adjtimex
  * consult `man adjtimex` for more information
  * CALLERS:
- *    kernel.syscall.adjtimex
+ *    syscall.adjtimex
  */
 function _adjtx_mode_str(f) {
    if((f & 32769) == 32769) bs="ADJ_OFFSET_SINGLESHOT|".bs
@@ -723,8 +723,8 @@ function _adjtx_mode_str(f) {
  * of the how argument given in *sigprocmask
  * consult  `man sigprocmask`  for more info
  * CALLERS:
- *    kernel.syscall.sigprocmask
- *    kernel.syscall.rt_sigprocmask
+ *    syscall.sigprocmask
+ *    syscall.rt_sigprocmask
  */
 function _sigprocmask_how_str(how) {
    if(how==0) return "SIG_BLOCK"
@@ -738,8 +738,8 @@ function _sigprocmask_how_str(how) {
  * of the which argument  given to setitimer
  * consult  `man setitimer`  for  more  info
  * CALLERS:
- *    kernel.syscall.getitimer
- *    kernel.syscall.setitimer
+ *    syscall.getitimer
+ *    syscall.setitimer
  */
 function _itimer_which_str(which) {
    if(which==0) return "ITIMER_REAL"
@@ -753,11 +753,11 @@ function _itimer_which_str(which) {
  * of the clockid argument  given to create_timer
  * consult  `man create_timer`  for  more  info
  * CALLERS:
- *    kernel.syscall.timer_create
- *    kernel.syscall.clock_settime
- *    kernel.syscall.clock_gettime
- *    kernel.syscall.clock_getres
- *    kernel.syscall.clock_nanosleep
+ *    syscall.timer_create
+ *    syscall.clock_settime
+ *    syscall.clock_gettime
+ *    syscall.clock_getres
+ *    syscall.clock_nanosleep
  */
 function _get_wc_str(wc) {
    if(wc==0) return "CLOCK_REALTIME"
@@ -1144,6 +1144,15 @@ function _madvice_advice_str(behavior) {
    return ""
 }
 
+function _fadvice_advice_str(behavior) {
+   if(behavior==0x00000000) return "FADV_NORMAL"
+   if(behavior==0x00000001) return "FADV_RANDOM"
+   if(behavior==0x00000002) return "FADV_SEQUENTIAL"
+   if(behavior==0x00000003) return "FADV_WILLNEED"
+   if(behavior==0x00000004) return "FADV_DONTNEED"
+   return ""
+}
+
 function _fcntl_cmd_str(cmd) {
    if(cmd==0x00000000) return "F_DUPFD"
    if(cmd==0x00000001) return "F_GETFD"
diff --git a/tapset/conversions.stp b/tapset/conversions.stp
index 96c7162a..c311d25a 100644
--- a/tapset/conversions.stp
+++ b/tapset/conversions.stp
@@ -51,14 +51,8 @@ function user_string_warn:string (addr:long) %{ /* pure */
 %}
 
 function user_string_quoted:string (addr:long) %{ /* pure */
-  if (THIS->addr == 0)
+  if (THIS->addr == 0)	
 	strlcpy (THIS->__retvalue, "NULL", MAXSTRINGLEN);
-  else {
-	*THIS->__retvalue = '\"';
-	if (_stp_strncpy_from_user (THIS->__retvalue+1, 
-		(const char __user*) (uintptr_t) THIS->addr, MAXSTRINGLEN-2) < 0)
-			strlcpy (THIS->__retvalue, "<unknown>", MAXSTRINGLEN);
-	else
-		strlcat(THIS->__retvalue, "\"", MAXSTRINGLEN);
-  }
+  else
+	_stp_text_str(THIS->__retvalue, (char *)(uintptr_t)THIS->addr, MAXSTRINGLEN, 1, 1);
 %}
diff --git a/tapset/i686/syscalls.stp b/tapset/i686/syscalls.stp
index 340fca6f..a7dfa4fc 100644
--- a/tapset/i686/syscalls.stp
+++ b/tapset/i686/syscalls.stp
@@ -5,7 +5,7 @@ probe syscall.getgroups16 = kernel.function("sys_getgroups16") {
 	name = "getgroups16"
 	size = $gidsetsize
 	list_uaddr = $grouplist
-	argstr = sprintf("%d, [%p]", size, list_uaddr)
+	argstr = sprintf("%d, %p", size, list_uaddr)
 }
 probe syscall.getgroups16.return = kernel.function("sys_getgroups16").return {
 	name = "getgroups16"
@@ -30,37 +30,6 @@ probe syscall.setgroups16.return = kernel.function("sys_setgroups16").return {
 }
 
 
-# acct _______________________________________________________
-# long sys_acct(const char __user *name)
-probe syscall.acct = kernel.function("sys_acct") {
-	name = "acct"
-        filename = user_string($name)
-	argstr = filename
-}
-probe syscall.acct.return = kernel.function("sys_acct").return {
-	name = "acct"
-	retstr = returnstr(1)
-}
-
-# add_key ____________________________________________________
-# long sys_add_key(const char __user *_type,
-#             const char __user *_description,
-#             const void __user *_payload,
-#             size_t plen,
-#             key_serial_t ringid)
-#probe syscall.add_key = kernel.function("sys_add_key") {
-#	name = "add_key"
-#	type_uaddr = $_type
-#	description_auddr = $_description
-#	payload_uaddr = $_payload
-#	plen = $plen
-#	ringid = $ringid
-#	argstr = "add_key"
-#}
-#probe syscall.add_key.return = kernel.function("sys_add_key").return {
-#	name = "add_key"
-#	retstr = returnstr(1)
-#}
 
 # quotactl ___________________________________________________
 #
@@ -77,7 +46,7 @@ probe syscall.quotactl = kernel.function("sys_quotactl") {
 	special_str = user_string($special)
 	id = $id
 	addr_uaddr = $addr
-	argstr = sprintf("%s, %s, %p, [%p]", cmd_str, special_str,
+	argstr = sprintf("%s, %s, %p, %p", cmd_str, special_str,
 				id, addr_uaddr)
 }
 probe syscall.quotactl.return = kernel.function("sys_quotactl").return {
@@ -98,7 +67,7 @@ probe syscall.request_key = kernel.function("sys_request_key") {
 	description_uaddr = $_description
 	callout_info_uaddr = $_callout_info
 	destringid = $destringid
-	argstr = sprintf("[%p], [%p], [%p], %p", type_uaddr,
+	argstr = sprintf("%p, %p, %p, %p", type_uaddr,
 			description_uaddr, callout_info_uaddr, destringid)
 }
 probe syscall.request_key.return = kernel.function("sys_request_key").return {
@@ -133,7 +102,7 @@ probe syscall.fcntl64.return = kernel.function("sys_fcntl64").return {
 probe syscall.get_thread_area = kernel.function("sys_get_thread_area") {
 	name = "get_thread_area"
 	u_info_uaddr = $u_info
-	argstr = sprintf("[%p]", u_info_uaddr)
+	argstr = sprintf("%p", u_info_uaddr)
 }
 probe syscall.get_thread_area.return =
 	kernel.function("sys_get_thread_area").return {
@@ -193,56 +162,21 @@ probe syscall.inotify_rm_watch.return =
 	name = "inotify_rm_watch"
 	retstr = returnstr(1)
 }
+
 # iopl _______________________________________________________
-/*
- * asmlinkage long
- * sys_iopl(unsigned long unused)
- */
+# long sys_iopl(unsigned long unused)
+# NOTE. This function is only in i386 and x86_64 and its args vary
+# between those two archs.
+#
 probe syscall.iopl = kernel.function("sys_iopl") {
 	name = "iopl"
-	level = $unused
-	argstr = sprint($unused)
+	argstr = ""
 }
 probe syscall.iopl.return = kernel.function("sys_iopl").return {
 	name = "iopl"
 	retstr = returnstr(1)
 }
-# ioprio_get _________________________________________________
-/*
- * asmlinkage long
- * sys_ioprio_get(int which,
- *                int who)
- */
-probe syscall.ioprio_get = kernel.function("sys_ioprio_get") {
-	name = "ioprio_get"
-	which = $which
-	who = $who
-	argstr = sprintf("%d, %d", $which, $who)
-}
-probe syscall.ioprio_get.return =
-	kernel.function("sys_ioprio_get").return {
-	name = "ioprio_get"
-	retstr = returnstr(1)
-}
-# ioprio_set _________________________________________________
-/*
- * asmlinkage long
- * sys_ioprio_set(int which,
- *                int who,
- *                int ioprio)
- */
-probe syscall.ioprio_set = kernel.function("sys_ioprio_set") {
-	name = "ioprio_set"
-	which = $which
-	who = $who
-	ioprio = $ioprio
-	argstr = sprintf("%d, %d, %d", $which, $who, $ioprio)
-}
-probe syscall.ioprio_set.return =
-	kernel.function("sys_ioprio_set").return {
-	name = "ioprio_set"
-	retstr = returnstr(1)
-}
+
 # ipc ________________________________________________________
 /*
  * asmlinkage int
@@ -261,7 +195,7 @@ probe syscall.ipc = kernel.function("sys_ipc") {
 	third = $third
 	ptr_uaddr = $ptr
 	fifth = $fifth
-	argstr = sprintf("%d, %d, %d, %d, [%p], %d", $call, $first,
+	argstr = sprintf("%d, %d, %d, %d, %p, %d", $call, $first,
 			$second, $third, ptr_uaddr, $fifth)
 }
 probe syscall.ipc.return = kernel.function("sys_ipc").return {
@@ -275,7 +209,7 @@ probe syscall.lstat64 = kernel.function("sys_lstat64") {
 	name = "lstat"
 	filename = user_string($filename)
 	buf_uaddr = $statbuf
-	argstr = sprintf("\"%s\", [%p]", filename, $statbuf)
+	argstr = sprintf("\"%s\", %p", filename, $statbuf)
 }
 probe syscall.lstat64.return = kernel.function("sys_lstat64").return {
 	name = "lstat"
@@ -289,50 +223,13 @@ probe syscall.lstat64.return = kernel.function("sys_lstat64").return {
 probe syscall.olduname = kernel.function("sys_olduname") {
 	name = "olduname"
 	name_uaddr = $name
-	argstr = sprintf("[%p]", name_uaddr)
+	argstr = sprintf("%p", name_uaddr)
 }
 probe syscall.olduname.return = kernel.function("sys_olduname").return {
 	name = "olduname"
 	retstr = returnstr(1)
 }
-# rt_sigreturn _______________________________________________
-/*
- * asmlinkage int
- * sys_rt_sigreturn(unsigned long __unused)
- */
-probe syscall.rt_sigreturn = kernel.function("sys_rt_sigreturn") {
-	name = "rt_sigreturn"
-	__unused = $__unused
-	argstr = sprint($__unused)
-}
-probe syscall.rt_sigreturn.return =
-	kernel.function("sys_rt_sigreturn").return {
-	name = "rt_sigreturn"
-	retstr = returnstr(1)
-}
-# sched_setaffinity __________________________________________
-/*
- * asmlinkage long
- * sys_sched_setaffinity(pid_t pid,
- *                       unsigned int len,
- *                       unsigned long __user *user_mask_ptr)
- */
-probe syscall.sched_setaffinity =
-	kernel.function("sys_sched_setaffinity") {
-	name = "sched_setaffinity"
-	pid = $pid
-      /*
-       * doesnt like $len on x86_64 ????
-       */
-	len = $len
-	mask_uaddr = $user_mask_ptr
-	argstr = sprintf("%d, %d, [%p]", $pid, $len, mask_uaddr)
-}
-probe syscall.sched_setaffinity.return =
-	kernel.function("sys_sched_setaffinity").return {
-	name = "sched_setaffinity"
-	retstr = returnstr(1)
-}
+
 # sched_setparam _____________________________________________
 /*
  * asmlinkage long
@@ -344,7 +241,7 @@ probe syscall.sched_setparam =
 	name = "sched_setparam"
 	pid = $pid
 	p_uaddr = $param
-	argstr = sprintf("%d, [%p]", $pid, p_uaddr)
+	argstr = sprintf("%d, %p", $pid, p_uaddr)
 }
 probe syscall.sched_setparam.return =
 	kernel.function("do_sched_setscheduler").return {
@@ -365,7 +262,7 @@ probe syscall.sched_setscheduler =
 	policy = $policy
 	policy_str = _sched_policy_str($policy)
 	p_uaddr = $param
-	argstr = sprintf("%d, %s, [%p]", $pid, policy_str, p_uaddr)
+	argstr = sprintf("%d, %s, %p", $pid, policy_str, p_uaddr)
 }
 probe syscall.sched_setscheduler.return =
 	kernel.function("do_sched_setscheduler").return {
@@ -381,7 +278,7 @@ probe syscall.set_thread_area =
 	kernel.function("sys_set_thread_area") {
 	name = "set_thread_area"
 	u_info_uaddr = $u_info
-	argstr = sprintf("[%p]", u_info_uaddr)
+	argstr = sprintf("%p", u_info_uaddr)
 }
 probe syscall.set_thread_area.return =
 	kernel.function("sys_set_thread_area").return {
@@ -423,50 +320,49 @@ probe syscall.shmat =
 	shmid = $shmid
 	shmaddr_uaddr = $shmaddr
 	shmflg = $shmflg
-	argstr = sprintf("%d, [%p], %d", $shmid, shmaddr_uaddr, $shmflg)
+	argstr = sprintf("%d, %p, %d", $shmid, shmaddr_uaddr, $shmflg)
 }
 probe syscall.shmat.return =
 	kernel.function("sys_shmat").return {
 	name = "shmat"
 	retstr = returnstr(1)
 }
+
 # sigaction __________________________________________________
-/*
- * asmlinkage int
- * sys_sigaction(int sig,
- *               const struct old_sigaction __user *act,
- *               struct old_sigaction __user *oact)
- */
+# int sys_sigaction(int sig,
+#               const struct old_sigaction __user *act,
+#               struct old_sigaction __user *oact)
+#
 probe syscall.sigaction =
 	kernel.function("sys_sigaction") {
 	name = "sigaction"
 	sig = $sig
 	act_uaddr = $act
 	oact_uaddr = $oact
-	argstr = sprintf("%s, [%p], [%p]", _signal_name($sig),
-				act_uaddr, oact_uaddr)
+	# FIXME - decode $act
+	argstr = sprintf("%s, %p, %p", _signal_name($sig), $act, $oact)
 }
 probe syscall.sigaction.return =
 	kernel.function("sys_sigaction").return {
 	name = "sigaction"
 	retstr = returnstr(1)
 }
+
 # sigaltstack ________________________________________________
-/*
- * asmlinkage int
- * sys_sigaltstack(unsigned long ebx)
- */
-probe syscall.sigaltstack =
-	kernel.function("sys_sigaltstack") {
+# int sys_sigaltstack(unsigned long ebx)
+#
+# NOTE: args vary between archs.
+#
+probe syscall.sigaltstack = kernel.function("sys_sigaltstack") {
 	name = "sigaltstack"
 	ebx = $ebx
 	argstr = sprintf("%p", $ebx)
 }
-probe syscall.sigaltstack.return =
-	kernel.function("sys_sigaltstack").return {
+probe syscall.sigaltstack.return = kernel.function("sys_sigaltstack").return {
 	name = "sigaltstack"
 	retstr = returnstr(1)
 }
+
 # sigreturn __________________________________________________
 /*
  * asmlinkage int
@@ -509,28 +405,13 @@ probe syscall.stat64 = kernel.function("sys_stat64") {
 	name = "stat"
 	filename = user_string($filename)
 	buf_uaddr = $statbuf
-	argstr = sprintf("\"%s\", [%p]", filename, $statbuf)
+	argstr = sprintf("\"%s\", %p", filename, $statbuf)
 }
 probe syscall.stat64.return = kernel.function("sys_stat64").return {
 	name = "stat"
 	retstr = returnstr(1)
 }
 
-# umask ______________________________________________________
-/*
- * asmlinkage long
- * sys_umask(int mask)
- */
-probe syscall.umask = kernel.function("sys_umask") {
-	name = "umask"
-	mask = $mask
-	argstr = sprintf("%#o", $mask)
-}
-probe syscall.umask.return =
-	kernel.function("sys_umask").return {
-	name = "umask"
-	retstr = returnstr(3)
-}
 # vm86 _______________________________________________________
 /*
  * asmlinkage int
diff --git a/tapset/ppc64/syscalls.stp b/tapset/ppc64/syscalls.stp
index b487fbc8..5dc993c9 100644
--- a/tapset/ppc64/syscalls.stp
+++ b/tapset/ppc64/syscalls.stp
@@ -601,8 +601,7 @@ probe syscall.compat_sys_select.return =
 }
 # compat_rt_sigaction _______________________________________________
 #
-# asmlinkage long
-# compat_sys_rt_sigaction(int sig,
+# long compat_sys_rt_sigaction(int sig,
 #                       const struct sigaction __user *act,
 #                       struct sigaction __user *oact,
 #                       size_t sigsetsize)
@@ -614,8 +613,7 @@ probe syscall.compat_rt_sigaction = kernel.function("compat_sys_rt_sigaction")?,
 	act_uaddr = $act
 	oact_uaddr = $oact
 	sigsetsize = $sigsetsize
-	argstr = sprintf("%s, [%p], [%p], %p", _signal_name($sig),
-	act_uaddr, oact_uaddr, sigsetsize)
+	argstr = sprintf("%s, %p, %p, %d", _signal_name($sig), $act, $oact, $sigsetsize)
 }
 probe syscall.compat_rt_sigaction.return =
 	kernel.function("compat_sys_rt_sigaction").return ? ,
@@ -1266,8 +1264,7 @@ probe syscall.sys32_sigaction = kernel.function("sys32_sigaction") ? {
 	sig = $sig
 	act_uaddr = $act
 	oact_uaddr = $oact
-	argstr = sprintf("%s, [%p], [%p]", _signal_name($sig),
-			act_uaddr, oact_uaddr)
+	argstr = sprintf("%s, %p, %p", _signal_name($sig), $act, $oact)
 }
 probe syscall.sys32_sigaction.return =
 	kernel.function("sys32_sigaction").return ? {
@@ -1489,8 +1486,7 @@ probe syscall.sys32_rt_sigaction = kernel.function("sys32_rt_sigaction") ? {
 	act_uaddr = $act
 	oact_uaddr = $oact
 	sigsetsize = $sigsetsize
-	argstr = sprintf("%s, [%p], [%p], %p", _signal_name($sig),
-				act_uaddr, oact_uaddr, sigsetsize)
+	argstr = sprintf("%s, %p, %p, %d", _signal_name($sig), $act, $oact, $sigsetsize)
 }
 probe syscall.sys32_rt_sigaction.return =
 	kernel.function("sys32_rt_sigaction").return ? {
@@ -1509,8 +1505,8 @@ probe syscall.sys32_rt_sigprocmask = kernel.function("sys32_rt_sigprocmask") ? {
 	set_uaddr = $set
 	oset_uaddr = $oset
 	sigsetsize = $sigsetsize
-	argstr = sprintf("%s, [%p], [%p], %p", how_str, set_uaddr,
-				oset_uaddr, sigsetsize)
+	argstr = sprintf("%s, %p, %p, %d", how_str, $set,
+				$oset, $sigsetsize)
 }
 probe syscall.sys32_rt_sigprocmask.return =
 	kernel.function("sys32_rt_sigprocmask").return ? {
diff --git a/tapset/string.stp b/tapset/string.stp
index a4cff3e4..28f8e2dc 100644
--- a/tapset/string.stp
+++ b/tapset/string.stp
@@ -55,12 +55,12 @@ function isinstr:long(s1:string,s2:string) %{ /* pure */
  */
 function text_str:string(input:string)
 %{ /* pure */
-	_stp_text_str(THIS->__retvalue, THIS->input, 0, 0);
+	_stp_text_str(THIS->__retvalue, THIS->input, 0, 0, 0);
 %}
 
 function text_strn:string(input:string, len:long, quoted:long)
 %{ /* pure */
-	_stp_text_str(THIS->__retvalue, THIS->input, THIS->len, THIS->quoted);
+	_stp_text_str(THIS->__retvalue, THIS->input, THIS->len, THIS->quoted, 0);
 %}
 
 
diff --git a/tapset/syscalls.stp b/tapset/syscalls.stp
index 0d4f85bd..0e09bda1 100644
--- a/tapset/syscalls.stp
+++ b/tapset/syscalls.stp
@@ -15,10 +15,12 @@
 *
 * argstr - a string containing the decoded args in an easy-to-read format.
 *          It doesn't need to contain everything, but should have all the
-*          important args. Set in entry probes only.
+*          important args. Set in entry probes only. Values enclosed in
+*          square brackets are user-space pointers. Values in curly
+*          braces are decoded structs.
 *
 * retstr - a string containing the return value in an easy-to-read format.
-*          Set in return probes only.
+*          Set in return probes only. 
 */
 
 
@@ -51,6 +53,43 @@ probe syscall.access.return = kernel.function("sys_access").return {
 	retstr = returnstr(1)
 }
 
+# acct _______________________________________________________
+# long sys_acct(const char __user *name)
+probe syscall.acct = kernel.function("sys_acct") {
+	name = "acct"
+        filename = user_string($name)
+	argstr = user_string_quoted($name)
+}
+probe syscall.acct.return = kernel.function("sys_acct").return {
+	name = "acct"
+	retstr = returnstr(1)
+}
+
+# add_key ____________________________________________________
+# long sys_add_key(const char __user *_type,
+#             const char __user *_description,
+#             const void __user *_payload,
+#             size_t plen,
+#             key_serial_t ringid)
+#
+probe syscall.add_key = kernel.function("sys_add_key") {
+	name = "add_key"
+	type_uaddr = $_type
+	description_auddr = $_description
+	payload_uaddr = $_payload
+	plen = $plen
+	ringid = $ringid
+	argstr = sprintf("%s, %s, %s, %d, %d", 
+			user_string_quoted($_type),
+			user_string_quoted($_description),
+			text_strn(user_string($_payload),20,1),
+			$plen, $ringid)
+}
+probe syscall.add_key.return = kernel.function("sys_add_key").return {
+	name = "add_key"
+	retstr = returnstr(1)
+}
+
 # adjtimex ___________________________________________________
 # long sys_adjtimex(struct timex __user *txc_p)
 probe syscall.adjtimex = kernel.function("sys_adjtimex") {
@@ -251,7 +290,7 @@ probe syscall.clock_getres = kernel.function("sys_clock_getres") {
 	clk_id = $which_clock
 	clk_id_str = _get_wc_str($which_clock)
 	res_uaddr = $tp
-	#fixme argstr
+	argstr = sprintf("%s, %p", _get_wc_str($which_clock), $tp)
 }
 probe syscall.clock_getres.return = kernel.function("sys_clock_getres").return {
 	name = "clock_getres"
@@ -265,51 +304,53 @@ probe syscall.clock_gettime = kernel.function("sys_clock_gettime") {
 	clk_id = $which_clock
 	clk_id_str = _get_wc_str($which_clock)
 	tp_uaddr = $tp
-	#fixme argstr
+	argstr = sprintf("%s, %p", _get_wc_str($which_clock), $tp)
 }
 probe syscall.clock_gettime.return = kernel.function("sys_clock_gettime").return {
 	name = "clock_gettime"
 	retstr = returnstr(1)
 }
+
 # clock_nanosleep ____________________________________________
-/*
- * asmlinkage long
- * sys_clock_nanosleep(clockid_t which_clock,
- *                     int flags,
- *                     const struct timespec __user *rqtp,
- *                     struct timespec __user *rmtp)
- */
-probe kernel.syscall.clock_nanosleep =
-   kernel.function("sys_clock_nanosleep") {
-      name = "clock_nanosleep"
-      clock_id = $which_clock
-      clock_id_str = _get_wc_str($which_clock)
-      flags = $flags
-      flag_str = "TIMER_ABSTIME"
-      rqtp_uaddr = $rqtp
-      rmtp_uaddr = $rmtp
-   }
-probe kernel.syscall.clock_nanosleep.return =
-   kernel.function("sys_clock_nanosleep").return {
-      name = "clock_nanosleep.return"
-   }
+# long sys_clock_nanosleep(clockid_t which_clock,
+#                     int flags,
+#                     const struct timespec __user *rqtp,
+#                     struct timespec __user *rmtp)
+#
+probe syscall.clock_nanosleep = kernel.function("sys_clock_nanosleep") {
+	name = "clock_nanosleep"
+	clock_id = $which_clock
+	clock_id_str = _get_wc_str($which_clock)
+	flags = $flags
+	if ($flags == 0)
+		flag_str = "0"
+	else
+		flag_str = "TIMER_ABSTIME"
+	rqtp_uaddr = $rqtp
+	rmtp_uaddr = $rmtp
+	argstr = sprintf("%s, %s, %s, %p", clock_id_str, flag_str, 
+			_struct_timespec_u($rqtp), $rmtp)
+}
+probe syscall.clock_nanosleep.return = kernel.function("sys_clock_nanosleep").return {
+	name = "clock_nanosleep"
+	retstr = returnstr(1)
+}
+
 # clock_settime ______________________________________________
-/*
- * asmlinkage long
- * sys_clock_settime(clockid_t which_clock,
- *                   const struct timespec __user *tp)
- */
-probe kernel.syscall.clock_settime =
-   kernel.function("sys_clock_settime") {
-      name = "clock_settime"
-      clk_id = $which_clock
-      clk_id_str = _get_wc_str($which_clock)
-      tp_uaddr = $tp
-   }
-probe kernel.syscall.clock_settime.return =
-   kernel.function("sys_clock_settime").return {
-      name = "clock_settime.return"
-   }
+# long sys_clock_settime(clockid_t which_clock,
+#                   const struct timespec __user *tp)
+#
+probe syscall.clock_settime = kernel.function("sys_clock_settime") {
+	name = "clock_settime"
+	clk_id = $which_clock
+	clk_id_str = _get_wc_str($which_clock)
+	tp_uaddr = $tp
+	argstr = sprintf("%s, %s", clk_id_str, _struct_timespec_u($tp))
+}
+probe syscall.clock_settime.return = kernel.function("sys_clock_settime").return {
+	name = "clock_settime"
+	retstr = returnstr(1)
+}
 
 # close ______________________________________________________
 # long sys_close(unsigned int fd)
@@ -387,46 +428,40 @@ probe syscall.epoll_create.return = kernel.function("sys_epoll_create").return {
 }
 
 # epoll_ctl __________________________________________________
-/*
- * asmlinkage long
- * sys_epoll_ctl(int epfd,
- *               int op,
- *               int fd,
- *               struct epoll_event __user *event)
- */
-probe kernel.syscall.epoll_ctl =
-   kernel.function("sys_epoll_ctl") {
-      name = "epoll_ctl"
-      epfd = $epfd
-      op = $op
-      op_str = _opoll_op_str($op)
-      fd = $fd
-      event_uaddr = $event
-   }
-probe kernel.syscall.epoll_ctl.return =
-   kernel.function("sys_epoll_ctl").return {
-      name = "epoll_ctl.return"
-   }
+#
+# long sys_epoll_ctl(int epfd, int op, int fd, struct epoll_event __user *event)
+#
+probe syscall.epoll_ctl = kernel.function("sys_epoll_ctl") {
+	name = "epoll_ctl"
+	epfd = $epfd
+	op = $op
+	op_str = _opoll_op_str($op)
+	fd = $fd
+	event_uaddr = $event
+	argstr = sprintf("%d, %s, %d, %p", $epfd, _opoll_op_str($op), $fd, $event)
+}
+probe syscall.epoll_ctl.return = kernel.function("sys_epoll_ctl").return {
+	name = "epoll_ctl"
+	retstr = returnstr(1)
+}
+
 # epoll_wait _________________________________________________
-/*
- * asmlinkage long
- * sys_epoll_wait(int epfd,
- *                struct epoll_event __user *events,
- *                int maxevents,
- *                int timeout)
- */
-probe kernel.syscall.epoll_wait =
-   kernel.function("sys_epoll_wait") {
-      name = "epoll_wait"
-      epfd = $epfd
-      events_uaddr = $events
-      maxevents = $maxevents
-      timeout = $timeout
-   }
-probe kernel.syscall.epoll_wait.return =
-   kernel.function("sys_epoll_wait").return {
-      name = "epoll_wait.return"
-   }
+#
+# long sys_epoll_wait(int epfd, struct epoll_event __user *events,
+#               int maxevents, int timeout)
+#
+probe syscall.epoll_wait = kernel.function("sys_epoll_wait") {
+	name = "epoll_wait"
+	epfd = $epfd
+	events_uaddr = $events
+	maxevents = $maxevents
+	timeout = $timeout
+	argstr = sprintf("%d, %p, %d, %d", $epfd, $events, $maxevents, $timeout)
+}
+probe syscall.epoll_wait.return = kernel.function("sys_epoll_wait").return {
+	name = "epoll_wait"
+	retstr = returnstr(1)
+}
 
 # execve _____________________________________________________
 # int sys_execve(struct pt_regs regs)
@@ -458,58 +493,47 @@ probe syscall.exit = kernel.function("do_exit") {
 probe syscall.exit.return = end {}
 
 # exit_group _________________________________________________
-/*
- * asmlinkage void
- * sys_exit_group(int error_code)
- */
-probe kernel.syscall.exit_group =
-   kernel.function("sys_exit_group") {
-      name = "exit_group"
-      status = $error_code
-   }
+# void sys_exit_group(int error_code)
+#
+probe syscall.exit_group = kernel.function("sys_exit_group") {
+	name = "exit_group"
+	status = $error_code
+	argstr = sprint($error_code)
+}
 
-probe kernel.syscall.exit_group.return = end {}
+probe syscall.exit_group.return = end {}
 
 # fadvise64 __________________________________________________
-/*
- * asmlinkage long
- * sys_fadvise64_64(int fd,
- *                  loff_t offset,
- *                  loff_t len,
- *                  int advice)
- */
-probe kernel.syscall.fadvise64 =
-   kernel.function("sys_fadvise64_64") {
-      name = "fadvise64"
-      fd = $fd
-      offset = $offset
-      len = $len
-      advice = $advice
-   }
-probe kernel.syscall.fadvise64.return =
-   kernel.function("sys_fadvise64_64").return {
-      name = "fadvise64.return"
-   }
+# long sys_fadvise64(int fd, loff_t offset, size_t len,  int advice)
+#
+probe syscall.fadvise64 = kernel.function("sys_fadvise64") {
+	name = "fadvise64"
+	fs = $fd
+	offset = $offset
+	len = $len
+	advice = $advice
+	argstr = sprintf("%d, %d, %d, %s", $fd, $offset, $len, _fadvice_advice_str($advice))
+}
+probe syscall.fadvise64.return = kernel.function("sys_fadvise64").return {
+	name = "fadvise64"
+	retstr = returnstr(1)
+}
+
 # fadvise64_64 _______________________________________________
-/*
- * asmlinkage long
- * sys_fadvise64_64(int fd,
- *                  loff_t offset,
- *                  loff_t len,
- *                  int advice)
- */
-probe kernel.syscall.fadvise64_64 =
-   kernel.function("sys_fadvise64_64") {
-      name = "fadvise64_64"
-      fs = $fd
-      offset = $offset
-      len = $len
-      advice = $advice
-   }
-probe kernel.syscall.fadvise64_64.return =
-   kernel.function("sys_fadvise64_64").return {
-      name = "fadvise64_64.return"
-   }
+# long sys_fadvise64_64(int fd, loff_t offset, loff_t len,  int advice)
+#
+probe syscall.fadvise64_64 = kernel.function("sys_fadvise64_64") {
+	name = "fadvise64_64"
+	fs = $fd
+	offset = $offset
+	len = $len
+	advice = $advice
+	argstr = sprintf("%d, %d, %d, %s", $fd, $offset, $len, _fadvice_advice_str($advice))
+}
+probe syscall.fadvise64_64.return =  kernel.function("sys_fadvise64_64").return {
+	name = "fadvise64_64"
+	retstr = returnstr(1)
+}
 
 # fchdir _____________________________________________________
 # long sys_fchdir(unsigned int fd)
@@ -601,7 +625,7 @@ probe syscall.fgetxattr = kernel.function("sys_fgetxattr") {
 	name2 = user_string($name)
 	value_uaddr = $value
 	size  = $size
-	argstr = sprintf("%d, %s, [%p], %d", filedes, user_string_quoted($name), value_uaddr, size)
+	argstr = sprintf("%d, %s, %p, %d", filedes, user_string_quoted($name), value_uaddr, size)
 }
 probe syscall.fgetxattr.return = kernel.function("sys_fgetxattr").return {
 	name = "fgetxattr"
@@ -614,7 +638,7 @@ probe syscall.flistxattr = kernel.function("sys_flistxattr") {
 	filedes = $fd
 	list_uaddr = $list
 	size = $size
-	argstr = sprintf("%d, [%p], %d", filedes, list_uaddr, size)
+	argstr = sprintf("%d, %p, %d", filedes, list_uaddr, size)
 }
 probe syscall.flistxattr.return = kernel.function("sys_flistxattr").return {
 	name = "flistxattr"
@@ -695,7 +719,7 @@ probe syscall.fsetxattr = kernel.function("sys_fsetxattr") {
 	value_uaddr = $value
 	size = $size
 	flags = $flags
-	argstr = sprintf("%d, %s, [%p], %d, %p", filedes, user_string_quoted($name), value_uaddr, size, flags)
+	argstr = sprintf("%d, %s, %p, %d, %p", filedes, user_string_quoted($name), value_uaddr, size, flags)
 }
 probe syscall.fsetxattr.return = kernel.function("sys_fsetxattr").return {
 	name = "fsetxattr"
@@ -716,7 +740,7 @@ probe syscall.fstat =
 	name = "fstat"
 	filedes = $fd
 	buf_uaddr = $statbuf
-	argstr = sprintf("%d, [%p]", $fd, $statbuf)
+	argstr = sprintf("%d, %p", $fd, $statbuf)
 }
 probe syscall.fstat.return = 
 		kernel.function("sys_fstat").return ?,
@@ -734,7 +758,7 @@ probe syscall.fstatfs = kernel.function("sys_fstatfs") {
 	name = "fstatfs"
 	fd = $fd
 	buf_uaddr = $buf
-	argstr = sprintf("%d, [%p]", fd, buf_uaddr)
+	argstr = sprintf("%d, %p", fd, buf_uaddr)
 }
 probe syscall.fstatfs.return = kernel.function("sys_fstatfs").return {
 	name = "fstatfs"
@@ -748,7 +772,7 @@ probe syscall.fstatfs64 = kernel.function("sys_fstatfs64") {
 	fd = $fd
 	sz = $sz
 	buf_uaddr = $buf
-	argstr = sprintf("%d, %d, [%p]", fd, sz, buf_uaddr)
+	argstr = sprintf("%d, %d, %p", fd, sz, buf_uaddr)
 }
 probe syscall.fstatfs64.return = kernel.function("sys_fstatfs64").return {
 	name = "fstatfs"
@@ -826,7 +850,7 @@ probe syscall.getcwd = kernel.function("sys_getcwd") {
 	name = "getcwd"
 	buf_uaddr = $buf
 	size = $size
-	argstr = sprintf("[%p], %d", buf_uaddr, size)
+	argstr = sprintf("%p, %d", buf_uaddr, size)
 }
 probe syscall.getcwd.return = kernel.function("sys_getcwd").return {
 	name = "getcwd"
@@ -842,7 +866,7 @@ probe syscall.getdents = kernel.function("sys_getdents") {
 	fd = $fd
 	dirp_uaddr = $dirent
 	count = $count
-	argstr = sprintf("%d, [%p], %d", fd, dirp_uaddr, count)
+	argstr = sprintf("%d, %p, %d", fd, dirp_uaddr, count)
 }
 probe syscall.getdents.return = kernel.function("sys_getdents").return {
 	name = "getdents"
@@ -858,7 +882,7 @@ probe syscall.getdents64 = kernel.function("sys_getdents64") {
 	fd = $fd
 	dirp_uaddr = $dirent
 	count = $count
-	argstr = sprintf("%d, [%p], %d", fd, dirp_uaddr, count)
+	argstr = sprintf("%d, %p, %d", fd, dirp_uaddr, count)
 }
 probe syscall.getdents64.return = kernel.function("sys_getdents64").return {
 	name = "getdents"
@@ -931,7 +955,7 @@ probe syscall.getgroups = kernel.function("sys_getgroups") {
 	name = "getgroups"
 	size = $gidsetsize
 	list_uaddr = $grouplist
-	argstr = sprintf("%d, [%p]", size, list_uaddr)
+	argstr = sprintf("%d, %p", size, list_uaddr)
 }
 probe syscall.getgroups.return = kernel.function("sys_getgroups").return {
 	name = "getgroups"
@@ -944,7 +968,7 @@ probe syscall.gethostname = kernel.function("sys_gethostname") {
 	name = "gethostname"
 	name_uaddr = $name
 	len = $len
-	argstr = sprintf ("[%p], %d", name_uaddr, len)
+	argstr = sprintf ("%p, %d", name_uaddr, len)
 }
 probe syscall.gethostname.return = kernel.function("sys_gethostname").return {
 	name = "gethostname"
@@ -957,31 +981,50 @@ probe syscall.getitimer = kernel.function("sys_getitimer") {
 	name = "getitimer"
 	which = $which
 	value_uaddr = $value
-	argstr = sprintf("%s, [%p]", _itimer_which_str(which), value_uaddr) 
+	argstr = sprintf("%s, %p", _itimer_which_str($which), $value) 
 }
 probe syscall.getitimer.return = kernel.function("sys_getitimer").return {
 	name = "getitimer"
 	retstr = returnstr(1)
 }
 
+# get_mempolicy ______________________________________________
+# long sys_get_mempolicy(int __user *policy,
+#                   unsigned long __user *nmask,
+#                   unsigned long maxnode,
+#                   unsigned long addr,
+#                   unsigned long flags)
+#
+probe syscall.get_mempolicy = kernel.function("sys_get_mempolicy") ? {
+	name = "get_mempolicy"
+	policy_uaddr = $policy
+	nmask_uaddr = $nmask
+	maxnode = $maxnode
+	addr = $addr
+	flags = $flags
+	argstr = sprintf("%p, %p, %d, %p, %d", policy_uaddr,
+			nmask_uaddr, $maxnode, $addr, $flags)
+}
+probe syscall.get_mempolicy.return = 
+		kernel.function("sys_get_mempolicy").return ? {
+	name = "get_mempolicy"
+	retstr = returnstr(1)
+}
+
 # getpeername ________________________________________________
-/*
- * asmlinkage long
- * sys_getpeername(int fd,
- *                 struct sockaddr __user *usockaddr,
- *                 int __user *usockaddr_len)
- */
-probe kernel.syscall.getpeername =
-   kernel.function("sys_getpeername") {
-      name = "getpeername"
-      s = $fd
-      name_uaddr = $usockaddr
-      namelen_uaddr = $usockaddr_len
-   }
-probe kernel.syscall.getpeername.return =
-   kernel.function("sys_getpeername").return {
-      name = "getpeername.return"
-   }
+# long sys_getpeername(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len)
+#
+probe syscall.getpeername = kernel.function("sys_getpeername") {
+	name = "getpeername"
+	s = $fd
+	name_uaddr = $usockaddr
+	namelen_uaddr = $usockaddr_len
+	argstr = sprintf("%d, %p, %p", $fd, $usockaddr, $usockaddr_len)
+}
+probe syscall.getpeername.return = kernel.function("sys_getpeername").return {
+	name = "getpeername"
+	retstr = returnstr(1)
+}
 
 # getpgid ____________________________________________________
 # long sys_getpgid(void)
@@ -1044,7 +1087,7 @@ probe syscall.getresgid = kernel.function("sys_getresgid") {
 	rgid_uaddr = $rgid
 	egid_uaddr = $egid
 	sgid_uaddr = $sgid
-	argstr = sprintf("[%p], [%p], [%p]", rgid_uaddr, egid_uaddr, sgid_uaddr)
+	argstr = sprintf("%p, %p, %p", rgid_uaddr, egid_uaddr, sgid_uaddr)
 }
 probe syscall.getresgid.return = kernel.function("sys_getresgid").return {
 	name = "getresgid"
@@ -1060,7 +1103,7 @@ probe syscall.getresgid16 = kernel.function("sys_getresgid16") ? {
 	rgid_uaddr = $rgid
 	egid_uaddr = $egid
 	sgid_uaddr = $sgid
-	argstr = sprintf("[%p], [%p], [%p]", rgid_uaddr, egid_uaddr, sgid_uaddr)
+	argstr = sprintf("%p, %p, %p", rgid_uaddr, egid_uaddr, sgid_uaddr)
 }
 probe syscall.getresgid16.return = kernel.function("sys_getresgid16").return ? {
 	name = "getresgid16"
@@ -1076,7 +1119,7 @@ probe syscall.getresuid = kernel.function("sys_getresuid") {
 	ruid_uaddr = $ruid
 	euid_uaddr = $euid
 	suid_uaddr = $suid
-	argstr = sprintf("[%p], [%p], [%p]", ruid_uaddr, euid_uaddr, suid_uaddr)
+	argstr = sprintf("%p, %p, %p", ruid_uaddr, euid_uaddr, suid_uaddr)
 }
 probe syscall.getresuid.return = kernel.function("sys_getresuid").return {
 	name = "getresuid"
@@ -1092,7 +1135,7 @@ probe syscall.getresuid16 = kernel.function("sys_getresuid16") ? {
 	ruid_uaddr = $ruid
 	euid_uaddr = $euid
 	suid_uaddr = $suid
-	argstr = sprintf("[%p], [%p], [%p]", ruid_uaddr, euid_uaddr, suid_uaddr)
+	argstr = sprintf("%p, %p, %p", ruid_uaddr, euid_uaddr, suid_uaddr)
 }
 probe syscall.getresuid16.return = kernel.function("sys_getresuid16").return ? {
 	name = "getresuid16"
@@ -1105,7 +1148,7 @@ probe syscall.getrlimit = kernel.function("sys_getrlimit") {
 	name = "getrlimit"
 	resource = $resource
 	rlim_uaddr = $rlim
-	argstr = sprintf("%s, [%p]", _rlimit_resource_str($resource), rlim_uaddr)
+	argstr = sprintf("%s, %p", _rlimit_resource_str($resource), rlim_uaddr)
 }
 probe syscall.getrlimit.return = kernel.function("sys_getrlimit").return {
 	name = "getrlimit"
@@ -1118,7 +1161,7 @@ probe syscall.getrusage = kernel.function("sys_getrusage") {
 	name = "getrusage"
 	who = $who
 	usage_uaddr = $ru
-	argstr = sprintf("%s, [%p]",_rusage_who_str($who), usage_uaddr)
+	argstr = sprintf("%s, %p",_rusage_who_str($who), usage_uaddr)
 }
 probe syscall.getrusage.return = kernel.function("sys_getrusage").return {
 	name = "getrusage"
@@ -1141,42 +1184,40 @@ probe syscall.getsid.return = kernel.function("sys_getsid").return {
 # long sys_getsockname(int fd,
 #		struct sockaddr __user *usockaddr,
 #		int __user *usockaddr_len)
-probe kernel.syscall.getsockname =
-   kernel.function("sys_getsockname") {
-      name = "getsockname"
-      s = $fd
-      name_uaddr = $usockaddr
-      namelen_uaddr = $usockaddr_len
-   }
-probe kernel.syscall.getsockname.return =
-   kernel.function("sys_getsockname").return {
-      name = "getsockname.return"
-   }
+probe syscall.getsockname = kernel.function("sys_getsockname") {
+	name = "getsockname"
+	s = $fd
+	name_uaddr = $usockaddr
+	namelen_uaddr = $usockaddr_len
+	argstr = sprintf("%d, %p, %p", $fd, $usockaddr, $usockaddr_len)
+}
+probe syscall.getsockname.return = kernel.function("sys_getsockname").return {
+	name = "getsockname"
+	retstr = returnstr(1)
+}
 
 # getsockopt _________________________________________________
-/*
- * asmlinkage long
- * sys_getsockopt(int fd,
- *                int level,
- *                int optname,
- *                char __user *optval,
- *                int __user *optlen)
- */
-probe kernel.syscall.getsockopt =
-   kernel.function("sys_getsockopt") {
-      name = "getsockopt"
-      fd = $fd
-      level = $level
-      level_str = _sockopt_level_str($level)
-      optname = $optname
-      optname_str = _sockopt_optname_str($optname)
-      optval_uaddr = $optval
-      optlen_uaddr = $optlen
-   }
-probe kernel.syscall.getsockopt.return =
-   kernel.function("sys_getsockopt").return {
-      name = "getsockopt.return"
-   }
+# long sys_getsockopt(int fd,
+#                int level,
+#                int optname,
+#                char __user *optval,
+#                int __user *optlen)
+#
+probe syscall.getsockopt = kernel.function("sys_getsockopt") {
+	name = "getsockopt"
+	fd = $fd
+	level = $level
+	level_str = _sockopt_level_str($level)
+	optname = $optname
+	optname_str = _sockopt_optname_str($optname)
+	optval_uaddr = $optval
+	optlen_uaddr = $optlen
+	argstr = sprintf("%d, %s, %s, %p, %p", $fd,  _sockopt_level_str($level),
+			_sockopt_optname_str($optname), $optval, $optlen)
+}
+probe syscall.getsockopt.return = kernel.function("sys_getsockopt").return {
+	name = "getsockopt.return"
+}
 
 # gettid _____________________________________________________
 # long sys_gettid(void)
@@ -1195,7 +1236,7 @@ probe syscall.gettimeofday = kernel.function("sys_gettimeofday") {
 	name = "gettimeofday"
 	tv_uaddr = $tv
 	tz_uaddr = $tz
-	argstr = sprintf("[%p], [%p]", tv_uaddr, tz_uaddr)
+	argstr = sprintf("%p, %p", $tv, $tz)
 }
 probe syscall.gettimeofday.return = kernel.function("sys_gettimeofday").return {
 	name = "gettimeofday"
@@ -1232,7 +1273,7 @@ probe syscall.getxattr = kernel.function("sys_getxattr") {
 	name2 = user_string($name)
 	value_uaddr = $value
 	size = $size
-	argstr = sprintf("%s, %s, [%p], %d", 
+	argstr = sprintf("%s, %s, %p, %d", 
 		user_string_quoted($path), 
 		user_string_quoted($name),
 		value_uaddr, size)
@@ -1251,7 +1292,7 @@ probe syscall.init_module = kernel.function("sys_init_module") {
 	umod_uaddr = $umod
 	len = $len
 	uargs = user_string($uargs)
-	argstr = sprintf("[%p], %d, %s", umod_uaddr, len, uargs)
+	argstr = sprintf("%p, %d, %s", umod_uaddr, len, uargs)
 }
 probe syscall.init_module.return = kernel.function("sys_init_module").return {
 	name = "init_module"
@@ -1267,7 +1308,7 @@ probe syscall.io_cancel = kernel.function("sys_io_cancel") {
 	ctx_id = $ctx_id
 	iocb_uaddr = $iocb
 	result_uaddr = $result
-	argstr = sprintf("%d, [%p], [%p]", ctx_id, iocb_uaddr, result_uaddr)	
+	argstr = sprintf("%d, %p, %p", ctx_id, iocb_uaddr, result_uaddr)	
 }
 probe syscall.io_cancel.return = kernel.function("sys_io_cancel").return {
 	name = "io_cancel"
@@ -1282,7 +1323,7 @@ probe syscall.ioctl = kernel.function("sys_ioctl") {
 	fd = $fd
 	request = $cmd
 	argp = $arg
-	argstr = sprintf("%d, %d, [%p]", fd, request, argp)
+	argstr = sprintf("%d, %d, %p", fd, request, argp)
 }
 probe syscall.ioctl.return = kernel.function("sys_ioctl").return {
 	name = "ioctl"
@@ -1316,7 +1357,7 @@ probe syscall.io_getevents = kernel.function("sys_io_getevents") {
 	events_uaddr = $events
 	timeout_uaddr = $timeout
 	timestr = _struct_timespec_u($timeout)
-	argstr = sprintf("%d, %d, %d, [%p], [%p], %s", ctx_id, min_nr,
+	argstr = sprintf("%d, %d, %d, %p, %p, %s", ctx_id, min_nr,
 		nr, events_uaddr, timeout_uaddr, timestr)
 }
 probe syscall.io_getevents.return = kernel.function("sys_io_getevents").return {
@@ -1325,106 +1366,120 @@ probe syscall.io_getevents.return = kernel.function("sys_io_getevents").return {
 }
 
 # ioperm _____________________________________________________
-/*
- * asmlinkage long
- * sys_ioperm(unsigned long from,
- *            unsigned long num,
- *            int turn_on)
- */
-probe kernel.syscall.ioperm =
-   kernel.function("sys_ioperm") {
-      name = "ioperm"
-      from = $from
-      num = $num
-      turn_on = $turn_on
-   }
-probe kernel.syscall.ioperm.return =
-   kernel.function("sys_ioperm").return {
-      name = "ioperm.return"
-   }
+# long sys_ioperm(unsigned long from, unsigned long num, int turn_on)
+#
+probe syscall.ioperm = kernel.function("sys_ioperm") ? {
+	name = "ioperm"
+	from = $from
+	num = $num
+	turn_on = $turn_on
+	argstr = sprintf("%d, %d, %d", $from, $num, $turn_on)
+}
+probe syscall.ioperm.return = kernel.function("sys_ioperm").return ? {
+	name = "ioperm"
+	retstr = returnstr(1)
+}
+
 # io_setup ___________________________________________________
-/*
- * asmlinkage long
- * sys_io_setup(unsigned nr_events,
- *              aio_context_t __user *ctxp)
- */
-probe syscall.io_setup =
-   kernel.function("sys_io_setup") {
+# long sys_io_setup(unsigned nr_events, aio_context_t __user *ctxp)
+#
+probe syscall.io_setup = kernel.function("sys_io_setup") {
 	name = "io_setup"
 	maxevents = $nr_events
 	ctxp_uaddr = $ctxp
 	argstr = sprintf("%d, %p", maxevents, ctxp_uaddr)
 }
 
-probe syscall.io_setup.return =
-   kernel.function("sys_io_setup").return {
+probe syscall.io_setup.return = kernel.function("sys_io_setup").return {
 	name = "io_setup"
 	retstr = returnstr(1)
-   }
+}
+
 # io_submit __________________________________________________
-/*
- * asmlinkage long
- * sys_io_submit(aio_context_t ctx_id,
- *               long nr,
- *               struct iocb __user * __user *iocbpp)
- */
-probe syscall.io_submit =
-   kernel.function("sys_io_submit") {
-      name = "io_submit"
-      ctx_id = $ctx_id
-      nr = $nr
-      iocbpp_uaddr = $iocbpp
-      argstr = sprintf("%d, %d, %p", ctx_id, nr, iocbpp_uaddr)
-}
-probe syscall.io_submit.return =
-   kernel.function("sys_io_submit").return {
-      name = "io_submit"
-      retstr = returnstr(1)
-   }
+# long sys_io_submit(aio_context_t ctx_id,
+#               long nr,
+#               struct iocb __user * __user *iocbpp)
+#
+probe syscall.io_submit = kernel.function("sys_io_submit") {
+	name = "io_submit"
+	ctx_id = $ctx_id
+	nr = $nr
+	iocbpp_uaddr = $iocbpp
+	argstr = sprintf("%d, %d, %p", ctx_id, nr, iocbpp_uaddr)
+}
+probe syscall.io_submit.return = kernel.function("sys_io_submit").return {
+	name = "io_submit"
+	retstr = returnstr(1)
+}
+
+# ioprio_get _________________________________________________
+# long sys_ioprio_get(int which, int who)
+#
+probe syscall.ioprio_get = kernel.function("sys_ioprio_get") {
+	name = "ioprio_get"
+	which = $which
+	who = $who
+	argstr = sprintf("%d, %d", $which, $who)
+}
+probe syscall.ioprio_get.return = kernel.function("sys_ioprio_get").return {
+	name = "ioprio_get"
+	retstr = returnstr(1)
+}
+
+# ioprio_set _________________________________________________
+# long sys_ioprio_set(int which, int who, int ioprio)
+#
+probe syscall.ioprio_set = kernel.function("sys_ioprio_set") {
+	name = "ioprio_set"
+	which = $which
+	who = $who
+	ioprio = $ioprio
+	argstr = sprintf("%d, %d, %d", $which, $who, $ioprio)
+}
+probe syscall.ioprio_set.return = kernel.function("sys_ioprio_set").return {
+	name = "ioprio_set"
+	retstr = returnstr(1)
+}
+
 # kexec_load _________________________________________________
-/*
- * asmlinkage long
- * sys_kexec_load(unsigned long entry,
- *                unsigned long nr_segments,
- *                struct kexec_segment __user *segments,
- *                unsigned long flags)
- */
-/*
-probe kernel.syscall.kexec_load =
-   kernel.function("sys_kexec_load") {
-      name = "kexec_load"
-      entry = $entry
-      nr_segments = $nr_segments
-      segments_uaddr = $segments_uaddr
-      flags = $flags
-   }
-probe kernel.syscall.kexec_load.return =
-   kernel.function("sys_kexec_load").return {
-      name = "kexec_load.return"
-   }
-*/
+# long sys_kexec_load(unsigned long entry,
+#                unsigned long nr_segments,
+#                struct kexec_segment __user *segments,
+#                unsigned long flags)
+#
+probe syscall.kexec_load = kernel.function("sys_kexec_load") {
+	name = "kexec_load"
+	entry = $entry
+	nr_segments = $nr_segments
+	segments_uaddr = $segments_uaddr
+	flags = $flags
+	argstr = sprintf("%p, %d, %p, %d", $entry, $nr_segments, $segments, $flags)
+}
+probe syscall.kexec_load.return = kernel.function("sys_kexec_load").return {
+	name = "kexec_load"
+	retstr = returnstr(1)	
+}
+
 # keyctl _____________________________________________________
-/*
- * asmlinkage long
- * sys_keyctl(int option,
- *            unsigned long arg2,
- *            unsigned long arg3,
- *            unsigned long arg4,
- *            unsigned long arg5)
- */
-probe kernel.syscall.keyctl =
-   kernel.function("sys_keyctl") {
-      name = "keyctl"
-      option = $option
-      arg2 = $arg2
-      arg3 = $arg3
-      arg4 = $arg4
-      arg5 = $arg5
-   }
-probe kernel.syscall.keyctl.return =
-   kernel.function("sys_keyctl").return {
-      name = "keyctl.return"
-   }
+# long sys_keyctl(int option,
+#            unsigned long arg2,
+#            unsigned long arg3,
+#            unsigned long arg4,
+#            unsigned long arg5)
+#
+probe syscall.keyctl = kernel.function("sys_keyctl") {
+	name = "keyctl"
+	option = $option
+	arg2 = $arg2
+	arg3 = $arg3
+	arg4 = $arg4
+	arg5 = $arg5
+	argstr = sprintf("%d", $option)
+}
+probe syscall.keyctl.return = kernel.function("sys_keyctl").return {
+	name = "keyctl"
+	retstr = returnstr(1)
+}
 
 # kill _______________________________________________________
 # long sys_kill(int pid, int sig)
@@ -1470,25 +1525,27 @@ probe syscall.lchown16.return = kernel.function("sys_lchown16").return ? {
 	retstr = returnstr(1)
 }
 # lgetxattr __________________________________________________
-/*
- * asmlinkage ssize_t
- * sys_lgetxattr(char __user *path,
- *               char __user *name,
- *               void __user *value,
- *               size_t size)
- */
-probe kernel.syscall.lgetxattr =
-   kernel.function("sys_lgetxattr") {
-      name = "lgetxattr"
-      path_uaddr = $path
-      name_uaddr = $name
-      value_uaddr = $value
-      size = $size
-   }
-probe kernel.syscall.lgetxattr.return =
-   kernel.function("sys_lgetxattr").return {
-      name = "lgetxattr.return"
-   }
+# ssize_t sys_lgetxattr(char __user *path,
+#               char __user *name,
+#               void __user *value,
+#               size_t size)
+#
+probe syscall.lgetxattr = kernel.function("sys_lgetxattr") {
+	name = "lgetxattr"
+	path = user_string($path)
+	# FIXME
+	name2 = user_string($name)
+	value_uaddr = $value
+	size = $size
+	argstr = sprintf("%s, %s, %p, %d", 
+		user_string_quoted($path), 
+		user_string_quoted($name),
+		value_uaddr, size)
+}
+probe syscall.lgetxattr.return = kernel.function("sys_lgetxattr").return {
+	name = "lgetxattr"
+	retstr = returnstr(1)
+}
 # link _______________________________________________________
 # long sys_link(const char __user * oldname,
 #          const char __user * newname)
@@ -1519,41 +1576,37 @@ probe syscall.listen.return = kernel.function("sys_listen").return {
 }
 
 # listxattr __________________________________________________
-/*
- * asmlinkage ssize_t
- * sys_listxattr(char __user *path,
- *               char __user *list,
- *               size_t size)
- */
-probe kernel.syscall.listxattr =
-   kernel.function("sys_listxattr") {
-      name = "listxattr"
-      path_uaddr = $path
-      list_uaddr = $list
-      size = $size
-   }
-probe kernel.syscall.listxattr.return =
-   kernel.function("sys_listxattr").return {
-      name = "listxattr.return"
-   }
+# ssize_t sys_listxattr(char __user *path, char __user *list, size_t size)
+#
+probe syscall.listxattr = kernel.function("sys_listxattr") {
+	name = "listxattr"
+	path_uaddr = $path
+	path = user_string($path)
+	list_uaddr = $list
+	size = $size
+	argstr = sprintf("%s, %p, %d", user_string_quoted($path), $list, $size)
+}
+probe syscall.listxattr.return = kernel.function("sys_listxattr").return {
+	name = "listxattr"
+	retstr = returnstr(1)
+}
+
 # llistxattr _________________________________________________
-/*
- * asmlinkage ssize_t
- * sys_llistxattr(char __user *path,
- *                char __user *list,
- *                size_t size)
- */
-probe kernel.syscall.llistxattr =
-   kernel.function("sys_llistxattr") {
-      name = "llistxattr"
-      path_uaddr = $path
-      list_uaddr = $list
-      size = $size
-   }
-probe kernel.syscall.llistxattr.return =
-   kernel.function("sys_llistxattr").return {
-      name = "llistxattr.return"
-   }
+# ssize_t sys_llistxattr(char __user *path, char __user *list, size_t size)
+#
+probe syscall.llistxattr = kernel.function("sys_llistxattr") {
+	name = "llistxattr"
+	path_uaddr = $path
+	path = user_string($path)
+	list_uaddr = $list
+	size = $size
+	argstr = sprintf("%s, %p, %d", user_string_quoted($path), $list, $size)
+}
+probe syscall.llistxattr.return = kernel.function("sys_llistxattr").return {
+	name = "llistxattr"
+	retstr = returnstr(1)
+}
+
 # llseek _____________________________________________________
 # long sys_llseek(unsigned int fd,
 #            unsigned long offset_high,
@@ -1575,40 +1628,38 @@ probe syscall.llseek.return = kernel.function("sys_llseek").return {
 	name = "llseek"
 	retstr = returnstr(1)
 }
+
 # lookup_dcookie _____________________________________________
-/*
- * asmlinkage long
- * sys_lookup_dcookie(u64 cookie64,
- *                    char __user * buf,
- *                    size_t len)
- */
-probe kernel.syscall.lookup_dcookie =
-   kernel.function("sys_lookup_dcookie") {
-      name = "lookup_dcookie"
-      cookie = $cookie64
-      buffer_uaddr = $buf
-      len = $len
-   }
-probe kernel.syscall.lookup_dcookie.return =
-   kernel.function("sys_lookup_dcookie").return {
-      name = "lookup_dcookie.return"
-   }
+# long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len)
+#
+probe syscall.lookup_dcookie = kernel.function("sys_lookup_dcookie") {
+	name = "lookup_dcookie"
+	cookie = $cookie64
+	buffer_uaddr = $buf
+	len = $len
+	argstr = sprintf("%d, %p, %d", $cookie64, $buf, $len)
+}
+probe syscall.lookup_dcookie.return = kernel.function("sys_lookup_dcookie").return {
+	name = "lookup_dcookie"
+	retstr = returnstr(1)
+}
+
 # lremovexattr _______________________________________________
-/*
- * asmlinkage long
- * sys_lremovexattr(char __user *path,
- *                  char __user *name)
- */
-probe kernel.syscall.lremovexattr =
-   kernel.function("sys_lremovexattr") {
-      name = "lremovexattr"
-      path_uaddr = $path
-      name_uaddr = $name
-   }
-probe kernel.syscall.lremovexattr.return =
-   kernel.function("sys_lremovexattr").return {
-      name = "lremovexattr.return"
-   }
+# long sys_lremovexattr(char __user *path, char __user *name)
+#
+probe syscall.lremovexattr = kernel.function("sys_lremovexattr") {
+	name = "lremovexattr"
+	path_uaddr = $path
+	path = user_string($path)
+	name_uaddr = $name
+	name2 = user_string($name)
+	argstr = sprintf("%s, %s", user_string_quoted($path), user_string_quoted($name)) 
+}
+probe syscall.lremovexattr.return = kernel.function("sys_lremovexattr").return {
+	name = "lremovexattr"
+	retstr = returnstr(1)
+}
+
 # lseek ______________________________________________________
 # off_t sys_lseek(unsigned int fd, off_t offset, unsigned int origin)
 probe syscall.lseek = kernel.function("sys_lseek") {
@@ -1623,28 +1674,32 @@ probe syscall.lseek.return = kernel.function("sys_lseek").return {
 	name = "lseek"
 	retstr = returnstr(1)
 }
+
 # lsetxattr __________________________________________________
-/*
- * asmlinkage long
- * sys_lsetxattr(char __user *path,
- *               char __user *name,
- *               void __user *value,
- *               size_t size,
- *               int flags)
- */
-probe kernel.syscall.lsetxattr =
-   kernel.function("sys_lsetxattr") {
-      name = "lsetxattr"
-      path_uaddr = $path
-      name_uaddr = $name
-      value_uaddr = $value
-      size = $size
-      flags = $flags
-   }
-probe kernel.syscall.lsetxattr.return =
-   kernel.function("sys_lsetxattr").return {
-      name = "lsetxattr.return"
-   }
+# long sys_lsetxattr(char __user *path,
+#               char __user *name,
+#               void __user *value,
+#               size_t size,
+#               int flags)
+#
+probe syscall.lsetxattr = kernel.function("sys_lsetxattr") {
+	name = "lsetxattr"
+	path_uaddr = $path
+	path = user_string($path)
+	name_uaddr = $name
+	name_str = user_string($name)
+	value_uaddr = $value
+	size = $size
+	flags = $flags
+	argstr = sprintf("%s, %s, %p, %d, %d", 
+			user_string_quoted($path), 
+			user_string_quoted($name),
+			value_uaddr, $size, $flags)
+}
+probe syscall.lsetxattr.return = kernel.function("sys_lsetxattr").return {
+	name = "lsetxattr"
+	retstr = returnstr(1)
+}
 
 # lstat ______________________________________________________
 # long sys_lstat(char __user * filename, struct __old_kernel_stat __user * statbuf)
@@ -1654,7 +1709,7 @@ probe syscall.lstat =
 	name = "lstat"
 	file_name = user_string($filename)
 	buf_uaddr = $statbuf
-	argstr = sprintf("%s, [%p]", user_string_quoted($filename), buf_uaddr) 
+	argstr = sprintf("%s, %p", user_string_quoted($filename), buf_uaddr) 
 }
 probe syscall.lstat.return = 
 		kernel.function("sys_lstat").return ?
@@ -1664,42 +1719,59 @@ probe syscall.lstat.return =
 }
 
 # madvise ____________________________________________________
-/*
- * asmlinkage long
- * sys_madvise(unsigned long start,
- *             size_t len_in,
- *             int behavior)
- */
-probe kernel.syscall.madvise =
-   kernel.function("sys_madvise") {
-      name = "madvise"
-      start = $start
-      length = $len_in
-      advice = $behavior
-      advice_str = _madvice_advice_str($behavior)
-   }
-probe kernel.syscall.madvise.return =
-   kernel.function("sys_madvise").return {
-      name = "madvise.return"
-   }
+# long sys_madvise(unsigned long start, size_t len_in, int behavior)
+#
+probe syscall.madvise = kernel.function("sys_madvise") {
+	name = "madvise"
+	start = $start
+	length = $len_in
+	advice = $behavior
+	advice_str = _madvice_advice_str($behavior)
+	argstr = sprintf("%p, %d, %s", $start, $len_in, _madvice_advice_str($behavior))
+}
+probe syscall.madvise.return = kernel.function("sys_madvise").return {
+	name = "madvise"
+	retstr = returnstr(1)
+}
+
+# mbind ______________________________________________________
+# long sys_mbind(unsigned long start,
+#	unsigned long len,
+#	unsigned long mode,
+#	unsigned long __user *nmask,
+#	unsigned long maxnode,
+#	unsigned flags)
+#
+probe syscall.mbind = kernel.function("sys_mbind") ? {
+	name = "mbind"
+	start = $start
+	len = $len
+	mode = $mode
+	nmask_uaddr = $nmask
+	maxnode = $maxnode
+	flags = $flags
+	argstr = sprintf("%d, %d, %d, %p, %d, %d", $start, $len, $mode,
+				nmask_uaddr, $maxnode, $flags)
+}
+probe syscall.mbind.return = kernel.function("sys_mbind").return ? {
+	name = "mbind"
+	retstr = returnstr(1)
+}
+
 # mincore ____________________________________________________
-/*
- * asmlinkage long
- * sys_mincore(unsigned long start,
- *             size_t len,
- *             unsigned char __user * vec)
- */
-probe kernel.syscall.mincore =
-   kernel.function("sys_mincore") {
-      name = "mincore"
-      start = $start
-      length = $len
-      vec_uaddr = $vec
-   }
-probe kernel.syscall.mincore.return =
-   kernel.function("sys_mincore").return {
-      name = "mincore.return"
-   }
+# long sys_mincore(unsigned long start, size_t len, unsigned char __user * vec)
+#
+probe syscall.mincore = kernel.function("sys_mincore") {
+	name = "mincore"
+	start = $start
+	length = $len
+	vec_uaddr = $vec
+	argstr = sprintf("%p, %d, %p", $start, $len, $vec)
+}
+probe syscall.mincore.return = kernel.function("sys_mincore").return {
+	name = "mincore"
+	retstr = returnstr(1)	
+}
 
 # mkdir ______________________________________________________
 # long sys_mkdir(const char __user * pathname, int mode)
@@ -1823,23 +1895,20 @@ probe syscall.mmap2.return = kernel.function("sys_mmap2").return ? {
 
 
 # modify_ldt _________________________________________________
-/*
- * asmlinkage int
- * sys_modify_ldt(int func,
- *                void __user *ptr,
- *                unsigned long bytecount)
- */
-probe kernel.syscall.modify_ldt =
-   kernel.function("sys_modify_ldt") {
-      name = "modify_ldt"
-      func = $func
-      ptr_uaddr = $ptr
-      bytecount = $bytecount
-   }
-probe kernel.syscall.modify_ldt.return =
-   kernel.function("sys_modify_ldt").return {
-      name = "modify_ldt.return"
-   }
+# int sys_modify_ldt(int func, void __user *ptr, unsigned long bytecount)
+#
+probe syscall.modify_ldt = kernel.function("sys_modify_ldt") {
+	name = "modify_ldt"
+	func = $func
+	ptr_uaddr = $ptr
+	bytecount = $bytecount
+	argstr = sprintf("%d, %p, %d", $func, $ptr, $bytecount)
+}
+probe syscall.modify_ldt.return = kernel.function("sys_modify_ldt").return {
+	name = "modify_ldt"
+	retstr = returnstr(1)
+}
+
 # mount ______________________________________________________
 # long sys_mount(char __user * dev_name,
 #          char __user * dir_name,
@@ -1866,235 +1935,224 @@ probe syscall.mount.return = kernel.function("sys_mount").return {
 }
 
 # mprotect ___________________________________________________
-/*
- * asmlinkage long
- * sys_mprotect(unsigned long start,
- *              size_t len,
- *              unsigned long prot)
- */
-probe kernel.syscall.mprotect =
-   kernel.function("sys_mprotect") {
-      name = "mprotect"
-      addr = $start
-      len = $len
-      prot = $prot
-      prot_str = _mprotect_prot_str($prot)
-   }
-probe kernel.syscall.mprotect.return =
-   kernel.function("sys_mprotect").return {
-      name = "mprotect.return"
-   }
+# long sys_mprotect(unsigned long start, size_t len, unsigned long prot)
+#
+probe syscall.mprotect = kernel.function("sys_mprotect") {
+	name = "mprotect"
+	addr = $start
+	len = $len
+	prot = $prot
+	prot_str = _mprotect_prot_str($prot)
+	argstr = sprintf("%p, %d, %s", $start, $len, _mprotect_prot_str($prot))
+}
+probe syscall.mprotect.return = kernel.function("sys_mprotect").return {
+	name = "mprotect"
+	retstr = returnstr(1)
+}
+
 # mq_getsetattr ______________________________________________
-/*
- * asmlinkage long
- * sys_mq_getsetattr(mqd_t mqdes,
- *                   const struct mq_attr __user *u_mqstat,
- *                   struct mq_attr __user *u_omqstat)
- */
-probe kernel.syscall.mq_getsetattr =
-   kernel.function("sys_mq_getsetattr") {
-      name = "mq_getsetattr"
-      mqdes = $mqdes
-      u_mqstat_uaddr = $u_mqstat
-      u_omqstat_uaddr = $u_omqstat
-   }
-probe kernel.syscall.mq_getsetattr.return =
-   kernel.function("sys_mq_getsetattr").return {
-      name = "mq_getsetattr.return"
-   }
+# long sys_mq_getsetattr(mqd_t mqdes,
+#                  const struct mq_attr __user *u_mqstat,
+#                  struct mq_attr __user *u_omqstat)
+#
+probe syscall.mq_getsetattr = kernel.function("sys_mq_getsetattr") {
+	name = "mq_getsetattr"
+	mqdes = $mqdes
+	u_mqstat_uaddr = $u_mqstat
+	u_omqstat_uaddr = $u_omqstat
+	argstr = sprintf("%d, %p, %p", $mqdes, $u_mqstat, $u_omqstat)
+}
+probe syscall.mq_getsetattr.return = kernel.function("sys_mq_getsetattr").return {
+	name = "mq_getsetattr"
+	retstr = returnstr(1)
+}
+
 # mq_notify __________________________________________________
-/*
- * asmlinkage long
- * sys_mq_notify(mqd_t mqdes,
- *               const struct sigevent __user *u_notification)
- */
-probe kernel.syscall.mq_notify =
-   kernel.function("sys_mq_notify") {
-      name = "mq_notify"
-      mqdes = $mqdes
-      notification_uaddr = $u_notification
-   }
-probe kernel.syscall.mq_notify.return =
-   kernel.function("sys_mq_notify").return {
-      name = "mq_notify.return"
-   }
+# long sys_mq_notify(mqd_t mqdes, const struct sigevent __user *u_notification)
+#
+probe syscall.mq_notify = kernel.function("sys_mq_notify") {
+	name = "mq_notify"
+	mqdes = $mqdes
+	notification_uaddr = $u_notification
+	argstr = sprintf("%d, %p", $mqdes, $u_notification)
+}
+probe syscall.mq_notify.return = kernel.function("sys_mq_notify").return {
+	name = "mq_notify"
+	retstr = returnstr(1)
+}
+
 # mq_open ____________________________________________________
-/*
- * asmlinkage long
- * sys_mq_open(const char __user *u_name,
- *             int oflag,
- *             mode_t mode,
- *             struct mq_attr __user *u_attr)
- */
-probe kernel.syscall.mq_open =
-   kernel.function("sys_mq_open") {
-      name = "mq_open"
-      name_uaddr = $u_name
-      oflag = $oflag
-      mode = $mode
-      u_attr_uaddr = $u_attr
-   }
-probe kernel.syscall.mq_open.return =
-   kernel.function("sys_mq_open").return {
-      name = "mq_open.return"
-   }
+# long  sys_mq_open(const char __user *u_name,
+#             int oflag,
+#             mode_t mode,
+#             struct mq_attr __user *u_attr)
+#
+probe syscall.mq_open = kernel.function("sys_mq_open") {
+	name = "mq_open"
+	name_uaddr = $u_name
+	filename = user_string($u_name)
+	mode = $mode
+	u_attr_uaddr = $u_attr
+	oflag = $oflag
+	if (oflag & 64)
+		argstr = sprintf("%s, %s, %#o, %p", user_string_quoted($u_name), 
+			_sys_open_flag_str(oflag), $mode, $u_attr)
+	else
+		argstr = sprintf("%s, %s", user_string_quoted($u_name), _sys_open_flag_str(oflag))
+}
+probe syscall.mq_open.return = kernel.function("sys_mq_open").return {
+	name = "mq_open"
+	retstr = returnstr(1)
+}
+
 # mq_timedreceive ____________________________________________
-/*
- * asmlinkage ssize_t
- * sys_mq_timedreceive(mqd_t mqdes,
- *                     char __user *u_msg_ptr,
- *                     size_t msg_len,
- *                     unsigned int __user *u_msg_prio,
- *                     const struct timespec __user *u_abs_timeout)
- */
-probe kernel.syscall.mq_timedreceive =
-   kernel.function("sys_mq_timedreceive") {
-      name = "mq_timedreceive"
-      mqdes = $mqdes
-      msg_ptr_uaddr = $u_msg_ptr
-      msg_len = $msg_len
-      msg_prio_uaddr = $u_msg_prio
-      abs_timout_uaddr = $u_abs_timeout
-   }
-probe kernel.syscall.mq_timedreceive.return =
-   kernel.function("sys_mq_timedreceive").return {
-      name = "mq_timedreceive.return"
-   }
+# ssize_t sys_mq_timedreceive(mqd_t mqdes,
+#                     char __user *u_msg_ptr,
+#                     size_t msg_len,
+#                     unsigned int __user *u_msg_prio,
+#                     const struct timespec __user *u_abs_timeout)
+#
+probe syscall.mq_timedreceive = kernel.function("sys_mq_timedreceive") {
+	name = "mq_timedreceive"
+	mqdes = $mqdes
+	msg_ptr_uaddr = $u_msg_ptr
+	msg_len = $msg_len
+	msg_prio_uaddr = $u_msg_prio
+	abs_timout_uaddr = $u_abs_timeout
+	argstr = sprintf("%d, %p, %d, %p, %p", $mqdes, $u_msg_ptr, $msg_len,
+			$u_msg_prio, $u_abs_timeout)
+}
+probe syscall.mq_timedreceive.return = kernel.function("sys_mq_timedreceive").return {
+	name = "mq_timedreceive"
+	retstr = returnstr(1)
+}
+
 # mq_timedsend _______________________________________________
-/*
- * asmlinkage long
- * sys_mq_timedsend(mqd_t mqdes,
- *                  const char __user *u_msg_ptr,
- *                  size_t msg_len,
- *                  unsigned int msg_prio,
- *                  const struct timespec __user *u_abs_timeout)
- */
-probe kernel.syscall.mq_timedsend =
-   kernel.function("sys_mq_timedsend") {
-      name = "mq_timedsend"
-      mqdes = $mqdes
-      msg_ptr_uaddr = $u_msg_ptr
-      msg_len = $msg_len
-      msg_prio = $msg_prio
-      abs_timeout_uaddr = $u_abs_timeout
-   }
-probe kernel.syscall.mq_timedsend.return =
-   kernel.function("sys_mq_timedsend").return {
-      name = "mq_timedsend.return"
-   }
+# long sys_mq_timedsend(mqd_t mqdes,
+#                  const char __user *u_msg_ptr,
+#                  size_t msg_len,
+#                  unsigned int msg_prio,
+#                  const struct timespec __user *u_abs_timeout)
+#
+probe syscall.mq_timedsend = kernel.function("sys_mq_timedsend") {
+	name = "mq_timedsend"
+	mqdes = $mqdes
+	msg_ptr_uaddr = $u_msg_ptr
+	msg_len = $msg_len
+	msg_prio = $msg_prio
+	abs_timeout_uaddr = $u_abs_timeout
+	argstr = sprintf("%d, %p, %d, %d, %p", $mqdes, $u_msg_ptr, $msg_len,
+			$msg_prio, $u_abs_timeout)
+}
+probe syscall.mq_timedsend.return = kernel.function("sys_mq_timedsend").return {
+	name = "mq_timedsend"
+	retstr = returnstr(1)
+}
+
 # mq_unlink __________________________________________________
-/*
- * asmlinkage long
- * sys_mq_unlink(const char __user *u_name)
- */
-probe kernel.syscall.mq_unlink =
-   kernel.function("sys_mq_unlink") {
-      name = "mq_unlink"
-      u_name_uaddr = $u_name
-   }
-probe kernel.syscall.mq_unlink.return =
-   kernel.function("sys_mq_unlink").return {
-      name = "mq_unlink.return"
-   }
+# long sys_mq_unlink(const char __user *u_name)
+#
+probe syscall.mq_unlink = kernel.function("sys_mq_unlink") {
+	name = "mq_unlink"
+	u_name_uaddr = $u_name
+	u_name = user_string($u_name)
+	argstr = user_string_quoted($u_name)
+}
+probe syscall.mq_unlink.return = kernel.function("sys_mq_unlink").return {
+	name = "mq_unlink"
+	retstr = returnstr(1)
+}
+
 # mremap _____________________________________________________
-/*
- * asmlinkage unsigned long
- * sys_mremap(unsigned long addr,
- *            unsigned long old_len,
- *            unsigned long new_len,
- *            unsigned long flags,
- *            unsigned long new_addr)
- */
-probe kernel.syscall.mremap =
-   kernel.function("sys_mremap") {
-      name = "mremap"
-      old_address = $addr
-      old_size = $old_len
-      new_size = $new_len
-      flags = $flags
-      new_address = $new_addr
-   }
-probe kernel.syscall.mremap.return =
-   kernel.function("sys_mremap").return {
-      name = "mremap.return"
-   }
+# unsigned long sys_mremap(unsigned long addr,
+#            unsigned long old_len,
+#            unsigned long new_len,
+#            unsigned long flags,
+#            unsigned long new_addr)
+#
+probe syscall.mremap = kernel.function("sys_mremap") {
+	name = "mremap"
+	old_address = $addr
+	old_size = $old_len
+	new_size = $new_len
+	flags = $flags
+	new_address = $new_addr
+	argstr = sprintf("%p, %d, %d, %s, %p", $addr, $old_len, $new_len,
+		_mmap_flags($flags), $new_addr)
+}
+probe syscall.mremap.return = kernel.function("sys_mremap").return {
+	name = "mremap"
+	retstr = returnstr(2)
+}
+
 # msgctl _____________________________________________________
-/*
- * asmlinkage long
- * sys_msgctl (int msqid,
- *             int cmd,
- *             struct msqid_ds __user *buf)
- */
-probe kernel.syscall.msgctl =
-   kernel.function("sys_msgctl") {
-      name = "msgctl"
-      msqid = $msqid
-      cmd = $cmd
-      buf_uaddr = $buf
-   }
-probe kernel.syscall.msgctl.return =
-   kernel.function("sys_msgctl").return {
-      name = "msgctl.return"
-   }
+# long sys_msgctl (int msqid, int cmd, struct msqid_ds __user *buf)
+#
+probe syscall.msgctl = kernel.function("sys_msgctl") {
+	name = "msgctl"
+	msqid = $msqid
+	cmd = $cmd
+	buf_uaddr = $buf
+	argstr = sprintf("%d, %d, %p", $msqid, $cmd, $buf)
+}
+probe syscall.msgctl.return = kernel.function("sys_msgctl").return {
+	name = "msgctl"
+	retstr = returnstr(1)
+}
+
 # msgget _____________________________________________________
-/*
- * asmlinkage long
- * sys_msgget (key_t key,
- *             int msgflg)
- */
-probe kernel.syscall.msgget =
-   kernel.function("sys_msgget") {
-      name = "msgget"
-      key = $key
-      msgflg = $msgflg
-      msgflg_str = _sys_open_flag_str($msgflg)
-   }
-probe kernel.syscall.msgget.return =
-   kernel.function("sys_msgget").return {
-      name = "msgget.return"
-   }
+# long sys_msgget (key_t key, int msgflg)
+#
+probe syscall.msgget = kernel.function("sys_msgget") {
+	name = "msgget"
+	key = $key
+	msgflg = $msgflg
+	msgflg_str = _sys_open_flag_str($msgflg)
+	argstr = sprintf("%d, %s", $key, _sys_open_flag_str($msgflg))
+}
+probe syscall.msgget.return = kernel.function("sys_msgget").return {
+	name = "msgget"
+	retstr = returnstr(1)
+}
+
 # msgrcv _____________________________________________________
-/*
- * asmlinkage long
- * sys_msgrcv (int msqid,
- *             struct msgbuf __user *msgp,
- *             size_t msgsz,
- *             long msgtyp,
- *             int msgflg)
- */
-probe kernel.syscall.msgrcv =
-   kernel.function("sys_msgrcv") {
-      name = "msgrcv"
-      msqid = $msqid
-      msgp_uaddr = $msgp
-      msgsz = $msgsz
-      msgtyp = $msgtyp
-      msgflg = $msgflg
-   }
-probe kernel.syscall.msgrcv.return =
-   kernel.function("sys_msgrcv").return {
-      name = "msgrcv.return"
-   }
+# long sys_msgrcv (int msqid,
+#             struct msgbuf __user *msgp,
+#             size_t msgsz,
+#             long msgtyp,
+#             int msgflg)
+#
+probe syscall.msgrcv = kernel.function("sys_msgrcv") {
+	name = "msgrcv"
+	msqid = $msqid
+	msgp_uaddr = $msgp
+	msgsz = $msgsz
+	msgtyp = $msgtyp
+	msgflg = $msgflg
+	argstr = sprintf("%d, %p, %d, %d, %d", $msqid, $msgp, $msgsz, $msgtyp, $msgflg)
+}
+probe syscall.msgrcv.return = kernel.function("sys_msgrcv").return {
+	name = "msgrcv"
+	retstr = returnstr(1)
+}
+
 # msgsnd _____________________________________________________
-/*
- * asmlinkage long
- * sys_msgsnd (int msqid,
- *             struct msgbuf __user *msgp,
- *             size_t msgsz,
- *             int msgflg)
- */
-probe kernel.syscall.msgsnd =
-   kernel.function("sys_msgsnd") {
-      name = "msgsnd"
-      msqid = $msqid
-      msgp_uaddr = $msgp
-      msgsz = $msgsz
-      msgflg = $msgflg
-   }
-probe kernel.syscall.msgsnd.return =
-   kernel.function("sys_msgsnd").return {
-      name = "msgsnd.return"
-   }
+# long sys_msgsnd (int msqid,
+#             struct msgbuf __user *msgp,
+#             size_t msgsz,
+#             int msgflg)
+#
+probe syscall.msgsnd = kernel.function("sys_msgsnd") {
+	name = "msgsnd"
+	msqid = $msqid
+	msgp_uaddr = $msgp
+	msgsz = $msgsz
+	msgflg = $msgflg
+	argstr = sprintf("%d, %p, %d, %d", $msqid, $msgp, $msgsz, $msgflg)
+}
+probe syscall.msgsnd.return = kernel.function("sys_msgsnd").return {
+	name = "msgsnd"
+	retstr = returnstr(1)}
 
 # msync ______________________________________________________
 # long sys_msync(unsigned long start, size_t len, int flags)
diff --git a/tapset/syscalls2.stp b/tapset/syscalls2.stp
index 1e39c7e0..d0d0e85f 100644
--- a/tapset/syscalls2.stp
+++ b/tapset/syscalls2.stp
@@ -45,7 +45,7 @@ probe syscall.newlstat = kernel.function("sys_newlstat") ?,
 	name = "newlstat"
 	pathname = user_string($filename)
 	buf_uaddr = $statbuf
-	argstr = sprintf("%s, [%p]", 
+	argstr = sprintf("%s, %p", 
 		user_string_quoted($filename), buf_uaddr)  
 }
 probe syscall.newlstat.return = kernel.function("sys_newlstat").return ?,
@@ -62,7 +62,7 @@ probe syscall.newstat = kernel.function("sys_newstat") {
 	name = "stat"
 	pathname = user_string($filename)
 	buf_uaddr = $statbuf
-	argstr = sprintf("%s, [%p]", user_string_quoted($filename), buf_uaddr)
+	argstr = sprintf("%s, %p", user_string_quoted($filename), buf_uaddr)
 }
 probe syscall.newstat.return = kernel.function("sys_newstat").return {
 	name = "stat"
@@ -75,7 +75,7 @@ probe syscall.newstat.return = kernel.function("sys_newstat").return {
 probe syscall.newuname = kernel.function("sys_newuname") {
 	name = "uname"
 	name_uaddr = $name
-	argstr = sprintf("[%p]", name_uaddr)
+	argstr = sprintf("%p", name_uaddr)
 }
 probe syscall.newuname.return = kernel.function("sys_newuname").return {
 	name = "uname"
@@ -93,7 +93,7 @@ probe syscall.nfsservctl = kernel.function("sys_nfsservctl") {
 	cmd = $cmd
 	argp_uaddr = $arg
 	resp_uaddr = $res
-	argstr = sprintf("%p, [%p], [%p]", cmd, argp_uaddr, resp_uaddr)
+	argstr = sprintf("%p, %p, %p", cmd, argp_uaddr, resp_uaddr)
 }
 probe syscall.nfsservctl.return = kernel.function("sys_nfsservctl").return {
 	name = "nfsservctl"
@@ -138,7 +138,7 @@ probe syscall.old_getrlimit = kernel.function("sys_old_getrlimit") {
 	resource = $resource
 	resource_str = _rlimit_resource_str($resource)
 	rlim_uaddr = $rlim
-	argstr = sprintf("%s, [%p]", resource_str, rlim_uaddr)
+	argstr = sprintf("%s, %p", resource_str, rlim_uaddr)
 }
 probe syscall.old_getrlimit.return = kernel.function("sys_old_getrlimit").return {
 	name = "old_getrlimit"
@@ -146,7 +146,7 @@ probe syscall.old_getrlimit.return = kernel.function("sys_old_getrlimit").return
 }
 
 # open _______________________________________________________
-# asmlinkage long sys_open(const char __user * filename, int flags, int mode)
+# long sys_open(const char __user * filename, int flags, int mode)
 probe syscall.open = 
 		kernel.function("sys_open") ?,
 		kernel.function("sys32_open") ?
@@ -157,10 +157,10 @@ probe syscall.open =
 	mode = $mode
 	if (flags & 64)
 		argstr = sprintf("%s, %s, %#o", user_string_quoted($filename), 
-				_sys_open_flag_str($flags), $mode)
+				_sys_open_flag_str(flags), $mode)
 	else
 		argstr = sprintf("%s, %s", user_string_quoted($filename), 
-			_sys_open_flag_str($flags))
+			_sys_open_flag_str(flags))
 }
 probe syscall.open.return = 
 		kernel.function("sys_open").return ?, 
@@ -219,7 +219,7 @@ probe syscall.pause.return = kernel.function("sys_pause").return {
 #	off = $off
 #	len = $len
 #	buf_uaddr = $buf
-#	argstr = sprintf("%p, %p, %p, %d, [%p]", bus, dfn, off,
+#	argstr = sprintf("%p, %p, %p, %d, %p", bus, dfn, off,
 #				len, buf_uaddr)
 #}
 #probe syscall.pciconfig_read.return =
@@ -244,7 +244,7 @@ probe syscall.pause.return = kernel.function("sys_pause").return {
 #	off = $off
 #	len = $len
 #	buf_uaddr = $buf
-#	argstr = sprintf("%p, %p, %p, %d, [%p]", bus, dfn, off,
+#	argstr = sprintf("%p, %p, %p, %d, %p", bus, dfn, off,
 #				len, buf_uaddr)
 #}
 #probe syscall.pciconfig_write.return =
@@ -313,7 +313,7 @@ probe syscall.poll = kernel.function("sys_poll") {
 %:
 	timeout = $timeout
 %)
-	argstr = sprintf("[%p], %d, %d", ufds_uaddr, nfds, timeout)
+	argstr = sprintf("%p, %d, %d", ufds_uaddr, nfds, timeout)
 }
 probe syscall.poll.return = kernel.function("sys_poll").return {
 	name = "poll"
@@ -356,7 +356,7 @@ probe syscall.pread64 = kernel.function("sys_pread64") {
 	buf_uaddr = $buf
 	count = $count
 	offset = $pos
-	argstr = sprintf("%d, [%p], %p, %p", fd, buf_uaddr,
+	argstr = sprintf("%d, %p, %p, %p", fd, buf_uaddr,
 				count, offset)
 }
 probe syscall.pread64.return = kernel.function("sys_pread64").return {
@@ -398,7 +398,7 @@ probe syscall.pwrite64 = kernel.function("sys_pwrite64") {
 	buf_uaddr = $buf
 	count = $count
 	offset = $pos
-	argstr = sprintf("%d, [%p], %p, %p", fd, buf_uaddr,
+	argstr = sprintf("%d, %p, %p, %p", fd, buf_uaddr,
 				count, offset)
 }
 probe syscall.pwrite64.return = kernel.function("sys_pwrite64").return {
@@ -413,7 +413,7 @@ probe syscall.read = kernel.function("sys_read") {
 	fd = $fd
 	buf_uaddr = $buf
 	count = $count
-	argstr = sprintf("%d, [%p], %d", $fd, $buf, $count)
+	argstr = sprintf("%d, %p, %d", $fd, $buf, $count)
 }
 probe syscall.read.return = kernel.function("sys_read").return {
 	name = "read"
@@ -449,7 +449,7 @@ probe syscall.readlink = kernel.function("sys_readlink") {
 	path = user_string($path)
 	buf_uaddr = $buf
 	bufsiz = $bufsiz
-	argstr = sprintf("%s, [%p], %d", user_string_quoted($path), 
+	argstr = sprintf("%s, %p, %d", user_string_quoted($path), 
 			buf_uaddr, bufsiz)
 }
 probe syscall.readlink.return = kernel.function("sys_readlink").return {
@@ -470,9 +470,9 @@ probe syscall.readv = kernel.function("sys_readv") {
 /* FIXME: RHEL4 U3 ppc64 can't resolve $fd */
 %( arch != "ppc64" %?
 	fd = $fd
-	argstr = sprintf("%d, [%p], %d", $fd, $vec, $vlen)
+	argstr = sprintf("%d, %p, %d", $fd, $vec, $vlen)
 %:
-	argstr = sprintf("unknown fd, [%p], %d", $vec, $vlen)
+	argstr = sprintf("unknown fd, %p, %d", $vec, $vlen)
 %)
 }
 probe syscall.readv.return = kernel.function("sys_readv").return {
@@ -496,7 +496,7 @@ probe syscall.reboot = kernel.function("sys_reboot") {
 	flag = $cmd
 	flag_str =  _reboot_flag_str(flag)
 	arg_uaddr = $arg
-	argstr = sprintf("%s, %s, %s, [%p]", magic_str, magic2_str,
+	argstr = sprintf("%s, %s, %s, %p", magic_str, magic2_str,
 				flag_str, arg_uaddr)
 }
 probe syscall.reboot.return = kernel.function("sys_reboot").return {
@@ -522,7 +522,7 @@ probe syscall.recv = kernel.function("sys_recvfrom") {
 	flags_str = _recvflags_str($flags)
 	addr_uaddr = $addr
 	addrlen_uaddr = $addr_len
-	argstr = sprintf("%d, [%p], %p, %s, [%p], %p",
+	argstr = sprintf("%d, %p, %p, %s, %p, %p",
 			s, buf_uaddr, len, flags_str, addr_uaddr,
 			addrlen_uaddr)			
 }
@@ -549,7 +549,7 @@ probe syscall.recvfrom = kernel.function("sys_recvfrom") {
 	flags_str = _recvflags_str($flags)
 	addr_uaddr = $addr
 	addrlen_uaddr = $addr_len
-	argstr = sprintf("%d, [%p], %p, %s, %p, %p",
+	argstr = sprintf("%d, %p, %p, %s, %p, %p",
 				s, buf_uaddr, len, flags_str,
 				addr_uaddr, addrlen_uaddr)
 }
@@ -570,7 +570,7 @@ probe syscall.recvmsg = kernel.function("sys_recvmsg") {
 	msg_uaddr = $msg
 	flags = $flags
 	flags_str = _recvflags_str($flags)
-	argstr = sprintf("%d, [%p], %s", s, msg_uaddr, flags_str)
+	argstr = sprintf("%d, %p, %s", s, msg_uaddr, flags_str)
 }
 probe syscall.recvmsg.return = kernel.function("sys_recvmsg").return {
 	name = "recvmsg"
@@ -664,8 +664,7 @@ probe syscall.rmdir.return = kernel.function("sys_rmdir").return {
 }
 # rt_sigaction _______________________________________________
 #
-# asmlinkage long
-# sys_rt_sigaction(int sig,
+# long sys_rt_sigaction(int sig,
 #			const struct sigaction __user *act,
 #			struct sigaction __user *oact,
 #			size_t sigsetsize)
@@ -677,8 +676,9 @@ probe syscall.rt_sigaction = kernel.function("sys_rt_sigaction") {
 	oact_uaddr = $oact
 	sigsetsize = $sigsetsize
 
-	argstr = sprintf("%s, [%p], [%p], %p", _signal_name($sig),
-			act_uaddr, oact_uaddr, sigsetsize)
+	//FIXME - decode $act
+	argstr = sprintf("%s, %p, %p, %d", _signal_name($sig),
+			$act, $oact, $sigsetsize)
 }
 probe syscall.rt_sigaction.return = kernel.function("sys_rt_sigaction").return {
 	name = "rt_sigaction"
@@ -694,7 +694,7 @@ probe syscall.rt_sigpending = kernel.function("do_sigpending") {
 	name = "rt_sigpending"
 	set_uaddr = $set
 	sigsetsize = $sigsetsize
-	argstr = sprintf("[%p], %p", set_uaddr, sigsetsize)
+	argstr = sprintf("%p, %d", $set, $sigsetsize)
 }
 probe syscall.rt_sigpending.return = kernel.function("do_sigpending").return {
 	name = "rt_sigpending"
@@ -702,8 +702,7 @@ probe syscall.rt_sigpending.return = kernel.function("do_sigpending").return {
 }
 # rt_sigprocmask _____________________________________________
 #
-# asmlinkage long
-# sys_rt_sigprocmask(int how,
+# long sys_rt_sigprocmask(int how,
 #			  sigset_t __user *set,
 #			  sigset_t __user *oset,
 #			  size_t sigsetsize)
@@ -713,16 +712,17 @@ probe syscall.rt_sigprocmask = kernel.function("sys_rt_sigprocmask") {
 	how = $how
 	how_str = _sigprocmask_how_str($how)
 	set_uaddr = $set
+	# FIXME - need to decode $set
 	oset_uaddr = $oset
 	sigsetsize = $sigsetsize
-	argstr = sprintf("%s, [%p], [%p], %p", how_str, set_uaddr,
-				oset_uaddr, sigsetsize)
+	argstr = sprintf("%s, %p, %p, %d", how_str, $set, $oset, $sigsetsize)
 }
 probe syscall.rt_sigprocmask.return =
 	kernel.function("sys_rt_sigprocmask").return {
 	name = "rt_sigprocmask"
 	retstr = returnstr(1)
 }
+
 # rt_sigqueueinfo ____________________________________________
 #
 # asmlinkage long
@@ -735,13 +735,26 @@ probe syscall.rt_sigqueueinfo = kernel.function("sys_rt_sigqueueinfo") {
 	pid = $pid
 	sig = $sig
 	uinfo_uaddr = $uinfo
-	argstr = sprintf("%p, %s, [%p]", pid, _signal_name($sig), uinfo_uaddr)
+	argstr = sprintf("%p, %s, %p", $pid, _signal_name($sig), $uinfo)
 }
 probe syscall.rt_sigqueueinfo.return =
 	kernel.function("sys_rt_sigqueueinfo").return {
 	name = "rt_sigqueueinfo"
 	retstr = returnstr(1)
 }
+
+# rt_sigreturn _______________________________________________
+# int sys_rt_sigreturn(unsigned long __unused)
+#
+probe syscall.rt_sigreturn = kernel.function("sys_rt_sigreturn") {
+	name = "rt_sigreturn"
+	argstr = ""
+}
+probe syscall.rt_sigreturn.return = kernel.function("sys_rt_sigreturn").return {
+	name = "rt_sigreturn"
+	retstr = returnstr(1)
+}
+
 # rt_sigsuspend ______________________________________________
 #
 # asmlinkage int
@@ -771,8 +784,7 @@ probe syscall.rt_sigtimedwait = kernel.function("sys_rt_sigtimedwait") {
 	uinfo_uaddr = $uinfo
 	uts_uaddr = $uts
 	sigsetsize = $sigsetsize
-	argstr = sprintf("[%p], [%p], [%p], %p", uthese_uaddr,
-			uinfo_uaddr, uts_uaddr, sigsetsize)
+	argstr = sprintf("%p, %p, %p, %d", $uthese, $uinfo, $uts, $sigsetsize)
 }
 probe syscall.rt_sigtimedwait.return =
 	kernel.function("sys_rt_sigtimedwait").return {
@@ -791,7 +803,7 @@ probe syscall.sched_getaffinity = kernel.function("sys_sched_getaffinity") {
 	pid = $pid
 	len = $len
 	mask_uaddr = $user_mask_ptr
-	argstr = sprintf("%d, %p, [%p]", pid, len, mask_uaddr)
+	argstr = sprintf("%d, %p, %p", pid, len, mask_uaddr)
 }
 probe syscall.sched_getaffinity.return =
 	kernel.function("sys_sched_getaffinity").return {
@@ -808,7 +820,7 @@ probe syscall.sched_getparam = kernel.function("sys_sched_getparam") {
 	name = "sched_getparam"
 	pid = $pid
 	p_uaddr = $param
-	argstr = sprintf("%d, [%p]", pid, p_uaddr)
+	argstr = sprintf("%d, %p", pid, p_uaddr)
 }
 probe syscall.sched_getparam.return =
 	kernel.function("sys_sched_getparam").return {
@@ -880,10 +892,26 @@ probe syscall.sched_rr_get_interval.return =
 	name = "sched_rr_get_interval"
 	retstr = returnstr(1)
 }
-# sched_yield ________________________________________________
+
+# sched_setaffinity __________________________________________
+# long sys_sched_setaffinity(pid_t pid,
+#	unsigned int len,
+#	unsigned long __user *user_mask_ptr)
 #
-# asmlinkage long
-# sys_sched_yield(void)
+probe syscall.sched_setaffinity = kernel.function("sys_sched_setaffinity") {
+	name = "sched_setaffinity"
+	pid = $pid
+	len = $len
+	mask_uaddr = $user_mask_ptr
+	argstr = sprintf("%d, %d, %p", $pid, $len, $user_mask_ptr)
+}
+probe syscall.sched_setaffinity.return = kernel.function("sys_sched_setaffinity").return {
+	name = "sched_setaffinity"
+	retstr = returnstr(1)
+}
+
+# sched_yield ________________________________________________
+# long sys_sched_yield(void)
 #
 probe syscall.sched_yield = kernel.function("sys_sched_yield") {
 	name = "sched_yield"
@@ -893,10 +921,9 @@ probe syscall.sched_yield.return = kernel.function("sys_sched_yield").return {
 	name = "sched_yield"
 	retstr = returnstr(1)
 }
+
 # select _____________________________________________________
-#
-# asmlinkage long
-# sys_select(int n,
+# long sys_select(int n,
 #		fd_set __user *inp,
 #		fd_set __user *outp,
 #		fd_set __user *exp,
@@ -918,10 +945,9 @@ probe syscall.select.return = kernel.function("sys_select").return {
 	name = "select"
 	retstr = returnstr(1)
 }
+
 # semctl _____________________________________________________
-#
-# asmlinkage long
-# sys_semctl (int semid,
+# long sys_semctl (int semid,
 #		 int semnum,
 #		 int cmd,
 #		 union semun arg)
@@ -941,12 +967,9 @@ probe syscall.semctl.return = kernel.function("sys_semctl").return {
 	name = "semctl"
 	retstr = returnstr(1)
 }
+
 # semget _____________________________________________________
-#
-# asmlinkage long
-# sys_semget (key_t key,
-#		 int nsems,
-#		 int semflg)
+# long sys_semget (key_t key, int nsems, int semflg)
 #
 probe syscall.semget = kernel.function("sys_semget") {
 	name = "semget"
@@ -959,6 +982,7 @@ probe syscall.semget.return = kernel.function("sys_semget").return {
 	name = "semget"
 	retstr = returnstr(1)
 }
+
 # semop ______________________________________________________
 #
 # asmlinkage long
@@ -971,7 +995,7 @@ probe syscall.semop = kernel.function("sys_semtimedop") {
 	semid = $semid
 	tsops_uaddr = $tsops
 	nsops = $nsops
-	argstr = sprintf("%d, [%p], %d", semid, tsops_uaddr, nsops)
+	argstr = sprintf("%d, %p, %d", semid, tsops_uaddr, nsops)
 }
 probe syscall.semop.return = kernel.function("sys_semtimedop").return {
 	name = "semop"
@@ -991,7 +1015,7 @@ probe syscall.semtimedop = kernel.function("sys_semtimedop") {
 	sops_uaddr = $tsops
 	nsops = $nsops
 	timeout_uaddr = $timeout
-	argstr = sprintf("%d, [%p], %d, %s", semid, sops_uaddr, nsops,
+	argstr = sprintf("%d, %p, %d, %s", semid, sops_uaddr, nsops,
 				_struct_timespec_u(timeout_uaddr))
 }
 probe syscall.semtimedop.return = kernel.function("sys_semtimedop").return {
@@ -1017,7 +1041,7 @@ probe syscall.send = kernel.function("sys_sendto") {
 	flags_str = _send_flags_str($flags)
 	to_uaddr = $addr
 	tolen = $addr_len
-	argstr = sprintf("%d, [%p], %s, [%p], %d", $fd, buf_uaddr,
+	argstr = sprintf("%d, %p, %s, %p, %d", $fd, buf_uaddr,
 			flags_str, to_uaddr, $addr_len)
 }
 probe syscall.send.return = kernel.function("sys_sendto").return {
@@ -1037,7 +1061,7 @@ probe syscall.sendfile = kernel.function("sys_sendfile") ?, kernel.function("sys
 	in_fd = $in_fd
 	offset_uaddr = $offset
 	count = $count
-	argstr = sprintf("%d, %d, [%p], %d", $out_fd, $in_fd, offset_uaddr,
+	argstr = sprintf("%d, %d, %p, %d", $out_fd, $in_fd, offset_uaddr,
 				$count)
 }
 probe syscall.sendfile.return = kernel.function("sys_sendfile").return ?,  kernel.function("sys_sendfile64").return ? {
@@ -1058,7 +1082,7 @@ probe syscall.sendmsg = kernel.function("sys_sendmsg") {
 	msg_uaddr = $msg
 	flags = $flags
 	flags_str = _send_flags_str($flags)
-	argstr = sprintf("%d, [%p], %s", $fd, msg_uaddr, flags_str)
+	argstr = sprintf("%d, %p, %s", $fd, msg_uaddr, flags_str)
 }
 probe syscall.sendmsg.return = kernel.function("sys_sendmsg").return {
 	name = "sendmsg"
@@ -1083,7 +1107,7 @@ probe syscall.sendto = kernel.function("sys_sendto") {
 	flags_str = _send_flags_str($flags)
 	to_uaddr = $addr
 	tolen = $addr_len
-	argstr = sprintf("%d, [%p], %d, %s, [%p], %d", $fd, buf_uaddr,
+	argstr = sprintf("%d, %p, %d, %s, %p, %d", $fd, buf_uaddr,
 			$len, flags_str, to_uaddr, $addr_len)
 }
 probe syscall.sendto.return = kernel.function("sys_sendto").return {
@@ -1197,7 +1221,7 @@ probe syscall.setgroups = kernel.function("sys_setgroups") {
 	 *  embedded C if need be.
 	 */
 	list_uaddr = $grouplist
-	argstr = sprintf("%d, [%p]", $gidsetsize, list_uaddr)
+	argstr = sprintf("%d, %p", $gidsetsize, list_uaddr)
 }
 probe syscall.setgroups.return = kernel.function("sys_setgroups").return {
 	name = "setgroups"
@@ -1240,6 +1264,24 @@ probe syscall.setitimer.return = kernel.function("sys_setitimer").return {
 	name = "setitimer"
 	retstr = returnstr(1)
 }
+
+# set_mempolicy ______________________________________________
+# long sys_set_mempolicy(int mode,
+#	unsigned long __user *nmask,
+#	unsigned long maxnode)
+#
+probe syscall.set_mempolicy = kernel.function("sys_set_mempolicy") ? {
+	name = "set_mempolicy"
+	mode = $mode
+	nmask_uaddr = $nmask
+	maxnode = $maxnode
+	argstr = sprintf("%d, %p, %d", $mode, nmask_uaddr, $maxnode)
+}
+probe syscall.set_mempolicy.return = kernel.function("sys_set_mempolicy").return ? {
+	name = "set_mempolicy"
+	retstr = returnstr(1)
+}
+
 # setpgid ____________________________________________________
 #
 # asmlinkage long
@@ -1441,7 +1483,7 @@ probe syscall.setsockopt = kernel.function("sys_setsockopt") {
 	optname_str = _sockopt_optname_str($optname)
 	optval_uaddr = $optval
 	optlen = $optlen
-	argstr = sprintf("%d, %s, %s, [%p], %d", $fd, level_str,
+	argstr = sprintf("%d, %s, %s, %p, %d", $fd, level_str,
 				optname_str, optval_uaddr, $optlen)
 }
 probe syscall.setsockopt.return = kernel.function("sys_setsockopt").return {
@@ -1456,7 +1498,7 @@ probe syscall.setsockopt.return = kernel.function("sys_setsockopt").return {
 probe syscall.set_tid_address = kernel.function("sys_set_tid_address") {
 	name = "set_tid_address"
 	tidptr_uaddr = $tidptr
-	argstr = sprintf("[%p]", tidptr_uaddr)
+	argstr = sprintf("%p", tidptr_uaddr)
 }
 probe syscall.set_tid_address.return =
 	kernel.function("sys_set_tid_address").return {
@@ -1465,21 +1507,13 @@ probe syscall.set_tid_address.return =
 }
 # settimeofday _______________________________________________
 #
-# asmlinkage long
-# sys_settimeofday(struct timeval __user *tv,
+# long sys_settimeofday(struct timeval __user *tv,
 #			struct timezone __user *tz)
 #
 probe syscall.settimeofday = kernel.function("sys_settimeofday") {
 	name = "settimeofday"
 	tv_uaddr = $tv
 	tz_uaddr = $tz
-	/*
-	 * XXX NOT SAFE -- might sleep
-	 * tv_tv_sec	   = __uget_tv_m($tv,0)
-	 * tv_tv_usec	  = __uget_tv_m($tv,1)
-	 * tz_tz_minuteswest = __uget_tz_m($tz,0)
-	 * tz_tz_dsttime     = __uget_tz_m($tz,1)
-	 */
 	argstr = sprintf("%s, %s", _struct_timeval_u($tv),
 				_struct_timezone_u($tz))
 }
@@ -1488,6 +1522,7 @@ probe syscall.settimeofday.return =
 	name = "settimeofday"
 	retstr = returnstr(1)
 }
+
 # setuid _____________________________________________________
 #
 # asmlinkage long
@@ -1517,9 +1552,7 @@ probe syscall.setuid16.return = kernel.function("sys_setuid16").return ? {
 	retstr = returnstr(1)
 }
 # setxattr ___________________________________________________
-#
-# asmlinkage long
-# sys_setxattr(char __user *path,
+# long sys_setxattr(char __user *path,
 #		  char __user *name,
 #		  void __user *value,
 #		  size_t size,
@@ -1534,7 +1567,7 @@ probe syscall.setxattr = kernel.function("sys_setxattr") {
 	value_uaddr = $value
 	size = $size
 	flags = $flags
-	argstr = sprintf("%s, %s, [%p], %d, %d", 
+	argstr = sprintf("%s, %s, %p, %d, %d", 
 			user_string_quoted($path), 
 			user_string_quoted($name),
 			value_uaddr, $size, $flags)
@@ -1567,7 +1600,7 @@ probe syscall.shmctl = kernel.function("sys_shmctl") {
 	shmid = $shmid
 	cmd = $cmd
 	buf_uaddr = $buf
-	argstr = sprintf("%d, %s, [%p]", $shmid, _semctl_cmd($cmd),
+	argstr = sprintf("%d, %s, %p", $shmid, _semctl_cmd($cmd),
 				buf_uaddr)
 }
 probe syscall.shmctl.return = kernel.function("sys_shmctl").return {
@@ -1582,7 +1615,7 @@ probe syscall.shmctl.return = kernel.function("sys_shmctl").return {
 probe syscall.shmdt = kernel.function("sys_shmdt") {
 	name = "shmdt"
 	shmaddr_uaddr = $shmaddr
-	argstr = sprintf("[%p]", shmaddr_uaddr)
+	argstr = sprintf("%p", shmaddr_uaddr)
 }
 probe syscall.shmdt.return = kernel.function("sys_shmdt").return {
 	name = "shmdt"
@@ -1624,30 +1657,26 @@ probe syscall.shutdown.return = kernel.function("sys_shutdown").return {
 	retstr = returnstr(1)
 }
 # signal _____________________________________________________
-#
-# asmlinkage unsigned long
-# sys_signal(int sig,
-#		__sighandler_t handler)
+# unsigned long sys_signal(int sig, __sighandler_t handler)
 #
 probe syscall.signal = kernel.function("sys_signal") {
 	name = "signal"
 	sig = $sig
 	handler = $handler
-	argstr = sprintf("%s, [%p]", _signal_name($sig), $handler)
+	argstr = sprintf("%s, %p", _signal_name($sig), $handler)
 }
 probe syscall.signal.return = kernel.function("sys_signal").return {
 	name = "signal"
 	retstr = returnstr(1)
 }
+
 # sigpending _________________________________________________
-#
-# long do_sigpending(void __user *set,
-#			  unsigned long sigsetsize)
+# long do_sigpending(void __user *set, unsigned long sigsetsize)
 #
 probe syscall.sigpending = kernel.function("do_sigpending") {
 	name = "sigpending"
-	/*
-	 * NOTE
+	/* 
+	 * FIXME
 	 *  set is defined as
 	 *  struct {
 	 *	unsigned long int __val[128];
@@ -1659,16 +1688,15 @@ probe syscall.sigpending = kernel.function("do_sigpending") {
 	 */
 	set_uaddr = $set
 	sigsetsize = $sigsetsize
-	argstr = sprintf("[%p], %d", set_uaddr, $sigsetsize)
+	argstr = sprintf("%p, %d", $set, $sigsetsize)
 }
 probe syscall.sigpending.return = kernel.function("do_sigpending").return {
 	name = "sigpending"
 	retstr = returnstr(1)
 }
+
 # sigprocmask ________________________________________________
-#
-# asmlinkage long
-# sys_sigprocmask(int how,
+# long sys_sigprocmask(int how,
 #		     old_sigset_t __user *set,
 #		     old_sigset_t __user *oset)
 #
@@ -1677,7 +1705,7 @@ probe syscall.sigprocmask = kernel.function("sys_sigprocmask") {
 	how  = $how
 	how_str = _sigprocmask_how_str($how)
 	/*
-	 * NOTE
+	 * FIXME
 	 *  set and oset are  defined as
 	 *  struct {
 	 *	unsigned long int __val[128];
@@ -1689,19 +1717,15 @@ probe syscall.sigprocmask = kernel.function("sys_sigprocmask") {
 	 */
 	set_uaddr    = $set
 	oldset_uaddr = $oset
-	argstr = sprintf("%s, [%p], [%p]", how_str, set_uaddr,
-			oldset_uaddr)
+	argstr = sprintf("%s, %p, %p", how_str, $set, $oset)
 }
 probe syscall.sigprocmask.return = kernel.function("sys_sigprocmask").return {
 	name = "sigprocmask"
 	retstr = returnstr(1)
 }
+
 # socket _____________________________________________________
-#
-# asmlinkage long
-# sys_socket(int family,
-#		int type,
-#		int protocol)
+# long sys_socket(int family, int type, int protocol)
 #
 probe syscall.socket = kernel.function("sys_socket") {
 	name = "socket"
@@ -1728,16 +1752,15 @@ probe syscall.socket.return = kernel.function("sys_socket").return {
 #	name = "socketcall"
 #	call = $call
 #	args_uaddr = $args
-#	argstr = sprintf("%d, [%p]", $call, args_uaddr)
+#	argstr = sprintf("%d, %p", $call, args_uaddr)
 #}
 #probe syscall.socketcall.return = kernel.function("sys_socketcall").return {
 #	name = "socketcall"
 #	retstr = returnstr(1)
 #}
+
 # socketpair _________________________________________________
-#
-# asmlinkage long
-# sys_socketpair(int family,
+# long sys_socketpair(int family,
 #		    int type,
 #		    int protocol,
 #		    int __user *usockvec)
@@ -1748,7 +1771,7 @@ probe syscall.socketpair = kernel.function("sys_socketpair") {
 	type = $type
 	protocol = $protocol
 	sv_uaddr = $usockvec
-	argstr = sprintf("%s, %s, %d, [%p]", 
+	argstr = sprintf("%s, %s, %d, %p", 
 				_sock_family_str($family),
 				_sock_type_str($type),
 				$protocol, sv_uaddr)
@@ -1783,7 +1806,7 @@ probe syscall.stat =
 	filename_uaddr = $filename
 	filename = user_string($filename)
 	buf_uaddr = $statbuf
-	argstr = sprintf("%s, [%p]", user_string_quoted($filename), buf_uaddr)
+	argstr = sprintf("%s, %p", user_string_quoted($filename), buf_uaddr)
 }
 probe syscall.stat.return = 
 		kernel.function("sys_stat").return ?, 
@@ -1800,7 +1823,7 @@ probe syscall.statfs = kernel.function("sys_statfs") {
 	name = "statfs"
 	path = user_string($path)
 	buf_uaddr = $buf
-	argstr = sprintf("%s, [%p]", user_string_quoted($path), $buf)
+	argstr = sprintf("%s, %p", user_string_quoted($path), $buf)
 }
 probe syscall.statfs.return = kernel.function("sys_statfs").return {
 	name = "statfs"
@@ -1818,7 +1841,7 @@ probe syscall.statfs64 = kernel.function("sys_statfs64") {
 	path = user_string($path)
 	sz = $sz
 	buf_uaddr = $buf
-	argstr = sprintf("%s, %d, [%p]", user_string_quoted($path), $sz, $buf) 
+	argstr = sprintf("%s, %d, %p", user_string_quoted($path), $sz, $buf) 
 }
 probe syscall.statfs64.return = kernel.function("sys_statfs64").return {
 	name = "statfs64"
@@ -1834,7 +1857,7 @@ probe syscall.stime = kernel.function("sys_stime") {
 	t_uaddr = $tptr
 	
 	/* Fixme, should just use get_user? */
-	argstr = sprintf("[%p]", t_uaddr)
+	argstr = sprintf("%p", t_uaddr)
 }
 probe syscall.stime.return = kernel.function("sys_stime").return {
 	name = "stime"
@@ -1905,7 +1928,7 @@ probe syscall.sync.return = kernel.function("sys_sync").return {
 probe syscall.sysctl = kernel.function("sys_sysctl") {
 	name = "sysctl"
 	args_uaddr = $args
-	argstr = sprintf("[%p]", args_uaddr)
+	argstr = sprintf("%p", args_uaddr)
 }
 probe syscall.sysctl.return = kernel.function("sys_sysctl").return {
 	name = "sysctl"
@@ -1937,7 +1960,7 @@ probe syscall.sysfs.return = kernel.function("sys_sysfs").return {
 probe syscall.sysinfo = kernel.function("sys_sysinfo") {
 	name = "sysinfo"
 	info_uaddr = $info
-	argstr = sprintf("[%p]", info_uaddr)
+	argstr = sprintf("%p", info_uaddr)
 }
 probe syscall.sysinfo.return = kernel.function("sys_sysinfo").return {
 	name = "sysinfo"
@@ -1955,7 +1978,7 @@ probe syscall.syslog = kernel.function("do_syslog") {
 	type = $type
 	bufp_uaddr = $buf
 	len = $len
-	argstr = sprintf("%d, [%p], %d", $type, bufp_uaddr, $len)
+	argstr = sprintf("%d, %p, %d", $type, bufp_uaddr, $len)
 }
 probe syscall.syslog.return = kernel.function("do_syslog").return {
 	name = "syslog"
@@ -1981,23 +2004,21 @@ probe syscall.tgkill.return = kernel.function("sys_tgkill").return {
 }
 # time _______________________________________________________
 #
-# asmlinkage long
-# sys_time(time_t __user * tloc)
+# long sys_time(time_t __user * tloc)
 #
 probe syscall.time = kernel.function("sys_time") {
 	name = "time"
 	t_uaddr = $tloc
-	/* FIXME */
-	argstr = sprintf("[%p]", t_uaddr)
+	argstr = sprintf("%p", $tloc)
 }
 probe syscall.time.return = kernel.function("sys_time").return {
 	name = "time"
 	retstr = returnstr(1)
 }
+
 # timer_create _______________________________________________
 #
-# asmlinkage long
-# sys_timer_create(clockid_t which_clock,
+# long sys_timer_create(clockid_t which_clock,
 #			struct sigevent __user *timer_event_spec,
 #			timer_t __user * created_timer_id)
 #
@@ -2007,22 +2028,17 @@ probe syscall.timer_create = kernel.function("sys_timer_create") {
 	clockid_str = _get_wc_str($which_clock)
 	evp_uaddr = $timer_event_spec
 	timerid_uaddr = $created_timer_id
-	/*
-	 * XXX NOT SAFE -- might sleep
-	 * timerid = __uget_num($created_timer_id)
-	 */
-	argstr = sprintf("%d, [%p], [%p]", $which_clock, evp_uaddr,
-				timerid_uaddr)
+	argstr = sprintf("%s, %p, %p", clockid_str, $timer_event_spec, $created_timer_id)
 }
 probe syscall.timer_create.return =
 	kernel.function("sys_timer_create").return {
 	name = "timer_create"
 	retstr = returnstr(1)
 }
+
 # timer_delete _______________________________________________
 #
-# asmlinkage long
-# sys_timer_delete(timer_t timer_id)
+# long sys_timer_delete(timer_t timer_id)
 #
 probe syscall.timer_delete = kernel.function("sys_timer_delete") {
 	name = "timer_delete"
@@ -2033,10 +2049,10 @@ probe syscall.timer_delete.return = kernel.function("sys_timer_delete").return {
 	name = "timer_delete"
 	retstr = returnstr(1)
 }
+
 # timer_getoverrun ___________________________________________
 #
-# asmlinkage long
-# sys_timer_getoverrun(timer_t timer_id)
+# long sys_timer_getoverrun(timer_t timer_id)
 #
 probe syscall.timer_getoverrun = kernel.function("sys_timer_getoverrun") {
 	name = "timer_getoverrun"
@@ -2048,28 +2064,27 @@ probe syscall.timer_getoverrun.return =
 	name = "timer_getoverrun"
 	retstr = returnstr(1)
 }
+
 # timer_gettime ______________________________________________
 #
-# asmlinkage long
-# sys_timer_gettime(timer_t timer_id,
+# long sys_timer_gettime(timer_t timer_id,
 #			 struct itimerspec __user *setting)
 #
 probe syscall.timer_gettime = kernel.function("sys_timer_gettime") {
 	name = "timer_gettime"
 	timerid = $timer_id
 	value_uaddr = $setting
-	argstr = sprintf("%d, %s", $timer_id,
-				_struct_timespec_u($setting))
+	argstr = sprintf("%d, %p", $timer_id, $setting)
 }
 probe syscall.timer_gettime.return =
 	kernel.function("sys_timer_gettime").return {
 	name = "timer_gettime"
 	retstr = returnstr(1)
 }
+
 # timer_settime ______________________________________________
 #
-# asmlinkage long
-# sys_timer_settime(timer_t timer_id,
+# long sys_timer_settime(timer_t timer_id,
 #			 int flags,
 #			 const struct itimerspec __user *new_setting,
 #			 struct itimerspec __user *old_setting)
@@ -2080,19 +2095,19 @@ probe syscall.timer_settime = kernel.function("sys_timer_settime") {
 	flags = $flags
 	value_uaddr  = $new_setting
 	ovalue_uaddr = $old_setting
-	argstr = sprintf("%d, %d, %s, %s", $timer_id, $flags,
+	argstr = sprintf("%d, %d, %s, %p", $timer_id, $flags,
 				_struct_itimerspec_u($new_setting),
-				_struct_itimerspec_u($old_setting))
+				$old_setting)
 }
 probe syscall.timer_settime.return =
 	kernel.function("sys_timer_settime").return {
 	name = "timer_settime"
 	retstr = returnstr(1)
 }
+
 # times ______________________________________________________
 #
-# asmlinkage long
-# sys_times(struct tms __user * tbuf)
+# long sys_times(struct tms __user * tbuf)
 #
 probe syscall.times = kernel.function("sys_times") {
 	name = "times"
@@ -2104,12 +2119,13 @@ probe syscall.times = kernel.function("sys_times") {
 	 * buf_tms_cutime = __uget_tms_m($tbuf,2)
 	 * buf_tms_cstime = __uget_tms_m($tbuf,3)
 	 */
-	argstr = sprintf("[%p]", buf_uaddr) 
+	argstr = sprintf("%p", buf_uaddr) 
 }
 probe syscall.times.return = kernel.function("sys_times").return {
 	name = "times"
 	retstr = returnstr(1)
 }
+
 # tkill ______________________________________________________
 #
 # asmlinkage long
@@ -2145,6 +2161,33 @@ probe syscall.truncate.return = kernel.function("sys_truncate").return ?, kernel
 	retstr = returnstr(1)
 }
 
+# tux ________________________________________________________
+# long sys_tux (unsigned int action, user_req_t *u_info)
+#
+probe syscall.tux = kernel.function("sys_tux") ? {
+	name = "tux"
+	action = $action
+	u_info_uaddr = $u_info
+	argstr = sprintf("%d, %p", $action, $u_info)
+}
+probe syscall.tux.return = kernel.function("sys_tux").return ? {
+	name = "tux"
+	retstr = returnstr(1)
+}
+
+# umask ______________________________________________________
+# long sys_umask(int mask)
+#
+probe syscall.umask = kernel.function("sys_umask") {
+	name = "umask"
+	mask = $mask
+	argstr = sprintf("%#o", $mask)
+}
+probe syscall.umask.return = kernel.function("sys_umask").return {
+	name = "umask"
+	retstr = returnstr(3)
+}
+
 # umount _____________________________________________________
 # long sys_umount(char __user * name, int flags)
 #
@@ -2209,7 +2252,7 @@ probe syscall.ustat = kernel.function("sys_ustat") {
 	name = "ustat"
 	dev = $dev
 	ubuf_uaddr = $ubuf
-	argstr = sprintf("%d, [%p]", $dev, ubuf_uaddr)
+	argstr = sprintf("%d, %p", $dev, ubuf_uaddr)
 }
 probe syscall.ustat.return = kernel.function("sys_ustat").return {
 	name = "ustat"
@@ -2277,7 +2320,7 @@ probe syscall.wait4 = kernel.function("sys_wait4") {
 	options = $options
 	options_str = _wait4_opt_str($options)
 	rusage_uaddr = $ru
-	argstr = sprintf("%d, [%p], %s, [%p]", $pid, status_uaddr,
+	argstr = sprintf("%d, %p, %s, %p", $pid, status_uaddr,
 					options_str, rusage_uaddr)
 					
 }
@@ -2303,7 +2346,7 @@ probe syscall.waitid = kernel.function("sys_waitid") {
 	options = $options
 	options_str = _wait4_opt_str($options)
 	rusage_uaddr = $ru
-	argstr = sprintf("%d, %d, [%p], %s, [%p]", $which, $pid,
+	argstr = sprintf("%d, %d, %p, %s, %p", $which, $pid,
 				infop_uaddr, options_str, rusage_uaddr)
 }
 probe syscall.waitid.return = kernel.function("sys_waitid").return {
@@ -2326,7 +2369,7 @@ probe syscall.waitpid = kernel.function("sys_wait4") {
 	options = $options
 	options_str = _wait4_opt_str($options)
 	rusage_uaddr = $ru
-	argstr = sprintf("%d, [%p], %s, [%p]", $pid, status_uaddr,
+	argstr = sprintf("%d, %p, %s, %p", $pid, status_uaddr,
 				options_str, rusage_uaddr)
 }
 probe syscall.waitpid.return = kernel.function("sys_wait4").return {
@@ -2364,9 +2407,9 @@ probe syscall.writev = kernel.function("sys_writev") {
 /* FIXME: RHEL4 U3 ppc64 can't resolve $fd */ 
 %( arch != "ppc64" %?
 	fd = $fd
-	argstr = sprintf("%d, [%p], %d", $fd, $vec, $vlen)
+	argstr = sprintf("%d, %p, %d", $fd, $vec, $vlen)
 %:
-	argstr = sprintf("unknown fd, [%p], %d", $vec, $vlen)
+	argstr = sprintf("unknown fd, %p, %d", $vec, $vlen)
 %)
 }
 probe syscall.writev.return = kernel.function("sys_writev").return {
diff --git a/tapset/x86_64/syscalls.stp b/tapset/x86_64/syscalls.stp
index ffe6df40..c5d2d3b1 100644
--- a/tapset/x86_64/syscalls.stp
+++ b/tapset/x86_64/syscalls.stp
@@ -4,7 +4,7 @@ probe syscall.getgroups16 = kernel.function("sys_getgroups16") {
 	name = "getgroups16"
 	size = $gidsetsize
 	list_uaddr = $grouplist
-	argstr = sprintf("%d, [%p]", size, list_uaddr)
+	argstr = sprintf("%d, %p", size, list_uaddr)
 }
 probe syscall.getgroups16.return = kernel.function("sys_getgroups16").return {
 	name = "getgroups16"
@@ -29,37 +29,6 @@ probe syscall.setgroups16.return = kernel.function("sys_setgroups16").return {
 }
 
 
-# acct _______________________________________________________
-# long sys_acct(const char __user *name)
-probe syscall.acct = kernel.function("sys_acct") {
-	name = "acct"
-        filename = user_string($name)
-	argstr = filename
-}
-probe syscall.acct.return = kernel.function("sys_acct").return {
-	name = "acct"
-	retstr = returnstr(1)
-}
-
-# add_key ____________________________________________________
-# long sys_add_key(const char __user *_type,
-#             const char __user *_description,
-#             const void __user *_payload,
-#             size_t plen,
-#             key_serial_t ringid)
-#probe syscall.add_key = kernel.function("sys_add_key") {
-#	name = "add_key"
-#	type_uaddr = $_type
-#	description_auddr = $_description
-#	payload_uaddr = $_payload
-#	plen = $plen
-#	ringid = $ringid
-#	argstr = "add_key"
-#}
-#probe syscall.add_key.return = kernel.function("sys_add_key").return {
-#	name = "add_key"
-#	retstr = returnstr(1)
-#}
 
 # quotactl ___________________________________________________
 #
@@ -76,7 +45,7 @@ probe syscall.quotactl = kernel.function("sys_quotactl") {
 	special_str = user_string($special)
 	id = $id
 	addr_uaddr = $addr
-	argstr = sprintf("%s, %s, %p, [%p]", cmd_str, special_str,
+	argstr = sprintf("%s, %s, %p, %p", cmd_str, special_str,
 				id, addr_uaddr)
 }
 probe syscall.quotactl.return = kernel.function("sys_quotactl").return {
@@ -97,7 +66,7 @@ probe syscall.request_key = kernel.function("sys_request_key") {
 	description_uaddr = $_description
 	callout_info_uaddr = $_callout_info
 	destringid = $destringid
-	argstr = sprintf("[%p], [%p], [%p], %p", type_uaddr,
+	argstr = sprintf("%p, %p, %p, %p", type_uaddr,
 			description_uaddr, callout_info_uaddr, destringid)
 }
 probe syscall.request_key.return = kernel.function("sys_request_key").return {
@@ -105,209 +74,66 @@ probe syscall.request_key.return = kernel.function("sys_request_key").return {
 	retstr = returnstr(1)
 }
 
+
+# arch_prctl _________________________________________________
+# long sys_arch_prctl(int code, unsigned long addr)
 #
-# OLD STUFF here, need more works
+# NOTE: x86_64 only.
 #
-# arch_prctl _________________________________________________
-/*
- * long sys_arch_prctl(int code,
- *                     unsigned long addr)
- */
-probe kernel.syscall.arch_prctl =
-	kernel.function("sys_arch_prctl") {
+probe syscall.arch_prctl = kernel.function("sys_arch_prctl") {
 	name = "arch_prctl"
 	code = $code
 	addr = $addr
 	argstr = sprintf("%d, %p", $code, $addr)
 }
-probe kernel.syscall.arch_prctl.return =
-   kernel.function("sys_arch_prctl").return {
+probe syscall.arch_prctl.return = kernel.function("sys_arch_prctl").return {
 	name = "arch_prctl"
 	retstr = returnstr(1)
 }
-# get_mempolicy ______________________________________________
-/*
- * asmlinkage long
- * sys_get_mempolicy(int __user *policy,
- *                   unsigned long __user *nmask,
- *                   unsigned long maxnode,
- *                   unsigned long addr,
- *                   unsigned long flags)
- */
-probe kernel.syscall.get_mempolicy =
-	kernel.function("sys_get_mempolicy") {
-	name = "get_mempolicy"
-	policy_uaddr = $policy
-	nmask_uaddr = $nmask
-	maxnode = $maxnode
-	addr = $addr
-	flags = $flags
-	argstr = sprintf("[%p], [%p], %d, %p, %d", policy_uaddr,
-			nmask_uaddr, $maxnode, $addr, $flags)
-}
-probe kernel.syscall.get_mempolicy.return =
-	kernel.function("sys_get_mempolicy").return {
-	name = "get_mempolicy"
-	retstr = returnstr(1)
-}
+
 # iopl _______________________________________________________
-/*
- * asmlinkage long
- * sys_iopl(unsigned long unused)
- */
-probe kernel.syscall.iopl = kernel.function("sys_iopl") {
+# long sys_iopl(unsigned int level, struct pt_regs *regs);
+# NOTE. This function is only in i386 and x86_64 and its args vary
+# between those two archs.
+#
+probe syscall.iopl = kernel.function("sys_iopl") {
 	name = "iopl"
 	level = $level
 	argstr = sprint($level)	
 }
-probe kernel.syscall.iopl.return = kernel.function("sys_iopl").return {
+probe syscall.iopl.return = kernel.function("sys_iopl").return {
 	name = "iopl"
 	retstr = returnstr(1)
 }
-# mbind ______________________________________________________
-/*
- * asmlinkage long
- * sys_mbind(unsigned long start,
- *           unsigned long len,
- *           unsigned long mode,
- *           unsigned long __user *nmask,
- *           unsigned long maxnode,
- *           unsigned flags)
- */
-probe kernel.syscall.mbind = kernel.function("sys_mbind") {
-	name = "mbind"
-	start = $start
-	len = $len
-	mode = $mode
-	nmask_uaddr = $nmask
-	maxnode = $maxnode
-	flags = $flags
-	argstr = sprintf("%d, %d, %d, [%p], %d, %d", $start, $len, $mode,
-				nmask_uaddr, $maxnode, $flags)
-}
-probe kernel.syscall.mbind.return = kernel.function("sys_mbind").return {
-	name = "mbind"
-	retstr = returnstr(1)
-}
 
-# rt_sigreturn _______________________________________________
-/*
- * asmlinkage int
- * sys_rt_sigreturn(unsigned long __unused)
- */
-probe kernel.syscall.rt_sigreturn = kernel.function("sys_rt_sigreturn") {
-	name = "rt_sigreturn"
-	regs = $regs
-	argstr = ""
-}
-probe kernel.syscall.rt_sigreturn.return =
-	kernel.function("sys_rt_sigreturn").return {
-	name = "rt_sigreturn"
-	retstr = returnstr(1)
-}
-# sched_setaffinity __________________________________________
-/*
- * asmlinkage long
- * sys_sched_setaffinity(pid_t pid,
- *                       unsigned int len,
- *                       unsigned long __user *user_mask_ptr)
- */
-probe kernel.syscall.sched_setaffinity =
-	kernel.function("sys_sched_setaffinity") {
-	name = "sched_setaffinity"
-	pid = $pid
-	len = $len
-	/*
-	 * doesnt like $len on x86_64 ????
-	 */
-	mask_uaddr = $user_mask_ptr
-	argstr = sprintf("%d, %d, [%p]", $pid, $len, mask_uaddr)
-}
-probe kernel.syscall.sched_setaffinity.return =
-	kernel.function("sys_sched_setaffinity").return {
-	name = "sched_setaffinity"
-	retstr = returnstr(1)
-}
-# set_mempolicy ______________________________________________
-/*
- * asmlinkage long
- * sys_set_mempolicy(int mode,
- *                   unsigned long __user *nmask,
- *                   unsigned long maxnode)
- */
-probe kernel.syscall.set_mempolicy = kernel.function("sys_set_mempolicy") {
-	name = "set_mempolicy"
-	mode = $mode
-	nmask_uaddr = $nmask
-	maxnode = $maxnode
-	argstr = sprintf("%d, [%p], %d", $mode, nmask_uaddr, $maxnode)
-}
-probe kernel.syscall.set_mempolicy.return =
-   kernel.function("sys_set_mempolicy").return {
-	name = "set_mempolicy"
-	retstr = returnstr(1)
-}
 # sigaltstack ________________________________________________
-/*
- * asmlinkage int
- * sys_sigaltstack(unsigned long ebx)
- */
-probe kernel.syscall.sigaltstack = kernel.function("sys_sigaltstack") {
+# long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
+#		struct pt_regs *regs)
+#
+# NOTE: args vary between archs.
+#
+probe syscall.sigaltstack = kernel.function("sys_sigaltstack") {
 	name = "sigaltstack"
 	uss_uaddr = $uss
 	uoss_uaddr = $uoss
 	regs_uaddr = $regs
-	argstr = sprintf("[%p], [%p]", uss_uaddr, uoss_uaddr)
+	argstr = sprintf("%p, %p", $uss, $uoss)
 }
-probe kernel.syscall.sigaltstack.return =
-	kernel.function("sys_sigaltstack").return {
+probe syscall.sigaltstack.return = kernel.function("sys_sigaltstack").return {
 	name = "sigaltstack"
 	retstr = returnstr(1)
 }
+
 # time64 _____________________________________________________
-/*
- * asmlinkage long
- * sys_time64(long __user * tloc)
- */
-probe kernel.syscall.time64 = kernel.function("sys_time64") {
+# long sys_time64(long __user * tloc)
+#
+probe syscall.time64 = kernel.function("sys_time64") {
 	name = "time64"
 	t_uaddr = $tloc
-	argstr = sprintf("[%p]", t_uaddr)
+	argstr = sprintf("%p", $tloc)
 }
-probe kernel.syscall.time64.return = kernel.function("sys_time64").return {
+probe syscall.time64.return = kernel.function("sys_time64").return {
 	name = "time64"
 	retstr = returnstr(1)
 }
-# tux ________________________________________________________
-/*
- * asmlinkage long
- * sys_tux (unsigned int action,
- *          user_req_t *u_info)
- */
-#probe kernel.syscall.tux = kernel.function("sys_tux") {
-#	name = "tux"
-#	action = $action
-#	u_info_uaddr = $u_info
-#	argstr = sprintf("%d, [%p]", $action, u_info_uaddr)
-#}
-#probe kernel.syscall.tux.return = kernel.function("sys_tux").return {
-#	name = "tux"
-#	retstr = returnstr(1)
-#}
-
-# umask ______________________________________________________
-/*
- * asmlinkage long
- * sys_umask(int mask)
- */
-probe syscall.umask = kernel.function("sys_umask") {
-	name = "umask"
-	mask = $mask
-	argstr = sprintf("%#o", $mask)
-}
-probe syscall.umask.return =
-	kernel.function("sys_umask").return {
-	name = "umask"
-	retstr = returnstr(3)
-}