From: Martin Cermak <mcermak@redhat.com>
Date: Wed, 27 May 2015 06:32:58 +0000 (+0200)
Subject: Syscall tapset cleanup
X-Git-Tag: release-2.8~50
X-Git-Url: https://sourceware.org/git/?a=commitdiff_plain;h=35bd6e1548e93134208a970cfdbd6c6e79f3eb0d;p=systemtap.git

Syscall tapset cleanup

* tapset/linux/syscalls.stpm: New macros, add pragma comments
* tapset/linux/syscalls[2].stp: Cleanup
---

diff --git a/tapset/linux/syscalls.stp b/tapset/linux/syscalls.stp
index eeccddb73..e49cdd695 100644
--- a/tapset/linux/syscalls.stp
+++ b/tapset/linux/syscalls.stp
@@ -1742,25 +1742,18 @@ probe syscall.fsync.return = kernel.function("sys_fsync").return
 # long sys_ftruncate(unsigned int fd, unsigned long length)
 # COMPAT_SYSCALL_DEFINE2(ftruncate, unsigned int, fd, compat_ulong_t, length)
 #
-probe syscall.ftruncate = __syscall.ftruncate, __syscall.compat_ftruncate ?
+probe syscall.ftruncate = __syscall.ftruncate,
+	kernel.function("compat_sys_ftruncate").call ?
 {
 	name = "ftruncate"
 	fd = __int32($fd)
+	length = @__compat_long($length)
 	argstr = sprintf("%d, %d", fd, length)
 }
 probe __syscall.ftruncate = kernel.function("sys_ftruncate").call
 {
 	@__syscall_compat_gate(%{ __NR_ftruncate %}, 
 			       %{ __NR_compat_ftruncate %})
-	if (%{ /* pure */ _stp_is_compat_task() %})
-		length = __int32($length)
-	else
-		length = __long($length)
-}
-probe __syscall.compat_ftruncate =
-	kernel.function("compat_sys_ftruncate").call ?
-{
-	length = __int32($length)
 }
 probe syscall.ftruncate.return = __syscall.ftruncate.return,
 	kernel.function("compat_sys_ftruncate").return ?
@@ -2745,29 +2738,24 @@ probe syscall.io_destroy.return = kernel.function("sys_io_destroy").return
 #		 struct io_event __user *events,
 #		 struct compat_timespec __user *timeout)
 #
-probe syscall.io_getevents = __syscall.io_getevents,
-	__syscall.compat_io_getevents ?
+probe syscall.io_getevents = __syscall.io_getevents ?,
+	kernel.function("compat_sys_io_getevents").call ?
 {
 	name = "io_getevents"
         ctx_id = __ulong($ctx_id)
 	events_uaddr = $events
 	timeout_uaddr = $timeout
+	nr = @__compat_long($nr)
+	min_nr = @__compat_long($min_nr)
+	timestr = (@__compat_task ?
+	           _struct_compat_timespec_u($timeout, 1) :
+	           _struct_timespec_u($timeout, 1))
 	argstr = sprintf("%u, %d, %d, %p, %s", ctx_id, min_nr,
 		nr, events_uaddr, timestr)
 }
-probe __syscall.io_getevents = kernel.function("sys_io_getevents").call ?
+probe __syscall.io_getevents = kernel.function("sys_io_getevents").call
 {
 	@__syscall_gate(%{ __NR_io_getevents %})
-	nr = $nr
-	min_nr = $min_nr
-	timestr = _struct_timespec_u($timeout, 1)
-}
-probe __syscall.compat_io_getevents =
-	kernel.function("compat_sys_io_getevents").call ?
-{
-	nr = __int32($nr)
-	min_nr = __int32($min_nr)
-	timestr = _struct_compat_timespec_u($timeout, 1)
 }
 probe syscall.io_getevents.return = __syscall.io_getevents.return,
 	kernel.function("compat_sys_io_getevents").return ?
@@ -2837,22 +2825,17 @@ probe __syscall.io_setup.return = kernel.function("sys_io_setup").return
 # long sys_io_submit(aio_context_t ctx_id, long nr, struct iocb __user * __user *iocbpp)
 #
 probe syscall.io_submit = __syscall.io_submit,
-	__syscall.compat_io_submit ?
+	kernel.function("compat_sys_io_submit").call ?
 {
 	name = "io_submit"
 	ctx_id = __ulong($ctx_id)
+	nr = @__compat_long($nr)
+	iocbpp_uaddr = @choose_defined($iocbpp, $iocb)
 	argstr = sprintf("%u, %d, %p", ctx_id, nr, iocbpp_uaddr)
 }
 probe __syscall.io_submit = kernel.function("sys_io_submit").call
 {
 	@__syscall_gate(%{ __NR_io_submit%})
-	nr = $nr
-	iocbpp_uaddr = $iocbpp
-}
-probe __syscall.compat_io_submit = kernel.function("compat_sys_io_submit").call
-{
-	nr = __int32($nr)
-	iocbpp_uaddr = $iocb
 }
 probe syscall.io_submit.return = __syscall.io_submit.return,
 	kernel.function("compat_sys_io_submit").return ?
@@ -2953,17 +2936,10 @@ probe syscall.keyctl = kernel.function("compat_sys_keyctl").call ?,
 {
 	name = "keyctl"
 	option = __int32($option)
-	if (%{ /* pure */ _stp_is_compat_task() %}) {
-		arg2 = __uint32($arg2)
-		arg3 = __uint32($arg3)
-		arg4 = __uint32($arg4)
-		arg5 = __uint32($arg5)
-	} else {
-		arg2 = __ulong($arg2)
-		arg3 = __ulong($arg3)
-		arg4 = __ulong($arg4)
-		arg5 = __ulong($arg5)
-	}
+	arg2 = @__compat_ulong($arg2)
+	arg3 = @__compat_ulong($arg3)
+	arg4 = @__compat_ulong($arg4)
+	arg5 = @__compat_ulong($arg5)
 	@__keyctl_argstr(option, arg2, arg3, arg4, arg5)
 }
 probe syscall.keyctl.return = kernel.function("compat_sys_keyctl").return ?,
@@ -3266,24 +3242,15 @@ probe syscall.lremovexattr.return = kernel.function("sys_lremovexattr").return
 # COMPAT_SYSCALL_DEFINE3(lseek, unsigned int, fd, compat_off_t, offset,
 #			 unsigned int, whence)
 #
-probe syscall.lseek = __syscall.lseek, __syscall.compat_lseek ?
+probe syscall.lseek = kernel.function("sys_lseek").call ?,
+                      kernel.function("compat_sys_lseek").call ?
 {
 	name = "lseek"
-	argstr = sprintf("%d, %d, %s", fildes, offset, whence_str)
-}
-probe __syscall.lseek = kernel.function("sys_lseek").call
-{
 	fildes = __int32($fd)
-	offset = $offset
-	whence = @choose_defined($whence, $origin)
-	whence_str = _seek_whence_str(@choose_defined($whence, $origin))
-}
-probe __syscall.compat_lseek = kernel.function("compat_sys_lseek").call
-{
-	fildes = __int32($fd)
-	offset = __int32($offset)
-	whence = __uint32(@choose_defined($whence, $origin))
+	offset = @__compat_long($offset)
+	whence = @__compat_ulong(@choose_defined($whence, $origin))
 	whence_str = _seek_whence_str(whence)
+	argstr = sprintf("%d, %d, %s", fildes, offset, whence_str)
 }
 probe syscall.lseek.return = kernel.function("sys_lseek").return,
 			     kernel.function("compat_sys_lseek").return ?
@@ -3399,13 +3366,8 @@ probe syscall.mbind = __syscall.mbind ?,
 	nmask_uaddr = $nmask
 	flags = __uint32($flags)
 	flags_str = _mempolicy_flags_str(flags)
-	if (%{ /* pure */ _stp_is_compat_task() %}) {
-		len = __uint32($len)
-		maxnode = __uint32($maxnode)
-	} else {
-		len = $len
-		maxnode = $maxnode
-	}
+	len = @__compat_ulong($len)
+	maxnode = @__compat_ulong($maxnode)
 	argstr = sprintf("%p, %u, %s, %p, %u, %s", start, len,
 	                 mode_str, nmask_uaddr, maxnode, flags_str)
 }
@@ -3455,7 +3417,7 @@ probe syscall.migrate_pages = __syscall.migrate_pages ?,
 	pid = __int32($pid)
 	old_nodes = $old_nodes
 	new_nodes = $new_nodes
-	if (%{ /* pure */ _stp_is_compat_task() %}) {
+	if (@__compat_task) {
 		maxnode = __uint32($maxnode)
 	} else {
 		maxnode = $maxnode
@@ -3641,30 +3603,22 @@ probe syscall.modify_ldt.return = kernel.function("sys_modify_ldt").return ?
 #                int flags)
 #
 probe syscall.move_pages = __syscall.move_pages ?,
-                           __syscall.compat_move_pages ?
+                           kernel.function("compat_sys_move_pages").call ?
 {
 	name = "move_pages"
+	pages = @choose_defined($pages32, $pages)
 	pid = __int32($pid)
 	nodes = $nodes
 	status = $status
 	flags = __int32($flags)
 	flags_str = _mempolicy_flags_str(flags)
-	if (%{ /* pure */ _stp_is_compat_task() %}) {
-		nr_pages = __uint32($nr_pages)
-	} else {
-		nr_pages = $nr_pages
-	}
+	nr_pages = @__compat_ulong($nr_pages)
 	argstr = sprintf("%d, %u, %p, %p, %p, %s", pid, nr_pages, pages,
 	                 nodes, status, flags_str)
 }
 probe __syscall.move_pages = kernel.function("sys_move_pages").call
 {
 	@__syscall_gate(%{ __NR_move_pages %})
-	pages = $pages
-}
-probe __syscall.compat_move_pages = kernel.function("compat_sys_move_pages").call
-{
-	pages = $pages32
 }
 probe syscall.move_pages.return = __syscall.move_pages.return ?,
                                   kernel.function("compat_sys_move_pages").return ?
@@ -3833,13 +3787,14 @@ probe __syscall.mq_notify.return = kernel.function("sys_mq_notify").return
 #			struct compat_mq_attr __user *u_attr)
 #
 probe syscall.mq_open = __syscall.mq_open,
-                        __syscall.compat_mq_open ?
+                        kernel.function("compat_sys_mq_open").call ?
 {
 	name = "mq_open"
 	name_uaddr = $u_name
 	filename = user_string_quoted($u_name)
 	u_attr_uaddr = $u_attr
 	oflag = __int32($oflag)
+	mode = (@__compat_task ? __ushort($mode) : __uint32($mode))
 	if (oflag & 64)
 		argstr = sprintf("%s, %s, %#o, %p", user_string_quoted($u_name),
 			_sys_open_flag_str(oflag), mode, $u_attr)
@@ -3849,12 +3804,7 @@ probe syscall.mq_open = __syscall.mq_open,
 
 probe __syscall.mq_open = kernel.function("sys_mq_open").call
 {
-        @__syscall_gate(%{ __NR_mq_open %})
-	mode = __uint32($mode)
-}
-probe __syscall.compat_mq_open = kernel.function("compat_sys_mq_open").call
-{
-	mode = __ushort($mode)
+	@__syscall_gate_compat_simple
 }
 probe syscall.mq_open.return =
         __syscall.mq_open.return,
@@ -3880,29 +3830,25 @@ probe __syscall.mq_open.return = kernel.function("sys_mq_open").return
 #			const struct compat_timespec __user *u_abs_timeout)
 #
 probe syscall.mq_timedreceive =
-        __syscall.mq_timedreceive ?,
-        __syscall.compat_mq_timedreceive ?
+	__syscall.mq_timedreceive ?,
+	kernel.function("compat_sys_mq_timedreceive").call ?
 {
 	name = "mq_timedreceive"
 	mqdes = __int32($mqdes)
 	msg_ptr_uaddr = $u_msg_ptr
 	msg_prio_uaddr = $u_msg_prio
 	abs_timeout_uaddr = $u_abs_timeout
+%( CONFIG_64BIT == "y" %?
+	msg_len = @__compat_ulong($msg_len)
+%:
+	msg_len = __uint32($msg_len)
+%)
 	argstr = sprintf("%d, %p, %u, %p, %p", mqdes, $u_msg_ptr, msg_len,
 		$u_msg_prio, $u_abs_timeout)
 }
-probe __syscall.compat_mq_timedreceive = kernel.function("compat_sys_mq_timedreceive").call
-{
-	msg_len = __uint32($msg_len)
-}
 probe __syscall.mq_timedreceive = kernel.function("sys_mq_timedreceive").call
 {
         @__syscall_gate(%{ __NR_mq_timedreceive %})
-%( CONFIG_64BIT == "y" %?
-	msg_len = __ulong($msg_len)
-%:
-	msg_len = __uint32($msg_len)
-%)
 }
 probe syscall.mq_timedreceive.return =
         __syscall.mq_timedreceive.return,
@@ -3913,7 +3859,7 @@ probe syscall.mq_timedreceive.return =
 }
 probe __syscall.mq_timedreceive.return = kernel.function("sys_mq_timedreceive").return
 {
-        @__syscall_gate(%{ __NR_mq_timedreceive %})
+	@__syscall_gate_compat_simple
 }
 
 # mq_timedsend _______________________________________________
@@ -3928,29 +3874,25 @@ probe __syscall.mq_timedreceive.return = kernel.function("sys_mq_timedreceive").
 #			const struct compat_timespec __user *u_abs_timeout)
 #
 probe syscall.mq_timedsend =
-        __syscall.mq_timedsend,
-	__syscall.compat_mq_timedsend ?
+	__syscall.mq_timedsend,
+	kernel.function("compat_sys_mq_timedsend").return ?
 {
 	name = "mq_timedsend"
 	mqdes = __int32($mqdes)
 	msg_ptr_uaddr = $u_msg_ptr
 	msg_prio = __uint32($msg_prio)
 	abs_timeout_uaddr = $u_abs_timeout
+%( CONFIG_64BIT == "y" %?
+	msg_len = @__compat_ulong($msg_len)
+%:
+	msg_len = __uint32($msg_len)
+%)
 	argstr = sprintf("%d, %p, %u, %u, %p", mqdes, $u_msg_ptr, msg_len,
 		__uint32($msg_prio), $u_abs_timeout)
 }
-probe __syscall.compat_mq_timedsend = kernel.function("compat_sys_mq_timedsend").call
-{
-	msg_len = __uint32($msg_len)
-}
 probe __syscall.mq_timedsend = kernel.function("sys_mq_timedsend").call
 {
         @__syscall_gate(%{ __NR_mq_timedsend %})
-%( CONFIG_64BIT == "y" %?
-	msg_len = __ulong($msg_len)
-%:
-	msg_len = __uint32($msg_len)
-%)
 }
 probe syscall.mq_timedsend.return =
         __syscall.mq_timedsend.return,
@@ -3961,7 +3903,7 @@ probe syscall.mq_timedsend.return =
 }
 probe __syscall.mq_timedsend.return = kernel.function("sys_mq_timedsend").return
 {
-        @__syscall_gate(%{ __NR_mq_timedsend %})
+	@__syscall_gate_compat_simple
 }
 
 # mq_unlink __________________________________________________
diff --git a/tapset/linux/syscalls.stpm b/tapset/linux/syscalls.stpm
index 1bfa4b2be..6c699eb1a 100644
--- a/tapset/linux/syscalls.stpm
+++ b/tapset/linux/syscalls.stpm
@@ -14,7 +14,7 @@
 	# syscalls use the same syscall number as the 64-bit
 	# syscall. So, we have to check to see if this is a
 	# 32-on-64-bit user task.
-	if (%{ _stp_is_compat_task() %}) next
+	if (%{ /* pure */ _stp_is_compat_task() %}) next
     %)
 	# If _stp_syscall_nr() fails, that means we aren't in user
 	# context. So, skip this call.
@@ -28,7 +28,7 @@
 	# syscalls use the same syscall number as the 64-bit
 	# syscall. So, we have to check to see if this is a
 	# 32-on-64-bit user task.
-	if (%{ _stp_is_compat_task() %}) next
+	if (%{ /* pure */ _stp_is_compat_task() %}) next
     %)
 	try { __nr = _stp_syscall_nr() } catch { next }
 	if ((__nr != @syscall_nr1) && (__nr != @syscall_nr2)) next
@@ -38,7 +38,7 @@
 %(
     %( CONFIG_COMPAT == "y" %?
 	try { __nr = _stp_syscall_nr() } catch { next }
-	if (%{ _stp_is_compat_task() %}) {
+	if (%{ /* pure */ _stp_is_compat_task() %}) {
 		if (__nr != @compat_syscall_nr)
 			next
 	}
@@ -53,7 +53,7 @@
 %(
     %( CONFIG_COMPAT == "y" %?
 	try { __nr = _stp_syscall_nr() } catch { next }
-	if (%{ _stp_is_compat_task() %}) {
+	if (%{ /* pure */ _stp_is_compat_task() %}) {
 		if (__nr != @compat_syscall_nr) next
 	}
     %)
@@ -63,7 +63,7 @@
 %(
     %( CONFIG_COMPAT == "y" %?
 	try { __nr = _stp_syscall_nr() } catch { next }
-	if (%{ _stp_is_compat_task() %}) {
+	if (%{ /* pure */ _stp_is_compat_task() %}) {
 		if (__nr == @compat_syscall_nr) next
 	}
     %)
@@ -72,7 +72,7 @@
 @define __syscall_gate_compat_simple
 %(
     %( CONFIG_COMPAT == "y" %?
-        if (%{ _stp_is_compat_task() %}) next
+        if (%{ /* pure */ _stp_is_compat_task() %}) next
     %)
 %)
 
@@ -289,4 +289,30 @@
 	}
 %)
 
+# @__compat_ulong() macro adds the ability to distinguish between compat and non-compat
+# task to the __ulong() function making it full-featured couterpart to ulong_arg().
+@define __compat_ulong(arg)
+%(
+	%( CONFIG_COMPAT == "y" %?
+		(%{ /* pure */ _stp_is_compat_task() %} ? __uint32(@arg) : __ulong(@arg))
+	%:
+		__ulong(@arg)
+	%)
+%)
+
+# @__compat_long() macro adds the ability to distinguish between compat and non-compat
+# task to the __long() function making it full-featured couterpart to long_arg().
+@define __compat_long(arg)
+%(
+	%( CONFIG_COMPAT == "y" %?
+		(%{ /* pure */ _stp_is_compat_task() %} ? __int32(@arg) : __long(@arg))
+	%:
+		__long(@arg)
+	%)
+%)
+
+@define __compat_task
+%(
+	%{ /* pure */ _stp_is_compat_task() %}
+%)
 
diff --git a/tapset/linux/syscalls2.stp b/tapset/linux/syscalls2.stp
index 71a6fcee0..15095da0f 100644
--- a/tapset/linux/syscalls2.stp
+++ b/tapset/linux/syscalls2.stp
@@ -750,23 +750,16 @@ probe syscall.compat_pselect7.return = kernel.function("compat_sys_pselect7").re
 #		long addr,
 #		long data)
 #
-probe syscall.ptrace = __syscall.ptrace ?, __syscall.compat_ptrace ?
+probe syscall.ptrace = kernel.function("sys_ptrace").call ?,
+		kernel.function("compat_sys_ptrace").call ? 
 {
 	name = "ptrace"
 	request = $request
 	pid = __int32($pid)
+	addr = @__compat_ulong($addr)
+	data = @__compat_ulong(@choose_defined($data, $cdata))
 	argstr = _ptrace_argstr($request, pid, addr, data)
 }
-probe __syscall.ptrace = kernel.function("sys_ptrace").call ?
-{
-	addr = __ulong($addr)
-	data = __ulong($data)
-}
-probe __syscall.compat_ptrace = kernel.function("compat_sys_ptrace").call ?
-{
-	addr = __uint32($addr)
-	data = __uint32(@choose_defined($data, $cdata))
-}
 probe syscall.ptrace.return = kernel.function("sys_ptrace").return ?,
 	kernel.function("compat_sys_ptrace").return ?
 {
@@ -1284,14 +1277,12 @@ probe syscall.compat_recvmmsg.return =
 #
 probe syscall.recvmsg = __syscall.recvmsg ?, __syscall.socketcall.recvmsg ?
 {
-%( CONFIG_COMPAT == "y" %?
 	# Avoid probe hits from compat_sys_socketcall() calling
 	# compat_sys_recvmsg(), which sometimes calls
 	# sys_recvmsg(). We could call __syscall_gate2() here with
 	# NR_recvmsg and NR_socketcall, but all we really need to
 	# check is that we're not in a compat task.
-	if (%{ _stp_is_compat_task() %}) next
-%)
+	@__syscall_gate_compat_simple
 	name = "recvmsg"
 	flags_str = _msg_flags_str(flags)
 	argstr = sprintf("%d, %p, %s", s, msg_uaddr, _msg_flags_str(flags))
@@ -1313,9 +1304,7 @@ probe __syscall.socketcall.recvmsg = kernel.function("sys_socketcall").call ?
 probe syscall.recvmsg.return = __syscall.recvmsg.return ?,
 	__syscall.socketcall.recvmsg.return ?
 {
-%( CONFIG_COMPAT == "y" %?
-	if (%{ _stp_is_compat_task() %}) next
-%)
+	@__syscall_gate_compat_simple
 	name = "recvmsg"
 	retstr = return_str(1, $return)
 }
@@ -1575,25 +1564,21 @@ probe syscall.rt_sigaction32.return =
 #				    compat_size_t sigsetsize)
 #
 probe syscall.rt_sigpending = __syscall.rt_sigpending ?,
-			      __syscall.compat_rt_sigpending ?
+                              kernel.function("compat_sys_rt_sigpending").call !,
+                              kernel.function("sys32_rt_sigpending").call ?
 {
 	name = "rt_sigpending"
 	set_uaddr = @choose_defined($uset, $set)
+	sigsetsize = @__compat_ulong($sigsetsize)
 	argstr = sprintf("%p, %u", set_uaddr, sigsetsize)
 }
 probe __syscall.rt_sigpending = kernel.function("sys_rt_sigpending").call ?
 {
 	@__syscall_gate(%{ __NR_rt_sigpending %})
-	sigsetsize = $sigsetsize
-}
-probe __syscall.compat_rt_sigpending =
-	kernel.function("compat_sys_rt_sigpending").call !,
-	kernel.function("sys32_rt_sigpending").call ?
-{
-	sigsetsize = __uint32($sigsetsize)
 }
 probe syscall.rt_sigpending.return = __syscall.rt_sigpending.return ?,
-				     __syscall.compat_rt_sigpending.return ?
+                                     kernel.function("compat_sys_rt_sigpending").return !,
+                                     kernel.function("sys32_rt_sigpending").return ?
 {
 	name = "rt_sigpending"
 	retstr = return_str(1, $return)
@@ -1603,11 +1588,6 @@ probe __syscall.rt_sigpending.return =
 {
 	@__syscall_gate(%{ __NR_rt_sigpending %})
 }
-probe __syscall.compat_rt_sigpending.return =
-	kernel.function("compat_sys_rt_sigpending").return !,
-	kernel.function("sys32_rt_sigpending").return ?
-{
-}
 
 # rt_sigprocmask _____________________________________________
 # long sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset,
@@ -1642,8 +1622,7 @@ probe syscall.rt_sigprocmask = kernel.function("sys_rt_sigprocmask").call ?
 	// On those kernels, a call to the 32-bit rt_sigprocmask goes
 	// straight to the 64-bit rt_sigprocmask function.
 %( arch == "x86_64" && kernel_v >= "3.4" && CONFIG_COMPAT == "y" %?
-	if (%{ /* pure */ _stp_is_compat_task() %}
-	    && _stp_syscall_nr() == %{ /* pure */ __NR_compat_rt_sigprocmask %}) {
+	if (@__compat_task && _stp_syscall_nr() == %{ /* pure */ __NR_compat_rt_sigprocmask %}) {
 		oldset_uaddr = __uint32($oset)
 		argstr = sprintf("%s, %s, %p, %d", how_str,
 				 _stp_compat_sigset_u(set_uaddr), oldset_uaddr,
@@ -1701,7 +1680,7 @@ probe syscall.rt_sigqueueinfo =
 	sig = __int32($sig)
 	uinfo_uaddr = $uinfo
 	argstr = sprintf("%d, %s, %s", pid, _signal_name(sig),
-			 (%{ /* pure */ _stp_is_compat_task() %}
+			 (@__compat_task
 			  ? _stp_compat_siginfo_u($uinfo)
 			  : _stp_siginfo_u($uinfo)))
 }
@@ -1752,12 +1731,9 @@ probe syscall.rt_sigsuspend = kernel.function("compat_sys_rt_sigsuspend").call ?
 {
 	name = "rt_sigsuspend"
 	set_uaddr = @__pointer($unewset)
-	if (%{ /* pure */ _stp_is_compat_task() %})
-		sigsetsize = __uint32($sigsetsize)
-	else
-		sigsetsize = __ulong($sigsetsize)
+	sigsetsize = @__compat_ulong($sigsetsize)
 	argstr = sprintf("%s, %u",
-			 (%{ /* pure */ _stp_is_compat_task() %}
+			 (@__compat_task
 			  ? _stp_compat_sigset_u(set_uaddr)
 			  : _stp_sigset_u(set_uaddr)), sigsetsize)
 }
@@ -1789,7 +1765,7 @@ probe syscall.rt_sigtimedwait =
 	uinfo_uaddr = @__pointer($uinfo)
 	uts_uaddr = @__pointer($uts)
 	sigsetsize = $sigsetsize
-	if (%{ /* pure */ _stp_is_compat_task() %})
+	if (@__compat_task)
 		argstr = sprintf("%s, %s, %s, %d",
 				 _stp_compat_sigset_u(uthese_uaddr),
 			 	 _stp_compat_siginfo_u(uinfo_uaddr),
@@ -1829,7 +1805,7 @@ probe syscall.rt_tgsigqueueinfo =
 	sig = __int32($sig)
 	uinfo_uaddr = $uinfo
 	argstr = sprintf("%d, %d, %s, %s", tgid, tid, _signal_name(sig),
-			 (%{ /* pure */ _stp_is_compat_task() %}
+			 (@__compat_task
 			  ? _stp_compat_siginfo_u(uinfo_uaddr)
 			  : _stp_siginfo_u(uinfo_uaddr)))
 }
@@ -2383,26 +2359,22 @@ probe __syscall.socketcall.send.return =
 # COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd,
 #		compat_loff_t __user *, offset, compat_size_t, count)
 #
-probe syscall.sendfile = __syscall.sendfile ?, __syscall.compat_sendfile ?
+probe syscall.sendfile = __syscall.sendfile ?,
+	kernel.function("compat_sys_sendfile").call ?,
+	kernel.function("compat_sys_sendfile64").call ?,
+	kernel.function("sys32_sendfile").call ?
 {
 	name = "sendfile"
 	out_fd = __int32($out_fd)
 	in_fd = __int32($in_fd)
 	offset_uaddr = $offset
+	count = @__compat_ulong($count)
 	argstr = sprintf("%d, %d, %p, %u", out_fd, in_fd, $offset, count)
 }
 probe __syscall.sendfile = kernel.function("sys_sendfile").call ?,
 	kernel.function("sys_sendfile64").call ?
 {
 	@__syscall_gate2(%{ __NR_sendfile %}, %{ __NR_sendfile64 %})
-	count = __ulong($count)
-}
-probe __syscall.compat_sendfile =
-	kernel.function("compat_sys_sendfile").call ?,
-	kernel.function("compat_sys_sendfile64").call ?,
-	kernel.function("sys32_sendfile").call ?
-{
-	count = __uint32($count)
 }
 probe syscall.sendfile.return = __syscall.sendfile.return ?,
 	kernel.function("compat_sys_sendfile").return ?,
@@ -2424,14 +2396,12 @@ probe __syscall.sendfile.return = kernel.function("sys_sendfile").return ?,
 #
 probe syscall.sendmsg = __syscall.sendmsg ?, __syscall.socketcall.sendmsg ?
 {
-%( CONFIG_COMPAT == "y" %?
 	# Avoid probe hits from compat_sys_socketcall() calling
 	# compat_sys_sendmsg(), which sometimes calls
 	# sys_sendmsg(). We could call __syscall_gate2() here with
 	# NR_sendmsg and NR_socketcall, but all we really need to
 	# check is that we're not in a compat task.
-	if (%{ _stp_is_compat_task() %}) next
-%)
+	@__syscall_gate_compat_simple
 	name = "sendmsg"
 	flags_str = _msg_flags_str(flags)
 	argstr = sprintf("%d, %p, %s", s, msg_uaddr, _msg_flags_str(flags))
@@ -2453,14 +2423,12 @@ probe __syscall.socketcall.sendmsg = kernel.function("sys_socketcall").call ?
 probe syscall.sendmsg.return = __syscall.sendmsg.return ?,
 	__syscall.socketcall.sendmsg.return ?
 {
-%( CONFIG_COMPAT == "y" %?
 	# Avoid probe hits from compat_sys_socketcall() calling
 	# compat_sys_sendmsg(), which sometimes calls
 	# sys_sendmsg(). We could call __syscall_gate2() here with
 	# NR_sendmsg and NR_socketcall, but all we really need to
 	# check is that we're not in a compat task.
-	if (%{ _stp_is_compat_task() %}) next
-%)
+	@__syscall_gate_compat_simple
 	name = "sendmsg"
 	retstr = return_str(1, $return)
 }
@@ -2521,14 +2489,12 @@ probe syscall.sendmmsg = __syscall.sendmmsg ?,
 }
 probe __syscall.sendmmsg = kernel.function("sys_sendmmsg").call ?
 {
-%( CONFIG_COMPAT == "y" %?
 	# Avoid probe hits from compat_sys_socketcall() calling
 	# compat_sys_sendmmsg(), which sometimes calls
 	# sys_sendmmsg(). We could call __syscall_gate2() here with
 	# NR_sendmmsg and NR_socketcall, but all we really need to
 	# check is that we're not in a compat task.
-	if (%{ _stp_is_compat_task() %}) next
-%)
+	@__syscall_gate_compat_simple
 	s = __int32($fd)
 	mmsg_uaddr = $mmsg
 	vlen = __uint32($vlen)
@@ -2561,14 +2527,12 @@ probe syscall.sendmmsg.return = __syscall.sendmmsg.return ?,
 }
 probe __syscall.sendmmsg.return = kernel.function("sys_sendmmsg").return ?
 {
-%( CONFIG_COMPAT == "y" %?
 	# Avoid probe hits from compat_sys_socketcall() calling
 	# compat_sys_sendmmsg(), which sometimes calls
 	# sys_sendmmsg(). We could call __syscall_gate2() here with
 	# NR_sendmmsg and NR_socketcall, but all we really need to
 	# check is that we're not in a compat task.
-	if (%{ _stp_is_compat_task() %}) next
-%)
+	@__syscall_gate_compat_simple
 }
 probe __syscall.compat_socketcall.sendmmsg.return =
 	kernel.function("compat_sys_socketcall").return ?
@@ -3069,21 +3033,16 @@ probe __syscall.setrlimit.return = kernel.function("sys_setrlimit").return
 #                        struct compat_robust_list_head __user *, head,
 #                        compat_size_t, len)
 probe syscall.set_robust_list = __syscall.set_robust_list ?,
-                                __syscall.compat_set_robust_list ?
+                                kernel.function("compat_sys_set_robust_list") ?
 {
 	name = "set_robust_list"
 	list_head_uaddr = @__pointer($head)
+	len = @__compat_ulong($len)
 	argstr = sprintf("%p, %u", list_head_uaddr, len)
 }
 probe __syscall.set_robust_list = kernel.function("sys_set_robust_list")
 {
 	@__syscall_gate_compat_simple
-	len = __ulong($len)
-}
-probe __syscall.compat_set_robust_list =
-		kernel.function("compat_sys_set_robust_list")
-{
-	len = __uint32($len)
 }
 probe syscall.set_robust_list.return = __syscall.set_robust_list.return ?,
 		kernel.function("compat_sys_set_robust_list").return ?
@@ -3552,7 +3511,7 @@ probe syscall.sigaltstack = kernel.function("sys_sigaltstack").call,
 	uss_uaddr = @__pointer(@choose_defined($uss, $uss_ptr))
 	uoss_uaddr = @__pointer(@choose_defined($uoss, $uoss_ptr))
 	argstr = sprintf("%s, %p",
-			 (%{ /* pure */ _stp_is_compat_task() %}
+			 (@__compat_task
 			  ? _stp_compat_sigaltstack_u(uss_uaddr)
 			  : _stp_sigaltstack_u(uss_uaddr)), uoss_uaddr)
 }
@@ -3684,23 +3643,18 @@ probe __syscall.sigpending.return = kernel.function("sys_sigpending").return ?
 #				         compat_old_sigset_t __user *oset)
 #
 probe syscall.sigprocmask = __syscall.sigprocmask ?,
-			    __syscall.compat_sigprocmask ?
+                            kernel.function("compat_sys_sigprocmask").call ?
 {
 	name = "sigprocmask"
 	how = __int32($how)
 	how_str = _sigprocmask_how_str(how)
 	set_uaddr = @__pointer(@choose_defined($set, $nset))
+	oldset_uaddr = @__compat_ulong($oset)
 	argstr = sprintf("%s, %p, %p", how_str, set_uaddr, oldset_uaddr)
 }
 probe __syscall.sigprocmask = kernel.function("sys_sigprocmask").call ?
 {
 	@__syscall_gate(%{ __NR_sigprocmask %})
-	oldset_uaddr = $oset
-}
-probe __syscall.compat_sigprocmask =
-	kernel.function("compat_sys_sigprocmask").call ?
-{
-	oldset_uaddr = __uint32($oset)
 }
 probe syscall.sigprocmask.return = __syscall.sigprocmask.return ?,
 	kernel.function("compat_sys_sigprocmask").return ?
@@ -4244,11 +4198,7 @@ probe syscall.tee = kernel.function("sys_tee").call ?
 	name = "tee"
 	fdin = __int32($fdin)
 	fdout = __int32($fdout)
-	if (%{ /* pure */ _stp_is_compat_task() %}) {
-		len = __uint32($len)
-	} else {
-		len = __ulong($len)
-	}
+	len = @__compat_ulong($len)
 	flags = __uint32($flags)
 	argstr = sprintf("%d, %d, %u, 0x%x", fdin, fdout, len, flags)
 }
@@ -4314,26 +4264,18 @@ probe syscall.time.return = kernel.function("sys32_time").return ?,
 #			timer_t __user * created_timer_id)
 #
 probe syscall.timer_create = __syscall.timer_create,
-                             __syscall.compat_timer_create ?
+                             kernel.function("compat_sys_timer_create").call ?
 {
 	name = "timer_create"
-}
-probe __syscall.timer_create = kernel.function("sys_timer_create").call
-{
-	@__syscall_gate(%{ __NR_timer_create %})
 	clockid = __int32($which_clock)
 	clockid_str = _get_wc_str(__int32($which_clock))
 	evp_uaddr = $timer_event_spec
 	timerid_uaddr = $created_timer_id
 	argstr = sprintf("%s, %p, %p", clockid_str, $timer_event_spec, $created_timer_id)
 }
-probe __syscall.compat_timer_create = kernel.function("compat_sys_timer_create").call ?
+probe __syscall.timer_create = kernel.function("sys_timer_create").call
 {
-	clockid = __int32($which_clock)
-	clockid_str = _get_wc_str(__int32($which_clock))
-	evp_uaddr = $timer_event_spec
-	timerid_uaddr = $created_timer_id
-	argstr = sprintf("%s, %p, %p", clockid_str, $timer_event_spec, $created_timer_id)
+	@__syscall_gate(%{ __NR_timer_create %})
 }
 probe syscall.timer_create.return =
 	__syscall.timer_create.return,
@@ -4387,23 +4329,16 @@ probe syscall.timer_getoverrun.return = kernel.function("sys_timer_getoverrun").
 #			 struct itimerspec __user *setting)
 #
 probe syscall.timer_gettime = __syscall.timer_gettime,
-                              __syscall.compat_timer_gettime ?
+                              kernel.function("compat_sys_timer_gettime").call ?
 {
 	name = "timer_gettime"
-}
-probe __syscall.timer_gettime = kernel.function("sys_timer_gettime").call
-{
-	@__syscall_gate(%{ __NR_timer_gettime %})
 	timerid = __int32($timer_id)
 	value_uaddr = $setting
 	argstr = sprintf("%d, %p", __int32($timer_id), $setting)
 }
-probe __syscall.compat_timer_gettime =
-	kernel.function("compat_sys_timer_gettime").call ?
+probe __syscall.timer_gettime = kernel.function("sys_timer_gettime").call
 {
-	timerid = __int32($timer_id)
-	value_uaddr = $setting
-	argstr = sprintf("%d, %p", __int32($timer_id), $setting)
+	@__syscall_gate(%{ __NR_timer_gettime %})
 }
 probe syscall.timer_gettime.return =
         __syscall.timer_gettime.return,
@@ -4428,29 +4363,26 @@ probe __syscall.timer_gettime.return = kernel.function("sys_timer_gettime").retu
 #			  struct compat_itimerspec __user *old)
 #
 probe syscall.timer_settime = __syscall.timer_settime,
-			      __syscall.compat_timer_settime ?
+                              kernel.function("compat_sys_timer_settime").call ?
 {
 	name = "timer_settime"
-}
-probe __syscall.timer_settime = kernel.function("sys_timer_settime").call
-{
-	@__syscall_gate(%{ __NR_timer_settime %})
 	timerid = __int32($timer_id)
 	flags = __int32($flags)
-	value_uaddr  = $new_setting
-	ovalue_uaddr = $old_setting
+	value_uaddr  = @choose_defined($new, $new_setting)
+	ovalue_uaddr = @choose_defined($old, $old_setting)
 	argstr = sprintf("%d, %d, %s, %p", __int32($timer_id), __int32($flags),
-			 _struct_itimerspec_u($new_setting), $old_setting)
+%( CONFIG_COMPAT == "y" %?
+			 (@__compat_task ?
+	                  _struct_compat_itimerspec_u(value_uaddr) :
+	                  _struct_itimerspec_u(value_uaddr)),
+%:
+	                 _struct_itimerspec_u(value_uaddr),
+%)
+	                 ovalue_uaddr)
 }
-probe __syscall.compat_timer_settime =
-	kernel.function("compat_sys_timer_settime").call ?
+probe __syscall.timer_settime = kernel.function("sys_timer_settime").call
 {
-	timerid = __int32($timer_id)
-	flags = __int32($flags)
-	value_uaddr  = $new
-	ovalue_uaddr = $old
-	argstr = sprintf("%d, %d, %s, %p", __int32($timer_id), __int32($flags),
-			 _struct_compat_itimerspec_u($new), $old)
+	@__syscall_gate(%{ __NR_timer_settime %})
 }
 probe syscall.timer_settime.return =
 	__syscall.timer_settime.return,
@@ -4546,32 +4478,27 @@ probe __syscall.timerfd_gettime.return =
 #		const struct compat_itimerspec __user *, utmr,
 #		struct compat_itimerspec __user *, otmr)
 probe syscall.timerfd_settime = __syscall.timerfd_settime ?,
-	__syscall.compat_timerfd_settime ?
-{
-	name = "timerfd_settime"
-}
-probe __syscall.timerfd_settime = kernel.function("sys_timerfd_settime").call ?
-{
-	@__syscall_gate_compat_simple
-	fd = __int32($ufd)
-	flags = __int32($flags)
-	flags_str = _stp_timerfd_flags_str(flags)
-	value_uaddr = $utmr
-	ovalue_uaddr = $otmr
-	argstr = sprintf("%d, %s, %s, %p", fd, flags_str,
-			 _struct_itimerspec_u($utmr), $otmr)
-}
-probe __syscall.compat_timerfd_settime =
 	kernel.function("compat_sys_timerfd_settime").call ?
 {
+	name = "timerfd_settime"
 	fd = __int32($ufd)
 	flags = __int32($flags)
 	flags_str = _stp_timerfd_flags_str(flags)
 	value_uaddr = @__pointer($utmr)
 	ovalue_uaddr = @__pointer($otmr)
 	argstr = sprintf("%d, %s, %s, %p", fd, flags_str,
-			 _struct_compat_itimerspec_u(value_uaddr),
-			 ovalue_uaddr)
+%( CONFIG_COMPAT == "y" %?
+	                 (@__compat_task ?
+	                  _struct_compat_itimerspec_u(value_uaddr) :
+	                  _struct_itimerspec_u(value_uaddr)),
+%:
+	                  _struct_itimerspec_u(value_uaddr),
+%)
+	                 ovalue_uaddr)
+}
+probe __syscall.timerfd_settime = kernel.function("sys_timerfd_settime").call ?
+{
+	@__syscall_gate_compat_simple
 }
 probe syscall.timerfd_settime.return = __syscall.timerfd_settime.return ?,
 	kernel.function("compat_sys_timerfd_settime").return ?
@@ -4629,68 +4556,23 @@ probe syscall.tkill.return = kernel.function("sys_tkill").return
 # COMPAT_SYSCALL_DEFINE2(truncate, const char __user *, path,
 #			 compat_off_t, length)
 #
-probe syscall.truncate = __syscall.truncate ?, __syscall.truncate64 ?,
-			 __syscall.compat_truncate ?
+probe syscall.truncate = __syscall.truncate ?,
+                         kernel.function("sys_truncate64").call ?,
+                         kernel.function("compat_sys_truncate").call ?
 {
 	name = "truncate"
-%( arch == "s390" %?
-	# Sigh. The syscall wrappers on s390x do odd things.
-	if (%{ /* pure */ _stp_is_compat_task() %})
-		path_uaddr = __uint32($path)
-	else
-		path_uaddr = $path
+	path_uaddr = @__pointer($path)
+%( CONFIG_64BIT == "y" %?
+	length = @__compat_long($length)
 %:
-	path_uaddr = $path
+	length = $length
 %)
 	path = user_string_quoted(path_uaddr)
 	argstr = sprintf("%s, %d", user_string_quoted(path_uaddr), length)
 }
 probe __syscall.truncate = kernel.function("sys_truncate").call ?
 {
-#%( arch == "powerpc" && CONFIG_COMPAT == "y" && kernel_v < "3.9.0" %?
-#	# Avoid probe hits from compat_sys_truncate() calling
-#	# compat_sys_truncate().  The following kernel commit
-#	# switched to a generic compat_sys_truncate() which doesn't
-#	# go through sys_truncate():
-#	#
-#	#   commit 3f6d078d4accfff8b114f968259a060bfdc7c682
-#	#   Author: Al Viro <viro@zeniv.linux.org.uk>
-#	#   Date:   Sun Feb 24 13:49:08 2013 -0500
-#	#
-#	#       fix compat truncate/ftruncate
-#	#
-#	#       Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
-#	#
-#	# We could call one of the syscall_gate macros here, but the
-#	# syscall number is the same number on ppc64 for the 64-bit
-#	# and 32-bit syscall. So, just check that we're not in a
-#	# compat task.
-#	if (%{ _stp_is_compat_task() %}) next
-#%)
-#%( arch == "s390" %?
-#	# Sigh. The syscall wrappers on s390x do odd things.
-#	if (%{ /* pure */ _stp_is_compat_task() %})
-#		length = __int32($length)
-#	else
-#		length = __long($length)
-#%:
-#	length = __long($length)
-#%)
-	@__syscall_compat_gate(%{ __NR_truncate %}, 
-			       %{ __NR_compat_truncate %})
-#	length = __long($length)
-	if (%{ /* pure */ _stp_is_compat_task() %})
-		length = __int32($length)
-	else
-		length = __long($length)
-}
-probe __syscall.truncate64 = kernel.function("sys_truncate64").call ?
-{
-	length = $length
-}
-probe __syscall.compat_truncate = kernel.function("compat_sys_truncate").call ?
-{
-	length = __int32($length)
+	@__syscall_compat_gate(%{ __NR_truncate %}, %{ __NR_compat_truncate %})
 }
 probe syscall.truncate.return = __syscall.truncate.return,
                                 kernel.function("sys_truncate64").return ?,
@@ -4701,11 +4583,7 @@ probe syscall.truncate.return = __syscall.truncate.return,
 }
 probe __syscall.truncate.return = kernel.function("sys_truncate").return
 {
-#%( arch == "powerpc" && CONFIG_COMPAT == "y" && kernel_v < "3.9.0" %?
-#	if (%{ _stp_is_compat_task() %}) next
-#%)
-	@__syscall_compat_gate(%{ __NR_truncate %}, 
-			       %{ __NR_compat_truncate %})
+	@__syscall_compat_gate(%{ __NR_truncate %}, %{ __NR_compat_truncate %})
 }
 
 # tux ________________________________________________________