FM / linux

/usr/share/systemtap/tapset/linux

Name	Size	Mode	Actions
arm/	-	0755	rm
arm64/	-	0755	rm
i386/	-	0755	rm
ia64/	-	0755	rm
mips/	-	0755	rm
powerpc/	-	0755	rm
riscv/	-	0755	rm
s390/	-	0755	rm
x86_64/	-	0755	rm
atomic.stp	1563	0644	edit dl rm
aux_syscalls.stp	151702	0644	edit dl rm
context-caller.stp	3148	0644	edit dl rm
context-envvar.stp	1761	0644	edit dl rm
context-symbols.stp	12276	0644	edit dl rm
context-unwind.stp	3283	0644	edit dl rm
context.stp	19015	0644	edit dl rm
context.stpm	125	0644	edit dl rm
conversions-guru.stp	5876	0644	edit dl rm
conversions.stp	17273	0644	edit dl rm
ctime.stp	5750	0644	edit dl rm
dentry.stp	10667	0644	edit dl rm
dev.stp	2074	0644	edit dl rm
endian.stp	602	0644	edit dl rm
errno.stpm	57	0644	edit dl rm
guru-delay.stp	1230	0644	edit dl rm
guru-signal.stp	1092	0644	edit dl rm
inet.stp	1456	0644	edit dl rm
inet.stpm	383	0644	edit dl rm
inet_sock.stp	1282	0644	edit dl rm
ioblock.stp	15597	0644	edit dl rm
ioscheduler.stp	14098	0644	edit dl rm
ip.stp	5483	0644	edit dl rm
ipmib-filter-default.stp	965	0644	edit dl rm
ipmib.stp	12981	0644	edit dl rm
irq.stp	5120	0644	edit dl rm
json.stp	9194	0644	edit dl rm
json.stpm	6256	0644	edit dl rm
kprocess.stp	4750	0644	edit dl rm
kretprobe.stp	2153	0644	edit dl rm
linuxmib-filter-default.stp	876	0644	edit dl rm
linuxmib.stp	3718	0644	edit dl rm
loadavg.stp	1995	0644	edit dl rm
logging.stp	2585	0644	edit dl rm
memory.stp	19219	0644	edit dl rm
netfilter.stp	36356	0644	edit dl rm
networking.stp	9656	0644	edit dl rm
nfs.stp	38997	0644	edit dl rm
nfsd.stp	47379	0644	edit dl rm
nfsderrno.stp	11979	0644	edit dl rm
nfs_proc.stp	58325	0644	edit dl rm
nfs_proc.stpm	1288	0644	edit dl rm
panic.stp	1092	0644	edit dl rm
perf.stp	5284	0644	edit dl rm
proc_mem.stp	12702	0644	edit dl rm
pstrace.stp	773	0644	edit dl rm
rcu.stp	928	0644	edit dl rm
rlimit.stp	1382	0644	edit dl rm
rpc.stp	38578	0644	edit dl rm
scheduler.stp	11661	0644	edit dl rm
scsi.stp	9721	0644	edit dl rm
signal.stp	29371	0644	edit dl rm
socket.stp	35024	0644	edit dl rm
syscalls.stpm	14643	0644	edit dl rm
syscalls_cfg_trunc.stp	111	0644	edit dl rm
syscall_any.stp	1560	0644	edit dl rm
syscall_table.stp	1475	0644	edit dl rm
sysc_accept.stp	7868	0644	edit dl rm
sysc_accept4.stp	7864	0644	edit dl rm
sysc_access.stp	2911	0644	edit dl rm
sysc_acct.stp	2583	0644	edit dl rm
sysc_add_key.stp	3532	0644	edit dl rm
sysc_adjtimex.stp	5672	0644	edit dl rm
sysc_alarm.stp	2833	0644	edit dl rm
sysc_bdflush.stp	3113	0644	edit dl rm
sysc_bind.stp	6965	0644	edit dl rm
sysc_bpf.stp	2738	0644	edit dl rm
sysc_brk.stp	2629	0644	edit dl rm
sysc_capget.stp	3101	0644	edit dl rm
sysc_capset.stp	3102	0644	edit dl rm
sysc_chdir.stp	2616	0644	edit dl rm
sysc_chmod.stp	2959	0644	edit dl rm
sysc_chown.stp	3775	0644	edit dl rm
sysc_chown16.stp	3115	0644	edit dl rm
sysc_chroot.stp	2679	0644	edit dl rm
sysc_clock_adjtime.stp	5243	0644	edit dl rm
sysc_clock_getres.stp	4248	0644	edit dl rm
sysc_clock_gettime.stp	4035	0644	edit dl rm
sysc_clock_nanosleep.stp	8041	0644	edit dl rm
sysc_clock_settime.stp	5554	0644	edit dl rm
sysc_clone.stp	6708	0644	edit dl rm
sysc_close.stp	2771	0644	edit dl rm
sysc_connect.stp	7452	0644	edit dl rm
sysc_copy_file_range.stp	3769	0644	edit dl rm
sysc_creat.stp	2728	0644	edit dl rm
sysc_delete_module.stp	3366	0644	edit dl rm
sysc_dup.stp	2383	0644	edit dl rm
sysc_dup2.stp	2991	0644	edit dl rm
sysc_dup3.stp	3073	0644	edit dl rm
sysc_epoll_create.stp	5742	0644	edit dl rm
sysc_epoll_ctl.stp	3998	0644	edit dl rm
sysc_epoll_pwait.stp	4157	0644	edit dl rm
sysc_epoll_wait.stp	4850	0644	edit dl rm
sysc_eventfd.stp	5411	0644	edit dl rm
sysc_execve.stp	6257	0644	edit dl rm
sysc_execveat.stp	6942	0644	edit dl rm
sysc_exit.stp	1984	0644	edit dl rm
sysc_exit_group.stp	2146	0644	edit dl rm
sysc_faccessat.stp	3736	0644	edit dl rm
sysc_faccessat2.stp	4434	0644	edit dl rm
sysc_fadvise64.stp	8639	0644	edit dl rm
sysc_fallocate.stp	3918	0644	edit dl rm
sysc_fanotify_init.stp	3432	0644	edit dl rm
sysc_fanotify_mark.stp	7572	0644	edit dl rm
sysc_fchdir.stp	2525	0644	edit dl rm
sysc_fchmod.stp	2880	0644	edit dl rm
sysc_fchmodat.stp	3734	0644	edit dl rm
sysc_fchown.stp	3722	0644	edit dl rm
sysc_fchown16.stp	3023	0644	edit dl rm
sysc_fchownat.stp	3903	0644	edit dl rm
sysc_fcntl.stp	4806	0644	edit dl rm
sysc_fdatasync.stp	2692	0644	edit dl rm
sysc_fgetxattr.stp	3720	0644	edit dl rm
sysc_finit_module.stp	3382	0644	edit dl rm
sysc_flistxattr.stp	3000	0644	edit dl rm
sysc_flock.stp	2579	0644	edit dl rm
sysc_fork.stp	2586	0644	edit dl rm
sysc_fremovexattr.stp	3229	0644	edit dl rm
sysc_fsetxattr.stp	4187	0644	edit dl rm
sysc_fstat.stp	6163	0644	edit dl rm
sysc_fstatat.stp	5789	0644	edit dl rm
sysc_fstatfs.stp	3266	0644	edit dl rm
sysc_fstatfs64.stp	3240	0644	edit dl rm
sysc_fsync.stp	2419	0644	edit dl rm
sysc_ftruncate.stp	6212	0644	edit dl rm
sysc_futex.stp	5810	0644	edit dl rm
sysc_futimesat.stp	6639	0644	edit dl rm
sysc_getcpu.stp	3034	0644	edit dl rm
sysc_getcwd.stp	2747	0644	edit dl rm
sysc_getdents.stp	5618	0644	edit dl rm
sysc_getegid.stp	3542	0644	edit dl rm
sysc_geteuid.stp	3484	0644	edit dl rm
sysc_getgid.stp	3402	0644	edit dl rm
sysc_getgroups.stp	4274	0644	edit dl rm
sysc_gethostname.stp	1249	0644	edit dl rm
sysc_getitimer.stp	5355	0644	edit dl rm
sysc_getpeername.stp	7522	0644	edit dl rm
sysc_getpgid.stp	2859	0644	edit dl rm
sysc_getpgrp.stp	2090	0644	edit dl rm
sysc_getpid.stp	2031	0644	edit dl rm
sysc_getppid.stp	2112	0644	edit dl rm
sysc_getpriority.stp	2943	0644	edit dl rm
sysc_getrandom.stp	3184	0644	edit dl rm
sysc_getresgid.stp	4172	0644	edit dl rm
sysc_getresuid.stp	3972	0644	edit dl rm
sysc_getrlimit.stp	4460	0644	edit dl rm
sysc_getrusage.stp	3803	0644	edit dl rm
sysc_getsid.stp	2509	0644	edit dl rm
sysc_getsockname.stp	7550	0644	edit dl rm
sysc_getsockopt.stp	8520	0644	edit dl rm
sysc_gettid.stp	2057	0644	edit dl rm
sysc_gettimeofday.stp	4078	0644	edit dl rm
sysc_getuid.stp	3427	0644	edit dl rm
sysc_getxattr.stp	3812	0644	edit dl rm
sysc_get_mempolicy.stp	4671	0644	edit dl rm
sysc_get_robust_list.stp	4572	0644	edit dl rm
sysc_init_module.stp	3241	0644	edit dl rm
sysc_inotify_add_watch.stp	3861	0644	edit dl rm
sysc_inotify_init.stp	5548	0644	edit dl rm
sysc_inotify_rm_watch.stp	3277	0644	edit dl rm
sysc_ioctl.stp	3536	0644	edit dl rm
sysc_ioperm.stp	2819	0644	edit dl rm
sysc_ioprio_get.stp	3018	0644	edit dl rm
sysc_ioprio_set.stp	3247	0644	edit dl rm
sysc_io_cancel.stp	3318	0644	edit dl rm
sysc_io_destroy.stp	2816	0644	edit dl rm
sysc_io_getevents.stp	4994	0644	edit dl rm
sysc_io_setup.stp	3838	0644	edit dl rm
sysc_io_submit.stp	3983	0644	edit dl rm
sysc_kcmp.stp	3007	0644	edit dl rm
sysc_kexec_file_load.stp	4041	0644	edit dl rm
sysc_kexec_load.stp	4513	0644	edit dl rm
sysc_keyctl.stp	3722	0644	edit dl rm
sysc_kill.stp	2591	0644	edit dl rm
sysc_lchown.stp	3880	0644	edit dl rm
sysc_lchown16.stp	3194	0644	edit dl rm
sysc_lgetxattr.stp	3912	0644	edit dl rm
sysc_link.stp	2885	0644	edit dl rm
sysc_linkat.stp	4005	0644	edit dl rm
sysc_listen.stp	6624	0644	edit dl rm
sysc_listxattr.stp	3318	0644	edit dl rm
sysc_llistxattr.stp	3379	0644	edit dl rm
sysc_llseek.stp	3371	0644	edit dl rm
sysc_lookup_dcookie.stp	4089	0644	edit dl rm
sysc_lremovexattr.stp	4001	0644	edit dl rm
sysc_lseek.stp	4500	0644	edit dl rm
sysc_lsetxattr.stp	4097	0644	edit dl rm
sysc_lstat.stp	6455	0644	edit dl rm
sysc_madvise.stp	2976	0644	edit dl rm
sysc_mbind.stp	4303	0644	edit dl rm
sysc_membarrier.stp	3017	0644	edit dl rm
sysc_memfd_create.stp	3247	0644	edit dl rm
sysc_memfd_secret.stp	2815	0644	edit dl rm
sysc_migrate_pages.stp	4374	0644	edit dl rm
sysc_mincore.stp	2900	0644	edit dl rm
sysc_mkdir.stp	2897	0644	edit dl rm
sysc_mkdirat.stp	3445	0644	edit dl rm
sysc_mknod.stp	2958	0644	edit dl rm
sysc_mknodat.stp	3644	0644	edit dl rm
sysc_mlock.stp	2618	0644	edit dl rm
sysc_mlock2.stp	2882	0644	edit dl rm
sysc_mlockall.stp	2771	0644	edit dl rm
sysc_mmap2.stp	6229	0644	edit dl rm
sysc_modify_ldt.stp	3112	0644	edit dl rm
sysc_mount.stp	4499	0644	edit dl rm
sysc_move_pages.stp	4725	0644	edit dl rm
sysc_mprotect.stp	2966	0644	edit dl rm
sysc_mq_getsetattr.stp	4460	0644	edit dl rm
sysc_mq_notify.stp	3936	0644	edit dl rm
sysc_mq_open.stp	5385	0644	edit dl rm
sysc_mq_timedreceive.stp	6183	0644	edit dl rm
sysc_mq_timedsend.stp	5928	0644	edit dl rm
sysc_mq_unlink.stp	3018	0644	edit dl rm
sysc_mremap.stp	3577	0644	edit dl rm
sysc_msgctl.stp	8255	0644	edit dl rm
sysc_msgget.stp	4423	0644	edit dl rm
sysc_msgrcv.stp	10689	0644	edit dl rm
sysc_msgsnd.stp	8866	0644	edit dl rm
sysc_msync.stp	2851	0644	edit dl rm
sysc_munlock.stp	2744	0644	edit dl rm
sysc_munlockall.stp	2342	0644	edit dl rm
sysc_munmap.stp	2709	0644	edit dl rm
sysc_name_to_handle_at.stp	4150	0644	edit dl rm
sysc_nanosleep.stp	5824	0644	edit dl rm
sysc_nfsservctl.stp	2284	0644	edit dl rm
sysc_nice.stp	2440	0644	edit dl rm
sysc_ni_syscall.stp	1433	0644	edit dl rm
sysc_open.stp	4329	0644	edit dl rm
sysc_openat.stp	3916	0644	edit dl rm
sysc_open_by_handle_at.stp	4298	0644	edit dl rm
sysc_pause.stp	2564	0644	edit dl rm
sysc_perf_event_open.stp	3808	0644	edit dl rm
sysc_personality.stp	3077	0644	edit dl rm
sysc_pipe.stp	10596	0644	edit dl rm
sysc_pivot_root.stp	3314	0644	edit dl rm
sysc_pkey_alloc.stp	3057	0644	edit dl rm
sysc_pkey_free.stp	2719	0644	edit dl rm
sysc_pkey_mprotect.stp	3392	0644	edit dl rm
sysc_poll.stp	2769	0644	edit dl rm
sysc_ppoll.stp	6493	0644	edit dl rm
sysc_prctl.stp	2993	0644	edit dl rm
sysc_pread.stp	5427	0644	edit dl rm
sysc_preadv.stp	5283	0644	edit dl rm
sysc_preadv2.stp	5667	0644	edit dl rm
sysc_prlimit64.stp	3495	0644	edit dl rm
sysc_process_vm_readv.stp	4775	0644	edit dl rm
sysc_process_vm_writev.stp	4897	0644	edit dl rm
sysc_pselect6.stp	6457	0644	edit dl rm
sysc_pselect7.stp	3668	0644	edit dl rm
sysc_ptrace.stp	3661	0644	edit dl rm
sysc_pwrite.stp	7239	0644	edit dl rm
sysc_pwritev.stp	5414	0644	edit dl rm
sysc_pwritev2.stp	5774	0644	edit dl rm
sysc_quotactl.stp	4691	0644	edit dl rm
sysc_read.stp	3721	0644	edit dl rm
sysc_readahead.stp	3601	0644	edit dl rm
sysc_readdir.stp	4043	0644	edit dl rm
sysc_readlink.stp	3114	0644	edit dl rm
sysc_readlinkat.stp	3833	0644	edit dl rm
sysc_readv.stp	3502	0644	edit dl rm
sysc_reboot.stp	3253	0644	edit dl rm
sysc_recv.stp	7260	0644	edit dl rm
sysc_recvfrom.stp	8554	0644	edit dl rm
sysc_recvmmsg.stp	6462	0644	edit dl rm
sysc_recvmsg.stp	10962	0644	edit dl rm
sysc_remap_file_pages.stp	3935	0644	edit dl rm
sysc_removexattr.stp	3320	0644	edit dl rm
sysc_rename.stp	3038	0644	edit dl rm
sysc_renameat.stp	4191	0644	edit dl rm
sysc_renameat2.stp	4500	0644	edit dl rm
sysc_request_key.stp	4138	0644	edit dl rm
sysc_restart_syscall.stp	2565	0644	edit dl rm
sysc_rmdir.stp	2657	0644	edit dl rm
sysc_rt_sigaction.stp	6952	0644	edit dl rm
sysc_rt_sigpending.stp	4799	0644	edit dl rm
sysc_rt_sigprocmask.stp	9105	0644	edit dl rm
sysc_rt_sigqueueinfo.stp	4750	0644	edit dl rm
sysc_rt_sigreturn.stp	1639	0644	edit dl rm
sysc_rt_sigsuspend.stp	3879	0644	edit dl rm
sysc_rt_sigtimedwait.stp	6024	0644	edit dl rm
sysc_rt_tgsigqueueinfo.stp	4460	0644	edit dl rm
sysc_sched_getaffinity.stp	4102	0644	edit dl rm
sysc_sched_getattr.stp	3671	0644	edit dl rm
sysc_sched_getparam.stp	3236	0644	edit dl rm
sysc_sched_getscheduler.stp	3296	0644	edit dl rm
sysc_sched_get_priority_max.stp	3640	0644	edit dl rm
sysc_sched_get_priority_min.stp	3640	0644	edit dl rm
sysc_sched_rr_get_interval.stp	4864	0644	edit dl rm
sysc_sched_setaffinity.stp	3960	0644	edit dl rm
sysc_sched_setattr.stp	3445	0644	edit dl rm
sysc_sched_setparam.stp	3221	0644	edit dl rm
sysc_sched_setscheduler.stp	3666	0644	edit dl rm
sysc_sched_yield.stp	2315	0644	edit dl rm
sysc_seccomp.stp	3365	0644	edit dl rm
sysc_select.stp	6359	0644	edit dl rm
sysc_semctl.stp	8206	0644	edit dl rm
sysc_semget.stp	4596	0644	edit dl rm
sysc_semop.stp	5770	0644	edit dl rm
sysc_semtimedop.stp	9936	0644	edit dl rm
sysc_send.stp	7369	0644	edit dl rm
sysc_sendfile.stp	4912	0644	edit dl rm
sysc_sendmmsg.stp	9305	0644	edit dl rm
sysc_sendmsg.stp	12110	0644	edit dl rm
sysc_sendto.stp	8357	0644	edit dl rm
sysc_setdomainname.stp	3729	0644	edit dl rm
sysc_setfsgid.stp	4796	0644	edit dl rm
sysc_setfsuid.stp	4839	0644	edit dl rm
sysc_setgid.stp	4573	0644	edit dl rm
sysc_setgroups.stp	4519	0644	edit dl rm
sysc_sethostname.stp	3274	0644	edit dl rm
sysc_setitimer.stp	6286	0644	edit dl rm
sysc_setns.stp	2804	0644	edit dl rm
sysc_setpgid.stp	2760	0644	edit dl rm
sysc_setpriority.stp	3218	0644	edit dl rm
sysc_setregid.stp	6660	0644	edit dl rm
sysc_setresgid.stp	7040	0644	edit dl rm
sysc_setresuid.stp	7055	0644	edit dl rm
sysc_setreuid.stp	6630	0644	edit dl rm
sysc_setrlimit.stp	4030	0644	edit dl rm
sysc_setsid.stp	2101	0644	edit dl rm
sysc_setsockopt.stp	8444	0644	edit dl rm
sysc_settimeofday.stp	6646	0644	edit dl rm
sysc_setuid.stp	4572	0644	edit dl rm
sysc_setxattr.stp	3993	0644	edit dl rm
sysc_set_mempolicy.stp	4171	0644	edit dl rm
sysc_set_robust_list.stp	4358	0644	edit dl rm
sysc_set_tid_address.stp	3195	0644	edit dl rm
sysc_sgetmask.stp	2169	0644	edit dl rm
sysc_shmat.stp	6777	0644	edit dl rm
sysc_shmctl.stp	8139	0644	edit dl rm
sysc_shmdt.stp	3982	0644	edit dl rm
sysc_shmget.stp	4501	0644	edit dl rm
sysc_shutdown.stp	6909	0644	edit dl rm
sysc_sigaction.stp	5782	0644	edit dl rm
sysc_sigaltstack.stp	4267	0644	edit dl rm
sysc_signal.stp	2867	0644	edit dl rm
sysc_signalfd.stp	12464	0644	edit dl rm
sysc_sigpending.stp	3712	0644	edit dl rm
sysc_sigprocmask.stp	4172	0644	edit dl rm
sysc_sigreturn.stp	1461	0644	edit dl rm
sysc_sigsuspend.stp	4575	0644	edit dl rm
sysc_socket.stp	7438	0644	edit dl rm
sysc_socketpair.stp	8297	0644	edit dl rm
sysc_splice.stp	3363	0644	edit dl rm
sysc_ssetmask.stp	2810	0644	edit dl rm
sysc_stat.stp	6535	0644	edit dl rm
sysc_statfs.stp	3491	0644	edit dl rm
sysc_statfs64.stp	3459	0644	edit dl rm
sysc_statx.stp	4118	0644	edit dl rm
sysc_stime.stp	3083	0644	edit dl rm
sysc_swapoff.stp	2875	0644	edit dl rm
sysc_swapon.stp	3121	0644	edit dl rm
sysc_symlink.stp	3028	0644	edit dl rm
sysc_symlinkat.stp	4060	0644	edit dl rm
sysc_sync.stp	1925	0644	edit dl rm
sysc_syncfs.stp	2571	0644	edit dl rm
sysc_sync_file_range.stp	6011	0644	edit dl rm
sysc_sysctl.stp	3095	0644	edit dl rm
sysc_sysfs.stp	3648	0644	edit dl rm
sysc_sysinfo.stp	3286	0644	edit dl rm
sysc_syslog.stp	2826	0644	edit dl rm
sysc_tee.stp	2743	0644	edit dl rm
sysc_tgkill.stp	2883	0644	edit dl rm
sysc_time.stp	3505	0644	edit dl rm
sysc_timerfd.stp	1829	0644	edit dl rm
sysc_timerfd_create.stp	3394	0644	edit dl rm
sysc_timerfd_gettime.stp	4219	0644	edit dl rm
sysc_timerfd_settime.stp	5282	0644	edit dl rm
sysc_timer_create.stp	4975	0644	edit dl rm
sysc_timer_delete.stp	2942	0644	edit dl rm
sysc_timer_getoverrun.stp	3207	0644	edit dl rm
sysc_timer_gettime.stp	4670	0644	edit dl rm
sysc_timer_settime.stp	6075	0644	edit dl rm
sysc_times.stp	3167	0644	edit dl rm
sysc_tkill.stp	2695	0644	edit dl rm
sysc_truncate.stp	7031	0644	edit dl rm
sysc_tux.stp	1068	0644	edit dl rm
sysc_umask.stp	2522	0644	edit dl rm
sysc_umount.stp	5360	0644	edit dl rm
sysc_uname.stp	5145	0644	edit dl rm
sysc_unlink.stp	2866	0644	edit dl rm
sysc_unlinkat.stp	3380	0644	edit dl rm
sysc_unshare.stp	2814	0644	edit dl rm
sysc_uselib.stp	2871	0644	edit dl rm
sysc_userfaultfd.stp	3005	0644	edit dl rm
sysc_ustat.stp	5333	0644	edit dl rm
sysc_utime.stp	6173	0644	edit dl rm
sysc_utimensat.stp	7044	0644	edit dl rm
sysc_utimes.stp	6331	0644	edit dl rm
sysc_vfork.stp	2029	0644	edit dl rm
sysc_vhangup.stp	2128	0644	edit dl rm
sysc_vmsplice.stp	6337	0644	edit dl rm
sysc_wait4.stp	5097	0644	edit dl rm
sysc_waitid.stp	4253	0644	edit dl rm
sysc_waitpid.stp	3460	0644	edit dl rm
sysc_write.stp	3939	0644	edit dl rm
sysc_writev.stp	3656	0644	edit dl rm
target_set.stp	1769	0644	edit dl rm
task.stp	22880	0644	edit dl rm
task.stpm	253	0644	edit dl rm
task_ancestry.stp	1621	0644	edit dl rm
task_time.stp	7861	0644	edit dl rm
tcp.stp	22642	0644	edit dl rm
tcpmib-filter-default.stp	885	0644	edit dl rm
tcpmib.stp	10824	0644	edit dl rm
timestamp.stp	1761	0644	edit dl rm
timestamp_gtod.stp	1629	0644	edit dl rm
timestamp_monotonic.stp	5589	0644	edit dl rm
tty.stp	7351	0644	edit dl rm
tzinfo.stp	803	0644	edit dl rm
ucontext-symbols.stp	8842	0644	edit dl rm
ucontext-unwind.stp	7645	0644	edit dl rm
ucontext.stp	2237	0644	edit dl rm
udp.stp	6097	0644	edit dl rm
utrace.stp	1363	0644	edit dl rm
vfs.stp	33826	0644	edit dl rm

Edit: /usr/share/systemtap/tapset/linux/aux_syscalls.stp (151702B)

%{
// Be sure we have the __NR_* defines.
#include <asm/unistd.h>
#include "linux/compat_unistd.h"

// Be sure we have the SYS_* defines.
#include <linux/net.h>
#include "linux/compat_net.h"

#ifdef CONFIG_COMPAT
// Be sure we have 'SHMCTL', etc. defined.
#include <linux/ipc.h>
#ifndef SEMOP
#define SEMOP 1
#endif
#ifndef SEMCTL
#define SEMCTL 3
#endif
#ifndef SEMTIMEDOP
#define SEMTIMEDOP 4
#endif
#ifndef MSGSND
#define MSGSND 11 
#endif
#ifndef MSGRCV
#define MSGRCV 12
#endif
#ifndef MSGCTL
#define MSGCTL 14
#endif
#ifndef SHMCTL
#define SHMCTL 24
#endif
#endif

/* deprecation: struct compat_*time* aliases moved to this header */
#if defined(STAPCONF_TIME32_H)
#include <linux/time32.h>
/* further deprecation: struct compat_*time* aliases renamed to old_*time* */
#elif defined(STAPCONF_TIME32_OLD_H)
#include <linux/time32.h>
#define compat_time_t          old_time32_t
#define compat_timeval         old_timeval32
#define timeval                old_timeval32             
#define compat_timespec        old_timespec32
#define timespec               old_timespec32             
#define compat_itimerspec      old_itimerspec32
#define itimerspec             old_itimerspec32
#define ns_to_compat_timeval   ns_to_old_timeval32
#define get_compat_itimerspec64        get_old_itimerspec32
#define put_compat_itimerspec64        put_old_itimerspec32
#define compat_get_timespec64  get_old_timespec32
#define compat_put_timespec64  put_old_timespec32
/* in kernel/time/itimer.c */             
struct old_itimerval32 {
       struct old_timeval32    it_interval;
       struct old_timeval32    it_value;
     };
#define compat_itimerval old_itimerval32
#define itimerval        old_itimerval32
#define timex            old_timex32
#endif

/*
* Simple lookup functions for mapping values to names
* using embedded C. Use these functions to create safe,
* consistent lookups.
*/

// Get _stp_val_array and _stp_lookup_* definitions.
#include "linux/syscalls-common.h"

// Get _stp_syscall_get_nr() definitions.
#include "syscall.h"

static void
_stp_lookup_str2(const _stp_val_array * const array, long val, char *ptr,
		 int len, int base)
{
	int i = 0, slen;
	while (array[i].name) {
		if (array[i].val == val) {
			strlcat (ptr, array[i].name, len);
			return;
		}
		i++;
	}
	slen = strlen(ptr);
	if (base == 10)
		_stp_snprintf(ptr + slen, len - slen, "%ld", val);
	else if (base == 8)
		_stp_snprintf(ptr + slen, len - slen, "%#lo", val);
	else
		_stp_snprintf(ptr + slen, len - slen, "0x%lx", val);
}

static inline void
_stp_lookup_str(const _stp_val_array * const array, long val, char *ptr,
		int len)
{
	_stp_lookup_str2(array, val, ptr, len, 16);
}

static void
_stp_lookup_or_str2(const _stp_val_array * const array, long val, char *ptr,
		    int len, int base)
{
	int i = 0, flag = 0, slen;

if (val == 0) {
		_stp_lookup_str2(array, val, ptr, len, base);
		return;
	}

while (array[i].name) {
		if (array[i].val & val) {
			if (flag)
				strlcat(ptr, "|", len);
			strlcat(ptr, array[i].name, len);
			val &= (~array[i].val);
			flag = 1;
		}
		i++;
	}
	if (val) {
		if (flag)
			strlcat(ptr, "|", len);
		slen = strlen(ptr);
		if (base == 10)
			_stp_snprintf(ptr + slen, len - slen, "%ld", val);
		else if (base == 8)
			_stp_snprintf(ptr + slen, len - slen, "%#lo", val);
		else
			_stp_snprintf(ptr + slen, len - slen, "0x%lx", val);
	}
}

static inline void
_stp_lookup_or_str(const _stp_val_array * const array, long val, char *ptr,
		   int len)
{
	_stp_lookup_or_str2(array, val, ptr, len, 16);
}
%}

%{
#ifdef CONFIG_COMPAT
#include <linux/compat.h>

#ifndef STAPCONF_SIGSET_FROM_COMPAT_EXPORTED
void
sigset_from_compat(sigset_t *set, compat_sigset_t *compat)
{
	switch (_NSIG_WORDS) {
	case 4: set->sig[3] = compat->sig[6] | (((long)compat->sig[7]) << 32 );
          fallthrough;
	case 3: set->sig[2] = compat->sig[4] | (((long)compat->sig[5]) << 32 );
          fallthrough;
	case 2: set->sig[1] = compat->sig[2] | (((long)compat->sig[3]) << 32 );
          fallthrough;
	case 1: set->sig[0] = compat->sig[0] | (((long)compat->sig[1]) << 32 );
	}
}
#endif /* STAPCONF_SIGSET_FROM_COMPAT_EXPORTED */
#endif /* CONFIG_COMPAT */

#
# Given a userspace pointer to a timeval,
# copy and decode it and return a string.
#
function _struct_timeval_u:string(uaddr:long, n:long)
%{ /* pure */
	int n = (int)STAP_ARG_n;
	struct timeval tv[2]; /* maximum enforced below */
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	
	if (ptr == NULL || n < 1 || n > 2)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char*)&tv, ptr,
					n*sizeof(struct timeval)) == 0) {
			if (n == 2)
				snprintf(STAP_RETVALUE, MAXSTRINGLEN,
					 "[%ld.%06ld][%ld.%.06ld]", 
					 (long)tv[0].tv_sec, (long)tv[0].tv_usec,
					 (long)tv[1].tv_sec, (long)tv[1].tv_usec);
			else
				snprintf(STAP_RETVALUE, MAXSTRINGLEN,
					 "[%ld.%06ld]", (long)tv[0].tv_sec,
					 (long)tv[0].tv_usec);
	   	}
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
	}
%}

function _struct_compat_timeval_u:string(uaddr:long, n:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
	int n = (int)STAP_ARG_n;
        struct compat_timeval tv[2]; /* maximum enforced below */
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;

if (ptr == NULL || n < 1 || n > 2)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char*)&tv, ptr,
					n*sizeof(struct compat_timeval)) == 0) {
			if (n == 2)
				snprintf(STAP_RETVALUE, MAXSTRINGLEN,
					 "[%ld.%06ld][%ld.%.06ld]", 
					 (long)tv[0].tv_sec,
					 (long)tv[0].tv_usec,
					 (long)tv[1].tv_sec,
					 (long)tv[1].tv_usec);
			else
				snprintf(STAP_RETVALUE, MAXSTRINGLEN,
					 "[%ld.%06ld]", (long)tv[0].tv_sec,
					 (long)tv[0].tv_usec);
		}
	   	else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
	}
#endif
%}

function _struct_timezone_u:string(uaddr:long)
%{ /* pure */
	struct timezone tz;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	
	if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char*)&tz, ptr,
					sizeof(struct timezone)) == 0)
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "[%d, %d]",
				 tz.tz_minuteswest, tz.tz_dsttime);
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
	}
%}

%{
// Needed for the following four functions
// _struct_utimbuf_actime, _struct_utimbuf_modtime,
// _struct_compat_utimbuf_actime, _struct_compat_utimbuf_modtime
#include <linux/utime.h>
%}

function _stp_clock_nanosleep_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	static const _stp_val_array nanosleep_flags_list[] = {
		V(TIMER_ABSTIME),
		{0, NULL}
	};
	_stp_lookup_str(nanosleep_flags_list, (unsigned int)STAP_ARG_flags,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

// Returns the value of the actime field of a utimbuf in user space
// at the given address, or zero on when userspace data is not accessible.
function _struct_utimbuf_actime:long(uaddr:long)
%{ /* pure */
	struct utimbuf ubuf;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	
	if (ptr == NULL)
	  STAP_RETVALUE = 0;
	else
	  if(_stp_copy_from_user((char*)&ubuf,ptr,sizeof(ubuf)) == 0)
	    STAP_RETVALUE = ubuf.actime;
	  else
	    STAP_RETVALUE = 0;
%}

// Returns the value of the modtime field of a utimbuf in user space
// at the given address, or zero on when userspace data is not accessible.
function _struct_utimbuf_modtime:long(uaddr:long)
%{ /* pure */
	struct utimbuf ubuf;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	
	if (ptr == NULL)
	  STAP_RETVALUE = 0;
	else
	  if(_stp_copy_from_user((char*)&ubuf,ptr,sizeof(ubuf)) == 0)
	    STAP_RETVALUE = ubuf.modtime;
	  else
	    STAP_RETVALUE = 0;
%}

// Returns the value of the actime field of a compat_utimbuf in user space
// at the given address, or zero on when userspace data is not accessible.
function _struct_compat_utimbuf_actime:long(uaddr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
#if defined(STAPCONF_COMPAT_UTIMBUF)
        struct compat_utimbuf ubuf;
#else
        struct old_utimbuf32 ubuf;
#endif
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	
	if (ptr == NULL)
	  STAP_RETVALUE = 0;
	else
	  if(_stp_copy_from_user((char*)&ubuf,ptr,sizeof(ubuf)) == 0)
	    STAP_RETVALUE = ubuf.actime;
	  else
	    STAP_RETVALUE = 0;
#endif
%}

// Returns the value of the modtime field of a compat_utimbuf in user space
// at the given address, or zero on when userspace data is not accessible.
function _struct_compat_utimbuf_modtime:long(uaddr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
#if defined(STAPCONF_COMPAT_UTIMBUF)
        struct compat_utimbuf ubuf;
#else
        struct old_utimbuf32 ubuf;
#endif
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	
	if (ptr == NULL)
	  STAP_RETVALUE = 0;
	else
	  if(_stp_copy_from_user((char*)&ubuf,ptr,sizeof(ubuf)) == 0)
	    STAP_RETVALUE = ubuf.modtime;
	  else
	    STAP_RETVALUE = 0;
#endif
%}

function _struct_timespec_u:string(uaddr:long, n:long)
%{ /* pure */
#define STP_UTIME_NOW  ((1l << 30) - 1l)
#define STP_UTIME_OMIT ((1l << 30) - 2l)
	int n = (int)STAP_ARG_n;
        struct timespec ts[2];  /* maximum enforced below */
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;

if (ptr == NULL || n < 1 || n > 2)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char *)&ts, ptr,
		    n*sizeof(struct timespec)))  {
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
		}
		else {
			char *str;
			int len, i = 0;
			ptr = STAP_RETVALUE;
			while (i < n) {
				str = NULL;
				if (ts[i].tv_nsec == STP_UTIME_NOW)
					str = "UTIME_NOW";
				else if (ts[i].tv_nsec == STP_UTIME_OMIT)
					str = "UTIME_OMIT";
				if (str)
					len = snprintf(ptr, MAXSTRINGLEN,
						       "[%s]", str);
				else
					len = snprintf(ptr, MAXSTRINGLEN,
						       "[%ld.%09ld]",
						       (long)ts[i].tv_sec,
						       (long)ts[i].tv_nsec);
				ptr += len;
				i++;
			}
		}
	}
#undef STP_UTIME_NOW
#undef STP_UTIME_OMIT
%}

function _struct_compat_timespec_u:string(uaddr:long, n:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
#define STP_UTIME_NOW  ((1l << 30) - 1l)
#define STP_UTIME_OMIT ((1l << 30) - 2l)
	int n = (int)STAP_ARG_n;
        struct compat_timespec ts[2]; /* maximum, enforced below */
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;

if (ptr == NULL || n < 1 || n > 2)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char *)&ts, ptr,
		    n*sizeof(struct compat_timespec)))  {
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
		}
		else {
			char *str;
			int len, i = 0;
			ptr = STAP_RETVALUE;
			while (i < n) {
				str = NULL;
				if (ts[i].tv_nsec == STP_UTIME_NOW)
					str = "UTIME_NOW";
				else if (ts[i].tv_nsec == STP_UTIME_OMIT)
					str = "UTIME_OMIT";
				if (str)
					len = snprintf(ptr, MAXSTRINGLEN,
						       "[%s]", str);
				else
					len = snprintf(ptr, MAXSTRINGLEN,
						       "[%ld.%09ld]",
						       (long)ts[i].tv_sec,
						       (long)ts[i].tv_nsec);
				ptr += len;
				i++;
			}
		}
	}
#undef STP_UTIME_NOW
#undef STP_UTIME_OMIT
#endif
%}

function _struct_itimerspec_u:string(uaddr:long)
%{ /* pure */
	struct itimerspec its;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	
	if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if(_stp_copy_from_user((char *)&its, ptr,sizeof(struct itimerspec)))
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				(unsigned long)ptr);
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "[%d.%06d,%d.%06d]",
				(int)its.it_interval.tv_sec, (int)its.it_interval.tv_nsec,
				(int)its.it_value.tv_sec, (int)its.it_value.tv_nsec);
	}	
%}

function _struct_compat_itimerspec_u:string(uaddr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
	struct compat_itimerspec its;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	
	if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char *)&its, ptr, sizeof(its)))
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				(unsigned long)ptr);
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
				 "[%d.%06d,%d.%06d]",
				 (int)its.it_interval.tv_sec,
				 (int)its.it_interval.tv_nsec,
				 (int)its.it_value.tv_sec,
				 (int)its.it_value.tv_nsec);
	}
#endif
%}

function _struct_itimerval_u:string(uaddr:long)
%{ /* pure */
	struct itimerval itv;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;

if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if(_stp_copy_from_user((char *)&itv,ptr,sizeof(struct itimerval)))
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "[%d.%06d,%d.%06d]", 
				(int)itv.it_interval.tv_sec, (int)itv.it_interval.tv_usec,
				(int)itv.it_value.tv_sec, (int)itv.it_value.tv_usec);
	}
%}

function _struct_compat_itimerval_u:string(uaddr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
	struct compat_itimerval itv;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;

if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if(_stp_copy_from_user((char *)&itv,ptr,sizeof(struct compat_itimerval)))
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "[%d.%06d,%d.%06d]", 
				(int)itv.it_interval.tv_sec, (int)itv.it_interval.tv_usec,
				(int)itv.it_value.tv_sec, (int)itv.it_value.tv_usec);
	}
#endif
%}

%{
// Needed for @__private30 function _struct_sockaddr_u_impl. Unfortunately cannot be
// inlined into the function since these header files define static
// functions themselves.
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/netlink.h>
%}

%{
// Enum for _struct_sockaddr_u_* functions.
typedef enum {
    SA_PRETTY           = 1,
    SA_IP_ADDR          = 2,
    SA_TCP_PORT         = 4,
    SA_FAMILY           = 8,
    SA_IPV6_FLOWINFO    = 16,
    SA_IPV6_SCOPE_ID    = 32,
} sa_dispatch;
%}

function _struct_sockaddr_u_ip_addr:string(uaddr:long, len:long)
{
    return _struct_sockaddr_u_impl(uaddr, len, @const("SA_IP_ADDR"));
}

function _struct_sockaddr_u_tcp_port:string(uaddr:long, len:long)
{
    return _struct_sockaddr_u_impl(uaddr, len, @const("SA_TCP_PORT"));
}

@__private30 function _struct_sockaddr_u_ip_addr_tcp_port:string(uaddr:long, len:long)
{
    return _struct_sockaddr_u_impl(uaddr, len, @const("SA_IP_ADDR") | @const("SA_TCP_PORT"));
}

function _struct_sockaddr_u_sa_family:string(uaddr:long, len:long)
{
    return _struct_sockaddr_u_impl(uaddr, len, @const("SA_FAMILY"));
}

function _struct_sockaddr_u_ipv6_flowinfo:string(uaddr:long, len:long)
{
    return _struct_sockaddr_u_impl(uaddr, len, @const("SA_IPV6_FLOWINFO"));
}

function _struct_sockaddr_u_ipv6_scope_id:string(uaddr:long, len:long)
{
    return _struct_sockaddr_u_impl(uaddr, len, @const("SA_IPV6_SCOPE_ID"));
}

function _struct_sockaddr_u:string(uaddr:long, len:long)
{
    return _struct_sockaddr_u_impl(uaddr, len, @const("SA_PRETTY"));
}

%{
#define STAP_NEED_CONTEXT_SOCKADDR_BIG_BUFFERS 1
%}

@__private30 function _struct_sockaddr_u_impl:string(uaddr:long, len:long, what:long)
%{ /* pure */

#include <linux/version.h>
#include <linux/in6.h>
#include <linux/un.h>
#include <linux/if_packet.h>

sa_dispatch what = (sa_dispatch)STAP_ARG_what;

char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
    size_t len = clamp_t(size_t, STAP_ARG_len, 0, 128);
    struct sockaddr *sa = (struct sockaddr *)CONTEXT->buf;

char *stap_retvalue = (char *)(unsigned long)STAP_RETVALUE;
    int maxstringlen = MAXSTRINGLEN;
    size_t n;

if (ptr == NULL)
	{
		strlcpy(STAP_RETVALUE, "NULL", MAXSTRINGLEN);
		return;
	}

// This helps handle variable lenght sockaddr_un.
    // Some application - like systemd - sends path string
    // without ending null character. Kernel will handle this
    // but we need pretty output without random memory stuff.
    memset(CONTEXT->buf, 0, 128);

if (_stp_copy_from_user(CONTEXT->buf, ptr, len))
	{
		strlcpy(STAP_RETVALUE, "{...}", MAXSTRINGLEN);
		return;
	}

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11)
#define LPORT   (inet->inet.num)
#define DADDR   (&inet->inet.daddr)
#else
#define LPORT   (inet->num)
#define DADDR   (&inet->daddr)
#endif

// Use kernel builtin instead of picking up user space ntohs (function).
#define _stp_ntohs be16_to_cpu

if ((sa->sa_family == AF_INET) && (len == sizeof(struct sockaddr_in)))
	{
		struct sockaddr_in *sin = (struct sockaddr_in *)CONTEXT->buf;

if (what & SA_PRETTY)
        {
#ifndef NIPQUAD_FMT                     // kver >= 2.6.36
            snprintf(STAP_RETVALUE, MAXSTRINGLEN, "{AF_INET, %pI4, %d}",
                &sin->sin_addr, _stp_ntohs(sin->sin_port));
#else
            snprintf(STAP_RETVALUE, MAXSTRINGLEN,
                "{AF_INET, " NIPQUAD_FMT ", %d}",
                NIPQUAD(sin->sin_addr), _stp_ntohs(sin->sin_port));
#endif
            return;
        }

if (what & SA_FAMILY)
        {
            n = strlcpy(stap_retvalue, "AF_INET", maxstringlen);
			// (n - 1) mean: cut of null char
			stap_retvalue += (n);
			maxstringlen -= (n - 1);
        }

if (what & SA_IP_ADDR)
        {
#ifndef NIPQUAD_FMT                     // kver >= 2.6.36
            n = snprintf(stap_retvalue, maxstringlen, "%pI4", &sin->sin_addr);
#else
            n = snprintf(stap_retvalue, maxstringlen, NIPQUAD_FMT,
                    NIPQUAD(sin->sin_addr));
#endif
            // (n - 1) mean: cut of null char
            stap_retvalue += (n);
            maxstringlen -= (n - 1);
        }

if (what & SA_TCP_PORT)
        {
            n = snprintf(stap_retvalue, maxstringlen, "%d",
            _stp_ntohs(sin->sin_port));
            // (n - 1) mean: cut of null char
            stap_retvalue += (n);
            maxstringlen -= (n - 1);
        }
	}
    // Why 2 * sizeof (char) here?
    // Because I want to support abstract sockets with
    // at least one usable byte after initial \0 char.
    // Unnamed sockets aren't supported yet.
	else if ((sa->sa_family == AF_UNIX)
            && ((len == sizeof(struct sockaddr_un))
            || (len >= ((sizeof(sa_family_t)) + (2 * sizeof(char))))))
	{
		struct sockaddr_un *sun = (struct sockaddr_un *)CONTEXT->buf;
		if (what & SA_PRETTY)
		{

// Support for abstract sockets
			if (sun->sun_path[0] == '\0')
			{
                // Abstract sockets aren't string oriented.
                // We need conversion on this place.
                // No check of ret value, because _stp_text_str returns
                // "<unknown>" if bad things happen.

_stp_text_str(CONTEXT->out_str, &sun->sun_path[1],
                    len - sizeof(sa_family_t), MAXSTRINGLEN - 1, 0, 0, 1);

// Why a precision of (MAXSTRINGLEN - 18) here? To
		// make sure the formatted string doesn't get
		// truncated by a long out_str variable, we'll specify
		// the maximum number of characters to add from
		// out_str. That number is MAXSTRINGLEN - 17 (the
		// length of the 'static' part of the format string) -
		// 1 (for the formatted string's null character).
		snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			 "{AF_UNIX, \"\\000%.*s\"}", (MAXSTRINGLEN - 18),
			 CONTEXT->out_str);
            } else
			{
                // Just cut path if is too long
                CONTEXT->buf[127] = '\0';
                snprintf(STAP_RETVALUE, MAXSTRINGLEN, "{AF_UNIX, \"%s\"}",
                    sun->sun_path);
			}
		} else if (what & SA_FAMILY)
		{
            strlcpy(STAP_RETVALUE, "AF_UNIX", MAXSTRINGLEN);
		} else
		{
			strlcpy(STAP_RETVALUE, "", MAXSTRINGLEN);
		}
	}
	else if ((sa->sa_family == AF_NETLINK)
		 && (len == sizeof(struct sockaddr_nl)))
	{
		struct sockaddr_nl *nl = (struct sockaddr_nl *)CONTEXT->buf;

if (what & SA_PRETTY) {
            snprintf(STAP_RETVALUE, MAXSTRINGLEN,
                "{AF_NETLINK, pid=%d, groups=%08x}",
                nl->nl_pid, nl->nl_groups);
        } else if (what & SA_FAMILY)
        {
            strlcpy(STAP_RETVALUE, "AF_NETLINK", MAXSTRINGLEN);
        } else
        {
            strlcpy(STAP_RETVALUE, "", MAXSTRINGLEN);
        }
    }
	else if ((sa->sa_family == AF_INET6)
		 && (len == sizeof(struct sockaddr_in6)))
	{
		struct sockaddr_in6 *sin = (struct sockaddr_in6 *)CONTEXT->buf;

if (what & SA_PRETTY)
        {
#ifndef NIP6_FMT			// kver >= 2.6.36
            snprintf(STAP_RETVALUE, MAXSTRINGLEN,
                 "{AF_INET6, %pI6, %d}", &sin->sin6_addr,
                 _stp_ntohs(sin->sin6_port));
#else
            snprintf(STAP_RETVALUE, MAXSTRINGLEN,
                 "{AF_INET6, " NIP6_FMT ", %d}", NIP6(sin->sin6_addr),
                 _stp_ntohs(sin->sin6_port));
#endif
            return;
        }

if (what & SA_FAMILY)
        {
            n = strlcpy(stap_retvalue, "AF_INET6", maxstringlen);
			// (n - 1) mean: cut of null char
			stap_retvalue += (n);
			maxstringlen -= (n - 1);
        }

if (what & SA_IP_ADDR)
        {
#ifndef NIP6_FMT			// kver >= 2.6.36
            n = snprintf(stap_retvalue, maxstringlen,
                 "%pI6", &sin->sin6_addr);
#else
            n = snprintf(stap_retvalue, maxstringlen,
                 NIP6_FMT, NIP6(sin->sin6_addr));
#endif
			// (n - 1) mean: cut of null char
			stap_retvalue += (n);
			maxstringlen -= (n - 1);
        }

if (what & SA_TCP_PORT)
        {
            n = snprintf(stap_retvalue, maxstringlen,
                "%d", _stp_ntohs(sin->sin6_port));
            // (n - 1) mean: cut of null char
            stap_retvalue += (n);
            maxstringlen -= (n - 1);
        }

if (what & SA_IPV6_FLOWINFO)
        {
            n = snprintf(stap_retvalue, maxstringlen,
                 "%d", sin->sin6_flowinfo);
			// (n - 1) mean: cut of null char
			stap_retvalue += (n);
			maxstringlen -= (n - 1);
        }

if (what & SA_IPV6_SCOPE_ID)
        {
            n = snprintf(stap_retvalue, maxstringlen,
                 "%d", sin->sin6_flowinfo);
			// (n - 1) mean: cut of null char
			stap_retvalue += (n);
			maxstringlen -= (n - 1);
        }
	}
	else if ((sa->sa_family == AF_PACKET)
		 && (len == sizeof(struct sockaddr_ll)))
	{
		struct sockaddr_ll *sll = (struct sockaddr_ll *)CONTEXT->buf;

if (what & SA_PRETTY)
        {
            snprintf(STAP_RETVALUE, MAXSTRINGLEN,
                 "{AF_PACKET, proto=%d, ind=%d, hatype=%d, pkttype=%d, halen=%d, addr=0x%llx}",
                 (int)sll->sll_protocol, sll->sll_ifindex,
                 (int)sll->sll_hatype, (int)sll->sll_pkttype,
                 (int)sll->sll_halen,
                 (long long)(*(uint64_t *)sll->sll_addr));
        } else if (what & SA_FAMILY)
        { 
            strlcpy(STAP_RETVALUE, "AF_PACKET", MAXSTRINGLEN);
        } else
        {
            strlcpy(STAP_RETVALUE, "", MAXSTRINGLEN);
        }
	}
	else
	{
		if (len >= sizeof(sa_family_t))
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
				 "{unknown sockaddr with sa=%d, salen=%d}",
				 sa->sa_family, (int) len);
		}
		else
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
				 "{unknown sockaddr with salen=%d}", (int)len);
		}
	}
%}

function _struct_rlimit_u:string(uaddr:long)
%{ /* pure */
	struct rlimit rl;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;

if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char *)&rl, ptr, sizeof(struct rlimit)) == 0)
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "[%ld,%ld]",
				rl.rlim_cur, rl.rlim_max);
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
	}
%}

function _fildes_index_u:long (uaddr:long, index:long)
%{ /* pure */
	int fd[2];
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;

if (ptr == NULL || !(STAP_ARG_index == 0 || STAP_ARG_index == 1))
		STAP_RETVALUE = 0;
	else {
		if (_stp_copy_from_user((char *)&fd, ptr, 2*sizeof(int)) == 0)
			STAP_RETVALUE = fd[STAP_ARG_index];
		else
			STAP_RETVALUE = 0;
	}
%}

function __sem_flags:string(semflg:long)
%{ /* pure */ /* unprivileged */
	long semflg = STAP_ARG_semflg;
	char *str = STAP_RETVALUE;
	int mode;
	int len;
	int flag = 0;

mode = semflg & S_IRWXUGO;
	semflg &= ~S_IRWXUGO;

str[0] = '\0';
	if (semflg & IPC_CREAT) {
		strlcat(str, "IPC_CREAT", MAXSTRINGLEN);
		semflg &= ~IPC_CREAT;
		flag = 1;
	}
	if (semflg & IPC_EXCL) {
		if (flag)
			strlcat(str, "|", MAXSTRINGLEN);
		strlcat(str, "IPC_EXCL", MAXSTRINGLEN);
		semflg &= ~IPC_EXCL;
		flag = 1;
	}
	if (semflg) {
		if (flag)
			strlcat(str, "|", MAXSTRINGLEN);
		len = strlen(str);
		_stp_snprintf(str + len, MAXSTRINGLEN - len, "0x%lx", semflg); 
		flag = 1;
	}
	if (mode) {
		if (flag)
			strlcat(str, "|", MAXSTRINGLEN);
		len = strlen(str);
		_stp_snprintf(str + len, MAXSTRINGLEN - len, "%#o", mode); 
	}
%}

%(systemtap_v <= "3.2" %?
@__private30 function __user_pointer:long (addr:long)
{
	return user_long_error(addr)
}
%)

/* This function copies an argv from userspace. */
function __get_argv:string(argv:long, first:long)
{
%( CONFIG_64BIT == "y" %?
	str = "["
	if (first && argv)
		# 8 == sizeof(long) on a 64-bit OS
		argv += (8 * first)
	while (argv) {
		try {
			vstr = user_long_error(argv)
		} catch {
			if (len)
				str .= ", "
			str .= sprintf("0x%x", argv)
			break
		}
		if (vstr == 0)
			break

if (len)
			str .= ", "
		str .= user_string_quoted(vstr)

newlen = strlen(str)
		if (newlen == len)
			break
		len = newlen
		# 8 == sizeof(long) on a 64-bit OS
		argv += 8
	}
	str .= "]"
	return str
%:
	return __get_compat_argv(argv, first)
%)
}

/* This function copies an argv from userspace. */
function __get_compat_argv:string(argv:long, first:long)
{
	str = "["
	if (first && argv)
		# 4 == sizeof(long) on a 32-bit OS
		argv += (4 * first)
	while (argv) {
		try {
			vstr = user_long_error(argv) & 0xffffffff
		} catch {
			if (len)
				str .= ", "
			str .= sprintf("0x%x", argv)
			break
		}
		if (vstr == 0)
			break

if (len)
			str .= ", "
		str .= user_string_quoted(vstr)

newlen = strlen(str)
		if (newlen == len)
			break
		len = newlen
		# 4 == sizeof(long) on a 32-bit OS
		argv += 4
	}
	str .= "]"
	return str
}

%( systemtap_v <= "3.2" %?
/*
 * The __count_envp() and __count_compat_envp() functions aren't
 * used anywhere, so let's deprecate them.
 */

/* Count the number of environment variables. */
function __count_envp:string(envp:long)
{
%( CONFIG_64BIT == "y" %?
	__argc = 0
	while (envp) {
		# We can call 'user_long(envp)' here because we don't
		# need to know the difference between a bad address
		# and just getting a 0.
		vstr = user_long(envp)
		if (vstr == 0)
			break

__argc++
		# 8 == sizeof(long) on a 64-bit OS
		envp += 8
	}
	return sprintf("[/* %d var%s */]", __argc, __argc != 1 ? "s" : "")
%:
	return __count_compat_envp(envp)
%)
}

function __count_compat_envp:string(envp:long)
{
	__argc = 0
	while (envp) {
		# We can call 'user_long(envp)' here because we don't
		# need to know the difference between a bad address
		# and just getting a 0.
		vstr = user_long(envp)
		if (vstr == 0)
			break

__argc++
		# 4 == sizeof(long) on a 32-bit OS
		envp += 4
	}
	return sprintf("[/* %d var%s */]", __argc, __argc != 1 ? "s" : "")
}
%)

%(systemtap_v <= "2.7" %?
/*
 * This function isn't actually used anywhere, so let's deprecate it.
 *
 * Return the  symbolic string  representation
 * of the struct timex.mode member of adjtimex
 * consult `man adjtimex` for more information
 * CALLERS:
 *    syscall.adjtimex
 */
function _adjtx_mode_str(f) {
   if((f & 32769) == 32769) bs="ADJ_OFFSET_SINGLESHOT|".bs
   if(f  & 16384) bs="ADJ_TICK|".bs
   if(f  & 32)    bs="ADJ_TIMECONST|".bs
   if(f  & 16)    bs="ADJ_STATUS|".bs
   if(f  & 8)     bs="ADJ_ESTERROR|".bs
   if(f  & 4)     bs="ADJ_MAXERROR|".bs
   if(f  & 2)     bs="ADJ_FREQUENCY|".bs
   if(f & 1 && ((f & 32769) != 32769)) bs="ADJ_OFFSET|".bs
   return substr(bs,0,strlen(bs)-1)
}
%)

%{
#include <linux/random.h>

static const _stp_val_array _stp_getrandom_list[] = {
#ifdef GRND_NONBLOCK
  V(GRND_NONBLOCK),
#endif
#ifdef GRND_RANDOM
  V(GRND_RANDOM),
#endif
  {0, NULL}
};
%}

function _getrandom_flags_str:string(flag:long)
%{ /* pure */ /* unprivileged */
	unsigned int grflag = (unsigned int)STAP_ARG_flag;  
	_stp_lookup_or_str(_stp_getrandom_list, grflag, STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#if (defined(CONFIG_INOTIFY) || defined(CONFIG_INOTIFY_USER))
#include <linux/inotify.h>
#endif
 
/* Ignore helper events IN_CLOSE and IN_MOVE, which are just
 * combinations of other events. */

static const _stp_val_array _stp_inotify_watch_mask_list[] = {
	V(IN_ACCESS),
	V(IN_MODIFY),
	V(IN_ATTRIB),
	V(IN_CLOSE_WRITE),
	V(IN_CLOSE_NOWRITE),
	V(IN_OPEN),
 	V(IN_MOVED_FROM),
	V(IN_MOVED_TO),
	V(IN_CREATE),
	V(IN_DELETE),
	V(IN_DELETE_SELF),
	V(IN_MOVE_SELF),
	V(IN_UNMOUNT),
	V(IN_Q_OVERFLOW),
	V(IN_IGNORED),
	V(IN_ONLYDIR),
	V(IN_DONT_FOLLOW),
#ifdef IN_EXCL_UNLINK
	V(IN_EXCL_UNLINK),
#endif
	V(IN_MASK_ADD),
	V(IN_ISDIR),
	V(IN_ONESHOT),
	{0, NULL}
};
%}

function _inotify_watch_mask_str:string(mask:long)
%{ /* pure */ /* unprivileged */
	uint32_t mask = (uint32_t)STAP_ARG_mask;
	_stp_lookup_or_str(_stp_inotify_watch_mask_list, mask, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

/*
 * Return the symbolic string representation
 * of the how argument given in *sigprocmask
 * consult  `man sigprocmask`  for more info
 * CALLERS:
 *    syscall.sigprocmask
 *    syscall.rt_sigprocmask
 */
function _sigprocmask_how_str:string(how:long)
%{ /* pure */ /* unprivileged */
	int len;
	char *str = STAP_RETVALUE;
	switch (STAP_ARG_how) {
	case SIG_BLOCK:
		strlcpy(str, "SIG_BLOCK", MAXSTRINGLEN);
		break;
	case SIG_UNBLOCK:
		strlcpy(str, "SIG_UNBLOCK", MAXSTRINGLEN);
		break;
	case SIG_SETMASK:
		strlcpy(str, "SIG_SETMASK", MAXSTRINGLEN);
		break;
	default:
		snprintf(str, MAXSTRINGLEN, "0x%lx", (long)STAP_ARG_how);
	}	
%}

/*
 * Return the symbolic string representation
 * of the which argument  given to setitimer
 * consult  `man setitimer`  for  more  info
 * CALLERS:
 *    syscall.getitimer
 *    syscall.setitimer
 * INCLUDE: <linux/time.h>
 */
%{
#include <linux/time.h>
static const _stp_val_array _stp_itimer_which_list[] = {
	V(ITIMER_REAL),
	V(ITIMER_VIRTUAL),
	V(ITIMER_PROF),
	{0, NULL}
};
%}
function _itimer_which_str:string(which:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_itimer_which_list, (unsigned int)STAP_ARG_which,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

/*
 * Return the command name for nfsservctl()
 * nfsservctl was removed in kernel 3.0/2.6.40.
 */
%( kernel_v < "2.6.40" && CONFIG_NFSD == "[ym]" %?
%{
#include <linux/sunrpc/svc.h>
#include <linux/nfsd/nfsfh.h>
#include <linux/nfsd/syscall.h>
static const _stp_val_array _stp_nfsctl_cmd_list[] = {
	V(NFSCTL_SVC),
	V(NFSCTL_ADDCLIENT),
	V(NFSCTL_DELCLIENT),
	V(NFSCTL_EXPORT),
	V(NFSCTL_UNEXPORT),
#ifdef NFSCTL_UGIDUPDATE
	V(NFSCTL_UGIDUPDATE),
#endif
#ifdef NFSCTL_GETFH
	V(NFSCTL_GETFH),
#endif
	V(NFSCTL_GETFD),
	V(NFSCTL_GETFS),
	{0, NULL}
};
%}

function _nfsctl_cmd_str:string(cmd:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_nfsctl_cmd_list, (unsigned int)STAP_ARG_cmd,
			STAP_RETVALUE, MAXSTRINGLEN);
%}
%)

/*
 * Return  the  symbolic   string  representation
 * of the clockid argument  given to create_timer
 * consult  `man create_timer`  for  more  info
 * CALLERS:
 *    syscall.timer_create
 *    syscall.clock_settime
 *    syscall.clock_gettime
 *    syscall.clock_getres
 *    syscall.clock_nanosleep
 */
%{
#include <linux/time.h>

static const _stp_val_array _stp_wc_str_list[] = {
	V(CLOCK_REALTIME),
	V(CLOCK_MONOTONIC),
	V(CLOCK_PROCESS_CPUTIME_ID),
	V(CLOCK_THREAD_CPUTIME_ID),
#ifdef CLOCK_MONOTONIC_RAW
	V(CLOCK_MONOTONIC_RAW),
#endif
#ifdef CLOCK_REALTIME_COARSE
	V(CLOCK_REALTIME_COARSE),
#endif
#ifdef CLOCK_MONOTONIC_COARSE
	V(CLOCK_MONOTONIC_COARSE),
#endif
#ifdef CLOCK_BOOTTIME
	V(CLOCK_BOOTTIME),
#endif
#ifdef CLOCK_REALTIME_ALARM
	V(CLOCK_REALTIME_ALARM),
#endif
#ifdef CLOCK_BOOTTIME_ALARM
	V(CLOCK_BOOTTIME_ALARM),
#endif
	V(CLOCK_SGI_CYCLE),
#ifdef CLOCK_TAI
	V(CLOCK_TAI),
#endif
	{0, NULL}
};
%}

function _get_wc_str:string(wc:long)
%{ /* pure */ /* unprivileged */
	unsigned int clkid = (unsigned int)STAP_ARG_wc;
	_stp_lookup_str(_stp_wc_str_list, clkid, STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/fcntl.h>

static const _stp_val_array _stp_flock_cmd_list[] = {
	V(LOCK_SH),
	V(LOCK_EX),
	V(LOCK_NB),
	V(LOCK_UN),
	V(LOCK_MAND),
	V(LOCK_READ),
	V(LOCK_WRITE),
	V(LOCK_RW),
	{0, NULL}
};

static const _stp_val_array _stp_pipe2_flags_list[] = {
#ifdef O_NONBLOCK
	V(O_NONBLOCK),
#endif
#ifdef O_CLOEXEC
	V(O_CLOEXEC),
#endif
#ifdef O_DIRECT
	V(O_DIRECT),
#endif
	{0, NULL}
};
%}

function _flock_cmd_str:string(c:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_flock_cmd_list, (unsigned int)STAP_ARG_c,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

/* `man 2 pipe2` for more information */
function _sys_pipe2_flag_str:string (f:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = STAP_ARG_f;

_stp_lookup_or_str(_stp_pipe2_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#include <linux/fcntl.h>
 
static const _stp_val_array _stp_open_mode_flags_list[] = {
#ifdef O_CREAT
	V(O_CREAT),
#endif
#ifdef O_EXCL
	V(O_EXCL),
#endif
#ifdef O_NOCTTY
	V(O_NOCTTY),
#endif
#ifdef O_TRUNC
	V(O_TRUNC),
#endif
#ifdef O_APPEND
	V(O_APPEND),
#endif
#ifdef O_NONBLOCK
	V(O_NONBLOCK),
#endif

/* Here's a comment from the kernel source:
 *
 * ====
 * Before Linux 2.6.33 only O_DSYNC semantics were implemented, but using
 * the O_SYNC flag.  We continue to use the existing numerical value
 * for O_DSYNC semantics now, but using the correct symbolic name for it.
 * This new value is used to request true Posix O_SYNC semantics.  It is
 * defined in this strange way to make sure applications compiled against
 * new headers get at least O_DSYNC semantics on older kernels.
 * ====
 *
 * On RHEL6 (2.6.32-431.3.1.el6.x86_64), the user headers are ahead of
 * the kernel source and define O_DSYNC, but the kernel just ignores
 * the extra bit set. We'll try to handle it here.
 */
#ifndef O_DSYNC
	{ O_SYNC | 04000000, "O_SYNC" },
#endif
#ifdef O_SYNC
	V(O_SYNC),
#endif
#ifdef O_DSYNC
	V(O_DSYNC),
#endif
#ifdef O_ASYNC
	V(O_ASYNC),
#elif defined(FASYNC)
	{ FASYNC, "O_ASYNC" },
#endif
#ifdef O_DIRECT
	V(O_DIRECT),
#endif
#ifdef O_LARGEFILE
	V(O_LARGEFILE),
#endif
#ifdef O_DIRECTORY
	V(O_DIRECTORY),
#endif
#ifdef O_NOFOLLOW
	V(O_NOFOLLOW),
#endif
#ifdef O_NOATIME
	V(O_NOATIME),
#endif
#ifdef O_CLOEXEC
	V(O_CLOEXEC),
#endif
#ifdef O_PATH
	V(O_PATH),
#endif
	{0, NULL}
};
%}

/* `man 2 open` for more information */
function _sys_open_flag_str:string (f:long)
%{ /* pure */ /* unprivileged */
	int flags = (int)STAP_ARG_f;
	int acc = flags & O_ACCMODE;

switch (acc) {
	case O_WRONLY:
		strlcpy (STAP_RETVALUE, "O_WRONLY", MAXSTRINGLEN);
		break;
	case O_RDWR:
		strlcpy (STAP_RETVALUE, "O_RDWR", MAXSTRINGLEN);
		break;
	default:
		strlcpy (STAP_RETVALUE, "O_RDONLY", MAXSTRINGLEN);
	}

flags &= ~O_ACCMODE;
	if (flags) {
		strlcat(STAP_RETVALUE, "|", MAXSTRINGLEN);
		_stp_lookup_or_str(_stp_open_mode_flags_list, flags,
				   STAP_RETVALUE, MAXSTRINGLEN);
	}
%}

%{
/* Notice that the kernel defines and the user defines are named
 * differently. */
static const _stp_val_array _stp_access_mode_list[] = {
	{0, "F_OK"},
	{MAY_READ, "R_OK"},
	{MAY_WRITE, "W_OK"},
	{MAY_EXEC, "X_OK"},
	{0, NULL}
};
%}

/* `man 2 open` for more information */
function _access_mode_str:string(mode:long)
%{ /* pure */ /* unprivileged */
	unsigned int mode = (unsigned int)STAP_ARG_mode;
	_stp_lookup_or_str(_stp_access_mode_list, mode, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_faccessat2_flags_list[] = {
	{0x100, "AT_SYMLINK_NOFOLLOW"},
	{0x200, "AT_EACCESS"},
	{0, NULL}
};
%}

function _faccessat2_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = (unsigned int)STAP_ARG_flags;
	_stp_lookup_or_str(_stp_faccessat2_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

/* `man 2 open` for more information */
@__private30 function _sys_open_mode_str(f)
{
   if ((f & @const("S_IRWXU"))
       == @const("S_IRWXU")) bs="S_IRWXU|".bs
   else {
        if (f & @const("S_IRUSR")) bs="S_IRUSR|" . bs
        if (f & @const("S_IWUSR")) bs="S_IWUSR|" . bs
        if (f & @const("S_IXUSR")) bs="S_IXUSR|" . bs
   }
   if ((f & @const("S_IRWXG"))
       == @const("S_IRWXG")) bs="S_IRWXG|" . bs
   else {
        if (f & @const("S_IRGRP")) bs="S_IRGRP|" . bs
        if (f & @const("S_IWGRP")) bs="S_IWGRP|" . bs
        if (f & @const("S_IXGRP")) bs="S_IXGRP|" . bs
   }
   if ((f & @const("S_IRWXO"))
       == @const("S_IRWXO")) bs="S_IRWXO|" . bs
   else {
        if (f & @const("S_IROTH")) bs="S_IROTH|" . bs
        if (f & @const("S_IWOTH")) bs="S_IWOTH|" . bs
        if (f & @const("S_IXOTH")) bs="S_IXOTH|" . bs
   }
   return (strlen(bs) > 0) ? substr(bs, 0, strlen(bs) - 1) : sprintf("%#o", f)
}

/* `man 2 mknod` for more information */
function _mknod_mode_str:string(mode:long)
{
   type = mode & @const("S_IFMT")
   mode &= ~@const("S_IFMT")
   if (type == @const("S_IFREG"))
        return sprintf("S_IFREG|%#o", mode)
   if (type == @const("S_IFCHR"))
        return sprintf("S_IFCHR|%#o", mode)
   if (type == @const("S_IFBLK"))
        return sprintf("S_IFBLK|%#o", mode)
   if (type == @const("S_IFIFO"))
        return sprintf("S_IFIFO|%#o", mode)
   if (type == @const("S_IFSOCK"))
        return sprintf("S_IFSOCK|%#o", mode)
   return sprintf("%#o", type | mode)
}

%{
#include <linux/mman.h>

static const _stp_val_array _stp_msync_flag_list[] = {
	V(MS_ASYNC),
	V(MS_INVALIDATE),
	V(MS_SYNC),
	{0, NULL}
};
%}

/* `man msync` for more information */
function _msync_flag_str:string(f:long)
%{ /* pure */ /* unprivileged */
	uint32_t flags = (uint32_t)STAP_ARG_f;
	_stp_lookup_or_str(_stp_msync_flag_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#include <linux/wait.h>

static const _stp_val_array _stp_wait4_op_list[] = {
	V(WNOHANG),
#if !defined(WSTOPPED) && defined(WUNTRACED)
	V(WUNTRACED),
#endif
	V(WEXITED),
#ifdef WSTOPPED
	V(WSTOPPED),
#endif
	V(WCONTINUED),
	V(WNOWAIT),
	V(__WNOTHREAD),
	V(__WALL),
	V(__WCLONE),
	{0, NULL}
};

%(systemtap_v <= "2.7" %?
function _internal_wait_opt_str:string(f:long, bit_num:long, bit_str:string)
%{ /* pure */ /* unprivileged */
	/* ignore bit_num and bit_str */
	_stp_lookup_or_str(_stp_wait4_op_list, (unsigned int)STAP_ARG_f,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

/* `man waitid` for more information */
function _waitid_opt_str:string(f:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_wait4_op_list, (unsigned int)STAP_ARG_f,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}
%)

/* `man wait4` for more information */
function _wait4_opt_str:string(f:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_wait4_op_list, (unsigned int)STAP_ARG_f,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

function WIFEXITED(f) {
  return (f & 0x7f) == 0
}

function WEXITSTATUS(f) {
  return (f & 0xff00) >> 8
}

@__private30 function WIFSIGNALED(f) {
  return (f & 0x7f) != 0 && (f & 0x7f) != 0x7f
}

@__private30 function WCOREDUMP(f) {
  return f & 0x80
}

function WTERMSIG(f) {
  return f & 0x7f
}

@__private30 function WIFSTOPPED(f) {
  return (f & 0xff) == 0x7f
}

@__private30 function WSTOPSIG(f) {
  return (f & 0xff00) >> 8
}

@__private30 function WIFCONTINUED(f) {
  return f == 0xffff
}

@__private30 function _ptrace_event_name(f)
{
  if (f == @const("PTRACE_EVENT_FORK"))
    return "PTRACE_EVENT_FORK"
  if (f == @const("PTRACE_EVENT_VFORK"))
    return "PTRACE_EVENT_VFORK"
  if (f == @const("PTRACE_EVENT_CLONE"))
    return "PTRACE_EVENT_CLONE"
  if (f == @const("PTRACE_EVENT_EXEC"))
    return "PTRACE_EVENT_EXEC"
  if (f == @const("PTRACE_EVENT_VFORK_DONE"))
    return "PTRACE_EVENT_VFORK_DONE"
  if (f == @const("PTRACE_EVENT_EXIT"))
    return "PTRACE_EVENT_EXIT"
  return ""
}

/* `man 2 wait` for more information */
function _wait_status_str(f) {
  if ((f >> 16) != 0)
    tail = sprintf (" | 0x%x", f & ~0xffff)
  else
    tail = ""

if (WIFEXITED(f))
    return sprintf ("WEXITSTATUS=%d", WEXITSTATUS(f)).tail
  if (WIFSIGNALED(f)) {
      if (WCOREDUMP(f))
        return "WCOREDUMP".tail
      return sprintf ("WTERMSIG=%s", _signal_name(WTERMSIG(f))).tail
    }
  if (WIFSTOPPED(f))
    {
      if (WSTOPSIG(f) == @const("SIGTRAP"))
	{
	  event = _ptrace_event_name (f >> 16)
	  if (event != "")
	    tail = " | ".event." << 8"
	}
      return sprintf ("WSTOPSIG=%s", _signal_name(WSTOPSIG(f))).tail
    }
  if (WIFCONTINUED(f))
    return "WIFCONTINUED".tail
  return sprintf ("?=0x%x", f)
}

%{
#include <linux/seccomp.h>
static const _stp_val_array _stp_seccomp_flags_list[] = {
#ifdef SECCOMP_FILTER_FLAG_TSYNC
        V(SECCOMP_FILTER_FLAG_TSYNC),
#endif
        {0, NULL}
};

static const _stp_val_array _stp_seccomp_mode_list[] = {
#ifdef SECCOMP_MODE_DISABLED
	V(SECCOMP_MODE_DISABLED),
#endif
#ifdef SECCOMP_MODE_STRICT
	V(SECCOMP_MODE_STRICT),
#endif
#ifdef SECCOMP_MODE_FILTER
	V(SECCOMP_MODE_FILTER),
#endif
        {0, NULL}
};
%}

function _seccomp_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
        unsigned int flags = (unsigned int)STAP_ARG_flags;
	_stp_lookup_str(_stp_seccomp_flags_list, flags, STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_msg_flags_list[] = {
	V(MSG_OOB),
	V(MSG_PEEK),
	V(MSG_DONTROUTE),
	V(MSG_TRYHARD),
	V(MSG_CTRUNC),
	V(MSG_PROBE),
	V(MSG_TRUNC),
	V(MSG_DONTWAIT),
	V(MSG_EOR),
	V(MSG_WAITALL),
	V(MSG_FIN),
	V(MSG_SYN),
	V(MSG_CONFIRM),
	V(MSG_RST),
	V(MSG_ERRQUEUE),
	V(MSG_NOSIGNAL),
	V(MSG_MORE),
#ifdef MSG_WAITFORONE
	V(MSG_WAITFORONE),
#endif
#ifdef MSG_SENDPAGE_NOTLAST
	V(MSG_SENDPAGE_NOTLAST),
#endif
	V(MSG_EOF),
#ifdef MSG_FASTOPEN
	V(MSG_FASTOPEN),
#endif
#ifdef MSG_CMSG_CLOEXEC
	V(MSG_CMSG_CLOEXEC),
#endif
	{0, NULL}
};
%}

function _msg_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	// Ignore MSG_CMSG_COMPAT in flags.
	_stp_lookup_or_str(_stp_msg_flags_list,
			   (STAP_ARG_flags & ~MSG_CMSG_COMPAT), STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%(systemtap_v <= "2.5" %?
function _sendflags_str:string(flags:long)
{
	return _msg_flags_str(flags)
}
function _recvflags_str:string(flags:long)
{
	return _msg_flags_str(flags)
}
%)

%{
#ifdef __NR_memfd_create
#include <uapi/linux/memfd.h>
#endif
static const _stp_val_array _stp_mfd_flags_list[] = {
#ifdef MFD_CLOEXEC
        V(MFD_CLOEXEC),
#endif
#ifdef MFD_ALLOW_SEALING
        V(MFD_ALLOW_SEALING),
#endif
#ifdef O_CLOEXEC
        V(O_CLOEXEC),
#endif
        {0, NULL}
};
%}

function _mfd_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
          unsigned int flags = (unsigned int)STAP_ARG_flags;
	  _stp_lookup_or_str(_stp_mfd_flags_list, flags, STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/mman.h>
static const _stp_val_array _stp_mlock2_flags_list[] = {
#ifdef MLOCK_ONFAULT  
         V(MLOCK_ONFAULT),
#endif
        {0, NULL}
};
%}
/* `man mlock2` for more information */
function _stp_mlock2_str:string(flags:long)
%{ /* pure */ /* unprivileged */
        uint32_t flags = (uint32_t)STAP_ARG_flags;
        _stp_lookup_or_str(_stp_mlock2_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#include <linux/mman.h>
static const _stp_val_array _stp_mlockall_flags_list[] = {
	V(MCL_CURRENT),
	V(MCL_FUTURE),
#ifdef MCL_ONFAULT
	V(MCL_ONFAULT),
#endif
	{0, NULL}
};
%}
/* `man mlockall` for more information */
function _mlockall_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	uint32_t flags = (uint32_t)STAP_ARG_flags;
	_stp_lookup_or_str(_stp_mlockall_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_module_flags_list[] = {
	V(O_TRUNC),
	V(O_NONBLOCK),
	{0, NULL}
};
%}

/* used by sys_delete_module */
function _module_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
 	_stp_lookup_or_str(_stp_module_flags_list, (unsigned int)STAP_ARG_flags,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/sched.h>
#if defined(STAPCONF_LINUX_SCHED_HEADERS)
#include <uapi/linux/sched/types.h>
#endif

static const _stp_val_array _stp_sched_policy_list[] = {
	{SCHED_NORMAL, "SCHED_OTHER"}, // SCHED_NORMAL==SCHED_OTHER
	V(SCHED_FIFO),
	V(SCHED_RR),
	V(SCHED_BATCH),
#ifdef SCHED_IDLE
	V(SCHED_IDLE),
#endif
#ifdef SCHED_DEADLINE
	V(SCHED_DEADLINE),
#endif
	{0, NULL}
};
%}

function _sched_policy_str:string(policy:long)
%{ /* pure */ /* unprivileged */
	unsigned int policy = (unsigned int)STAP_ARG_policy;
	int len;

#ifdef SCHED_RESET_ON_FORK
	if (((int)STAP_ARG_policy > 0) && (policy & SCHED_RESET_ON_FORK)) {
		strlcpy(STAP_RETVALUE, "SCHED_RESET_ON_FORK|", MAXSTRINGLEN);
		policy &= ~SCHED_RESET_ON_FORK;
	}
#endif
	len = strlen(STAP_RETVALUE);
	_stp_lookup_str(_stp_sched_policy_list, policy, STAP_RETVALUE + len,
			MAXSTRINGLEN - len);
%}

%{
static const _stp_val_array _stp_priority_which_list[] = {
	V(PRIO_PROCESS),
	V(PRIO_PGRP),
	V(PRIO_USER),
	{0, NULL}
};
%}

function _priority_which_str:string(which:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_priority_which_list, (unsigned int)STAP_ARG_which,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_shutdown_how_list[] = {
	V(SHUT_RD),
	V(SHUT_WR),
	V(SHUT_RDWR),
	{0, NULL}
};
%}

function _shutdown_how_str:string(how:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_shutdown_how_list, (unsigned int)STAP_ARG_how,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
// Needed for function __reboot_magic_str:string. Unfortunately cannot
// be inlined into the function since these header file defines static
// functions on some architectures.
#include <linux/reboot.h>

static const _stp_val_array _stp_reboot_magic_list[] = {
	V(LINUX_REBOOT_MAGIC1),
	V(LINUX_REBOOT_MAGIC2),
	V(LINUX_REBOOT_MAGIC2A),
	V(LINUX_REBOOT_MAGIC2B),
	V(LINUX_REBOOT_MAGIC2C),
	{0, NULL}
};
%}

function _reboot_magic_str:string(magic:long)
%{ /* pure */ /* unprivileged */
	unsigned int magic = (unsigned int)STAP_ARG_magic;
	_stp_lookup_str(_stp_reboot_magic_list, magic, STAP_RETVALUE,
			MAXSTRINGLEN);
%}

%{
#include <linux/reboot.h>
static const _stp_val_array _stp_reboot_flag_list[] = {
	V(LINUX_REBOOT_CMD_RESTART),
	V(LINUX_REBOOT_CMD_HALT),
	V(LINUX_REBOOT_CMD_CAD_ON),
	V(LINUX_REBOOT_CMD_CAD_OFF),
	V(LINUX_REBOOT_CMD_POWER_OFF),
	V(LINUX_REBOOT_CMD_RESTART2),
	V(LINUX_REBOOT_CMD_SW_SUSPEND),
	V(LINUX_REBOOT_CMD_KEXEC),
	{0, NULL}
};	
%}

function _reboot_flag_str:string(flag:long)
%{  /* pure */ /* unprivileged */
	unsigned int flag = (unsigned int)STAP_ARG_flag;
	_stp_lookup_str(_stp_reboot_flag_list, flag, STAP_RETVALUE,
			MAXSTRINGLEN);
%}

%{
#include <linux/wait.h>
static const _stp_val_array _stp_waitid_which_list[] = {
	V(P_ALL),
	V(P_PID),
	V(P_PGID),
	{0, NULL}
};
%}

function _waitid_which_str:string(flag:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_waitid_which_list, (unsigned int)STAP_ARG_flag,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/futex.h>

// We need the following defines to have a value for the
// @__futex_argstr() macro.
#ifndef FUTEX_WAIT_BITSET
#define FUTEX_WAIT_BITSET	9
#endif
#ifndef FUTEX_WAKE_BITSET
#define FUTEX_WAKE_BITSET	10
#endif
#ifndef FUTEX_WAIT_REQUEUE_PI
#define FUTEX_WAIT_REQUEUE_PI	11
#endif
#ifndef FUTEX_CMP_REQUEUE_PI
#define FUTEX_CMP_REQUEUE_PI	12
#endif
#ifndef FUTEX_PRIVATE_FLAG
#define FUTEX_PRIVATE_FLAG 128
#endif
#ifndef FUTEX_WAIT_BITSET_PRIVATE
#define FUTEX_WAIT_BITSET_PRIVATE (FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG)
#endif
#ifndef FUTEX_WAKE_BITSET_PRIVATE
#define FUTEX_WAKE_BITSET_PRIVATE (FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG)
#endif
#ifndef FUTEX_WAIT_REQUEUE_PI_PRIVATE
#define FUTEX_WAIT_REQUEUE_PI_PRIVATE	(FUTEX_WAIT_REQUEUE_PI | \
					 FUTEX_PRIVATE_FLAG)
#endif
#ifndef FUTEX_CMP_REQUEUE_PI_PRIVATE
#define FUTEX_CMP_REQUEUE_PI_PRIVATE	(FUTEX_CMP_REQUEUE_PI | \
					 FUTEX_PRIVATE_FLAG)
#endif

static const _stp_val_array _stp_futex_op_list[] = {
	V(FUTEX_WAIT),
	V(FUTEX_WAKE),
	V(FUTEX_FD),
	V(FUTEX_REQUEUE),
	V(FUTEX_CMP_REQUEUE),
	V(FUTEX_WAKE_OP),
	V(FUTEX_LOCK_PI),
	V(FUTEX_UNLOCK_PI),
	V(FUTEX_TRYLOCK_PI),
	V(FUTEX_WAIT_BITSET),
	V(FUTEX_WAKE_BITSET),
	V(FUTEX_WAIT_REQUEUE_PI),
	V(FUTEX_CMP_REQUEUE_PI),
	V(FUTEX_WAIT_PRIVATE),
	V(FUTEX_WAKE_PRIVATE),
	V(FUTEX_REQUEUE_PRIVATE),
	V(FUTEX_CMP_REQUEUE_PRIVATE),
	V(FUTEX_WAKE_OP_PRIVATE),
	V(FUTEX_LOCK_PI_PRIVATE),
	V(FUTEX_UNLOCK_PI_PRIVATE),
	V(FUTEX_TRYLOCK_PI_PRIVATE),
	V(FUTEX_WAIT_BITSET_PRIVATE),
	V(FUTEX_WAKE_BITSET_PRIVATE),
	V(FUTEX_WAIT_REQUEUE_PI_PRIVATE),
	V(FUTEX_CMP_REQUEUE_PI_PRIVATE),
	{0, NULL}
};

static const _stp_val_array _stp_futex_wake_ops_list[] = {
	V(FUTEX_OP_SET),
	V(FUTEX_OP_ADD),
	V(FUTEX_OP_OR),
	V(FUTEX_OP_ANDN),
	V(FUTEX_OP_XOR),
	{0, NULL}
};
static const _stp_val_array _stp_futex_wake_cmps_list[] = {
	V(FUTEX_OP_CMP_EQ),
	V(FUTEX_OP_CMP_NE),
	V(FUTEX_OP_CMP_LT),
	V(FUTEX_OP_CMP_LE),
	V(FUTEX_OP_CMP_GT),
	V(FUTEX_OP_CMP_GE),
	{0, NULL}
};
%}

function _futex_op_str:string(op:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_futex_op_list, (unsigned int)STAP_ARG_op,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

function _futex_wake_op_str:string(encoded_op:long)
%{ /* pure */ /* unprivileged */
	int encoded_op = (int)STAP_ARG_encoded_op;
	int op = (encoded_op >> 28) & 7;
	int cmp = (encoded_op >> 24) & 15;
	int oparg = (encoded_op << 8) >> 20;
	int cmparg = (encoded_op << 20) >> 20;
	int slen;

strlcpy(STAP_RETVALUE, "{", MAXSTRINGLEN);
	slen = strlen(STAP_RETVALUE);

if (encoded_op & (FUTEX_OP_OPARG_SHIFT << 28)) {
		strlcat(STAP_RETVALUE + slen, "FUTEX_OP_OPARG_SHIFT|",
			MAXSTRINGLEN - slen);
		slen = strlen(STAP_RETVALUE);
	}

_stp_lookup_str(_stp_futex_wake_ops_list, op,
			STAP_RETVALUE + slen, MAXSTRINGLEN - slen);
	slen = strlen(STAP_RETVALUE);

_stp_snprintf(STAP_RETVALUE + slen, MAXSTRINGLEN - slen, ", %d, ",
		      oparg);
	slen = strlen(STAP_RETVALUE);

_stp_lookup_str(_stp_futex_wake_cmps_list, cmp,
			STAP_RETVALUE + slen, MAXSTRINGLEN - slen);
	slen = strlen(STAP_RETVALUE);

_stp_snprintf(STAP_RETVALUE + slen, MAXSTRINGLEN - slen, ", %d}",
		      cmparg);
%}

%{
#ifdef STAPCONF_UAPI_LINUX_MOUNT_H
#include <uapi/linux/mount.h>
#endif
static const _stp_val_array _stp_mountflags_list[] = {
	V(MS_RDONLY),
	V(MS_NOSUID),
	V(MS_NODEV),
	V(MS_NOEXEC),
	V(MS_SYNCHRONOUS),
	V(MS_REMOUNT),
	V(MS_MANDLOCK),
	V(MS_DIRSYNC),
	V(MS_NOATIME),
	V(MS_NODIRATIME),
	V(MS_BIND),
	V(MS_MOVE),
	V(MS_REC),
	/* MS_SILENT replaced MS_VERBOSE */
#ifdef MS_SILENT
	V(MS_SILENT),
#else
	V(MS_VERBOSE),
#endif
	V(MS_POSIXACL),
	V(MS_UNBINDABLE),
	V(MS_PRIVATE),
	V(MS_SLAVE),
	V(MS_SHARED),
#ifdef MS_RELATIME
	V(MS_RELATIME),
#endif
#ifdef MS_KERNMOUNT
	V(MS_KERNMOUNT),
#endif
#ifdef MS_I_VERSION
	V(MS_I_VERSION),
#endif
#ifdef MS_STRICTATIME
	V(MS_STRICTATIME),
#endif
	{0, NULL}
};

static const _stp_val_array _stp_umountflags_list[] = {
	V(MNT_FORCE),
	V(MNT_DETACH),
	V(MNT_EXPIRE),
#ifdef UMOUNT_NOFOLLOW
	V(UMOUNT_NOFOLLOW),
#endif
	{0, NULL}
};
%}

function _mountflags_str:string(op:long) 
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_mountflags_list, (unsigned long)STAP_ARG_op,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

function _umountflags_str:string(op:long) 
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_umountflags_list, (unsigned int)STAP_ARG_op,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

%(systemtap_v <= "2.7" %?
// This function is unused, so deprecate it.
function _statfs_f_type_str(f) {
   if(f==0xadf5)     return "ADFS_SUPER_MAGIC"
   if(f==0xADFF)     return "AFFS_SUPER_MAGIC"
   if(f==0x42465331) return "BEFS_SUPER_MAGIC"
   if(f==0x1BADFACE) return "BFS_MAGIC"
   if(f==0xFF534D42) return "CIFS_MAGIC_NUMBER"
   if(f==0x73757245) return "CODA_SUPER_MAGIC"
   if(f==0x012FF7B7) return "COH_SUPER_MAGIC"
   if(f==0x28cd3d45) return "CRAMFS_MAGIC"
   if(f==0x1373)     return "DEVFS_SUPER_MAGIC"
   if(f==0x00414A53) return "EFS_SUPER_MAGIC"
   if(f==0x137D)     return "EXT_SUPER_MAGIC"
   if(f==0xEF51)     return "EXT2_OLD_SUPER_MAGIC"
   if(f==0xEF53)     return "EXT2_SUPER_MAGIC"
   if(f==0xEF53)     return "EXT3_SUPER_MAGIC"
   if(f==0x4244)     return "HFS_SUPER_MAGIC"
   if(f==0xF995E849) return "HPFS_SUPER_MAGIC"
   if(f==0x958458f6) return "HUGETLBFS_MAGIC"
   if(f==0x9660)     return "ISOFS_SUPER_MAGIC"
   if(f==0x72b6)     return "JFFS2_SUPER_MAGIC"
   if(f==0x3153464a) return "JFS_SUPER_MAGIC"
   if(f==0x137F)     return "MINIX_SUPER_MAGIC"
   if(f==0x138F)     return "MINIX_SUPER_MAGIC2"
   if(f==0x2468)     return "MINIX2_SUPER_MAGIC"
   if(f==0x2478)     return "MINIX2_SUPER_MAGIC2"
   if(f==0x4d44)     return "MSDOS_SUPER_MAGIC"
   if(f==0x564c)     return "NCP_SUPER_MAGIC"
   if(f==0x6969)     return "NFS_SUPER_MAGIC"
   if(f==0x5346544e) return "NTFS_SB_MAGIC"
   if(f==0x9fa1)     return "OPENPROM_SUPER_MAGIC"
   if(f==0x9fa0)     return "PROC_SUPER_MAGIC"
   if(f==0x002f)     return "QNX4_SUPER_MAGIC"
   if(f==0x52654973) return "REISERFS_SUPER_MAGIC"
   if(f==0x7275)     return "ROMFS_MAGIC"
   if(f==0x517B)     return "SMB_SUPER_MAGIC"
   if(f==0x012FF7B6) return "SYSV2_SUPER_MAGIC"
   if(f==0x012FF7B5) return "SYSV4_SUPER_MAGIC"
   if(f==0x01021994) return "TMPFS_MAGIC"
   if(f==0x15013346) return "UDF_SUPER_MAGIC"
   if(f==0x00011954) return "UFS_MAGIC"
   if(f==0x9fa2)     return "USBDEVICE_SUPER_MAGIC"
   if(f==0xa501FCF5) return "VXFS_SUPER_MAGIC"
   if(f==0x012FF7B4) return "XENIX_SUPER_MAGIC"
   if(f==0x58465342) return "XFS_SUPER_MAGIC"
   if(f==0x012FD16D) return "_XIAFS_SUPER_MAGIC"
   return sprintf("UNKNOWN VALUE: %d", f)
}
%)

%{
#include <linux/mman.h>

static const _stp_val_array _stp_mremap_flags_list[] = {
	V(MREMAP_MAYMOVE),
	V(MREMAP_FIXED),
	{0, NULL}
};
%}

function _mremap_flags:string(flags:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_mremap_flags_list, (uint32_t)STAP_ARG_flags,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/mman.h>

static const _stp_val_array _stp_madvice_advice_list[] = {
	V(MADV_NORMAL),
	V(MADV_RANDOM),
	V(MADV_SEQUENTIAL),
	V(MADV_WILLNEED),
	V(MADV_DONTNEED),
#ifdef MADV_FREE
	V(MADV_FREE),
#endif
	V(MADV_REMOVE),
	V(MADV_DONTFORK),
	V(MADV_DOFORK),
#ifdef MADV_HWPOISON
	V(MADV_HWPOISON),
#endif
#ifdef MADV_SOFT_OFFLINE
	V(MADV_SOFT_OFFLINE),
#endif
#ifdef MADV_MERGEABLE
	V(MADV_MERGEABLE),
#endif
#ifdef MADV_UNMERGEABLE
	V(MADV_UNMERGEABLE),
#endif
#ifdef MADV_HUGEPAGE
	V(MADV_HUGEPAGE),
#endif
#ifdef MADV_NOHUGEPAGE
	V(MADV_NOHUGEPAGE),
#endif
#ifdef MADV_DONTDUMP
	V(MADV_DONTDUMP),
#endif
#ifdef MADV_DODUMP
	V(MADV_DODUMP),
#endif
	{0, NULL}
};
%}

function _madvice_advice_str:string(behavior:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_madvice_advice_list,
			(unsigned int)STAP_ARG_behavior, STAP_RETVALUE,
			MAXSTRINGLEN);
%}

%{
#include <linux/fadvise.h>

static const _stp_val_array _stp_fadvice_advice_list[] = {
	V(POSIX_FADV_NORMAL),
	V(POSIX_FADV_RANDOM),
	V(POSIX_FADV_SEQUENTIAL),
	V(POSIX_FADV_WILLNEED),
	V(POSIX_FADV_DONTNEED),
	V(POSIX_FADV_NOREUSE),
#if defined(__s390x__)
	/* On s390x, 64-bit exes and 32-bit exes have different
	 * versions of the following values. */
	{4, "POSIX_FADV_DONTNEED"},
	{5, "POSIX_FADV_NOREUSE"},
#endif
	{0, NULL}
};
%}

function _fadvice_advice_str:string(behavior:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_fadvice_advice_list,
			(unsigned int)STAP_ARG_behavior, STAP_RETVALUE,
			MAXSTRINGLEN);
%}

%{
#include <linux/fcntl.h>

static const _stp_val_array _stp_fcntl_cmd_list[] = {
	V(F_DUPFD),
	V(F_GETFD),
	V(F_SETFD),
	V(F_GETFL),
	V(F_SETFL),
	V(F_GETLK),
	V(F_SETLK),
	V(F_SETLKW),
	V(F_SETOWN),
	V(F_GETOWN),
	V(F_SETSIG),
	V(F_GETSIG),
#ifdef F_GETLK64
	V(F_GETLK64),
#endif
#ifdef F_SETLK64
	V(F_SETLK64),
#endif
#ifdef F_SETLKW64
	V(F_SETLKW64),
#endif
#ifdef F_SETOWN_EX
	V(F_SETOWN_EX),
#endif
#ifdef F_GETOWN_EX
	V(F_GETOWN_EX),
#endif
#ifdef F_GETOWNER_UIDS
	V(F_GETOWNER_UIDS),
#endif
#ifdef F_SETLEASE
	V(F_SETLEASE),
#endif
#ifdef F_GETLEASE
	V(F_GETLEASE),
#endif
#ifdef F_DUPFD_CLOEXEC
 	V(F_DUPFD_CLOEXEC),
#endif
#ifdef F_NOTIFY
	V(F_NOTIFY),
#endif
#ifdef F_SETPIPE_SZ
	V(F_SETPIPE_SZ),
#endif
#ifdef F_GETPIPE_SZ
	V(F_GETPIPE_SZ),
#endif
	{0, NULL}
};
%}

function _fcntl_cmd_str:string(cmd:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_fcntl_cmd_list, (unsigned int)STAP_ARG_cmd,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/fs.h>
#ifndef SEEK_SET
#define SEEK_SET	0
#endif
#ifndef SEEK_CUR
#define SEEK_CUR	1
#endif
#ifndef SEEK_END
#define SEEK_END	2
#endif
#ifndef SEEK_DATA
#define SEEK_DATA	3
#endif
#ifndef SEEK_HOLE
#define SEEK_HOLE	4
#endif
static const _stp_val_array _stp_seek_whence_list[] = {
	V(SEEK_SET),
	V(SEEK_CUR),
	V(SEEK_END),
	V(SEEK_DATA),
	V(SEEK_HOLE),
	{0, NULL}
};

%}
function _seek_whence_str:string(w:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_seek_whence_list, (unsigned int)STAP_ARG_w,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/quota.h>

static const _stp_val_array _stp_quotactl_cmd_list[] = {
	V(Q_SYNC),
	V(Q_QUOTAON),
	V(Q_QUOTAOFF),
	V(Q_GETFMT),
	V(Q_GETINFO),
	V(Q_SETINFO),
	V(Q_GETQUOTA),
	V(Q_SETQUOTA),
	/* XFS Quota Manager (XQM) Codes */
	V(Q_XQUOTAON),
	V(Q_XQUOTAOFF),
	V(Q_XGETQUOTA),
	V(Q_XSETQLIM),
	V(Q_XGETQSTAT),
	V(Q_XQUOTARM),
	V(Q_XQUOTASYNC),
#ifdef Q_XGETQSTATV
	V(Q_XGETQSTATV),
#endif
	{0, NULL}
};
%}

function _quotactl_cmd_str:string(cmd:long)
%{ /* pure */ /* unprivileged */
	unsigned int cmd = (unsigned int)STAP_ARG_cmd >> SUBCMDSHIFT;
	unsigned int type = (unsigned int)STAP_ARG_cmd & SUBCMDMASK;

_stp_lookup_str(_stp_quotactl_cmd_list, cmd, STAP_RETVALUE,
			MAXSTRINGLEN);
	if (type == USRQUOTA)
		strlcat(STAP_RETVALUE, "|USRQUOTA", MAXSTRINGLEN);
	else if (type == GRPQUOTA)
		strlcat(STAP_RETVALUE, "|GRPQUOTA", MAXSTRINGLEN);
	else {
		int len = strlen(STAP_RETVALUE);
		_stp_snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
			      "|0x%x", type);
	}
%}

function _quotactl_subcmd:long(cmd:long)
%{ /* pure */ /* unprivileged */
	STAP_RETVALUE = (unsigned int)STAP_ARG_cmd >> SUBCMDSHIFT;
%}

%{
static const _stp_val_array _stp_quotactl_format_list[] = {
	V(QFMT_VFS_OLD),
#ifdef QFMT_VFS_V0
	V(QFMT_VFS_V0),
#endif
#ifdef QFMT_OCFS2
	V(QFMT_OCFS2),
#endif
#ifdef QFMT_VFS_V1
	V(QFMT_VFS_V1),
#endif
	{0, NULL}
};
%}

function _quotactl_quota_type_str:string(fmt:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_quotactl_format_list,
	                (int)STAP_ARG_fmt, STAP_RETVALUE, MAXSTRINGLEN);
%}

function _struct_dqblk_u:string(uaddr:long)
%{ /* pure */
	struct if_dqblk dqb;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else
	{
		if (_stp_copy_from_user((char*)&dqb, ptr,
		    sizeof(struct if_dqblk)) == 0)
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			         "{dqb_bhardlimit=%llu, dqb_bsoftlimit=%llu, dqb_curspace=%llu, dqb_ihardlimit=%llu, dqb_isoftlimit=%llu, ...}",
			         (unsigned long long)dqb.dqb_bhardlimit, (unsigned long long)dqb.dqb_bsoftlimit, (unsigned long long)dqb.dqb_curspace,
			         (unsigned long long)dqb.dqb_ihardlimit, (unsigned long long)dqb.dqb_isoftlimit);
		}
		else
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			         (unsigned long)ptr);
		}
	}
%}

function _struct_dqinfo_u:string(uaddr:long)
%{ /* pure */
	struct if_dqinfo dqi;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else
	{
		if (_stp_copy_from_user((char*)&dqi, ptr,
		    sizeof(struct if_dqinfo)) == 0)
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			         "{dqi_bgrace=%llu, dqi_igrace=%llu, dqi_flags=%d, dqi_valid=%d}",
			         (unsigned long long)dqi.dqi_bgrace, (unsigned long long)dqi.dqi_igrace,
			         dqi.dqi_flags, dqi.dqi_valid);
		}
		else
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			         (unsigned long)ptr);
		}
	}
%}

%{
#include <linux/socket.h>

static const _stp_val_array _stp_sockopt_optname_list[] = {
	V(SO_DEBUG),
	V(SO_REUSEADDR),
	V(SO_TYPE),
	V(SO_ERROR),
	V(SO_DONTROUTE),
	V(SO_BROADCAST),
	V(SO_SNDBUF),
	V(SO_RCVBUF),
	V(SO_SNDBUFFORCE),
	V(SO_RCVBUFFORCE),
	V(SO_KEEPALIVE),
	V(SO_OOBINLINE),
	V(SO_NO_CHECK),
	V(SO_PRIORITY),
	V(SO_LINGER),
	V(SO_BSDCOMPAT),
#ifdef SO_REUSEPORT
	V(SO_REUSEPORT),
#endif
	V(SO_PASSCRED),
	V(SO_PEERCRED),
	V(SO_RCVLOWAT),
	V(SO_SNDLOWAT),
#ifdef SO_RCVTIMEO
	V(SO_RCVTIMEO),
#endif
#ifdef SO_SNDTIMEO
	V(SO_SNDTIMEO),
#endif
	V(SO_SECURITY_AUTHENTICATION),
	V(SO_SECURITY_ENCRYPTION_TRANSPORT),
	V(SO_SECURITY_ENCRYPTION_NETWORK),
	V(SO_BINDTODEVICE),
	V(SO_ATTACH_FILTER),
	V(SO_DETACH_FILTER),
	V(SO_PEERNAME),
#ifdef SO_TIMESTAMP
	V(SO_TIMESTAMP),
#endif
	V(SO_ACCEPTCONN),
	V(SO_PEERSEC),
	V(SO_PASSSEC),
#ifdef SO_TIMESTAMPNS
	V(SO_TIMESTAMPNS),
#endif
#ifdef SO_MARK
	V(SO_MARK),
#endif
#ifdef SO_TIMESTAMPING
	V(SO_TIMESTAMPING),
#endif
#ifdef SO_PROTOCOL
	V(SO_PROTOCOL),
#endif
#ifdef SO_DOMAIN
	V(SO_DOMAIN),
#endif
#ifdef SO_RXQ_OVFL
	V(SO_RXQ_OVFL),
#endif
#ifdef SO_WIFI_STATUS
	V(SO_WIFI_STATUS),
#endif
#ifdef SO_PEEK_OFF
	V(SO_PEEK_OFF),
#endif
#ifdef SO_NOFCS
	V(SO_NOFCS),
#endif
#ifdef SO_LOCK_FILTER
	V(SO_LOCK_FILTER),
#endif
#ifdef SO_SELECT_ERR_QUEUE
	V(SO_SELECT_ERR_QUEUE),
#endif
#ifdef SO_BUSY_POLL
	V(SO_BUSY_POLL),
#endif
#ifdef SO_MAX_PACING_RATE
	V(SO_MAX_PACING_RATE),
#endif
#ifdef SO_BPF_EXTENSIONS
	V(SO_BPF_EXTENSIONS),
#endif
#ifdef SO_INCOMING_CPU
	V(SO_INCOMING_CPU),
#endif
#ifdef SO_ATTACH_BPF
	V(SO_ATTACH_BPF),
#endif
#ifdef SO_DETACH_BPF
	V(SO_DETACH_BPF),
#endif
#ifdef SO_ATTACH_REUSEPORT_CBPF
	V(SO_ATTACH_REUSEPORT_CBPF),
#endif
#ifdef SO_ATTACH_REUSEPORT_EBPF
	V(SO_ATTACH_REUSEPORT_EBPF),
#endif
#ifdef SO_CNX_ADVICE
	V(SO_CNX_ADVICE),
#endif
#ifdef SCM_TIMESTAMPING_OPT_STATS
	V(SCM_TIMESTAMPING_OPT_STATS),
#endif
#ifdef SO_MEMINFO
	V(SO_MEMINFO),
#endif
#ifdef SO_INCOMING_NAPI_ID
	V(SO_INCOMING_NAPI_ID),
#endif
#ifdef SO_COOKIE
	V(SO_COOKIE),
#endif
#ifdef SCM_TIMESTAMPING_PKTINFO
	V(SCM_TIMESTAMPING_PKTINFO),
#endif
#ifdef SO_PEERGROUPS
	V(SO_PEERGROUPS),
#endif
#ifdef SO_ZEROCOPY
	V(SO_ZEROCOPY),
#endif
#ifdef SO_TXTIME
	V(SO_TXTIME),
#endif
#ifdef SCM_TXTIME
	V(SCM_TXTIME),
#endif
#ifdef SO_BINDTOIFINDEX
	V(SO_BINDTOIFINDEX),
#endif
#ifdef SO_TIMESTAMP_OLD
	V(SO_TIMESTAMP_OLD),
#endif
#ifdef SO_TIMESTAMPNS_OLD
	V(SO_TIMESTAMPNS_OLD),
#endif
#ifdef SO_TIMESTAMPING_OLD
	V(SO_TIMESTAMPING_OLD),
#endif
#ifdef SO_TIMESTAMP_NEW
	V(SO_TIMESTAMP_NEW),
#endif
#ifdef SO_TIMESTAMPNS_NEW
	V(SO_TIMESTAMPNS_NEW),
#endif
#ifdef SO_TIMESTAMPING_NEW
	V(SO_TIMESTAMPING_NEW),
#endif
#ifdef SO_RCVTIMEO_NEW
	V(SO_RCVTIMEO_NEW),
#endif
#ifdef SO_SNDTIMEO_NEW
	V(SO_SNDTIMEO_NEW),
#endif
	{0, NULL}
};
%}

/* see sys/socket.h (for setsockopt) */
function _sockopt_optname_str:string(opt:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_sockopt_optname_list, STAP_ARG_opt, STAP_RETVALUE,
			MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_sockopt_level_list[] = {
	V(SOL_IP),
	V(SOL_SOCKET),
	V(SOL_TCP),
	V(SOL_UDP),
	V(SOL_IPV6),
	V(SOL_ICMPV6),
	V(SOL_SCTP),
#ifdef SOL_UDPLITE
	V(SOL_UDPLITE),
#endif
	V(SOL_RAW),
	V(SOL_IPX),
	V(SOL_AX25),
	V(SOL_ATALK),
	V(SOL_NETROM),
	V(SOL_ROSE),
	V(SOL_DECNET),
#ifdef SOL_X25
	V(SOL_X25),
#endif
	V(SOL_PACKET),
	V(SOL_ATM),
	V(SOL_AAL),
	V(SOL_IRDA),
	V(SOL_NETBEUI),
	V(SOL_LLC),
	V(SOL_DCCP),
	V(SOL_NETLINK),
	V(SOL_TIPC),
#ifdef SOL_RXRPC
	V(SOL_RXRPC),
#endif
#ifdef SOL_PPPOL2TP
	V(SOL_PPPOL2TP),
#endif
#ifdef SOL_BLUETOOTH
	V(SOL_BLUETOOTH),
#endif
#ifdef SOL_PNPIPE
	V(SOL_PNPIPE),
#endif
#ifdef SOL_RDS
	V(SOL_RDS),
#endif
	V(SOL_IUCV),
#ifdef SOL_CAIF
	V(SOL_CAIF),
#endif
#ifdef SOL_ALG
	V(SOL_ALG),
#endif
#ifdef SOL_NFC
	V(SOL_NFC),
#endif
	{0, NULL}
};
%}

/* `man 2 setsockopt` for more information */
function _sockopt_level_str:string(level:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_sockopt_level_list, STAP_ARG_level, STAP_RETVALUE,
			MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_sock_family_list[] = {
	V(PF_UNSPEC),
	V(PF_LOCAL),			/* same thing as PF_UNIX */
	V(PF_INET),
	V(PF_AX25),
	V(PF_IPX),
	V(PF_APPLETALK),
	V(PF_NETROM),
	V(PF_BRIDGE),
	V(PF_ATMPVC),
	V(PF_X25),
	V(PF_INET6),
	V(PF_ROSE),
	V(PF_DECnet),
	V(PF_NETBEUI),
	V(PF_SECURITY),
	V(PF_KEY),
	V(PF_NETLINK),
	V(PF_ROUTE),
	V(PF_PACKET),
	V(PF_ASH),
	V(PF_ECONET),
	V(PF_ATMSVC),
#ifdef PF_RDS
	V(PF_RDS),
#endif
	V(PF_SNA),
	V(PF_IRDA),
	V(PF_PPPOX),
	V(PF_WANPIPE),
	V(PF_LLC),
#ifdef PF_IB
	V(PF_IB),
#endif
#ifdef PF_CAN
	V(PF_CAN),
#endif
	V(PF_TIPC),
	V(PF_BLUETOOTH),
	V(PF_IUCV),
#ifdef PF_RXRPC
	V(PF_RXRPC),
#endif
#ifdef PF_ISDN
	V(PF_ISDN),
#endif
#ifdef PF_PHONET
	V(PF_PHONET),
#endif
#ifdef PF_IEEE802154
	V(PF_IEEE802154),
#endif
#ifdef PF_CAIF
	V(PF_CAIF),
#endif
#ifdef PF_ALG
	V(PF_ALG),
#endif
#ifdef PF_NFC
	V(PF_NFC),
#endif
#ifdef PF_VSOCK
	V(PF_VSOCK),
#endif
	{0, NULL}
};
%}

function _sock_family_str:string(f:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_sock_family_list, (unsigned int)STAP_ARG_f,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

function _sock_type_str:string(type:long)
%{ /* pure */ /* unprivileged */
#ifdef SOCK_TYPE_MASK
	int flags = (int)STAP_ARG_type & ~SOCK_TYPE_MASK;
	int t = (int)STAP_ARG_type & SOCK_TYPE_MASK;
#else
	int t = (int)STAP_ARG_type;
#endif
	int data_added = 0;

/*
	 * This is a bit tricky. We've got 2 types of information
	 * here. A socket type and a possible combination of socket
	 * flags. In addition, we only want one final listing of
	 * any unknown bits set.
	 *
	 * We can't call _stp_lookup_str() here since it would go
	 * ahead and display any unknown type value, and we want to
	 * wait until after any possible flags are displayed.
	 */
	switch (t) {
	case SOCK_STREAM:
		strlcpy (STAP_RETVALUE, "SOCK_STREAM", MAXSTRINGLEN);
		t = 0;
		data_added = 1;
		break;
	case SOCK_DGRAM:
		strlcpy (STAP_RETVALUE, "SOCK_DGRAM", MAXSTRINGLEN);
		t = 0;
		data_added = 1;
		break;
	case SOCK_RAW:
		strlcpy (STAP_RETVALUE, "SOCK_RAW", MAXSTRINGLEN);
		t = 0;
		data_added = 1;
		break;
	case SOCK_RDM:
		strlcpy (STAP_RETVALUE, "SOCK_RDM", MAXSTRINGLEN);
		t = 0;
		data_added = 1;
		break;
	case SOCK_SEQPACKET:
		strlcpy (STAP_RETVALUE, "SOCK_SEQPACKET", MAXSTRINGLEN);
		t = 0;
		data_added = 1;
		break;
#ifdef SOL_DCCP
	case SOCK_DCCP:
		strlcpy (STAP_RETVALUE, "SOCK_DCCP", MAXSTRINGLEN);
		t = 0;
		data_added = 1;
		break;
#endif
	case SOCK_PACKET:
		strlcpy (STAP_RETVALUE, "SOCK_PACKET", MAXSTRINGLEN);
		t = 0;
		data_added = 1;
		break;
	}

#ifdef SOCK_TYPE_MASK
	/* We can't use _stp_lookup_or_str() here since if none of
	 * these flags are set it would put a "0x0" on the end, which
	 * we don't want to add to the socket type. */
	if (flags & SOCK_CLOEXEC) {
		if (data_added)
			strlcat(STAP_RETVALUE, "|", MAXSTRINGLEN);
		strlcat (STAP_RETVALUE, "SOCK_CLOEXEC", MAXSTRINGLEN);
		flags &= ~SOCK_CLOEXEC;
		data_added = 1;
	}
	if (flags & SOCK_NONBLOCK) {
		if (data_added)
			strlcat(STAP_RETVALUE, "|", MAXSTRINGLEN);
		strlcat (STAP_RETVALUE, "SOCK_NONBLOCK", MAXSTRINGLEN);
		flags &= ~SOCK_NONBLOCK;
		data_added = 1;
	}
	
	/* If we have any leftover flags bits, add them back to the
	 * type bits to get displayed together. */
	t |= flags;
#endif

/* Display any leftover bits. */
	if (t != 0 || !data_added) {
		int slen;
		if (data_added)
			strlcat(STAP_RETVALUE, "|", MAXSTRINGLEN);
		slen = strlen(STAP_RETVALUE);
		_stp_snprintf(STAP_RETVALUE + slen, MAXSTRINGLEN - slen,
			      "0x%x", t);
	}
%}

%{
static const _stp_val_array _stp_sock_flags_list[] = {
#ifdef SOCK_TYPE_MASK
	V(SOCK_CLOEXEC),
	V(SOCK_NONBLOCK),
#endif
	{0, NULL}
};
%}

function _sock_flags_str:string(f:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_sock_flags_list, (unsigned int)STAP_ARG_f,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
// Be sure we have the IPPROTO_* defines. But, on some older kernels
// we don't have all of them defined. Also note that on some older
// kernels these values are enum values, not defines. But, the
// following code should work anyway.
#include <linux/in.h>
#ifndef IPPROTO_TP
#define IPPROTO_TP 29
#endif
#ifndef IPPROTO_MTP
#define IPPROTO_MTP 92
#endif
#ifndef IPPROTO_ENCAP
#define IPPROTO_ENCAP 98
#endif
#ifndef IPPROTO_UDPLITE
#define IPPROTO_UDPLITE 136
#endif
%}

function _sock_protocol_str:string(family:long, protocol:long)
{
    if (family == @const("PF_INET")
	|| family == @const("PF_INET6")) {
	if (protocol == @const("IPPROTO_IP")) return "IPPROTO_IP"
	if (protocol == @const("IPPROTO_ICMP")) return "IPPROTO_ICMP"
	if (protocol == @const("IPPROTO_IGMP")) return "IPPROTO_IGMP"
	if (protocol == @const("IPPROTO_IPIP")) return "IPPROTO_IPIP"
	if (protocol == @const("IPPROTO_TCP")) return "IPPROTO_TCP"
	if (protocol == @const("IPPROTO_EGP")) return "IPPROTO_EGP"
	if (protocol == @const("IPPROTO_PUP")) return "IPPROTO_PUP"
	if (protocol == @const("IPPROTO_UDP")) return "IPPROTO_UDP"
	if (protocol == @const("IPPROTO_IDP")) return "IPPROTO_IDP"
	if (protocol == @const("IPPROTO_TP")) return "IPPROTO_TP"
	if (protocol == @const("IPPROTO_DCCP")) return "IPPROTO_DCCP"
	if (protocol == @const("IPPROTO_IPV6")) return "IPPROTO_IPV6"
	if (protocol == @const("IPPROTO_RSVP")) return "IPPROTO_RSVP"
	if (protocol == @const("IPPROTO_GRE")) return "IPPROTO_GRE"
	if (protocol == @const("IPPROTO_ESP")) return "IPPROTO_ESP"
	if (protocol == @const("IPPROTO_AH")) return "IPPROTO_AH"
	if (protocol == @const("IPPROTO_MTP")) return "IPPROTO_MTP"
	if (protocol == @const("IPPROTO_ENCAP")) return "IPPROTO_ENCAP"
	if (protocol == @const("IPPROTO_PIM")) return "IPPROTO_PIM"
	if (protocol == @const("IPPROTO_COMP")) return "IPPROTO_COMP"
	if (protocol == @const("IPPROTO_SCTP")) return "IPPROTO_SCTP"
	if (protocol == @const("IPPROTO_UDPLITE")) return "IPPROTO_UDPLITE"
	if (protocol == @const("IPPROTO_RAW")) return "IPPROTO_RAW"
    }
    return sprintf("%d", protocol)
}

function _opoll_op_str:string(o:long)
%{ /* pure */ /* unprivileged */
	static const _stp_val_array opoll_op_list[] = {
		V(EPOLL_CTL_ADD),
		V(EPOLL_CTL_MOD),
		V(EPOLL_CTL_DEL),
		{0, NULL}
	};
	_stp_lookup_str(opoll_op_list, (unsigned int)STAP_ARG_o,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

%(systemtap_v <= "2.7" %?
// This function isn't actually used anywhere, so let's deprecate it.
function _epoll_events_str(e) {
   if(e==1) return "EPOLLIN"
   if(e==4) return "EPOLLOUT"
   if(e==2) return "EPOLLPRI"
   if(e==8) return "EPOLLERR"
   if(e==16) return "EPOLLHUP"
   if(e==-2147483648) return "EPOLLET"
   if(e==1073741824) return "EPOLLONESHOT"
   return sprintf("UNKNOWN VALUE: %d", e)
}
%)

%{
#include <linux/resource.h>

static const _stp_val_array _stp_rlimit_resource_list[] = {
	{ (unsigned int)RLIM_INFINITY, "RLIM_INFINITY"},
	V(RLIMIT_CPU),
	V(RLIMIT_FSIZE),
	V(RLIMIT_DATA),
	V(RLIMIT_STACK),
	V(RLIMIT_CORE),
	V(RLIMIT_RSS),
	V(RLIMIT_NPROC),
	V(RLIMIT_NOFILE),
	V(RLIMIT_MEMLOCK),
	V(RLIMIT_AS),
	V(RLIMIT_LOCKS),
	V(RLIMIT_SIGPENDING),
	V(RLIMIT_MSGQUEUE),
	V(RLIMIT_NICE),
	V(RLIMIT_RTPRIO),
#ifdef RLIMIT_RTTIME
	V(RLIMIT_RTTIME),
#endif
	V(RLIM_NLIMITS),
	{0, NULL}
};

static const _stp_val_array _stp_rusage_who_list[] = {
	V(RUSAGE_SELF),
	{(unsigned int)RUSAGE_CHILDREN, "RUSAGE_CHILDREN"},
	{(unsigned int)RUSAGE_BOTH, "RUSAGE_BOTH"},
	V(RUSAGE_THREAD),
	{0, NULL}
};
%}

function _rlimit_resource_str:string(r:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_rlimit_resource_list, (unsigned int)STAP_ARG_r,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

function _rusage_who_str:string(w:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_rusage_who_list, (unsigned int)STAP_ARG_w,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

/* for accessing 16-bit values encoded in a long */
function __short:long(val:long)
%{ /* pure */ /* unprivileged */
	STAP_RETVALUE = (short)STAP_ARG_val;
%}

function __ushort:long(val:long)
%{ /* pure */ /* unprivileged */
	STAP_RETVALUE = (unsigned short)STAP_ARG_val;
%}

/* uid_t is unsigned, but calling functions take "-1" as a parameter */
/* so this hack is necessary to correct that mismatch. */
function __int32:long(val:long)
%{ /* pure */ /* unprivileged */
	STAP_RETVALUE = (int32_t)STAP_ARG_val;
%}

function __uint32:long(val:long)
%{ /* pure */ /* unprivileged */
	STAP_RETVALUE = (uint32_t)STAP_ARG_val;
%}

/* Unsigned values can get get sign-extended and become negative. */
function __ulong:long(val:long)
%{ /* pure */ /* unprivileged */
	STAP_RETVALUE = (unsigned long)STAP_ARG_val;
%}

function __long:long(val:long)
%{ /* pure */ /* unprivileged */
	STAP_RETVALUE = (long)STAP_ARG_val;
%}

# For utimensat and futimesat, the directory fd can have a special value
function _dfd_str:string(d:long)
{
	if (d == @const("AT_FDCWD"))
		return "AT_FDCWD"
	return sprint(d)
}

%{
static const _stp_val_array _stp_adjtimex_return_str_list[] = {
	V(TIME_OK),
	V(TIME_INS),
	V(TIME_DEL),
	V(TIME_OOP),
	V(TIME_WAIT),
	V(TIME_ERROR),
	V(TIME_BAD),
       {0, NULL}
};
%}

function _adjtimex_return_str:string(ret:long)
%{ /* pure */ /* unprivileged */
	int len;
	snprintf (STAP_RETVALUE, MAXSTRINGLEN, "%d (", (int)STAP_ARG_ret);
	len = strlen(STAP_RETVALUE);
	_stp_lookup_str2(_stp_adjtimex_return_str_list, (int)STAP_ARG_ret,
	                 STAP_RETVALUE + len, MAXSTRINGLEN - len, 10);
	strlcat (STAP_RETVALUE, ")", MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_signal_list[] = {
	{0, "SIG_0"},
	V(SIGHUP),
	V(SIGINT),
	V(SIGQUIT),
	V(SIGILL),
	V(SIGTRAP),
	V(SIGABRT),
	V(SIGBUS),
	V(SIGFPE),
	V(SIGKILL),
	V(SIGUSR1),
	V(SIGSEGV),
	V(SIGPIPE),
	V(SIGUSR2),
	V(SIGALRM),
	V(SIGTERM),
	V(SIGCHLD),
	V(SIGCONT),
	V(SIGSTOP),
	V(SIGTSTP),
	V(SIGTTIN),
	V(SIGTTOU),
	V(SIGURG),
#ifdef SIGXCPU
	V(SIGXCPU),
#endif
#ifdef SIGXFSZ
	V(SIGXFSZ),
#endif
	V(SIGVTALRM),
	V(SIGPROF),
	V(SIGWINCH),
	{SIGIO,"SIGIO/SIGPOLL"},
	V(SIGPWR),
#ifdef SIGSYS
	V(SIGSYS),
#endif
	{SIGTRAP|0x80,"TRACESYSGOOD"},
	{0, NULL}
};

static void _stp_sigset_str(sigset_t *mask, char *ptr, int len)
{
	const _stp_val_array * const array = _stp_signal_list;
	int i = 0, flag = 0;
	while (array[i].name) {
		if (array[i].val > 0 && array[i].val <= _NSIG
		    && sigismember(mask, array[i].val)) {
			if (flag)
				strlcat(ptr, "|", len);
			else
				strlcat(ptr, "[",  len);
			strlcat(ptr, array[i].name, len);
			flag = 1;
		}
		i++;
	}
	if (flag == 0)
		strlcat(ptr, "[EMPTY]", len);
	else
		strlcat(ptr, "]", len);
}
%}

function _signal_name:string(sig:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_signal_list, (unsigned int)STAP_ARG_sig,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_semctl_list[] = {
	V(IPC_INFO),
	V(SEM_INFO),
	V(SEM_STAT),
	V(GETALL),
	V(GETVAL),
	V(GETPID),
	V(GETNCNT),
	V(GETZCNT),
	V(IPC_STAT),
	V(SETVAL),
	V(SETALL),
	V(IPC_RMID),
	V(IPC_SET),
	{0, NULL}
};
%}

function _semctl_cmd:string(cmd:long)
%{ /* pure */ /* unprivileged */
	unsigned int cmd = STAP_ARG_cmd;
	int len;

#ifdef IPC_64
	if (cmd & IPC_64) {
		strlcpy(STAP_RETVALUE, "IPC_64|", MAXSTRINGLEN);
		cmd &= ~IPC_64;
	}
#endif
	len = strlen(STAP_RETVALUE);
	_stp_lookup_str(_stp_semctl_list, cmd, STAP_RETVALUE + len,
			MAXSTRINGLEN - len);
%}

function _stp_sigset_u:string(setptr:long)
%{ /* pure */
	char *ptr = (char *)(uintptr_t)STAP_ARG_setptr;
	sigset_t set;

if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char*)&set,ptr,sizeof(sigset_t)) == 0)
			_stp_sigset_str(&set, STAP_RETVALUE, MAXSTRINGLEN);
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
	}
%}

function _stp_compat_sigset_u:string(setptr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
	char *ptr = (char *)(uintptr_t)STAP_ARG_setptr;

if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		compat_sigset_t set;

if (_stp_copy_from_user((char*)&set, ptr,
					sizeof(compat_sigset_t)) == 0) {
			sigset_t new_set;
			sigset_from_compat(&new_set, &set);
			_stp_sigset_str(&new_set, STAP_RETVALUE, MAXSTRINGLEN);
		}
		else
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				 (unsigned long)ptr);
	}
#endif
%}

%{
static const _stp_val_array _stp_fork_list[] = {
	V(CLONE_VM),
	V(CLONE_FS),
	V(CLONE_FILES),
	V(CLONE_SIGHAND),
	V(CLONE_PTRACE),
	V(CLONE_VFORK),
	V(CLONE_PARENT),
	V(CLONE_THREAD),
	V(CLONE_NEWNS),
	V(CLONE_SYSVSEM),
	V(CLONE_SETTLS),
	V(CLONE_PARENT_SETTID),
	V(CLONE_CHILD_CLEARTID),
	V(CLONE_DETACHED),
	V(CLONE_UNTRACED),
	V(CLONE_CHILD_SETTID),
#ifdef CLONE_STOPPED
	V(CLONE_STOPPED),
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)
	V(CLONE_NEWUTS),
	V(CLONE_NEWIPC),
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
	V(CLONE_NEWUSER),
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
	V(CLONE_NEWPID),
	V(CLONE_NEWNET),
#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25)
	V(CLONE_IO),
#endif
	{0, NULL}
};
%}

function __fork_flags:string(flags:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_fork_list, STAP_ARG_flags & ~0xff, STAP_RETVALUE, MAXSTRINGLEN);
	if ( STAP_ARG_flags & 0xff ) {
		/* flags contains the termination signal */
		if (*STAP_RETVALUE)
			strlcat(STAP_RETVALUE, "|", MAXSTRINGLEN);
		_stp_lookup_str(_stp_signal_list, STAP_ARG_flags & 0xff,
				STAP_RETVALUE, MAXSTRINGLEN);
	}
%}

%{
static const _stp_val_array _stp_atflag_list[] = {
#ifdef AT_SYMLINK_NOFOLLOW
	V(AT_SYMLINK_NOFOLLOW),
#endif
#ifdef AT_REMOVEDIR
	V(AT_REMOVEDIR),
#endif
#ifdef AT_SYMLINK_FOLLOW
	V(AT_SYMLINK_FOLLOW),
#endif
#ifdef AT_NO_AUTOMOUNT
	V(AT_NO_AUTOMOUNT),
#endif
#ifdef AT_EMPTY_PATH
	V(AT_EMPTY_PATH),
#endif
	{0, NULL}
};
%}

function _at_flag_str:string(f:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_atflag_list, STAP_ARG_f, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#include <linux/eventpoll.h>
%}
function _epoll_create1_flag_str:string(f:long)
%{ /* pure */ /* unprivileged */
	static const _stp_val_array epoll_create1_flags_list[] = {
#ifdef EPOLL_CLOEXEC
		V(EPOLL_CLOEXEC),
#endif
		{0, NULL}
	};
	_stp_lookup_or_str(epoll_create1_flags_list, (unsigned int)STAP_ARG_f,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
#include <linux/eventfd.h>
#endif

static const _stp_val_array _stp_eventfd2_flag_list[] = {
#ifdef EFD_NONBLOCK
	V(EFD_NONBLOCK),
#endif
#ifdef EFD_CLOEXEC
	V(EFD_CLOEXEC),
#endif
#ifdef EFD_SEMAPHORE
	V(EFD_SEMAPHORE),
#endif
	{0, NULL}
};
%}
function _eventfd2_flag_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	uint32_t flags = (uint32_t)STAP_ARG_flags;
	_stp_lookup_or_str(_stp_eventfd2_flag_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
#include <linux/signalfd.h>
#endif

static const _stp_val_array _stp_signalfd4_flags_list[] = {
#ifdef SFD_NONBLOCK
	V(SFD_NONBLOCK),
#endif
#ifdef SFD_CLOEXEC
	V(SFD_CLOEXEC),
#endif
	{0, NULL}
};
%}
function _signalfd4_flags_str:string(f:long)
%{ /* pure */ /* unprivileged */
	uint32_t flags = (uint32_t)STAP_ARG_f;
	_stp_lookup_or_str(_stp_signalfd4_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#if (defined(CONFIG_INOTIFY) || defined(CONFIG_INOTIFY_USER))
#include <linux/inotify.h>
#endif

static const _stp_val_array _stp_inotify_init1_flag_list[] = {
#if defined(IN_NONBLOCK)
	V(IN_NONBLOCK),
#endif
#if defined(IN_CLOEXEC)
	V(IN_CLOEXEC),
#endif
	{0, NULL}
};
%}

function _inotify_init1_flag_str:string(f:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = (unsigned int)STAP_ARG_f;
	_stp_lookup_or_str(_stp_inotify_init1_flag_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

function _dup3_flag_str:string(f:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = (unsigned int)STAP_ARG_f;
	_stp_lookup_or_str(_stp_open_mode_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#include <linux/shm.h>
static const _stp_val_array _stp_shmat_list[] = {
	V(SHM_RDONLY),
	V(SHM_RND),
	V(SHM_REMAP),
	V(SHM_EXEC),
	{0, NULL}
};
%}

function _shmat_flags_str:string(f:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_shmat_list, STAP_ARG_f, STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/mman.h>
static const _stp_val_array _stp_mprotect_list[] = {
	{0, "PROT_NONE"},
	V(PROT_READ),
	V(PROT_WRITE),
	V(PROT_EXEC),
	V(PROT_SEM),
	V(PROT_GROWSDOWN),
	V(PROT_GROWSUP),
#ifdef PROT_SAO // powerpc only
	V(PROT_SAO),
#endif
	{0, NULL}
};
%}

function _mprotect_prot_str:string(prot:long) 
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_mprotect_list, STAP_ARG_prot, STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/mman.h>
static const _stp_val_array _stp_mmap_list[] = {
	V(MAP_SHARED),
	V(MAP_PRIVATE),
	V(MAP_FIXED),
	V(MAP_ANONYMOUS),
	V(MAP_GROWSDOWN),
	V(MAP_DENYWRITE),
	V(MAP_EXECUTABLE),
	V(MAP_LOCKED),
	V(MAP_NORESERVE),
	V(MAP_POPULATE),
	V(MAP_NONBLOCK),
#ifdef MAP_STACK
	V(MAP_STACK),
#endif
#ifdef MAP_HUGETLB
	V(MAP_HUGETLB),
#endif
#ifdef MAP_UNINITIALIZED
	V(MAP_UNINITIALIZED),
#endif
#ifdef MAP_32BIT // x86 only
	V(MAP_32BIT),
#endif
	{0, NULL}
};
%}

function _mmap_flags:string(flags:long) 
%{ /* pure */ /* unprivileged */
#ifdef MAP_HUGE_SHIFT
	// Extract the huge page size for special treatment.
	u8 huge = (STAP_ARG_flags >> MAP_HUGE_SHIFT) & MAP_HUGE_MASK;
	STAP_ARG_flags &= ~((long)MAP_HUGE_MASK << MAP_HUGE_SHIFT);

if (huge) {
		// MAP_HUGE_2MB and MAP_HUGE_1GB are predefined on x86, but
		// the log2 value can be used to represent any power of two.
		const char* suffix = "";
		if (huge >= 60) { huge -= 60; suffix = "EB"; }
		else if (huge >= 50) { huge -= 50; suffix = "PB"; }
		else if (huge >= 40) { huge -= 40; suffix = "TB"; }
		else if (huge >= 30) { huge -= 30; suffix = "GB"; }
		else if (huge >= 20) { huge -= 20; suffix = "MB"; }
		else if (huge >= 10) { huge -= 10; suffix = "KB"; }
		_stp_snprintf(STAP_RETVALUE, MAXSTRINGLEN, "MAP_HUGE_%ld%s|", 1L << huge, suffix);
	}
#endif

_stp_lookup_or_str(_stp_mmap_list, STAP_ARG_flags, STAP_RETVALUE, MAXSTRINGLEN);
%}

%( systemtap_v <= "3.0" %?
# old mmap functions passed in a struct like this.
#
function get_mmap_args:string (args:long)
%{ /* pure */
#if defined (__x86_64__) || defined (__ia64__)
	struct mmap_arg_struct {
		unsigned int addr;
		unsigned int len;
		unsigned int prot;
		unsigned int flags;
		int fd;
		unsigned int offset;
	} a;
#else
	struct mmap_arg_struct {
		unsigned long addr;
		unsigned long len;
		unsigned long prot;
		unsigned long flags;
		long fd;
		unsigned long offset;
	} a;
#endif

if(_stp_copy_from_user((char *)&a,(char *)(uintptr_t)STAP_ARG_args, sizeof(a))== 0) {
		int len;
		_stp_snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx, %lu, ",
			      (unsigned long)a.addr, (unsigned long)a.len);
		_stp_lookup_or_str(_stp_mprotect_list, a.prot, STAP_RETVALUE, MAXSTRINGLEN);
		strlcat (STAP_RETVALUE, ", ", MAXSTRINGLEN);
		_stp_lookup_or_str(_stp_mmap_list, a.flags, STAP_RETVALUE, MAXSTRINGLEN);
		strlcat (STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len, "%ld, %ld", (long)a.fd, (long)a.offset);
	} else
		snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			 (unsigned long)STAP_ARG_args);
%}
%)

function _sighandler_str:string(uaddr:long)
%{ /* pure */ /* unprivileged */
	static const _stp_val_array _stp_sa_handler_list[] = {
		{0, "SIG_DFL"},
		{1, "SIG_IGN"},
		{0, NULL}
	};
	_stp_lookup_str(_stp_sa_handler_list, (long)STAP_ARG_uaddr, STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
static void _stp_sigaction_str(struct sigaction *act, char *ptr, int len)
{
  static const _stp_val_array _stp_sa_handler_list[] = {
    {0, "SIG_DFL"},
    {1, "SIG_IGN"},
    {0, NULL}
  };

static const _stp_val_array _stp_sa_flags_list[] = {
    V(SA_NOCLDSTOP),
    V(SA_NOCLDWAIT),
    V(SA_RESETHAND),
    V(SA_ONSTACK),
    V(SA_RESTART),
    V(SA_NODEFER),
    V(SA_SIGINFO),
#ifdef SA_RESTORER
    V(SA_RESTORER),
#endif
    {0, NULL}
  };
  
  int slen;
  _stp_lookup_str(_stp_sa_handler_list, (long)act->sa_handler,
		  ptr, len);
  if (act->sa_handler != SIG_IGN && act->sa_handler != SIG_DFL)
    {
      strlcat (ptr, ", ", len);
      _stp_lookup_or_str(_stp_sa_flags_list, act->sa_flags, ptr, len);
      strlcat (ptr, ", ", len);
#if !defined (__ia64__) && !defined (__mips__) && !defined(__riscv)
      slen = strlen(ptr);
      _stp_snprintf(ptr + slen, len - slen,
		    "0x%lx, ", (long)act->sa_restorer);
#endif
      _stp_sigset_str(&act->sa_mask, ptr, len);
    }
}
%}

function _stp_sigmask_str:string(sigmask:long)
%{ /* pure */
  unsigned long mask = (unsigned long)STAP_ARG_sigmask;
  sigset_t set;

siginitset(&set, mask);
  _stp_sigset_str(&set, STAP_RETVALUE, MAXSTRINGLEN);
%}

function _struct_sigaction_u:string(uaddr:long)
%{ /* pure */
  struct sigaction act;
  char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
  
  if (ptr == NULL)
    strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
  else
    {
      if(_stp_copy_from_user((char*)&act, ptr,
			     sizeof(struct sigaction)) == 0)
	_stp_sigaction_str(&act, STAP_RETVALUE, MAXSTRINGLEN);
      else
	snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx", (unsigned long)ptr);
    }
%}

function _struct_sigaction32_u:string(uaddr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
#include <linux/compat.h>
  
#ifdef AUTOCONF_COMPAT_SIGACTION
  struct compat_sigaction act32;
#else
  // There seems to be no public cross arch header that defines this.
  // For x86, you can find it in asm/ia32.h.  For s390x, it is defined
  // in a private header.
  struct sigaction32 {
    compat_uptr_t  sa_handler;
    unsigned int sa_flags;
    unsigned int sa_restorer;       /* Another 32 bit pointer */
    compat_sigset_t sa_mask;        /* A 32 bit mask */
  };
  
  struct sigaction32 act32;
#endif

char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
  
  if (ptr == NULL)
    strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
  else
    {
      if(_stp_copy_from_user((char*)&act32, ptr,
			     sizeof(act32)) == 0)
	{
	  struct sigaction act;

act.sa_handler = (void *)compat_ptr(act32.sa_handler);
	  act.sa_flags = (unsigned long)act32.sa_flags;
#ifdef SA_RESTORER
	  act.sa_restorer = (void *)compat_ptr(act32.sa_restorer);
#endif
	  /* swap words around to get right endian order. */
	  switch (_NSIG_WORDS)
	    {
	    case 4: act.sa_mask.sig[3] = act32.sa_mask.sig[6]
		| (((long)act32.sa_mask.sig[7]) << 32);
              fallthrough;
	    case 3: act.sa_mask.sig[2] = act32.sa_mask.sig[4]
		| (((long)act32.sa_mask.sig[5]) << 32);
              fallthrough;
	    case 2: act.sa_mask.sig[1] = act32.sa_mask.sig[2]
		| (((long)act32.sa_mask.sig[3]) << 32);
              fallthrough;
	    case 1: act.sa_mask.sig[0] = act32.sa_mask.sig[0]
		| (((long)act32.sa_mask.sig[1]) << 32);
	    }

_stp_sigaction_str(&act, STAP_RETVALUE, MAXSTRINGLEN);	  
	}
      else
	snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx", (unsigned long)ptr);
    }
#endif
%}

function _struct_old_sigaction32_u:string(uaddr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
#include <linux/compat.h>

#ifdef CONFIG_COMPAT_OLD_SIGACTION
  struct compat_old_sigaction act32;
#else
  // There seems to be no public cross arch header that defines this.
  // For x86, you can find it in asm/ia32.h.  For s390x, it is defined
  // in a private header.
  struct old_sigaction32 {
    compat_uptr_t  sa_handler;
    compat_old_sigset_t sa_mask;    /* A 32 bit mask */
    unsigned int sa_flags;
    unsigned int sa_restorer;       /* Another 32 bit pointer */
  };

struct old_sigaction32 act32;
#endif
  char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
  
  if (ptr == NULL)
    strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
  else
    {
      if(_stp_copy_from_user((char*)&act32, ptr, sizeof(act32)) == 0)
	{
	  struct sigaction act;

act.sa_handler = (void *)compat_ptr(act32.sa_handler);
#ifdef SA_RESTORER
	  act.sa_restorer = (void *)compat_ptr(act32.sa_restorer);
#endif
	  act.sa_flags = (unsigned long)act32.sa_flags;
	  siginitset(&act.sa_mask, act32.sa_mask);
	  _stp_sigaction_str(&act, STAP_RETVALUE, MAXSTRINGLEN);	  
	}
      else
	snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx", (unsigned long)ptr);
    }
#endif
%}

/*
 * Function irqflags_str :
 * 	Returns the symbolic string representation of the IRQ flags.
 *
 */

%{
#include <linux/interrupt.h>
#ifndef IRQF_ONESHOT
#define IRQF_ONESHOT 0x00002000
#endif
static const _stp_val_array _stp_irq_list[] = {
#ifdef IRQF_DISABLED
	V(IRQF_DISABLED),
#endif
#ifdef IRQF_SAMPLE_RANDOM
	V(IRQF_SAMPLE_RANDOM),
#endif
#ifdef IRQF_SHARED
	V(IRQF_SHARED),
#endif
#ifdef IRQF_PROBE_SHARED
	V(IRQF_PROBE_SHARED),
#endif
#ifdef IRQF_TIMER
	V(IRQF_TIMER),
#endif
#ifdef IRQF_PERCPU
	V(IRQF_PERCPU),
#endif
#ifdef IRQF_NOBALANCING
	V(IRQF_NOBALANCING),
#endif
#ifdef IRQF_IRQPOLL
	V(IRQF_IRQPOLL),
#endif
	V(IRQF_ONESHOT),
	{0, NULL}
};
%}

function irqflags_str:string(f:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_irq_list, STAP_ARG_f, STAP_RETVALUE, MAXSTRINGLEN);
%}

@__private30 function _stp_struct_iovec_u:string(iov_uaddr:long)
%{ /* pure */
	char *iov_uaddr = (void *)(uintptr_t)STAP_ARG_iov_uaddr;
	struct iovec iov = { 0 };
	if (iov_uaddr == NULL)
		strlcpy(STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char*)&iov, iov_uaddr,
					sizeof(struct iovec)) == 0) {
			_stp_snprintf(STAP_RETVALUE, MAXSTRINGLEN,
				      "[{%#lx, %lu}]", iov.iov_base,
				      iov.iov_len);
	   	}
		else
			_stp_snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				      (unsigned long)iov_uaddr);
	}
%}

@__private30 function _stp_struct_compat_iovec_u:string(iov_uaddr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
	char *iov_uaddr = (void *)(uintptr_t)STAP_ARG_iov_uaddr;
	struct compat_iovec iov = { 0 };
	if (iov_uaddr == NULL)
		strlcpy(STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else {
		if (_stp_copy_from_user((char*)&iov, iov_uaddr,
					sizeof(struct compat_iovec)) == 0) {
			_stp_snprintf(STAP_RETVALUE, MAXSTRINGLEN,
				      "[{%#lx, %lu}]", iov.iov_base,
				      iov.iov_len);
	   	}
		else
			_stp_snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
				      (unsigned long)iov_uaddr);
	}
#endif
%}

%{
#include <linux/ptrace.h>
static const _stp_val_array _stp_ptrace_options_list[] = {
#ifdef PTRACE_O_EXITKILL
	V(PTRACE_O_EXITKILL),
#endif
	V(PTRACE_O_TRACECLONE),
	V(PTRACE_O_TRACEEXEC),
	V(PTRACE_O_TRACEEXIT),
	V(PTRACE_O_TRACEFORK),
	V(PTRACE_O_TRACESYSGOOD),
	V(PTRACE_O_TRACEVFORK),
	V(PTRACE_O_TRACEVFORKDONE),
#ifdef PTRACE_O_TRACESECCOMP
	V(PTRACE_O_TRACESECCOMP),
#endif
	{0, NULL}
};
%}

/* PTRACE_SETOPTIONS parser of the DATA parameter. */
function _ptrace_options_str:string(f:long)
%{ /* pure */ /* unprivileged */
	unsigned long f = (unsigned long)STAP_ARG_f;  
	_stp_lookup_or_str(_stp_ptrace_options_list, f, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

/* ptrace syscall provisioning of argstr. */
%{
#include <linux/elf.h>
static const _stp_val_array _stp_elf_notes_list[] = {
	V(NT_PRSTATUS),
	V(NT_PRFPREG),
	V(NT_PRPSINFO),
	V(NT_TASKSTRUCT),
	V(NT_AUXV),
#ifdef NT_SIGINFO
	V(NT_SIGINFO),
#endif
#ifdef NT_FILE
	V(NT_FILE),
#endif
	V(NT_PRXFPREG),
#ifdef NT_PPC_VMX
	V(NT_PPC_VMX),
#endif
#ifdef NT_PPC_SPE
	V(NT_PPC_SPE),
#endif
#ifdef NT_PPC_VSX
	V(NT_PPC_VSX),
#endif
#ifdef NT_386_TLS
	V(NT_386_TLS),
#endif
#ifdef NT_386_IOPERM
	V(NT_386_IOPERM),
#endif
#ifdef NT_X86_XSTATE
	V(NT_X86_XSTATE),
#endif
#ifdef NT_S390_HIGH_GPRS
	V(NT_S390_HIGH_GPRS),
#endif
#ifdef NT_S390_TIMER
	V(NT_S390_TIMER),
#endif
#ifdef NT_S390_TODCMP
	V(NT_S390_TODCMP),
#endif
#ifdef NT_S390_TODPREG
	V(NT_S390_TODPREG),
#endif
#ifdef NT_S390_CTRS
	V(NT_S390_CTRS),
#endif
#ifdef NT_S390_PREFIX
	V(NT_S390_PREFIX),
#endif
#ifdef NT_S390_LAST_BREAK
	V(NT_S390_LAST_BREAK),
#endif
#ifdef NT_S390_SYSTEM_CALL
	V(NT_S390_SYSTEM_CALL),
#endif
#ifdef NT_S390_TDB
	V(NT_S390_TDB),
#endif
#ifdef NT_S390_VXRS_LOW
	V(NT_S390_VXRS_LOW),
#endif
#ifdef NT_S390_VXRS_HIGH
	V(NT_S390_VXRS_HIGH),
#endif
#ifdef NT_ARM_VFP
	V(NT_ARM_VFP),
#endif
#ifdef NT_ARM_TLS
	V(NT_ARM_TLS),
#endif
#ifdef NT_ARM_HW_BREAK
	V(NT_ARM_HW_BREAK),
#endif
#ifdef NT_ARM_HW_WATCH
	V(NT_ARM_HW_WATCH),
#endif
#ifdef NT_ARM_SYSTEM_CALL
	V(NT_ARM_SYSTEM_CALL),
#endif
#ifdef NT_METAG_CBUF
	V(NT_METAG_CBUF),
#endif
#ifdef NT_METAG_RPIPE
	V(NT_METAG_RPIPE),
#endif
#ifdef NT_METAG_TLS
	V(NT_METAG_TLS),
#endif
	{0, NULL}
};
%}

@__private30 function _stp_elf_notes_str:string(value:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_elf_notes_list, (unsigned long)STAP_ARG_value,
			STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#ifndef PTRACE_GETREGSET
# define PTRACE_GETREGSET	0x4204
#endif
#ifndef PTRACE_SETREGSET
# define PTRACE_SETREGSET	0x4205
#endif
#ifndef PTRACE_SEIZE
# define PTRACE_SEIZE		0x4206
#endif
#ifndef PTRACE_INTERRUPT
# define PTRACE_INTERRUPT	0x4207
#endif
#ifndef PTRACE_LISTEN
# define PTRACE_LISTEN		0x4208
#endif
#ifndef PTRACE_PEEKSIGINFO
# define PTRACE_PEEKSIGINFO	0x4209
#endif
#ifndef PTRACE_GETSIGMASK
# define PTRACE_GETSIGMASK	0x420a
#endif
#ifndef PTRACE_SETSIGMASK
# define PTRACE_SETSIGMASK	0x420b
#endif

/* These are the architecture-independent ptrace requests (although
 * some return architecture-dependent register buffers). */

static const _stp_val_array _stp_ptrace_request_list[] = {
	V(PTRACE_TRACEME),
	V(PTRACE_PEEKTEXT),
	V(PTRACE_PEEKDATA),
	V(PTRACE_PEEKUSR),
	V(PTRACE_POKETEXT),
	V(PTRACE_POKEDATA),
	V(PTRACE_POKEUSR),
	V(PTRACE_CONT),
	V(PTRACE_KILL),
	V(PTRACE_SINGLESTEP),
	V(PTRACE_ATTACH),
	V(PTRACE_DETACH),
	V(PTRACE_SYSCALL),
	V(PTRACE_SETOPTIONS),
	V(PTRACE_GETEVENTMSG),
	V(PTRACE_GETSIGINFO),
	V(PTRACE_SETSIGINFO),
	V(PTRACE_GETREGSET),
	V(PTRACE_SETREGSET),
	V(PTRACE_SEIZE),
	V(PTRACE_INTERRUPT),
	V(PTRACE_LISTEN),
	V(PTRACE_PEEKSIGINFO),
	V(PTRACE_GETSIGMASK),
	V(PTRACE_SETSIGMASK),
	{0, NULL}
};
%}

@__private30 function __ptrace_request_str:string(request:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_ptrace_request_list,
			(unsigned long)STAP_ARG_request, STAP_RETVALUE,
			MAXSTRINGLEN);
%}

function _ptrace_argstr(request, pid, addr, data)
{
	// Handle arch-specific ptrace requests first.
	retval=_arch_ptrace_argstr(request, pid, addr, data)
	if (retval != "")
		return retval

// Handle generic ptrace requests.
	if (request == @const("PTRACE_PEEKTEXT")
	    || request == @const("PTRACE_PEEKDATA")
	    || request == @const("PTRACE_PEEKUSR"))
		/* For PTRACE_PEEK{TEXT,DATA,USR}, 'data' is ignored
		 * from the user's point of view, but glibc stores the
		 * result at the 'data' address. */
		return sprintf("%s, %d, %p, [%p]",
			       __ptrace_request_str(request), pid, addr, data)
	if (request == @const("PTRACE_POKETEXT")
	    || request == @const("PTRACE_POKEDATA")
	    || request == @const("PTRACE_POKEUSR")
	    || request == @const("PTRACE_PEEKSIGINFO"))
		return sprintf("%s, %d, %p, %p",
			       __ptrace_request_str(request), pid, addr, data)
	if (request == @const("PTRACE_CONT")
	    || request == @const("PTRACE_SYSCALL")
	    || request == @const("PTRACE_SINGLESTEP")
	    || request == @const("PTRACE_DETACH"))
		return sprintf("%s, %d, %#x, %s",
			       __ptrace_request_str(request), pid, addr,
			       _signal_name (data))
	if (request == @const("PTRACE_GETSIGINFO")
	    || request == @const("PTRACE_SETSIGINFO")
	    || request == @const("PTRACE_GETEVENTMSG")
	    || request == @const("PTRACE_GETSIGMASK")
	    || request == @const("PTRACE_SETSIGMASK"))
		return sprintf("%s, %d, %#x, %p",
			       __ptrace_request_str(request), pid, addr, data)
	if (request == @const("PTRACE_GETREGSET")
	    || request == @const("PTRACE_SETREGSET"))
		return sprintf("%s, %d, %s, %s",
			       __ptrace_request_str(request), pid,
			       _stp_elf_notes_str(addr),
			       (@__compat_task
			        ? _stp_struct_compat_iovec_u(data)
				: _stp_struct_iovec_u(data)))
	if (request == @const("PTRACE_TRACEME")
	    || request == @const("PTRACE_KILL")
	    || request == @const("PTRACE_ATTACH")
	    || request == @const("PTRACE_SEIZE")
	    || request == @const("PTRACE_INTERRUPT")
	    || request == @const("PTRACE_LISTEN"))
		return sprintf("%s, %d, %#x, %#x",
			       __ptrace_request_str(request), pid, addr, data)
	if (request == @const("PTRACE_SETOPTIONS"))
		return sprintf("PTRACE_SETOPTIONS, %d, %#x, %s", pid,
			       addr, _ptrace_options_str(data))

return sprintf("%s, %d, %p, %p", __ptrace_request_str(request),
		       pid, addr, data)
}

/* ptrace.return syscall decoder for PTRACE_GETEVENTMSG. */
function _ptrace_return_geteventmsg_data(request,data)
{
	if (request == @const("PTRACE_GETEVENTMSG"))
		return user_long(data)
}

%{
#include <linux/swap.h>

static const _stp_val_array _stp_swapon_flags_list[] = {
	V(SWAP_FLAG_PREFER),
#ifdef SWAP_FLAG_DISCARD
	V(SWAP_FLAG_DISCARD),
#endif
#ifdef SWAP_FLAG_DISCARD_ONCE
	V(SWAP_FLAG_DISCARD_ONCE),
#endif
#ifdef SWAP_FLAG_DISCARD_PAGES
	V(SWAP_FLAG_DISCARD_PAGES),
#endif
	{0, NULL}
};
%}

function _swapon_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = (unsigned int)STAP_ARG_flags;
	_stp_lookup_or_str(_stp_swapon_flags_list,
			   (flags & ~SWAP_FLAG_PRIO_MASK), STAP_RETVALUE,
			   MAXSTRINGLEN);
	if (STAP_ARG_flags & SWAP_FLAG_PREFER) {
		int slen;
		slen = strlen(STAP_RETVALUE);
		_stp_snprintf(STAP_RETVALUE + slen, MAXSTRINGLEN - slen, 
			      "|%d", flags & SWAP_FLAG_PRIO_MASK);
	}
%}

/* do_fork helper function to determine fork type. */
@__private30 function __is_user_regs:long (regs:long)
%{ /* pure */
	struct pt_regs * regs = (void *)((uintptr_t)STAP_ARG_regs);
/* copied from asm/ptrace.h */
#if defined(__i386__)
#ifdef STAPCONF_X86_UNIREGS
	int cs = kread(&regs->cs);
#else
	int cs = kread(&regs->xcs);
#endif
	STAP_RETVALUE = (!!((cs & 3)));
#elif defined(__x86_64__)
	unsigned long cs = kread(&regs->cs);
	STAP_RETVALUE = (!!((cs & 3)));
#elif defined(__ia64__)
	unsigned long psr = kread(&regs->cr_ipsr);
	STAP_RETVALUE = (((struct ia64_psr *) &psr)->cpl != 0);
#elif defined(__powerpc64__)
	unsigned long msr = kread(&regs->msr);
	STAP_RETVALUE = ((msr >> MSR_PR_LG) & 0x1);
#elif defined(__powerpc__)
	unsigned long msr = kread(&regs->msr);
	STAP_RETVALUE = ((msr >> MSR_PR) != 0);
#elif defined(__arm__)
	long cpsr = kread(&regs->ARM_cpsr);
	STAP_RETVALUE = ((cpsr & 0xf) == 0);
#elif defined(__mips__)
	unsigned long cp0 = kread(&regs->cp0_status);
#if defined(CONFIG_CPU_R3000) || defined(CONFIG_CPU_TX39XX)
	STAP_RETVALUE = ((cp0 & 0x08) == 8);
#else
	STAP_RETVALUE = ((cp0 & 0x18) == 0x10);
#endif
#elif defined(__s390__) || defined(__s390x__)
	unsigned long mask = kread(&regs->psw.mask);
	STAP_RETVALUE = ((mask & PSW_MASK_PSTATE) != 0);
#elif defined(__aarch64__)
	long pstate = kread(&regs->pstate);
	STAP_RETVALUE = ((pstate & PSR_MODE_MASK) == PSR_MODE_EL0t);
#else
#error "Unimplemented architecture"
#endif
CATCH_DEREF_FAULT();
%}

%{
#include <linux/ipc.h>
#include <linux/shm.h>
static const _stp_val_array _stp_shmget_flags_list[] = {
	V(IPC_CREAT),
	V(IPC_EXCL),
	V(SHM_HUGETLB),
	V(SHM_NORESERVE),
	{0, NULL}
};
%}

function _stp_shmget_flags_str:string(shmflg:long)
%{ /* pure */ /* unprivileged */
	unsigned int shmflg = (unsigned int)STAP_ARG_shmflg;  
	unsigned int modebits;

/* Lowest 9 bits are mode bits. */
	modebits = shmflg & 0777;
	shmflg &= ~0777;
	_stp_lookup_or_str(_stp_shmget_flags_list, shmflg, STAP_RETVALUE,
			   MAXSTRINGLEN);
	if (modebits) {
		int slen;
		slen = strlen(STAP_RETVALUE);
		if (slen)
			_stp_snprintf(STAP_RETVALUE + slen, MAXSTRINGLEN - slen,
				      "|%#o", modebits);
		else		
			_stp_snprintf(STAP_RETVALUE, MAXSTRINGLEN, "%#o",
				      modebits);
	}
%}

function _stp_msgget_key_str:string(key:long)
{
	if (key == @const("IPC_PRIVATE"))
		return "IPC_PRIVATE"
	return sprintf("%d", key)
}

%{
#include <linux/msg.h>

static const _stp_val_array _stp_msgctl_list[] = {
	V(IPC_INFO),
	V(IPC_STAT),
	V(IPC_RMID),
	V(IPC_SET),
	V(MSG_INFO),
	V(MSG_STAT),
	{0, NULL}
};
%}

function _stp_msgctl_cmd_str:string(cmd:long)
%{ /* pure */ /* unprivileged */
	unsigned int cmd = STAP_ARG_cmd;

if (cmd & IPC_64) {
		strlcpy (STAP_RETVALUE, "IPC_64|", MAXSTRINGLEN);
		cmd &= ~IPC_64;
	}
	_stp_lookup_str(_stp_msgctl_list, cmd, STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_msgflg_list[] = {
	V(MSG_NOERROR),
	V(MSG_EXCEPT),
	V(IPC_NOWAIT),
	{0, NULL}
};
%}

function _stp_msgflg_str:string(msgflg:long)
%{ /* pure */ /* unprivileged */
	unsigned int msgflg = STAP_ARG_msgflg;

_stp_lookup_or_str(_stp_msgflg_list, msgflg, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
// Copied from ipc/compat.c.

#ifdef CONFIG_COMPAT
struct compat_ipc_kludge {
	compat_uptr_t msgp;
	compat_long_t msgtyp;
};
#endif
%}

function _stp_compat_msgrcv_msgbuf:long(uaddr:long, version:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	int version = (int)(unsigned long)STAP_ARG_version;
	void *msgbuf = ptr;

if (!version) {
		struct compat_ipc_kludge ipck;

msgbuf = NULL;
		if (ptr != NULL
		    && _stp_copy_from_user((char*)&ipck, ptr,
					   sizeof(ipck)) == 0) {
			msgbuf = compat_ptr(ipck.msgp);
		}
	}
	STAP_RETVALUE = (unsigned long)msgbuf;
#endif
%}

function _stp_compat_msgrcv_msgtyp:long(uaddr:long, version:long, msgtyp:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	int version = (int)(unsigned long)STAP_ARG_version;
	long msgtyp = (long)STAP_ARG_msgtyp;

if (!version) {
		struct compat_ipc_kludge ipck;

if (ptr != NULL
		    && _stp_copy_from_user((char*)&ipck, ptr,
					   sizeof(ipck)) == 0) {
			msgtyp = ipck.msgtyp;
		}
	}
	STAP_RETVALUE = msgtyp;
#endif
%}

%{
#include <linux/xattr.h>

static const _stp_val_array _stp_xattr_flags_list[] = {
	V(XATTR_CREATE),
	V(XATTR_REPLACE),
	{0, NULL}
};
%}

function _stp_xattr_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = STAP_ARG_flags;

_stp_lookup_or_str(_stp_xattr_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

function _stp_xattr_val_str:string(uaddr:long, size:long)
%{ /* pure */
	void *uaddr = (void *)(uintptr_t)STAP_ARG_uaddr;
	unsigned long size = STAP_ARG_size;
	unsigned char buffer[50];
	size_t copy_size = clamp_t(size_t, size, 0, sizeof(buffer));

if (uaddr != NULL && copy_size > 0
	    && _stp_copy_from_user(buffer, uaddr, copy_size) == 0) {
		size_t i;
		unsigned char *out = STAP_RETVALUE;
		// Save 3 chars: 2 for the leading and trailing
		// double-quote chars, one for the trailing NUL.
		size_t out_size = MAXSTRINGLEN - 3;

*out++ = '"';
		for (i = 0; i < copy_size; ++i) {
#define _stp_is_printable_ascii(c) ((c) >= ' ' && (c) <= 0x7e)
#define _stp_tohex(n) "0123456789abcdef"[n]

if (_stp_is_printable_ascii(buffer[i])) {
				if (--out_size >= 0)
					*out++ = buffer[i];
			}
			else {
				if (out_size < 4)
					break;
				out_size -= 4;
				if (out_size >= 0) {	
					*out++ = '\\';
					*out++ = 'x';
					*out++ = _stp_tohex(buffer[i] / 16);
					*out++ = _stp_tohex(buffer[i] % 16);
				}
			}
			if (out_size == 0)
				break;
		}
		// Don't print terminating NUL from the input data if
		// there is one.
		if (i > 1 && buffer[i - 1] == '\0'
		    && _stp_is_printable_ascii(buffer[i - 2]))
			out -= 4;
		*out++ = '"';
		*out = '\0';
	}
	else
		snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			 (unsigned long)uaddr);
%}

%{
#include <linux/ioprio.h>

static const _stp_val_array _stp_ioprio_who_list[] = {
	V(IOPRIO_WHO_PROCESS),
	V(IOPRIO_WHO_PGRP),
	V(IOPRIO_WHO_USER),
	{0, NULL}
};
static const _stp_val_array _stp_ioprio_class_list[] = {
	V(IOPRIO_CLASS_NONE),
	V(IOPRIO_CLASS_RT),
	V(IOPRIO_CLASS_BE),
	V(IOPRIO_CLASS_IDLE),
	{0, NULL}
};
%}

function _stp_ioprio_which_str:string(who:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str2(_stp_ioprio_who_list, (int)STAP_ARG_who,
			 STAP_RETVALUE, MAXSTRINGLEN, 10);
%}

function _stp_ioprio_value_str:string(value:long)
%{ /* pure */ /* unprivileged */
	unsigned int class = IOPRIO_PRIO_CLASS(((unsigned int)STAP_ARG_value));
	int slen;

_stp_lookup_str(_stp_ioprio_class_list, class, STAP_RETVALUE,
			MAXSTRINGLEN);
	slen = strlen(STAP_RETVALUE);
	_stp_snprintf(STAP_RETVALUE + slen, MAXSTRINGLEN - slen, "|%d",
		      IOPRIO_PRIO_DATA(((int)STAP_ARG_value)));
%}

%{
#include <linux/mempolicy.h>
static const _stp_val_array _stp_mempolicy_flags_list[] = {
	V(MPOL_F_NODE),
	V(MPOL_F_ADDR),
#ifdef MPOL_F_MEMS_ALLOWED
	V(MPOL_F_MEMS_ALLOWED),
#endif
	{0, NULL}
};

#ifndef MPOL_MODE_FLAGS
#define MPOL_MODE_FLAGS 0
#endif

static const _stp_val_array _stp_mempolicy_mode_flags_list[] = {
#ifdef MPOL_F_STATIC_NODES
	V(MPOL_F_STATIC_NODES),
#endif
#ifdef MPOL_F_RELATIVE_NODES
	V(MPOL_F_RELATIVE_NODES),
#endif
	{0, NULL}
};

static const _stp_val_array _stp_mempolicy_mode_list[] = {
	V(MPOL_DEFAULT),
	V(MPOL_PREFERRED),
	V(MPOL_BIND),
	V(MPOL_INTERLEAVE),
#ifdef MPOL_LOCAL
	V(MPOL_LOCAL),
#endif
	{0, NULL}
};
%}

function _mempolicy_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_mempolicy_flags_list,
			   (unsigned long)STAP_ARG_flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

function _mempolicy_mode_str:string(mode:long)
%{ /* pure */ /* unprivileged */
	unsigned int mode = (unsigned int)STAP_ARG_mode;
	int len = 0;

if (mode != 0xffffffff && mode & MPOL_MODE_FLAGS) {
		_stp_lookup_str(_stp_mempolicy_mode_flags_list,
				mode & MPOL_MODE_FLAGS, STAP_RETVALUE,
				MAXSTRINGLEN);
		strlcat(STAP_RETVALUE, "|", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		mode &= ~MPOL_MODE_FLAGS;
	}
	_stp_lookup_str(_stp_mempolicy_mode_list, mode, STAP_RETVALUE + len,
			MAXSTRINGLEN - len);
%}

%{
#include <linux/keyctl.h>

static const _stp_val_array _stp_keyctl_cmd_list[] = {
	V(KEYCTL_GET_KEYRING_ID),
	V(KEYCTL_JOIN_SESSION_KEYRING),
	V(KEYCTL_UPDATE),
	V(KEYCTL_REVOKE),
	V(KEYCTL_CHOWN),
	V(KEYCTL_SETPERM),
	V(KEYCTL_DESCRIBE),
	V(KEYCTL_CLEAR),
	V(KEYCTL_LINK),
	V(KEYCTL_UNLINK),
	V(KEYCTL_SEARCH),
	V(KEYCTL_READ),
	V(KEYCTL_INSTANTIATE),
	V(KEYCTL_NEGATE),
	V(KEYCTL_SET_REQKEY_KEYRING),
	V(KEYCTL_SET_TIMEOUT),
	V(KEYCTL_ASSUME_AUTHORITY),
#ifdef KEYCTL_GET_SECURITY
	V(KEYCTL_GET_SECURITY),
#endif
#ifdef KEYCTL_SESSION_TO_PARENT
	V(KEYCTL_SESSION_TO_PARENT),
#endif
#ifdef KEYCTL_REJECT
	V(KEYCTL_REJECT),
#endif
#ifdef KEYCTL_INSTANTIATE_IOV
	V(KEYCTL_INSTANTIATE_IOV),
#endif
#ifdef KEYCTL_INVALIDATE
	V(KEYCTL_INVALIDATE),
#endif
#ifdef KEYCTL_GET_PERSISTENT
	V(KEYCTL_GET_PERSISTENT),
#endif
        {0, NULL}
};

// For older kernels, we need to define new constants for the
// @__keyctl_argstr() macro
#ifndef KEYCTL_GET_SECURITY
#define KEYCTL_GET_SECURITY 17
#endif
#ifndef KEYCTL_SESSION_TO_PARENT
#define KEYCTL_SESSION_TO_PARENT 18
#endif
#ifndef KEYCTL_REJECT
#define KEYCTL_REJECT 19
#endif
#ifndef KEYCTL_INSTANTIATE_IOV
#define KEYCTL_INSTANTIATE_IOV 20
#endif
#ifndef KEYCTL_INVALIDATE
#define KEYCTL_INVALIDATE 21
#endif
#ifndef KEYCTL_GET_PERSISTENT
#define KEYCTL_GET_PERSISTENT 22
#endif
%}

function _stp_keyctl_cmd_str:string(cmd:long)
%{ /* pure */ /* unprivileged */
        _stp_lookup_str2(_stp_keyctl_cmd_list, (int)STAP_ARG_cmd,
                        STAP_RETVALUE, MAXSTRINGLEN, 10);
%}

%{
static const _stp_val_array _stp_keyctl_keyring_shortcut_list[] = {
        V(KEY_SPEC_THREAD_KEYRING),
        V(KEY_SPEC_PROCESS_KEYRING),
        V(KEY_SPEC_SESSION_KEYRING),
        V(KEY_SPEC_USER_KEYRING),
        V(KEY_SPEC_USER_SESSION_KEYRING),
        V(KEY_SPEC_GROUP_KEYRING),
        V(KEY_SPEC_REQKEY_AUTH_KEY),
#ifdef KEY_SPEC_REQUESTOR_KEYRING
        V(KEY_SPEC_REQUESTOR_KEYRING),
#endif
        {0, NULL}
};
%}

function _stp_keyctl_keyring_shortcut_str:string(id:long)
%{ /* pure */ /* unprivileged */
        _stp_lookup_str2(_stp_keyctl_keyring_shortcut_list, (int)STAP_ARG_id,
                        STAP_RETVALUE, MAXSTRINGLEN, 10);
%}

%{
static const _stp_val_array _stp_keyctl_default_keyrings_list[] = {
	V(KEY_REQKEY_DEFL_NO_CHANGE),
	V(KEY_REQKEY_DEFL_DEFAULT),
	V(KEY_REQKEY_DEFL_THREAD_KEYRING),
	V(KEY_REQKEY_DEFL_PROCESS_KEYRING),
	V(KEY_REQKEY_DEFL_SESSION_KEYRING),
	V(KEY_REQKEY_DEFL_USER_KEYRING),
	V(KEY_REQKEY_DEFL_USER_SESSION_KEYRING),
	V(KEY_REQKEY_DEFL_GROUP_KEYRING),
        {0, NULL}
};
%}

function _stp_keyctl_default_keyrings_str:string(id:long)
%{ /* pure */ /* unprivileged */
        _stp_lookup_str2(_stp_keyctl_default_keyrings_list, (int)STAP_ARG_id,
                        STAP_RETVALUE, MAXSTRINGLEN, 10);
%}

%{
#include <linux/key.h>

static const _stp_val_array _stp_keyctl_perm_list[] = {
#if defined(CONFIG_KEYS)
	V(KEY_POS_VIEW),
	V(KEY_POS_READ),
	V(KEY_POS_WRITE),
	V(KEY_POS_SEARCH),
	V(KEY_POS_LINK),
	V(KEY_POS_SETATTR),
	V(KEY_POS_ALL),
	V(KEY_USR_VIEW),
	V(KEY_USR_READ),
	V(KEY_USR_WRITE),
	V(KEY_USR_SEARCH),
	V(KEY_USR_LINK),
	V(KEY_USR_SETATTR),
	V(KEY_USR_ALL),
	V(KEY_GRP_VIEW),
	V(KEY_GRP_READ),
	V(KEY_GRP_WRITE),
	V(KEY_GRP_SEARCH),
	V(KEY_GRP_LINK),
	V(KEY_GRP_SETATTR),
	V(KEY_GRP_ALL),
	V(KEY_OTH_VIEW),
	V(KEY_OTH_READ),
	V(KEY_OTH_WRITE),
	V(KEY_OTH_SEARCH),
	V(KEY_OTH_LINK),
	V(KEY_OTH_SETATTR),
	V(KEY_OTH_ALL),
#endif /* CONFIG_KEYS */
	{0, NULL}
};
%}

function _stp_keyctl_perm_str:string(mask:long)
%{ /* pure */ /* unprivileged */
	uint32_t mask = (uint32_t)STAP_ARG_mask;
	_stp_lookup_or_str2(_stp_keyctl_perm_list, mask, STAP_RETVALUE,
			   MAXSTRINGLEN, 10);
%}

%{
#include <linux/module.h>

#ifndef MODULE_INIT_IGNORE_MODVERSIONS
#define MODULE_INIT_IGNORE_MODVERSIONS	1
#endif
#ifndef MODULE_INIT_IGNORE_VERMAGIC
#define MODULE_INIT_IGNORE_VERMAGIC	2
#endif

static const _stp_val_array _stp_finit_module_flags_list[] = {
	V(MODULE_INIT_IGNORE_MODVERSIONS),
	V(MODULE_INIT_IGNORE_VERMAGIC),
	{0, NULL}
};
%}

function _finit_module_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_finit_module_flags_list,
			   (unsigned int)STAP_ARG_flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)
#include <linux/prctl.h>
#else
#include <uapi/linux/prctl.h>
#endif

static const _stp_val_array _stp_prctl_option_list[] = {
	V(PR_SET_PDEATHSIG),
	V(PR_GET_PDEATHSIG),
	V(PR_GET_DUMPABLE),
	V(PR_SET_DUMPABLE),
	V(PR_GET_UNALIGN),
	V(PR_SET_UNALIGN),
	V(PR_GET_KEEPCAPS),
	V(PR_SET_KEEPCAPS),
	V(PR_GET_FPEMU),
	V(PR_SET_FPEMU),
	V(PR_GET_FPEXC),
	V(PR_SET_FPEXC),
	V(PR_GET_TIMING),
	V(PR_SET_TIMING),
	V(PR_SET_NAME),
	V(PR_GET_NAME),
	V(PR_GET_ENDIAN),
	V(PR_SET_ENDIAN),
#ifdef PR_GET_SECCOMP
	V(PR_GET_SECCOMP),
#endif
#ifdef PR_SET_SECCOMP
	V(PR_SET_SECCOMP),
#endif
#ifdef PR_CAPBSET_READ
	V(PR_CAPBSET_READ),
#endif
#ifdef PR_CAPBSET_DROP
	V(PR_CAPBSET_DROP),
#endif
#ifdef PR_GET_TSC
	V(PR_GET_TSC),
#endif
#ifdef PR_SET_TSC
	V(PR_SET_TSC),
#endif
#ifdef PR_GET_SECUREBITS
	V(PR_GET_SECUREBITS),
#endif
#ifdef PR_SET_SECUREBITS
	V(PR_SET_SECUREBITS),
#endif
#ifdef PR_SET_TIMERSLACK
	V(PR_SET_TIMERSLACK),
#endif
#ifdef PR_GET_TIMERSLACK
	V(PR_GET_TIMERSLACK),
#endif
#ifdef PR_TASK_PERF_EVENTS_DISABLE
	V(PR_TASK_PERF_EVENTS_DISABLE),
#endif
#ifdef PR_TASK_PERF_EVENTS_ENABLE
	V(PR_TASK_PERF_EVENTS_ENABLE),
#endif
#ifdef PR_MCE_KILL
	V(PR_MCE_KILL),
#endif
#ifdef PR_MCE_KILL_GET
	V(PR_MCE_KILL_GET),
#endif
#ifdef PR_SET_MM
	V(PR_SET_MM),
#endif
#ifdef PR_SET_PTRACER
	V(PR_SET_PTRACER),
#endif
#ifdef PR_SET_CHILD_SUBREAPER
	V(PR_SET_CHILD_SUBREAPER),
#endif
#ifdef PR_GET_CHILD_SUBREAPER
	V(PR_GET_CHILD_SUBREAPER),
#endif
#ifdef PR_SET_NO_NEW_PRIVS
	V(PR_SET_NO_NEW_PRIVS),
#endif
#ifdef PR_GET_NO_NEW_PRIVS
	V(PR_GET_NO_NEW_PRIVS),
#endif
#ifdef PR_GET_TID_ADDRESS
	V(PR_GET_TID_ADDRESS),
#endif
#ifdef PR_SET_THP_DISABLE
	V(PR_SET_THP_DISABLE),
#endif
#ifdef PR_GET_THP_DISABLE
	V(PR_GET_THP_DISABLE),
#endif
#ifdef PR_MPX_ENABLE_MANAGEMENT
	V(PR_MPX_ENABLE_MANAGEMENT),
#endif
#ifdef PR_MPX_DISABLE_MANAGEMENT
	V(PR_MPX_DISABLE_MANAGEMENT),
#endif
	{0, NULL}
};

// Options that get passed to PR_SET_UNALIGN and returned by PR_GET_UNALIGN.
static const _stp_val_array _stp_prctl_unalign_option_list[] = {
	V(PR_UNALIGN_NOPRINT),
	V(PR_UNALIGN_SIGBUS),
	{0, NULL}
};

// Options that get passed to PR_SET_FPEMU and returned by PR_GET_FPEMU.
static const _stp_val_array _stp_prctl_fpemu_option_list[] = {
	V(PR_FPEMU_NOPRINT),
	V(PR_FPEMU_SIGFPE),
	{0, NULL}
};

// Options that get passed to PR_SET_FPEXC and returned by PR_GET_FPEXC.
static const _stp_val_array _stp_prctl_fpexc_option_list[] = {
	V(PR_FP_EXC_SW_ENABLE),
	V(PR_FP_EXC_DIV),
	V(PR_FP_EXC_OVF),
	V(PR_FP_EXC_UND),
	V(PR_FP_EXC_RES),
	V(PR_FP_EXC_INV),
	V(PR_FP_EXC_DISABLED),
	V(PR_FP_EXC_NONRECOV),
	V(PR_FP_EXC_ASYNC),
	V(PR_FP_EXC_PRECISE),
	{0, NULL}
};

// Options that get passed to PR_SET_TIMING and returned by PR_GET_TIMING.
static const _stp_val_array _stp_prctl_timing_option_list[] = {
	V(PR_TIMING_STATISTICAL),
	V(PR_TIMING_TIMESTAMP),
	{0, NULL}
};

// Options that get passed to PR_SET_ENDIAN and returned by PR_GET_ENDIAN.
static const _stp_val_array _stp_prctl_endian_option_list[] = {
	V(PR_ENDIAN_BIG),
	V(PR_ENDIAN_LITTLE),
	V(PR_ENDIAN_PPC_LITTLE),
	{0, NULL}
};

#ifdef PR_SET_TSC
// Options that get passed to PR_SET_TSC and returned by PR_GET_TSC.
static const _stp_val_array _stp_prctl_tsc_option_list[] = {
	V(PR_TSC_ENABLE),
	V(PR_TSC_SIGSEGV),
	{0, NULL}
};
#endif

#ifdef PR_MCE_KILL
// Options that get passed to PR_MCE_KILL and returned by PR_MCE_KILL_GET.
static const _stp_val_array _stp_prctl_mce_kill_option_list[] = {
	V(PR_MCE_KILL_CLEAR),
	V(PR_MCE_KILL_SET),
	{0, NULL}
};
// Options for PR_MCE_KILL with PR_MCE_KILL_SET.
static const _stp_val_array _stp_prctl_mce_kill_option2_list[] = {
	V(PR_MCE_KILL_LATE),
	V(PR_MCE_KILL_EARLY),
	V(PR_MCE_KILL_DEFAULT),
	{0, NULL}
};
#endif

#ifdef PR_SET_MM
// Options that get passed to PR_SET_MM.
static const _stp_val_array _stp_prctl_mm_option_list[] = {
	V(PR_SET_MM_START_CODE),
	V(PR_SET_MM_END_CODE),
	V(PR_SET_MM_START_DATA),
	V(PR_SET_MM_END_DATA),
	V(PR_SET_MM_START_STACK),
	V(PR_SET_MM_START_BRK),
	V(PR_SET_MM_BRK),
#ifdef PR_SET_MM_ARG_START
	V(PR_SET_MM_ARG_START),
#endif
#ifdef PR_SET_MM_ARG_END
	V(PR_SET_MM_ARG_END),
#endif
#ifdef PR_SET_MM_ENV_START
	V(PR_SET_MM_ENV_START),
#endif
#ifdef PR_SET_MM_ENV_END
	V(PR_SET_MM_ENV_END),
#endif
#ifdef PR_SET_MM_AUXV
	V(PR_SET_MM_AUXV),
#endif
#ifdef PR_SET_MM_EXE_FILE
	V(PR_SET_MM_EXE_FILE),
#endif
#ifdef PR_SET_MM_MAP
	V(PR_SET_MM_MAP),
#endif
#ifdef PR_SET_MM_MAP_SIZE
	V(PR_SET_MM_MAP_SIZE),
#endif
	{0, NULL}
};
#endif

#ifdef PR_SET_PTRACER
// Options that get passed to PR_SET_PTRACER.
static const _stp_val_array _stp_prctl_ptracer_option_list[] = {
	V(PR_SET_PTRACER_ANY),
	{0, NULL}
};
#endif

#include <linux/capability.h>

static const _stp_val_array _stp_linux_capability_list[] = {
	V(CAP_CHOWN),
	V(CAP_DAC_OVERRIDE),
	V(CAP_DAC_READ_SEARCH),
	V(CAP_FOWNER),
	V(CAP_FSETID),
	V(CAP_KILL),
	V(CAP_SETGID),
	V(CAP_SETUID),
	V(CAP_SETPCAP),
	V(CAP_LINUX_IMMUTABLE),
	V(CAP_NET_BIND_SERVICE),
	V(CAP_NET_BROADCAST),
	V(CAP_NET_ADMIN),
	V(CAP_NET_RAW),
	V(CAP_IPC_LOCK),
	V(CAP_IPC_OWNER),
	V(CAP_SYS_MODULE),
	V(CAP_SYS_RAWIO),
	V(CAP_SYS_CHROOT),
	V(CAP_SYS_PTRACE),
	V(CAP_SYS_PACCT),
	V(CAP_SYS_ADMIN),
	V(CAP_SYS_BOOT),
	V(CAP_SYS_NICE),
	V(CAP_SYS_RESOURCE),
	V(CAP_SYS_TIME),
	V(CAP_SYS_TTY_CONFIG),
	V(CAP_MKNOD),
	V(CAP_LEASE),
	V(CAP_AUDIT_WRITE),
	V(CAP_AUDIT_CONTROL),
#ifdef CAP_SETFCAP
	V(CAP_SETFCAP),
#endif
#ifdef CAP_MAC_OVERRIDE
	V(CAP_MAC_OVERRIDE),
#endif
#ifdef CAP_MAC_ADMIN
	V(CAP_MAC_ADMIN),
#endif
#ifdef CAP_SYSLOG
	V(CAP_SYSLOG),
#endif
#ifdef CAP_WAKE_ALARM
	V(CAP_WAKE_ALARM),
#endif
#ifdef CAP_BLOCK_SUSPEND
	V(CAP_BLOCK_SUSPEND),
#endif
#ifdef CAP_AUDIT_READ
	V(CAP_AUDIT_READ),
#endif
	{0, NULL}
};

#ifdef PR_SET_SECUREBITS
#include <linux/securebits.h>

#ifndef SECBIT_NOROOT
#define SECBIT_NOROOT		(issecure_mask(SECURE_NOROOT))
#endif
#ifndef SECBIT_NOROOT_LOCKED
#define SECBIT_NOROOT_LOCKED	(issecure_mask(SECURE_NOROOT_LOCKED))
#endif
#ifndef SECBIT_NO_SETUID_FIXUP
#define SECBIT_NO_SETUID_FIXUP	(issecure_mask(SECURE_NO_SETUID_FIXUP))
#endif
#ifndef SECBIT_NO_SETUID_FIXUP_LOCKED
#define SECBIT_NO_SETUID_FIXUP_LOCKED \
			(issecure_mask(SECURE_NO_SETUID_FIXUP_LOCKED))
#endif
#ifndef SECBIT_KEEP_CAPS
#define SECBIT_KEEP_CAPS	(issecure_mask(SECURE_KEEP_CAPS))
#endif
#ifndef SECBIT_KEEP_CAPS_LOCKED
#define SECBIT_KEEP_CAPS_LOCKED (issecure_mask(SECURE_KEEP_CAPS_LOCKED))
#endif

static const _stp_val_array _stp_linux_securebits_list[] = {
	V(SECBIT_NOROOT),
	V(SECBIT_NOROOT_LOCKED),
	V(SECBIT_NO_SETUID_FIXUP),
	V(SECBIT_NO_SETUID_FIXUP_LOCKED),
	V(SECBIT_KEEP_CAPS),
	V(SECBIT_KEEP_CAPS_LOCKED),
	{0, NULL}
};
#endif
%}

function _prctl_argstr:string(option:long, arg2:long, arg3:long, arg4:long,
			      arg5:long)
%{ /* pure */ /* unprivileged */
	int len;

_stp_lookup_str(_stp_prctl_option_list, (unsigned int)STAP_ARG_option,
			STAP_RETVALUE, MAXSTRINGLEN);
	switch ((unsigned int)STAP_ARG_option) {
	// Options that take no arguments:
	case PR_GET_DUMPABLE:
	case PR_GET_TIMING:
	case PR_GET_KEEPCAPS:
#ifdef PR_GET_SECCOMP
	case PR_GET_SECCOMP:
#endif
#ifdef PR_TASK_PERF_EVENTS_DISABLE
	case PR_TASK_PERF_EVENTS_DISABLE:
#endif
#ifdef PR_TASK_PERF_EVENTS_ENABLE
	case PR_TASK_PERF_EVENTS_ENABLE:
#endif
#ifdef PR_GET_TIMERSLACK
	case PR_GET_TIMERSLACK:
#endif
#ifdef PR_MCE_KILL_GET
	case PR_MCE_KILL_GET:
#endif
#ifdef PR_GET_NO_NEW_PRIVS
	case PR_GET_NO_NEW_PRIVS:
#endif
#ifdef PR_GET_THP_DISABLE
	case PR_GET_THP_DISABLE:
#endif
#ifdef PR_MPX_ENABLE_MANAGEMENT
	case PR_MPX_ENABLE_MANAGEMENT:
#endif
#ifdef PR_MPX_DISABLE_MANAGEMENT
	case PR_MPX_DISABLE_MANAGEMENT:
#endif
#ifdef PR_GET_SECUREBITS
	case PR_GET_SECUREBITS:
#endif
		// We're done.
		break;

// Options that use arg2:
	case PR_SET_UNALIGN:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_prctl_unalign_option_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		break;
	case PR_SET_FPEMU:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_prctl_fpemu_option_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		break;
	case PR_SET_FPEXC:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_prctl_fpexc_option_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		break;
	case PR_SET_TIMING:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_prctl_timing_option_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		break;
	case PR_SET_ENDIAN:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_prctl_endian_option_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		break;
#ifdef PR_SET_TSC
	case PR_SET_TSC:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_prctl_tsc_option_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		break;
#endif
#ifdef PR_SET_PTRACER
	case PR_SET_PTRACER:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		// Notice we passing arg2 as a signed long
		// here. PR_SET_PTRACER_ANY is -1.
		_stp_lookup_str2(_stp_prctl_ptracer_option_list,
				 (_stp_is_compat_task()
				  ? (long)(int)STAP_ARG_arg2
				  : (long)STAP_ARG_arg2),
				 STAP_RETVALUE + len,
				 MAXSTRINGLEN - len, 10);
		break;
#endif
#if defined(PR_CAPBSET_READ) && defined(PR_CAPBSET_DROP)
	case PR_CAPBSET_READ:
	case PR_CAPBSET_DROP:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_linux_capability_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		break;
#endif
#ifdef PR_SET_SECUREBITS
	case PR_SET_SECUREBITS:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_or_str(_stp_linux_securebits_list,
				   (unsigned long)STAP_ARG_arg2,
				   STAP_RETVALUE + len, MAXSTRINGLEN - len);
		break;
#endif
	case PR_SET_PDEATHSIG:
	case PR_GET_PDEATHSIG:
	case PR_GET_UNALIGN:
	case PR_GET_FPEMU:
	case PR_GET_FPEXC:
	case PR_SET_NAME:
	case PR_GET_NAME:
	case PR_GET_ENDIAN:
#ifdef PR_GET_TSC
	case PR_GET_TSC:
#endif
#ifdef PR_GET_TID_ADDRESS
	case PR_GET_TID_ADDRESS:
#endif
#ifdef PR_GET_CHILD_SUBREAPER
	case PR_GET_CHILD_SUBREAPER:
#endif
#ifdef PR_SET_THP_DISABLE
	case PR_SET_THP_DISABLE:
#endif
		len = strlen(STAP_RETVALUE);
		_stp_snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
			      ", 0x%lx", (unsigned long)STAP_ARG_arg2);
		break;
	case PR_SET_DUMPABLE:
	case PR_SET_KEEPCAPS:
#ifdef PR_SET_CHILD_SUBREAPER
	case PR_SET_CHILD_SUBREAPER:
#endif
#ifdef PR_SET_NO_NEW_PRIVS
	case PR_SET_NO_NEW_PRIVS:
#endif
#ifdef PR_SET_TIMERSLACK
	case PR_SET_TIMERSLACK:
#endif
		len = strlen(STAP_RETVALUE);
		_stp_snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
			      ", %lu", (unsigned long)STAP_ARG_arg2);
		break;

// Options that use arg[23]:
#ifdef PR_MCE_KILL
	case PR_MCE_KILL:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_prctl_mce_kill_option_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		switch ((unsigned long)STAP_ARG_arg2) {
		case PR_MCE_KILL_SET:
			strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
			len = strlen(STAP_RETVALUE);
			_stp_lookup_str(_stp_prctl_mce_kill_option2_list,
					(unsigned long)STAP_ARG_arg3,
					STAP_RETVALUE + len,
					MAXSTRINGLEN - len);
			break;
		case PR_MCE_KILL_CLEAR:
			break;
		default:
			len = strlen(STAP_RETVALUE);
			_stp_snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
			      ", 0x%lx", (unsigned long)STAP_ARG_arg3);
			break;
		}
		break;
#endif
#ifdef PR_SET_SECCOMP
	case PR_SET_SECCOMP:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_seccomp_mode_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		len = strlen(STAP_RETVALUE);
		_stp_snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
			      ", 0x%lx", (unsigned long)STAP_ARG_arg3);
		break;
#endif
#ifdef PR_SET_MM
	case PR_SET_MM:
		strlcat(STAP_RETVALUE, ", ", MAXSTRINGLEN);
		len = strlen(STAP_RETVALUE);
		_stp_lookup_str(_stp_prctl_mm_option_list,
				(unsigned long)STAP_ARG_arg2,
				STAP_RETVALUE + len, MAXSTRINGLEN - len);
		len = strlen(STAP_RETVALUE);
		_stp_snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
			      ", 0x%lx", (unsigned long)STAP_ARG_arg3);
		break;
#endif

// Options that use arg[2-5]
	default:
		len = strlen(STAP_RETVALUE);
		_stp_snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
			      ", 0x%lx, 0x%lx, 0x%lx, 0x%lx",
			      (unsigned long)STAP_ARG_arg2,
			      (unsigned long)STAP_ARG_arg3,
			      (unsigned long)STAP_ARG_arg4,
			      (unsigned long)STAP_ARG_arg5);
		break;
	}
%}

%{
// RHEL5 x86_64 (2.6.18-398.el5) has __NR_timerfd_create but no
// timerfd.h.
#ifdef STAPCONF_TIMERFD_H
#include <linux/timerfd.h>
#endif

static const _stp_val_array _stp_timerfd_flags_list[] = {
#ifdef TFD_TIMER_ABSTIME
	V(TFD_TIMER_ABSTIME),
#endif
#ifdef TFD_TIMER_CANCEL_ON_SET
	V(TFD_TIMER_CANCEL_ON_SET),
#endif
#ifdef TFD_CLOEXEC
	V(TFD_CLOEXEC),
#endif
#ifdef TFD_NONBLOCK
	V(TFD_NONBLOCK),
#endif
	{0, NULL}
};
%}

function _stp_timerfd_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_timerfd_flags_list,
			   (unsigned int)STAP_ARG_flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
// RHEL5 linux/pipe_fs_i.h has SPLICE* defs. RHEL6+ has it in
// separate linux/splice.h, which does not exist on RHEL5.
#include <linux/pipe_fs_i.h>
#ifndef SPLICE_F_MOVE
#include <linux/splice.h>
#endif

static const _stp_val_array _stp_splice_flags_list[] = {
#ifdef SPLICE_F_MOVE
	V(SPLICE_F_MOVE),
#endif
#ifdef SPLICE_F_NONBLOCK
	V(SPLICE_F_NONBLOCK),
#endif
#ifdef SPLICE_F_MORE
	V(SPLICE_F_MORE),
#endif
#ifdef SPLICE_F_GIFT
	V(SPLICE_F_GIFT),
#endif
	{0, NULL}
};
%}

function _stp_splice_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_splice_flags_list,
			   (unsigned int)STAP_ARG_flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#include <linux/falloc.h>

static const _stp_val_array _stp_fallocate_mode_list[] = {
	V(FALLOC_FL_KEEP_SIZE),
#ifdef FALLOC_FL_PUNCH_HOLE
	V(FALLOC_FL_PUNCH_HOLE),
#endif
#ifdef FALLOC_FL_NO_HIDE_STALE
	V(FALLOC_FL_NO_HIDE_STALE),
#endif
#ifdef FALLOC_FL_COLLAPSE_RANGE
	V(FALLOC_FL_COLLAPSE_RANGE),
#endif
#ifdef FALLOC_FL_ZERO_RANGE
	V(FALLOC_FL_ZERO_RANGE),
#endif
	{0, NULL}
};
%}

function _stp_fallocate_mode_str:string(mode:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_or_str(_stp_fallocate_mode_list,
			   (unsigned int)STAP_ARG_mode, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
#ifdef __NR_arch_prctl
#include <asm/prctl.h>
#endif
static const _stp_val_array _stp_arch_prctl_func_list[] = {
#ifdef ARCH_SET_FS
	V(ARCH_SET_FS),
#endif
#ifdef ARCH_GET_FS
	V(ARCH_GET_FS),
#endif
#ifdef ARCH_SET_GS
	V(ARCH_SET_GS),
#endif
#ifdef ARCH_GET_GS
	V(ARCH_GET_GS),
#endif
	{0, NULL}
};
%}

function _stp_arch_prctl_func_str:string(func:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str2(_stp_arch_prctl_func_list,
	                   (int)STAP_ARG_func, STAP_RETVALUE,
	                   MAXSTRINGLEN, 10);
%}

%{
static const _stp_val_array _stp_adjtimex_modes_list[] = {
       V(ADJ_OFFSET),
       V(ADJ_FREQUENCY),
       V(ADJ_MAXERROR),
       V(ADJ_ESTERROR),
       V(ADJ_STATUS),
       V(ADJ_TIMECONST),
       V(ADJ_TICK),
       V(ADJ_OFFSET_SINGLESHOT),
       {0, NULL}
};
%}

function _struct_timex_u:string(uaddr:long)
%{ /* pure */
	struct timex ts;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	int len;
	if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else
	{
		if (_stp_copy_from_user((char*)&ts, ptr,
		    sizeof(struct timex)) == 0)
		{
			memset(STAP_RETVALUE, 0, MAXSTRINGLEN);
			STAP_RETVALUE[0] = '{';
			_stp_lookup_or_str(_stp_adjtimex_modes_list,
			                   (unsigned int)ts.modes, STAP_RETVALUE + 1,
			                   MAXSTRINGLEN - 1);
			len = strlen(STAP_RETVALUE);
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
			         ", constant=%lu, esterror=%lu, freq=%lu, maxerror=%lu, offset=%lu, precision=%lu, status=%d, tick=%lu, tolerance=%lu}",
                                 (long)ts.constant, (long)ts.esterror, (long)ts.freq, (long)ts.maxerror, (long)ts.offset, (long)ts.precision, ts.status, (long)ts.tick, (long)ts.tolerance);

}
		else
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			         (unsigned long)ptr);
		}
	}
%}

function _struct_compat_timex_u:string(uaddr:long)
%{ /* pure */
#if defined(CONFIG_COMPAT)
#if defined(CONFIG_COMPAT_32BIT_TIME) && (LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0))
#define compat_timex old_timex32
#endif
	struct compat_timex ts;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	int len;
	if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else
	{
		if (_stp_copy_from_user((char*)&ts, ptr,
		    sizeof(struct compat_timex)) == 0)
		{
			memset(STAP_RETVALUE, 0, MAXSTRINGLEN);
			STAP_RETVALUE[0] = '{';
			_stp_lookup_or_str(_stp_adjtimex_modes_list,
			                   (unsigned int)ts.modes, STAP_RETVALUE + 1,
			                   MAXSTRINGLEN - 1);
			len = strlen(STAP_RETVALUE);
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
			         ", constant=%u, esterror=%u, freq=%u, maxerror=%u, offset=%u, precision=%u, status=%d, tick=%u, tolerance=%u}",
			         ts.constant, ts.esterror, ts.freq, ts.maxerror, ts.offset, ts.precision, ts.status, ts.tick, ts.tolerance);

}
		else
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			         (unsigned long)ptr);
		}
	}
#if defined(CONFIG_COMPAT_32BIT_TIME) && (LINUX_VERSION_CODE >= KERNEL_VERSION(5,1,0))
#undef compat_timex
#endif
#endif
%}

%{
#include <linux/fs.h>
static const _stp_val_array _stp_sync_file_range_list[] = {
#ifdef SYNC_FILE_RANGE_WAIT_BEFORE
  V(SYNC_FILE_RANGE_WAIT_BEFORE),
#endif
#ifdef SYNC_FILE_RANGE_WRITE
  V(SYNC_FILE_RANGE_WRITE),
#endif
#ifdef SYNC_FILE_RANGE_WAIT_AFTER
  V(SYNC_FILE_RANGE_WAIT_AFTER),
#endif
  {0, NULL}
};
%}

function _sync_file_range_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = (unsigned int)STAP_ARG_flags;
	_stp_lookup_or_str(_stp_sync_file_range_list, flags,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <asm/siginfo.h>
static const _stp_val_array _stp_siginfo_si_code_list[] = {
  V(SI_USER),
  V(SI_KERNEL),
  V(SI_QUEUE),
  V(SI_TIMER),
  V(SI_MESGQ),
  V(SI_ASYNCIO),
  V(SI_SIGIO),
  V(SI_TKILL),
  V(SI_DETHREAD),
  {0, NULL}
};

/* SIGILL si_codes */
static const _stp_val_array _stp_sigill_si_code_list[] = {
  V(ILL_ILLOPC),
  V(ILL_ILLOPN),
  V(ILL_ILLADR),
  V(ILL_ILLTRP),
  V(ILL_PRVOPC),
  V(ILL_PRVREG),
  V(ILL_COPROC),
  V(ILL_BADSTK),
  {0, NULL}
};

/* SIGFPE si_codes */
static const _stp_val_array _stp_sigfpe_si_code_list[] = {
  V(FPE_INTDIV),
  V(FPE_INTOVF),
  V(FPE_FLTDIV),
  V(FPE_FLTOVF),
  V(FPE_FLTUND),
  V(FPE_FLTRES),
  V(FPE_FLTINV),
  V(FPE_FLTSUB),
  {0, NULL}
};

/* SIGSEGV si_codes */
static const _stp_val_array _stp_sigsegv_si_code_list[] = {
  V(SEGV_MAPERR),
  V(SEGV_ACCERR),
#ifdef SEGV_BNDERR
  V(SEGV_BNDERR),
#endif
  {0, NULL}
};

/* SIGBUS si_codes */
static const _stp_val_array _stp_sigbus_si_code_list[] = {
  V(BUS_ADRALN),
  V(BUS_ADRERR),
  V(BUS_OBJERR),
#ifdef BUS_MCEERR_AR
  V(BUS_MCEERR_AR),
#endif
#ifdef BUS_MCEERR_AO
  V(BUS_MCEERR_AO),
#endif
  {0, NULL}
};

/* SIGTRAP si_codes */
static const _stp_val_array _stp_sigtrap_si_code_list[] = {
  V(TRAP_BRKPT),
  V(TRAP_TRACE),
#ifdef TRAP_BRANCH
  V(TRAP_BRANCH),
#endif
#ifdef TRAP_HWBKPT
  V(TRAP_HWBKPT),
#endif
  {0, NULL}
};

/* SIGCHLD si_codes */
static const _stp_val_array _stp_sigchld_si_code_list[] = {
  V(CLD_EXITED),
  V(CLD_KILLED),
  V(CLD_DUMPED),
  V(CLD_TRAPPED),
  V(CLD_STOPPED),
  V(CLD_CONTINUED),
  {0, NULL}
};

/* SIGPOLL si_codes */
static const _stp_val_array _stp_sigpoll_si_code_list[] = {
  V(POLL_IN),
  V(POLL_OUT),
  V(POLL_MSG),
  V(POLL_ERR),
  V(POLL_PRI),
  V(POLL_HUP),
  {0, NULL}
};

/* SIGSYS si_codes */
static const _stp_val_array _stp_sigsys_si_code_list[] = {
#ifdef SYS_SECCOMP
  V(SYS_SECCOMP),
#endif
  {0, NULL}
};
%}

function _stp_siginfo_u:string(uaddr:long)
%{ /* pure */
	siginfo_t sinfo;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	int len;

if (ptr == NULL) {
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
		return;
	}
	if (_stp_copy_from_user((void *)&sinfo, ptr,
				sizeof(sinfo)) != 0) {
		snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			 (unsigned long)ptr);
		return;
	}

strlcpy(STAP_RETVALUE, "{si_signo=", MAXSTRINGLEN);
	len = strlen(STAP_RETVALUE);
	_stp_lookup_str(_stp_signal_list, sinfo.si_signo,
			STAP_RETVALUE + len, MAXSTRINGLEN - len);
	len = strlen(STAP_RETVALUE);
	strlcpy(STAP_RETVALUE + len, ", si_code=", MAXSTRINGLEN - len);
	len = strlen(STAP_RETVALUE);
	_stp_lookup_str(_stp_siginfo_si_code_list, sinfo.si_code,
			STAP_RETVALUE + len, MAXSTRINGLEN - len);

// OK, this is odd. If si_code didn't match anything in
	// _stp_siginfo_si_code_list, we need to decode si_code based
	// on the si_signo value.
	if (*(STAP_RETVALUE + len) == '0') {
		const _stp_val_array *array = NULL;
		switch (sinfo.si_signo) {
		case SIGILL:
			array = _stp_sigill_si_code_list;
			break;
		case SIGFPE:
			array = _stp_sigfpe_si_code_list;
			break;
		case SIGSEGV:
			array = _stp_sigsegv_si_code_list;
			break;
		case SIGBUS:
			array = _stp_sigbus_si_code_list;
			break;
		case SIGTRAP:
			array = _stp_sigtrap_si_code_list;
			break;
		case SIGCHLD:
			array = _stp_sigchld_si_code_list;
			break;
		case SIGPOLL:
			array = _stp_sigpoll_si_code_list;
			break;
		case SIGSYS:
			array = _stp_sigsys_si_code_list;
			break;
		default:
			// Do nothing. The original si_code lookup
			// added a hex version.
			break;
		}
		if (array)
			_stp_lookup_str(array, sinfo.si_code,
					STAP_RETVALUE + len, MAXSTRINGLEN - len);
	}
	len = strlen(STAP_RETVALUE);
#ifdef SI_FROMUSER
	if (SI_FROMUSER(&sinfo)) {
		switch (sinfo.si_code) {
		case SI_TIMER:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_tid=%#x, si_overrun=%d",
				 sinfo.si_tid, sinfo.si_overrun);
			break;
		default:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_pid=%lu, si_uid=%lu",
				 (unsigned long)sinfo.si_pid,
				 (unsigned long)sinfo.si_uid);
			break;
		}
	}
	else
#endif /* SI_FROMUSER */
	{
		switch (sinfo.si_signo) {
		case SIGCHLD:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_pid=%lu, si_uid=%lu, si_status=",
				 (unsigned long)sinfo.si_pid,
				 (unsigned long)sinfo.si_uid);
			len = strlen(STAP_RETVALUE);
			if (sinfo.si_code == CLD_EXITED)
				snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
					 "%d", sinfo.si_status);
			else
				_stp_lookup_str(_stp_signal_list,
						sinfo.si_status,
						STAP_RETVALUE + len,
						MAXSTRINGLEN - len);
			break;
		case SIGILL:
		case SIGFPE:
		case SIGSEGV:
		case SIGBUS:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_addr=%#lx", (unsigned long)sinfo.si_addr);
			break;
		case SIGPOLL:
			if (sinfo.si_code == POLL_IN
			    || sinfo.si_code == POLL_OUT
			    || sinfo.si_code == POLL_MSG)
				snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
					 ", si_band=%ld", (long)sinfo.si_band);
			break;
#if defined(SIGSYS) && defined(__ARCH_SIGSYS)
		case SIGSYS:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_call_addr=%#lx, si_syscall=%d, si_arch=%u",
				 (unsigned long)(sinfo.si_call_addr),
				 sinfo.si_syscall, sinfo.si_arch);
			break;
#endif
		default:
			if (sinfo.si_pid || sinfo.si_uid)
				snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
					 ", si_pid=%lu, si_uid=%lu",
					 (unsigned long)sinfo.si_pid,
					 (unsigned long)sinfo.si_uid);
			break;
		}
	}
	len = strlen(STAP_RETVALUE);
	strlcat(STAP_RETVALUE, "}", MAXSTRINGLEN);
%}

%{
#ifdef CONFIG_COMPAT
#include <linux/compat.h>
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)
#include "linux/compat_structs.h"
#endif
#endif
%}

function _stp_compat_siginfo_u:string(uaddr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
	compat_siginfo_t sinfo;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	int len;

// OK, this is odd. If si_code didn't match anything in
	// _stp_siginfo_si_code_list, we need to decode si_code based
	// on the si_signo value.
	if (*(STAP_RETVALUE + len) == '0') {
		const _stp_val_array *array = NULL;
		switch (sinfo.si_signo) {
		case SIGILL:
			array = _stp_sigill_si_code_list;
			break;
		case SIGFPE:
			array = _stp_sigfpe_si_code_list;
			break;
		case SIGSEGV:
			array = _stp_sigsegv_si_code_list;
			break;
		case SIGBUS:
			array = _stp_sigbus_si_code_list;
			break;
		case SIGTRAP:
			array = _stp_sigtrap_si_code_list;
			break;
		case SIGCHLD:
			array = _stp_sigchld_si_code_list;
			break;
		case SIGPOLL:
			array = _stp_sigpoll_si_code_list;
			break;
		case SIGSYS:
			array = _stp_sigsys_si_code_list;
			break;
		default:
			// Do nothing. The original si_code lookup
			// added a hex version.
			break;
		}
		if (array)
			_stp_lookup_str(array, sinfo.si_code,
					STAP_RETVALUE + len, MAXSTRINGLEN - len);
	}
	len = strlen(STAP_RETVALUE);
#ifdef SI_FROMUSER
	if (SI_FROMUSER(&sinfo)) {
		switch (sinfo.si_code) {
		case SI_TIMER:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_tid=%#x, si_overrun=%d",
				 sinfo.si_tid, sinfo.si_overrun);
			break;
		default:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_pid=%lu, si_uid=%lu",
				 (unsigned long)sinfo.si_pid,
				 (unsigned long)sinfo.si_uid);
			break;
		}
	}
	else
#endif /* SI_FROMUSER */
	{
		switch (sinfo.si_signo) {
		case SIGCHLD:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_pid=%lu, si_uid=%lu, si_status=",
				 (unsigned long)sinfo.si_pid,
				 (unsigned long)sinfo.si_uid);
			len = strlen(STAP_RETVALUE);
			if (sinfo.si_code == CLD_EXITED)
				snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
					 "%d", sinfo.si_status);
			else
				_stp_lookup_str(_stp_signal_list,
						sinfo.si_status,
						STAP_RETVALUE + len,
						MAXSTRINGLEN - len);
			break;
		case SIGILL:
		case SIGFPE:
		case SIGSEGV:
		case SIGBUS:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_addr=%#lx", (unsigned long)sinfo.si_addr);
			break;
		case SIGPOLL:
			if (sinfo.si_code == POLL_IN
			    || sinfo.si_code == POLL_OUT
			    || sinfo.si_code == POLL_MSG)
				snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
					 ", si_band=%ld", (long)sinfo.si_band);
			break;
// Checking for SIGSYS/__ARCH_SIGSYS is fine for the "real" siginfo_t,
// but the compat version can be without the SIGSYS fields, so we'll
// have to add an arch test.
#if defined(SIGSYS) && defined(__ARCH_SIGSYS) \
    && !defined(__s390x__) && !defined(__powerpc64__)
		case SIGSYS:
			snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
				 ", si_call_addr=%#lx, si_syscall=%d, si_arch=%u",
				 (unsigned long)sinfo.si_call_addr,
				 sinfo.si_syscall, sinfo.si_arch);
			break;
#endif
		default:
			if (sinfo.si_pid || sinfo.si_uid)
				snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len,
					 ", si_pid=%lu, si_uid=%lu",
					 (unsigned long)sinfo.si_pid,
					 (unsigned long)sinfo.si_uid);
			break;
		}
	}
	len = strlen(STAP_RETVALUE);
	strlcat(STAP_RETVALUE, "}", MAXSTRINGLEN);
#endif /* CONFIG_COMPAT */
%}

%{
#include <linux/times.h>
%}

function _struct_tms_u:string(uaddr:long)
%{ /* pure */
	struct tms tm;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else
	{
		if (_stp_copy_from_user((char*)&tm, ptr,
		    sizeof(struct tms)) == 0)
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			         "{tms_utime=%lu, tms_stime=%lu, tms_cutime=%lu, tms_cstime=%lu}",
			         tm.tms_utime, tm.tms_stime, tm.tms_cutime, tm.tms_cstime);
		}
		else
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			         (unsigned long)ptr);
		}
	}
%}

%{
#include <linux/kernel.h>
%}

function _struct_sysinfo_u:string(uaddr:long)
%{ /* pure */
	struct sysinfo si;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	if (ptr == NULL)
		strlcpy (STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else
	{
		if (_stp_copy_from_user((char*)&si, ptr,
		    sizeof(struct sysinfo)) == 0)
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			         "{uptime=%ld, loads=[%lu, %lu, %lu], totalram=%lu, freeram=%lu, "
			         "sharedram=%lu, bufferram=%lu, totalswap=%lu, freeswap=%lu, procs=%u}",
			         si.uptime, si.loads[0], si.loads[1], si.loads[2], si.totalram, si.freeram,
			         si.sharedram, si.bufferram, si.totalswap, si.freeswap, si.procs);
		}
		else
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			         (unsigned long)ptr);
		}
	}
%}

%{
#include <linux/kexec.h>
static const _stp_val_array _stp_kexec_flags_list[] = {
#if defined(CONFIG_KEXEC)
	V(KEXEC_ON_CRASH),
#ifdef KEXEC_PRESERVE_CONTEXT
	V(KEXEC_PRESERVE_CONTEXT),
#endif
	V(KEXEC_ARCH_DEFAULT),
	V(KEXEC_ARCH_386),
	V(KEXEC_ARCH_X86_64),
	V(KEXEC_ARCH_PPC),
	V(KEXEC_ARCH_PPC64),
	V(KEXEC_ARCH_IA_64),
#ifdef KEXEC_ARCH_ARM
	V(KEXEC_ARCH_ARM),
#endif
	V(KEXEC_ARCH_S390),
	V(KEXEC_ARCH_SH),
#ifdef KEXEC_ARCH_MIPS_LE
	V(KEXEC_ARCH_MIPS_LE),
#endif
#ifdef KEXEC_ARCH_MIPS
	V(KEXEC_ARCH_MIPS),
#endif
#endif /* CONFIG_KEXEC */
	{0, NULL}
};

static const _stp_val_array _stp_kexec_file_load_flags_list[] = {
#ifdef KEXEC_FILE_UNLOAD
	V(KEXEC_FILE_UNLOAD),
#endif
#ifdef KEXEC_FILE_ON_CRASH
	V(KEXEC_FILE_ON_CRASH),
#endif
#ifdef KEXEC_FILE_NO_INITRAMFS
	V(KEXEC_FILE_NO_INITRAMFS),
#endif
	{0, NULL}
};
%}

function _kexec_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	unsigned long flags = (unsigned long)STAP_ARG_flags;
	_stp_lookup_or_str(_stp_kexec_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

function _kexec_file_load_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	unsigned long flags = (unsigned long)STAP_ARG_flags;
	_stp_lookup_or_str(_stp_kexec_file_load_flags_list, flags,
			   STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#include <linux/signal.h>

static const _stp_val_array _stp_sigaltstack_flags_list[] = {
  V(SS_ONSTACK),
  V(SS_DISABLE),
  {0, NULL}
};

function _stp_sigaltstack_u:string(uaddr:long)
%{ /* pure */
	stack_t stk;

char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	int len;

if (ptr == NULL || _stp_copy_from_user((void *)&stk, ptr,
					       sizeof(stk)) != 0) {
		snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			 (unsigned long)ptr);
		return;
	}
	snprintf(STAP_RETVALUE, MAXSTRINGLEN, "{ss_sp=0x%lx, ss_flags=",
		 (unsigned long)stk.ss_sp);
	len = strlen(STAP_RETVALUE);
	_stp_lookup_str(_stp_sigaltstack_flags_list, stk.ss_flags,
			STAP_RETVALUE + len, MAXSTRINGLEN - len);
	len = strlen(STAP_RETVALUE);
	snprintf(STAP_RETVALUE + len, MAXSTRINGLEN - len, ", ss_size=%lu}",
		 (unsigned long)stk.ss_size);
%}

function _stp_compat_sigaltstack_u:string(uaddr:long)
%{ /* pure */
#ifdef CONFIG_COMPAT
#if defined(CONFIG_GENERIC_SIGALTSTACK) \
    || LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,0)
	compat_stack_t stk;
#elif defined(__x86_64__)
	stack_ia32_t stk;
#elif defined(__s390x__)
	stack_t32 stk;
#elif defined(__powerpc64__)
	stack_32_t stk;
#endif

char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	int len;

%{
#include <linux/fs.h>
static const _stp_val_array _stp_renameat2_flags_list[] = {
#ifdef RENAME_NOREPLACE
	V(RENAME_NOREPLACE),
#endif
#ifdef RENAME_EXCHANGE
	V(RENAME_EXCHANGE),
#endif
#ifdef RENAME_WHITEOUT
	V(RENAME_WHITEOUT),
#endif
	{0, NULL}
};
%}

function _renameat2_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = (unsigned int)STAP_ARG_flags;
	_stp_lookup_or_str(_stp_renameat2_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
// fanotify_init() and fanotify_mark() were enabled in kernel version
// 2.6.37 (but present in some earlier kernels).
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37) \
    && defined(__NR_fanotify_init) && defined(__NR_fanotify_mark)
#include <linux/fanotify.h>
static const _stp_val_array _stp_fanotify_init_class_flags_list[] = {
	V(FAN_CLASS_NOTIF),
	V(FAN_CLASS_CONTENT),
	V(FAN_CLASS_PRE_CONTENT),
	{0, NULL}
};

static const _stp_val_array _stp_fanotify_init_extra_flags_list[] = {
	V(FAN_CLOEXEC),
	V(FAN_NONBLOCK),
	V(FAN_UNLIMITED_QUEUE),
	V(FAN_UNLIMITED_MARKS),
	{0, NULL}
};

static const _stp_val_array _stp_fanotify_mark_flags_list[] = {
	V(FAN_MARK_ADD),
	V(FAN_MARK_REMOVE),
	V(FAN_MARK_FLUSH),
	V(FAN_MARK_DONT_FOLLOW),
	V(FAN_MARK_ONLYDIR),
	V(FAN_MARK_MOUNT),
	V(FAN_MARK_IGNORED_MASK),
	V(FAN_MARK_IGNORED_SURV_MODIFY),
	{0, NULL}
};

/* Note that FAN_CLOSE is (FAN_CLOSE_WRITE | FAN_CLOSE_NOWRITE). So,
 * we really can't use it. */
static const _stp_val_array _stp_fanotify_mark_mask_list[] = {
	V(FAN_ACCESS),
	V(FAN_MODIFY),
	V(FAN_CLOSE_WRITE),
	V(FAN_CLOSE_NOWRITE),
	V(FAN_OPEN),
	V(FAN_Q_OVERFLOW),
	V(FAN_OPEN_PERM),
	V(FAN_ACCESS_PERM),
	V(FAN_ONDIR),
	V(FAN_EVENT_ON_CHILD),
	{0, NULL}
};
#endif
%}

function _fanotify_init_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37) \
    && defined(__NR_fanotify_init) && defined(__NR_fanotify_mark)
	unsigned int flags = (unsigned int)STAP_ARG_flags;
/* deprecation: linux commit 23c9deeb3285d */
#ifndef FAN_ALL_CLASS_BITS
#define FAN_ALL_CLASS_BITS (FAN_CLASS_NOTIF | FAN_CLASS_CONTENT | FAN_CLASS_PRE_CONTENT)
#endif
	unsigned int flags_part1 = flags & FAN_ALL_CLASS_BITS;
	unsigned int flags_part2 = flags & ~FAN_ALL_CLASS_BITS;

_stp_lookup_str(_stp_fanotify_init_class_flags_list, flags_part1,
			STAP_RETVALUE, MAXSTRINGLEN);
	if (flags_part2) {
		strlcat(STAP_RETVALUE, "|", MAXSTRINGLEN);
		_stp_lookup_or_str(_stp_fanotify_init_extra_flags_list,
				   flags_part2, STAP_RETVALUE, MAXSTRINGLEN);
	}
#endif
%}

function _fanotify_mark_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37) \
    && defined(__NR_fanotify_init) && defined(__NR_fanotify_mark)
	unsigned int flags = (unsigned int)STAP_ARG_flags;

_stp_lookup_or_str(_stp_fanotify_mark_flags_list, flags,
			   STAP_RETVALUE, MAXSTRINGLEN);
#endif
%}

function _fanotify_mark_mask_str:string(mask:long)
%{ /* pure */ /* unprivileged */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37) \
    && defined(__NR_fanotify_init) && defined(__NR_fanotify_mark)
	__u64 mask = (__u64)STAP_ARG_mask;

_stp_lookup_or_str(_stp_fanotify_mark_mask_list, mask,
			   STAP_RETVALUE, MAXSTRINGLEN);
#endif
%}

%{
#if defined(__NR_perf_event_open) && defined(CONFIG_PERF_EVENTS)
#include <linux/perf_event.h>

static const _stp_val_array _stp_perf_event_open_flags_list[] = {
	V(PERF_FLAG_FD_NO_GROUP),
	V(PERF_FLAG_FD_OUTPUT),
#ifdef PERF_FLAG_PID_CGROUP
	V(PERF_FLAG_PID_CGROUP),
#endif
#ifdef PERF_FLAG_FD_CLOEXEC
	V(PERF_FLAG_FD_CLOEXEC),
#endif
	{0, NULL}
};
#endif
%}

function _perf_event_open_flags_str:string(flags:long)
%{ /* pure */ /* unprivileged */
#if defined(__NR_perf_event_open) && defined(CONFIG_PERF_EVENTS)
	unsigned long flags = (unsigned long)STAP_ARG_flags;

_stp_lookup_or_str(_stp_perf_event_open_flags_list, flags,
			   STAP_RETVALUE, MAXSTRINGLEN);
#endif
%}

%{
#ifdef CONFIG_CHECKPOINT_RESTORE
#include <linux/kcmp.h>
#endif

static const _stp_val_array _stp_kcmp_type_list[] = {
#ifdef CONFIG_CHECKPOINT_RESTORE
	V(KCMP_FILE),
	V(KCMP_VM),
	V(KCMP_FILES),
	V(KCMP_FS),
	V(KCMP_SIGHAND),
	V(KCMP_IO),
	V(KCMP_SYSVSEM),
	V(KCMP_TYPES),
#endif
	{0, NULL}
};
%}

function _kcmp_type_str:string(type:long)
%{ /* pure */ /* unprivileged */
	unsigned long type = (unsigned long)STAP_ARG_type;
        _stp_lookup_str(_stp_kcmp_type_list, (unsigned int)STAP_ARG_type,
                        STAP_RETVALUE, MAXSTRINGLEN);
%}

function _struct_sched_attr_u:string(uaddr:long)
%{ /* pure */
/* struct sched_attr introduced in kernel commit d50dde5a10 along with SCHED_ATTR_SIZE_VER0 */
#ifdef SCHED_ATTR_SIZE_VER0
	struct sched_attr sa;
	char *ptr = (char *)(uintptr_t)STAP_ARG_uaddr;
	if (ptr == NULL)
		strlcpy(STAP_RETVALUE, "NULL", MAXSTRINGLEN);
	else
	{
		if (_stp_copy_from_user((char*)&sa, ptr,
		    sizeof(struct sched_attr)) == 0)
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN,
			         "{size=%u, sched_policy=%u, sched_flags=%llu, "
			         "sched_nice=%d, sched_priority=%u, sched_runtime=%llu, "
			         "sched_deadline=%llu, sched_period=%llu}",
			         sa.size, sa.sched_policy, sa.sched_flags, sa.sched_nice,
			         sa.sched_priority, sa.sched_runtime, sa.sched_deadline,
			         sa.sched_period);
		}
		else
		{
			snprintf(STAP_RETVALUE, MAXSTRINGLEN, "0x%lx",
			         (unsigned long)ptr);
		}
	}
#endif
%}

%{
#ifdef CONFIG_SECCOMP
#include <linux/seccomp.h>
#endif

static const _stp_val_array _stp_seccomp_op_list[] = {
#ifdef SECCOMP_SET_MODE_STRICT
	V(SECCOMP_SET_MODE_STRICT),
#endif
#ifdef SECCOMP_SET_MODE_FILTER
	V(SECCOMP_SET_MODE_FILTER),
#endif
	{0, NULL}
};
%}

function _seccomp_op_str:string(op:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_seccomp_op_list, (unsigned int)STAP_ARG_op,
	                STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#ifdef CONFIG_BPF_SYSCALL
#include <uapi/linux/bpf.h>
#endif

static const _stp_val_array _stp_bpf_cmd_list[] = {
#ifdef CONFIG_BPF_SYSCALL
	V(BPF_MAP_CREATE),
	V(BPF_MAP_LOOKUP_ELEM),
	V(BPF_MAP_UPDATE_ELEM),
	V(BPF_MAP_DELETE_ELEM),
	V(BPF_MAP_GET_NEXT_KEY),
	V(BPF_PROG_LOAD),
#endif
	{0, NULL}
};
%}

function _bpf_cmd_str:string(cmd:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_bpf_cmd_list, (int)STAP_ARG_cmd,
	                STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
#ifdef CONFIG_MEMBARRIER
#include <linux/membarrier.h>
#endif

static const _stp_val_array _stp_membarrier_cmd_list[] = {
#ifdef CONFIG_MEMBARRIER
	V(MEMBARRIER_CMD_QUERY),
	V(MEMBARRIER_CMD_SHARED),
#endif
	{0, NULL}
};
%}

function _membarrier_cmd_str:string(cmd:long)
%{ /* pure */ /* unprivileged */
	_stp_lookup_str(_stp_membarrier_cmd_list, (unsigned int)STAP_ARG_cmd,
	                STAP_RETVALUE, MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_userfaultfd_flags_list[] = {
#ifdef O_NONBLOCK
	V(O_NONBLOCK),
#endif
#ifdef O_CLOEXEC
	V(O_CLOEXEC),
#endif
	{0, NULL}
};
%}

function _userfaultfd_flags_str:string (f:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = (unsigned int)STAP_ARG_f;
	_stp_lookup_or_str(_stp_userfaultfd_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_preadv2_flags_list[] = {
#ifdef RWF_HIPRI
	V(RWF_HIPRI),
#endif
	{0, NULL}
};
%}

function _preadv2_flags_str:string (f:long)
%{ /* pure */ /* unprivileged */
	unsigned int flags = (unsigned int)STAP_ARG_f;
	_stp_lookup_or_str(_stp_preadv2_flags_list, flags, STAP_RETVALUE,
			   MAXSTRINGLEN);
%}

%{
static const _stp_val_array _stp_statx_mask_list[] = {
#ifdef AT_STATX_SYNC_TYPE
	V(AT_STATX_SYNC_TYPE),
	V(AT_STATX_SYNC_AS_STAT),
	V(AT_STATX_FORCE_SYNC),
	V(AT_STATX_DONT_SYNC),
#endif
	{0, NULL}
};
%}

function _statx_mask_str:string(cmd:long)
%{ /* pure */ /* unprivileged */
        _stp_lookup_str(_stp_statx_mask_list, (int)STAP_ARG_cmd,
                        STAP_RETVALUE, MAXSTRINGLEN);
%}

function _pkey_alloc_init_val_str:string(init_val:long)
%{ /* pure */ /* unprivileged */
        static const _stp_val_array pkey_alloc_init_val_list[] = {
                V(PKEY_DISABLE_ACCESS),
                V(PKEY_DISABLE_WRITE),
                {0, NULL}
        };
        _stp_lookup_or_str(pkey_alloc_init_val_list, (unsigned int)STAP_ARG_init_val,
                           STAP_RETVALUE, MAXSTRINGLEN);
%}

/* Some syscall interjection mechanisms give us a pt_regs* structure
   for the syscall parameters/context. */
function __set_syscall_pt_regs(r)
%{ /* guru */
  CONTEXT->sregs = (void*)(uintptr_t) STAP_ARG_r;
%}

function _stp_syscall_nr:long ()
%{ /* pure */
  if (CONTEXT->sregs) {
        /* NB: same abi? */
	STAP_RETVALUE = _stp_syscall_get_nr(current, CONTEXT->sregs);
  } else {
	struct pt_regs *regs = _stp_current_pt_regs();
	if (!regs) {
		CONTEXT->last_error = ("Cannot access syscall number"
				       " (no registers available)");
		return;
	}
	STAP_RETVALUE = _stp_syscall_get_nr(current, regs);
  }
%}

cmd: