# 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 ?
# 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 ?
# 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 ?
{
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 ?,
# 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 ?
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)
}
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
# 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 ?
# 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)
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,
# 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,
}
probe __syscall.mq_timedreceive.return = kernel.function("sys_mq_timedreceive").return
{
- @__syscall_gate(%{ __NR_mq_timedreceive %})
+ @__syscall_gate_compat_simple
}
# mq_timedsend _______________________________________________
# 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,
}
probe __syscall.mq_timedsend.return = kernel.function("sys_mq_timedsend").return
{
- @__syscall_gate(%{ __NR_mq_timedsend %})
+ @__syscall_gate_compat_simple
}
# mq_unlink __________________________________________________
# 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 ?
{
#
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))
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)
}
# 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)
{
@__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,
// 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,
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)))
}
{
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)
}
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),
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)))
}
# 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 ?,
#
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))
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)
}
}
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)
}
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 ?
# 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 ?
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)
}
# 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 ?
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)
}
# 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,
# 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,
# 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,
# 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 ?
# 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 ?,
}
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 ________________________________________________________
git://sourceware.org / systemtap.git / commitdiff