* asmlinkage int
* sys_get_thread_area(struct user_desc __user *u_info)
*/
-probe syscall.get_thread_area = kernel.function("sys_get_thread_area") {
+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)
}
-probe syscall.get_thread_area.return =
- kernel.function("sys_get_thread_area").return {
+probe syscall.get_thread_area.return = kernel.function("sys_get_thread_area").return
+{
name = "get_thread_area"
retstr = returnstr(1)
}
# 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") {
+probe syscall.iopl = kernel.function("sys_iopl")
+{
name = "iopl"
argstr = ""
}
-probe syscall.iopl.return = kernel.function("sys_iopl").return {
+probe syscall.iopl.return = kernel.function("sys_iopl").return
+{
name = "iopl"
retstr = returnstr(1)
}
# ipc ________________________________________________________
# int sys_ipc (uint call, int first, int second, int third, void __user *ptr, long fifth)
#
-probe syscall.ipc = kernel.function("sys_ipc") ? {
+probe syscall.ipc = kernel.function("sys_ipc") ?
+{
name = "ipc"
call = $call
first = $first
argstr = sprintf("%d, %d, %d, %d, %p, %d", $call, $first,
$second, $third, $ptr, $fifth)
}
-probe syscall.ipc.return = kernel.function("sys_ipc").return ? {
+probe syscall.ipc.return = kernel.function("sys_ipc").return ?
+{
name = "ipc"
retstr = returnstr(1)
}
flags = $flags
fd = $fd
pgoffset = $pgoff
- argstr = sprintf("%p, %d, %s, %s, %d, %d", $addr,
+ argstr = sprintf("%p, %d, %s, %s, %d, %d", $addr,
$len, _mprotect_prot_str($prot), _mmap_flags($flags),
$fd, $pgoff)
}
* asmlinkage int
* sys_set_thread_area(struct user_desc __user *u_info)
*/
-probe syscall.set_thread_area =
- kernel.function("sys_set_thread_area") {
+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)
}
-probe syscall.set_thread_area.return =
- kernel.function("sys_set_thread_area").return {
+probe syscall.set_thread_area.return = kernel.function("sys_set_thread_area").return
+{
name = "set_thread_area"
retstr = returnstr(1)
}
* unsigned int zone,
* unsigned int state)
*/
-probe syscall.set_zone_reclaim =
- kernel.function("sys_set_zone_reclaim") ? {
+probe syscall.set_zone_reclaim = kernel.function("sys_set_zone_reclaim") ?
+{
name = "set_zone_reclaim"
node = $node
zone = $zone
state = $state
argstr = sprintf("%d, %d, %d", $node, $zone, $state)
}
-probe syscall.set_zone_reclaim.return =
- kernel.function("sys_set_zone_reclaim").return ? {
+probe syscall.set_zone_reclaim.return = kernel.function("sys_set_zone_reclaim").return ?
+{
name = "set_zone_reclaim"
retstr = returnstr(1)
}
#
# NOTE: args vary between archs.
#
-probe syscall.sigaltstack = kernel.function("sys_sigaltstack") {
+probe syscall.sigaltstack = kernel.function("sys_sigaltstack")
+{
name = "sigaltstack"
ussp = %( kernel_vr < "2.6.25" %? $ebx %: %( kernel_vr < "2.6.29" %? $bx %: $regs->bx %) %)
argstr = sprintf("%p", ussp)
}
-probe syscall.sigaltstack.return = kernel.function("sys_sigaltstack").return {
+probe syscall.sigaltstack.return = kernel.function("sys_sigaltstack").return
+{
name = "sigaltstack"
retstr = returnstr(1)
}
#
# int sys_vm86(struct pt_regs regs)
#
-probe syscall.vm86 = kernel.function("sys_vm86") ? {
+probe syscall.vm86 = kernel.function("sys_vm86") ?
+{
name = "vm86"
/*
* unsupported type identifier '$regs'
*/
argstr = ""
}
-probe syscall.vm86.return = kernel.function("sys_vm86").return ? {
- name = "vm86"
+probe syscall.vm86.return = kernel.function("sys_vm86").return ?
+{
+ name = "vm86"
retstr = returnstr(1)
}
#
# int sys_vm86old(struct pt_regs regs)
#
-probe syscall.vm86old = kernel.function("sys_vm86old") ? {
- name = "vm86old"
+probe syscall.vm86old = kernel.function("sys_vm86old") ?
+{
+ name = "vm86old"
/*
* unsupported type identifier '$regs'
* regs = $regs
*/
argstr = ""
}
-probe syscall.vm86old.return = kernel.function("sys_vm86old").return ? {
+probe syscall.vm86old.return = kernel.function("sys_vm86old").return ?
+{
name = "vm86old"
retstr = returnstr(1)
}
#
# time_t sys64_time(time_t __user * tloc)
#
-probe syscall.sys64_time = kernel.function("sys64_time") ? {
+probe syscall.sys64_time = kernel.function("sys64_time") ?
+{
name = "sys64_time"
argstr = sprintf("%p", $tloc)
}
-probe syscall.sys64_time.return = kernel.function("sys64_time").return ? {
+probe syscall.sys64_time.return = kernel.function("sys64_time").return ?
+{
name = "sys64_time"
retstr = returnstr(1)
}
#
# long ppc64_personality(unsigned long personality)
#
-probe syscall.ppc64_personality = kernel.function("ppc64_personality") {
+probe syscall.ppc64_personality = kernel.function("ppc64_personality")
+{
name = "ppc64_personality"
persona = $personality
argstr = sprint($personality)
}
-probe syscall.ppc64_personality.return = kernel.function("ppc64_personality").return {
+probe syscall.ppc64_personality.return = kernel.function("ppc64_personality").return
+{
name = "ppc64_personality"
retstr = returnstr(1)
}
#
# int ppc_rtas(struct rtas_args __user *uargs)
#
-probe syscall.ppc_rtas = kernel.function("ppc_rtas") ? {
+probe syscall.ppc_rtas = kernel.function("ppc_rtas") ?
+{
name = "ppc_rtas"
uargs_uaddr = $uargs
argstr = sprintf("%p", $uargs)
}
-probe syscall.ppc_rtas.return = kernel.function("ppc_rtas").return ? {
+probe syscall.ppc_rtas.return = kernel.function("ppc_rtas").return ?
+{
name = "ppc_rtas"
retstr = returnstr(1)
}
#
# long ppc64_sys32_stime(int __user * tptr)
#
-probe syscall.ppc64_sys32_stime = kernel.function("ppc64_sys32_stime") ? {
+probe syscall.ppc64_sys32_stime = kernel.function("ppc64_sys32_stime") ?
+{
name = "ppc64_sys32_stime"
t_uaddr = $tptr
argstr = sprintf("%p", $tptr)
}
-probe syscall.ppc64_sys32_stime.return = kernel.function("ppc64_sys32_stime").return ? {
+probe syscall.ppc64_sys32_stime.return = kernel.function("ppc64_sys32_stime").return ?
+{
name = "ppc64_sys32_stime"
retstr = returnstr(1)
}
# int sys32_ptrace(long request, long pid, unsigned long addr,
# unsigned long data)
#
-probe syscall.sys32_ptrace = kernel.function("sys32_ptrace") ? {
+probe syscall.sys32_ptrace = kernel.function("sys32_ptrace") ?
+{
name = "sys32_ptrace"
request = $request
pid = $pid
data = $data
argstr = sprintf("%p, %p, %p, %p", $request, $pid, $addr, $data)
}
-probe syscall.sys32_ptrace.return = kernel.function("sys32_ptrace").return ? {
+probe syscall.sys32_ptrace.return = kernel.function("sys32_ptrace").return ?
+{
name = "sys32_ptrace"
retstr = returnstr(1)
}
#
# (obsolete) long sys32_sysinfo(struct sysinfo32 __user *info)
#
-probe syscall.sys32_sysinfo = kernel.function("sys32_sysinfo") ? {
+probe syscall.sys32_sysinfo = kernel.function("sys32_sysinfo") ?
+{
name = "sys32_sysinfo"
info_uaddr = $info
argstr = sprintf("%p", info_uaddr)
}
-probe syscall.sys32_sysinfo.return = kernel.function("sys32_sysinfo").return ? {
+probe syscall.sys32_sysinfo.return = kernel.function("sys32_sysinfo").return ?
+{
name = "sys32_sysinfo"
retstr = returnstr(1)
}
# long sys32_ipc(u32 call, u32 first, u32 second, u32 third,
# compat_uptr_t ptr, u32 fifth)
#
-probe syscall.ipc = kernel.function("sys32_ipc") ? {
+probe syscall.ipc = kernel.function("sys32_ipc") ?
+{
name = "ipc"
argstr = sprintf("%d, %d, %d, %d, %p, %d", $call, $first, $second,
- $third, $ptr, $fifth)
+ $third, $ptr, $fifth)
}
-probe syscall.ipc.return = kernel.function("sys32_ipc").return ? {
+probe syscall.ipc.return = kernel.function("sys32_ipc").return ?
+{
name = "sys_ipc"
retstr = returnstr(1)
}
# long sys32_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
# struct pt_regs *regs)
#
-probe syscall.sys32_sigreturn = kernel.function("sys32_sigreturn") ? {
+probe syscall.sys32_sigreturn = kernel.function("sys32_sigreturn") ?
+{
name = "sys32_sigreturn"
r3 = $r3
r4 = $r4
argstr = sprintf("%p, %p, %p, %p, %p, %p",
$r3, $r4, $r5, $r6, $r7, $r8)
}
-probe syscall.sys32_sigreturn.return =
- kernel.function("sys32_sigreturn").return ? {
+probe syscall.sys32_sigreturn.return = kernel.function("sys32_sigreturn").return ?
+{
name = "sys32_sigreturn"
retstr = returnstr(1)
}
#
# long sys32_adjtimex(struct timex32 __user *utp)
#
-probe syscall.sys32_adjtimex = kernel.function("sys32_adjtimex") ? {
+probe syscall.sys32_adjtimex = kernel.function("sys32_adjtimex") ?
+{
name = "sys32_adjtimex"
argstr = sprintf("%p", $utp)
}
-probe syscall.sys32_adjtimex.return = kernel.function("sys32_adjtimex").return ? {
+probe syscall.sys32_adjtimex.return = kernel.function("sys32_adjtimex").return ?
+{
name = "sys32_adjtimex"
retstr = returnstr(1)
}
# struct linux_dirent32 __user *dirent,
# unsigned int count)
#
-probe syscall.sys32_getdents = kernel.function("sys32_getdents") ? {
+probe syscall.sys32_getdents = kernel.function("sys32_getdents") ?
+{
name = "sys32_getdents"
fd = $fd
dirp_uaddr = $dirent
count = $count
argstr = sprintf("%d, %p, %d", fd, dirp_uaddr, count)
}
-probe syscall.sys32_getdents.return =
- kernel.function("sys32_getdents").return ? {
+probe syscall.sys32_getdents.return = kernel.function("sys32_getdents").return ?
+{
name = "sys32_getdents"
retstr = returnstr(1)
}
#
# long compat_sys_sysctl(struct __sysctl_args32 __user *args)
#
-probe syscall.compat_sysctl = kernel.function("compat_sys_sysctl") ? {
+probe syscall.compat_sysctl = kernel.function("compat_sys_sysctl") ?
+{
name = "sysctl"
argstr = sprintf("%p", $args)
}
-probe syscall.compat_sysctl.return = kernel.function("compat_sys_sysctl").return ? {
+probe syscall.compat_sysctl.return = kernel.function("compat_sys_sysctl").return ?
+{
name = "sysctl"
retstr = returnstr(1)
}
# asmlinkage long sys32_sched_setparam(u32 pid,
# struct sched_param __user *param)
#
-probe syscall.sys32_sched_setparam = kernel.function("sys32_sched_setparam") ? {
+probe syscall.sys32_sched_setparam = kernel.function("sys32_sched_setparam") ?
+{
name = "sys32_sched_setparam"
pid = $pid
param_uaddr = $param
argstr = sprintf("%d, %p", pid, param_uaddr)
}
-probe syscall.sys32_sched_setparam.return =
- kernel.function("sys32_sched_setparam").return ? {
+probe syscall.sys32_sched_setparam.return = kernel.function("sys32_sched_setparam").return ?
+{
name = "sys32_sched_setparam"
retstr = returnstr(1)
}
# asmlinkage long sys32_sched_rr_get_interval(u32 pid,
# struct compat_timespec __user *interval)
#
-probe syscall.sys32_sched_rr_get_interval =
- kernel.function("sys32_sched_rr_get_interval") ? {
+probe syscall.sys32_sched_rr_get_interval = kernel.function("sys32_sched_rr_get_interval") ?
+{
name = "sys32_sched_rr_get_interval"
pid = $pid
interval_uaddr = $interval
- argstr = sprintf("%d, %p", pid, interval_uaddr)
+ argstr = sprintf("%d, %p", pid, interval_uaddr)
}
-probe syscall.sys32_sched_rr_get_interval.return =
- kernel.function("sys32_sched_rr_get_interval").return ? {
+probe syscall.sys32_sched_rr_get_interval.return = kernel.function("sys32_sched_rr_get_interval").return ?
+{
name = "sys32_sched_rr_get_interval"
retstr = returnstr(1)
}
# long sys32_rt_sigpending(compat_sigset_t __user *set,
# compat_size_t sigsetsize)
#
-probe syscall.sys32_rt_sigpending = kernel.function("sys32_rt_sigpending") ? {
+probe syscall.sys32_rt_sigpending = kernel.function("sys32_rt_sigpending") ?
+{
name = "sys32_rt_sigpending"
set_uaddr = $set
sigsetsize = $sigsetsize
argstr = sprintf("%p, %d", set_uaddr, $sigsetsize)
}
-probe syscall.sys32_rt_sigpending.return =
- kernel.function("sys32_rt_sigpending").return ? {
+probe syscall.sys32_rt_sigpending.return = kernel.function("sys32_rt_sigpending").return ?
+{
name = "sys32_rt_sigpending"
retstr = returnstr(1)
}
# struct compat_timespec __user *uts,
# compat_size_t sigsetsize)
#
-probe syscall.sys32_rt_sigtimedwait =
- kernel.function("sys32_rt_sigtimedwait") ? {
+probe syscall.sys32_rt_sigtimedwait = kernel.function("sys32_rt_sigtimedwait") ?
+{
name = "sys32_rt_sigtimedwait"
uthese_uaddr = $uthese
uinfo_uaddr = $uinfo
argstr = sprintf("%p, %p, %p, %p", uthese_uaddr,
uinfo_uaddr, uts_uaddr, sigsetsize)
}
-probe syscall.sys32_rt_sigtimedwait.return =
- kernel.function("sys32_rt_sigtimedwait").return ? {
+probe syscall.sys32_rt_sigtimedwait.return = kernel.function("sys32_rt_sigtimedwait").return ?
+{
name = "sys32_rt_sigtimedwait"
retstr = returnstr(1)
}
#
# long sys32_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
#
-probe syscall.sys32_rt_sigqueueinfo =
- kernel.function("sys32_rt_sigqueueinfo") ? {
+probe syscall.sys32_rt_sigqueueinfo = kernel.function("sys32_rt_sigqueueinfo") ?
+{
name = "sys32_rt_sigqueueinfo"
pid = $pid
sig = $sig
argstr = sprintf("%p, %s, %p", pid, _signal_name($sig),
uinfo_uaddr)
}
-probe syscall.sys32_rt_sigqueueinfo.return =
- kernel.function("sys32_rt_sigqueueinfo").return ? {
+probe syscall.sys32_rt_sigqueueinfo.return = kernel.function("sys32_rt_sigqueueinfo").return ?
+{
name = "sys32_rt_sigqueueinfo"
retstr = returnstr(1)
}
# int sys32_sigaltstack(u32 __new, u32 __old, int r5,
# int r6, int r7, int r8, struct pt_regs *regs)
#
-probe syscall.sys32_sigaltstack = kernel.function("sys32_sigaltstack") ? {
+probe syscall.sys32_sigaltstack = kernel.function("sys32_sigaltstack") ?
+{
name = "sys32_sigaltstack"
argstr = "FIXME"
}
-probe syscall.sys32_sigaltstack.return =
- kernel.function("sys32_sigaltstack").return ? {
+probe syscall.sys32_sigaltstack.return = kernel.function("sys32_sigaltstack").return ?
+{
name = "sys32_sigaltstack"
retstr = returnstr(1)
}
# asmlinkage int sys32_sendfile64(int out_fd, int in_fd,
# compat_loff_t __user *offset, s32 count)
#
-probe syscall.sys32_sendfile64 = kernel.function("sys32_sendfile64") ? {
+probe syscall.sys32_sendfile64 = kernel.function("sys32_sendfile64") ?
+{
name = "sys32_sendfile64"
out_fd = $out_fd
in_fd = $in_fd
argstr = sprintf("%d, %d, %p, %d", $out_fd, $in_fd, offset_uaddr,
$count)
}
-probe syscall.sys32_sendfile64.return =
- kernel.function("sys32_sendfile64").return ? {
+probe syscall.sys32_sendfile64.return = kernel.function("sys32_sendfile64").return ?
+{
name = "sys32_sendfile64"
retstr = returnstr(1)
}
# struct compat_sigevent __user *ev32,
# timer_t __user *timer_id)
#
-probe syscall.ppc32_timer_create = kernel.function("ppc32_timer_create") ? {
+probe syscall.ppc32_timer_create = kernel.function("ppc32_timer_create") ?
+{
name = "ppc32_timer_create"
which_clock = $clock
timer_event_spec = $ev32
argstr = sprintf("%d, %p, %p", which_clock, timer_event_spec,
created_timer_id)
}
-probe syscall.ppc32_timer_create.return =
- kernel.function("ppc32_timer_create").return ? {
+probe syscall.ppc32_timer_create.return = kernel.function("ppc32_timer_create").return ?
+{
name = "ppc32_timer_create"
retstr = returnstr(1)
}
# struct compat_itimerspec __user *new,
# struct compat_itimerspec __user *old)
#
-probe syscall.compat_timer_settime = kernel.function("compat_timer_settime") ? {
+probe syscall.compat_timer_settime = kernel.function("compat_timer_settime") ?
+{
name = "compat_timer_settime"
timer_id = $timer_id
flags = $flags
argstr = sprintf("%d, %d, %p, %p", timer_id, flags,
new_setting_uaddr, old_setting_uaddr)
}
-probe syscall.compat_timer_settime.return =
- kernel.function("compat_timer_settime").return ? {
+probe syscall.compat_timer_settime.return = kernel.function("compat_timer_settime").return ?
+{
name = "compat_timer_settime"
retstr = returnstr(1)
}
# long compat_timer_gettime(timer_t timer_id,
# struct compat_itimerspec __user *setting)
#
-probe syscall.compat_timer_gettime = kernel.function("compat_timer_gettime") ? {
+probe syscall.compat_timer_gettime = kernel.function("compat_timer_gettime") ?
+{
name = "compat_timer_gettime"
timer_id = $timer_id
setting_uaddr = $setting
argstr = sprintf("%d, %p", timer_id, setting_uaddr)
}
-probe syscall.compat_timer_gettime.return =
- kernel.function("compat_timer_gettime").return ? {
+probe syscall.compat_timer_gettime.return = kernel.function("compat_timer_gettime").return ?
+{
name = "compat_timer_gettime"
retstr = returnstr(1)
}
# long compat_clock_settime(clockid_t which_clock,
# struct compat_timespec __user *tp)
#
-probe syscall.compat_clock_settime = kernel.function("compat_clock_settime") ? {
+probe syscall.compat_clock_settime = kernel.function("compat_clock_settime") ?
+{
name = "compat_clock_settime"
which_clock = $which_clock
tp_uaddr = $tp
argstr = sprintf("%d, %p", which_clock, tp_uaddr)
}
-probe syscall.compat_clock_settime.return =
- kernel.function("compat_clock_settime").return ? {
+probe syscall.compat_clock_settime.return = kernel.function("compat_clock_settime").return ?
+{
name = "compat_clock_settime"
retstr = returnstr(1)
}
# int ctx_size, int r6, int r7, int r8,
# struct pt_regs *regs)
#
-probe syscall.sys32_swapcontext = kernel.function("sys32_swapcontext") ? {
+probe syscall.sys32_swapcontext = kernel.function("sys32_swapcontext") ?
+{
name = "sys32_swapcontext"
old_ctx_uaddr = $old_ctx
new_ctx_uaddr = $new_ctx
argstr = sprintf("%p, %p, %d, %d, %d, %d, %p",
old_ctx_uaddr, new_ctx_uaddr, r5, r6, r7, r8, regs)
}
-probe syscall.sys32_swapcontext.return =
- kernel.function("sys32_swapcontext").return ? {
+probe syscall.sys32_swapcontext.return = kernel.function("sys32_swapcontext").return ?
+{
name = "sys32_swapcontext"
retstr = returnstr(1)
}
# asmlinkage long sys32_utimes(char __user *filename,
# struct compat_timeval __user *tvs)
#
-probe syscall.sys32_utimes = kernel.function("sys32_utimes") ? {
+probe syscall.sys32_utimes = kernel.function("sys32_utimes") ?
+{
name = "sys32_utimes"
filename_uaddr = $filename
path = user_string($filename)
tvp_uaddr = $tvs
argstr = sprintf("%s, %p", user_string_quoted($filename), tvp_uaddr)
}
-probe syscall.sys32_utimes.return = kernel.function("sys32_utimes").return ? {
+probe syscall.sys32_utimes.return = kernel.function("sys32_utimes").return ?
+{
name = "sys32_utimes"
retstr = returnstr(1)
}
# compat_ulong_t mode, compat_ulong_t __user *nmask,
# compat_ulong_t maxnode, compat_ulong_t flags)
#
-probe syscall.compat_mbind = kernel.function("compat_mbind") ? {
+probe syscall.compat_mbind = kernel.function("compat_mbind") ?
+{
name = "compat_mbind"
start_uaddr = $start
len = $len
argstr = sprintf("%p, %d, %d, %p, %d, %d", start_uaddr, len,
policy, nodemask_uaddr, maxnode, flags)
}
-probe syscall.compat_mbind.return = kernel.function("compat_mbind").return ? {
+probe syscall.compat_mbind.return = kernel.function("compat_mbind").return ?
+{
name = "compat_mbind"
retstr = returnstr(1)
}
# compat_ulong_t maxnode,
# compat_ulong_t addr, compat_ulong_t flags)
#
-probe syscall.compat_get_mempolicy = kernel.function("compat_get_mempolicy") ? {
+probe syscall.compat_get_mempolicy = kernel.function("compat_get_mempolicy") ?
+{
name = "compat_get_mempolicy"
policy_uaddr = $policy
nmask_uaddr = $nmask
argstr = sprintf("%p, %p, %d, %d", policy_uaddr, nmask_uaddr,
maxnode, addr)
}
-probe syscall.compat_get_mempolicy.return =
- kernel.function("compat_get_mempolicy").return ? {
+probe syscall.compat_get_mempolicy.return = kernel.function("compat_get_mempolicy").return ?
+{
name = "compat_get_mempolicy"
retstr = returnstr(1)
}
# asmlinkage long compat_set_mempolicy(int mode, compat_ulong_t __user *nmask,
# compat_ulong_t maxnode)
#
-probe syscall.compat_set_mempolicy = kernel.function("compat_set_mempolicy") ? {
+probe syscall.compat_set_mempolicy = kernel.function("compat_set_mempolicy") ?
+{
name = "compat_set_mempolicy"
policy = $mode
nodemask_uaddr = $nmask
maxnode = $maxnode
argstr = sprintf("%d, %p, %d", policy, nodemask_uaddr, maxnode)
}
-probe syscall.compat_set_mempolicy.return =
- kernel.function("compat_set_mempolicy").return ? {
+probe syscall.compat_set_mempolicy.return = kernel.function("compat_set_mempolicy").return ?
+{
name = "compat_set_mempolicy"
retstr = returnstr(1)
}
# unsigned long prot, unsigned long flags,
# unsigned long fd, off_t offset)
#
-probe syscall.mmap = kernel.function("sys_mmap") ? {
+probe syscall.mmap = kernel.function("sys_mmap") ?
+{
name = "mmap"
start = $addr
len = $len
_mprotect_prot_str($prot), _mmap_flags($flags), $fd, $offset)
}
-probe syscall.mmap.return = kernel.function("sys_mmap").return ? {
+probe syscall.mmap.return = kernel.function("sys_mmap").return ?
+{
name = "mmap"
retstr = returnstr(2)
}
# unsigned long prot, unsigned long flags,
# unsigned long fd, unsigned long pgoff)
#
-probe syscall.mmap2 =
- kernel.function("sys_mmap2") ?,
- kernel.function("compat_sys_mmap2") ?
+probe syscall.mmap2 = kernel.function("sys_mmap2") ?,
+ kernel.function("compat_sys_mmap2") ?
{
name = "mmap2"
start = $addr
flags = $flags
fd = $fd
pgoffset = $pgoff
- argstr = sprintf("%p, %d, %s, %s, %d, %d", $addr,
+ argstr = sprintf("%p, %d, %s, %s, %d, %d", $addr,
$len, _mprotect_prot_str($prot), _mmap_flags($flags),
$fd, $pgoff)
}
-probe syscall.mmap2.return =
- kernel.function("sys_mmap2").return ?,
- kernel.function("compat_sys_mmap2").return ?
+probe syscall.mmap2.return = kernel.function("sys_mmap2").return ?,
+ kernel.function("compat_sys_mmap2").return ?
{
name = "mmap2"
retstr = returnstr(2)
#
# long ppc64_sys_stime(long __user * tptr)
#
-probe syscall.ppc64_sys_stime = kernel.function("ppc64_sys_stime") ? {
+probe syscall.ppc64_sys_stime = kernel.function("ppc64_sys_stime") ?
+{
name = "ppc64_sys_stime"
/* FIXME */
t_uaddr = $tptr
argstr = sprintf("%p", t_uaddr)
}
-probe syscall.ppc64_sys_stime.return =
- kernel.function("ppc64_sys_stime").return ? {
+probe syscall.ppc64_sys_stime.return = kernel.function("ppc64_sys_stime").return ?
+{
name = "ppc64_sys_stime"
retstr = returnstr(1)
}
#
# asmlinkage int ppc64_newuname(struct new_utsname __user * name)
#
-probe syscall.ppc64_newuname = kernel.function("ppc64_newuname") ? {
+probe syscall.ppc64_newuname = kernel.function("ppc64_newuname") ?
+{
name = "ppc64_newuname"
name_uaddr = $name
argstr = sprintf("%p", name_uaddr)
}
-probe syscall.ppc64_newuname.return = kernel.function("ppc64_newuname").return ? {
+probe syscall.ppc64_newuname.return = kernel.function("ppc64_newuname").return ?
+{
name = "ppc64_newuname"
retstr = returnstr(1)
}
#
-#
+#