File Manager

X7ROOT File Manager

Current Path: /usr/share/systemtap/tapset/linux

usr / share / systemtap / tapset / linux /

📁 ..
📁 arm
📁 arm64
📄 atomic.stp(1.53 KB)
📄 aux_syscalls.stp(143.78 KB)
📄 context-caller.stp(3.07 KB)
📄 context-envvar.stp(1.72 KB)
📄 context-symbols.stp(11.99 KB)
📄 context-unwind.stp(2.81 KB)
📄 context.stp(18.57 KB)
📄 context.stpm(125 B)
📄 conversions-guru.stp(5.74 KB)
📄 conversions.stp(15.34 KB)
📄 ctime.stp(5.54 KB)
📄 dentry.stp(10.11 KB)
📄 dev.stp(1.9 KB)
📄 endian.stp(602 B)
📄 guru-delay.stp(1.2 KB)
📄 guru-signal.stp(1.07 KB)
📁 i386
📁 ia64
📄 inet.stp(1.42 KB)
📄 inet.stpm(383 B)
📄 inet_sock.stp(1.25 KB)
📄 ioblock.stp(15.04 KB)
📄 ioscheduler.stp(11.89 KB)
📄 ip.stp(5.35 KB)
📄 ipmib-filter-default.stp(965 B)
📄 ipmib.stp(12.68 KB)
📄 irq.stp(5 KB)
📄 json.stp(8.98 KB)
📄 json.stpm(6.11 KB)
📄 kprocess.stp(4.4 KB)
📄 kretprobe.stp(2.1 KB)
📄 linuxmib-filter-default.stp(876 B)
📄 linuxmib.stp(3.63 KB)
📄 loadavg.stp(1.95 KB)
📄 logging.stp(2.12 KB)
📄 memory.stp(18.74 KB)
📁 mips
📄 netfilter.stp(35.49 KB)
📄 networking.stp(9.37 KB)
📄 nfs.stp(38.06 KB)
📄 nfs_proc.stp(55.46 KB)
📄 nfs_proc.stpm(1.18 KB)
📄 nfsd.stp(46.27 KB)
📄 nfsderrno.stp(11.7 KB)
📄 panic.stp(1.07 KB)
📄 perf.stp(5.16 KB)
📁 powerpc
📄 proc_mem.stp(12.05 KB)
📄 pstrace.stp(773 B)
📄 rcu.stp(928 B)
📄 rlimit.stp(1.35 KB)
📄 rpc.stp(37.67 KB)
📁 s390
📄 scheduler.stp(11.36 KB)
📄 scsi.stp(9.47 KB)
📄 signal.stp(28.69 KB)
📄 socket.stp(34.2 KB)
📄 sysc_accept.stp(7.32 KB)
📄 sysc_accept4.stp(7.24 KB)
📄 sysc_access.stp(2.45 KB)
📄 sysc_acct.stp(2.18 KB)
📄 sysc_add_key.stp(2.91 KB)
📄 sysc_adjtimex.stp(5.28 KB)
📄 sysc_alarm.stp(2.52 KB)
📄 sysc_bdflush.stp(2.75 KB)
📄 sysc_bind.stp(6.43 KB)
📄 sysc_bpf.stp(2.33 KB)
📄 sysc_brk.stp(2.33 KB)
📄 sysc_capget.stp(2.71 KB)
📄 sysc_capset.stp(2.71 KB)
📄 sysc_chdir.stp(2.23 KB)
📄 sysc_chmod.stp(2.51 KB)
📄 sysc_chown.stp(3.27 KB)
📄 sysc_chown16.stp(2.61 KB)
📄 sysc_chroot.stp(2.29 KB)
📄 sysc_clock_adjtime.stp(4.72 KB)
📄 sysc_clock_getres.stp(3.82 KB)
📄 sysc_clock_gettime.stp(3.62 KB)
📄 sysc_clock_nanosleep.stp(7.25 KB)
📄 sysc_clock_settime.stp(5.02 KB)
📄 sysc_clone.stp(6.19 KB)
📄 sysc_close.stp(2.47 KB)
📄 sysc_connect.stp(6.82 KB)
📄 sysc_copy_file_range.stp(3.15 KB)
📄 sysc_creat.stp(2.28 KB)
📄 sysc_delete_module.stp(2.87 KB)
📄 sysc_dup.stp(2.09 KB)
📄 sysc_dup2.stp(2.63 KB)
📄 sysc_dup3.stp(2.66 KB)
📄 sysc_epoll_create.stp(5.29 KB)
📄 sysc_epoll_ctl.stp(3.5 KB)
📄 sysc_epoll_pwait.stp(3.49 KB)
📄 sysc_epoll_wait.stp(4.33 KB)
📄 sysc_eventfd.stp(4.86 KB)
📄 sysc_execve.stp(6.11 KB)
📄 sysc_execveat.stp(6.78 KB)
📄 sysc_exit.stp(1.54 KB)
📄 sysc_exit_group.stp(1.66 KB)
📄 sysc_faccessat.stp(3.2 KB)
📄 sysc_fadvise64.stp(7.43 KB)
📄 sysc_fallocate.stp(3.29 KB)
📄 sysc_fanotify_init.stp(3.02 KB)
📄 sysc_fanotify_mark.stp(5.75 KB)
📄 sysc_fchdir.stp(2.23 KB)
📄 sysc_fchmod.stp(2.52 KB)
📄 sysc_fchmodat.stp(3.2 KB)
📄 sysc_fchown.stp(3.28 KB)
📄 sysc_fchown16.stp(2.59 KB)
📄 sysc_fchownat.stp(3.24 KB)
📄 sysc_fcntl.stp(4.37 KB)
📄 sysc_fdatasync.stp(2.39 KB)
📄 sysc_fgetxattr.stp(2.94 KB)
📄 sysc_finit_module.stp(2.86 KB)
📄 sysc_flistxattr.stp(2.61 KB)
📄 sysc_flock.stp(2.28 KB)
📄 sysc_fork.stp(2.53 KB)
📄 sysc_fremovexattr.stp(2.73 KB)
📄 sysc_fsetxattr.stp(3.34 KB)
📄 sysc_fstat.stp(5.76 KB)
📄 sysc_fstatat.stp(5.21 KB)
📄 sysc_fstatfs.stp(2.94 KB)
📄 sysc_fstatfs64.stp(2.86 KB)
📄 sysc_fsync.stp(2.18 KB)
📄 sysc_ftruncate.stp(5.54 KB)
📄 sysc_futex.stp(5.11 KB)
📄 sysc_futimesat.stp(5.91 KB)
📄 sysc_get_mempolicy.stp(4.1 KB)
📄 sysc_get_robust_list.stp(4.12 KB)
📄 sysc_getcpu.stp(2.63 KB)
📄 sysc_getcwd.stp(2.43 KB)
📄 sysc_getdents.stp(5.18 KB)
📄 sysc_getegid.stp(3.46 KB)
📄 sysc_geteuid.stp(3.4 KB)
📄 sysc_getgid.stp(3.32 KB)
📄 sysc_getgroups.stp(3.91 KB)
📄 sysc_gethostname.stp(1.22 KB)
📄 sysc_getitimer.stp(4.87 KB)
📄 sysc_getpeername.stp(7.01 KB)
📄 sysc_getpgid.stp(2.6 KB)
📄 sysc_getpgrp.stp(2.04 KB)
📄 sysc_getpid.stp(1.98 KB)
📄 sysc_getppid.stp(2.06 KB)
📄 sysc_getpriority.stp(2.62 KB)
📄 sysc_getrandom.stp(2.72 KB)
📄 sysc_getresgid.stp(3.73 KB)
📄 sysc_getresuid.stp(3.54 KB)
📄 sysc_getrlimit.stp(4.08 KB)
📄 sysc_getrusage.stp(3.45 KB)
📄 sysc_getsid.stp(2.26 KB)
📄 sysc_getsockname.stp(7.03 KB)
📄 sysc_getsockopt.stp(7.88 KB)
📄 sysc_gettid.stp(2.01 KB)
📄 sysc_gettimeofday.stp(3.7 KB)
📄 sysc_getuid.stp(3.35 KB)
📄 sysc_getxattr.stp(3 KB)
📄 sysc_init_module.stp(2.76 KB)
📄 sysc_inotify_add_watch.stp(3.25 KB)
📄 sysc_inotify_init.stp(5.26 KB)
📄 sysc_inotify_rm_watch.stp(2.89 KB)
📄 sysc_io_cancel.stp(2.85 KB)
📄 sysc_io_destroy.stp(2.5 KB)
📄 sysc_io_getevents.stp(4.25 KB)
📄 sysc_io_setup.stp(3.43 KB)
📄 sysc_io_submit.stp(3.46 KB)
📄 sysc_ioctl.stp(3.12 KB)
📄 sysc_ioperm.stp(2.41 KB)
📄 sysc_ioprio_get.stp(2.65 KB)
📄 sysc_ioprio_set.stp(2.82 KB)
📄 sysc_kcmp.stp(2.51 KB)
📄 sysc_kexec_file_load.stp(3.35 KB)
📄 sysc_kexec_load.stp(3.96 KB)
📄 sysc_keyctl.stp(3.16 KB)
📄 sysc_kill.stp(2.25 KB)
📄 sysc_lchown.stp(3.34 KB)
📄 sysc_lchown16.stp(2.66 KB)
📄 sysc_lgetxattr.stp(3.05 KB)
📄 sysc_link.stp(2.34 KB)
📄 sysc_linkat.stp(3.26 KB)
📄 sysc_listen.stp(6.17 KB)
📄 sysc_listxattr.stp(2.72 KB)
📄 sysc_llistxattr.stp(2.78 KB)
📄 sysc_llseek.stp(2.81 KB)
📄 sysc_lookup_dcookie.stp(3.39 KB)
📄 sysc_lremovexattr.stp(3.11 KB)
📄 sysc_lseek.stp(3.98 KB)
📄 sysc_lsetxattr.stp(3.22 KB)
📄 sysc_lstat.stp(5.91 KB)
📄 sysc_madvise.stp(2.55 KB)
📄 sysc_mbind.stp(3.69 KB)
📄 sysc_membarrier.stp(2.65 KB)
📄 sysc_memfd_create.stp(2.77 KB)
📄 sysc_migrate_pages.stp(3.83 KB)
📄 sysc_mincore.stp(2.47 KB)
📄 sysc_mkdir.stp(2.38 KB)
📄 sysc_mkdirat.stp(2.92 KB)
📄 sysc_mknod.stp(2.45 KB)
📄 sysc_mknodat.stp(3.07 KB)
📄 sysc_mlock.stp(2.27 KB)
📄 sysc_mlock2.stp(2.47 KB)
📄 sysc_mlockall.stp(2.46 KB)
📄 sysc_mmap2.stp(5.45 KB)
📄 sysc_modify_ldt.stp(2.67 KB)
📄 sysc_mount.stp(3.53 KB)
📄 sysc_move_pages.stp(4.09 KB)
📄 sysc_mprotect.stp(2.55 KB)
📄 sysc_mq_getsetattr.stp(3.95 KB)
📄 sysc_mq_notify.stp(3.51 KB)
📄 sysc_mq_open.stp(4.54 KB)
📄 sysc_mq_timedreceive.stp(5.18 KB)
📄 sysc_mq_timedsend.stp(4.96 KB)
📄 sysc_mq_unlink.stp(2.53 KB)
📄 sysc_mremap.stp(3.01 KB)
📄 sysc_msgctl.stp(7.35 KB)
📄 sysc_msgget.stp(3.73 KB)
📄 sysc_msgrcv.stp(9.48 KB)
📄 sysc_msgsnd.stp(7.81 KB)
📄 sysc_msync.stp(2.44 KB)
📄 sysc_munlock.stp(2.39 KB)
📄 sysc_munlockall.stp(2.29 KB)
📄 sysc_munmap.stp(2.35 KB)
📄 sysc_name_to_handle_at.stp(3.46 KB)
📄 sysc_nanosleep.stp(5.22 KB)
📄 sysc_nfsservctl.stp(2.23 KB)
📄 sysc_ni_syscall.stp(1.4 KB)
📄 sysc_nice.stp(2.15 KB)
📄 sysc_open.stp(3.79 KB)
📄 sysc_open_by_handle_at.stp(3.8 KB)
📄 sysc_openat.stp(3.34 KB)
📄 sysc_pause.stp(2.5 KB)
📄 sysc_perf_event_open.stp(3.24 KB)
📄 sysc_personality.stp(2.74 KB)
📄 sysc_pipe.stp(9.86 KB)
📄 sysc_pivot_root.stp(2.71 KB)
📄 sysc_poll.stp(2.35 KB)
📄 sysc_ppoll.stp(5.38 KB)
📄 sysc_prctl.stp(2.48 KB)
📄 sysc_pread.stp(4.51 KB)
📄 sysc_preadv.stp(4.12 KB)
📄 sysc_preadv2.stp(4.48 KB)
📄 sysc_prlimit64.stp(2.97 KB)
📄 sysc_process_vm_readv.stp(4.08 KB)
📄 sysc_process_vm_writev.stp(4.13 KB)
📄 sysc_pselect6.stp(5.62 KB)
📄 sysc_pselect7.stp(3.58 KB)
📄 sysc_ptrace.stp(3.18 KB)
📄 sysc_pwrite.stp(6.27 KB)
📄 sysc_pwritev.stp(4.23 KB)
📄 sysc_pwritev2.stp(4.58 KB)
📄 sysc_quotactl.stp(4 KB)
📄 sysc_read.stp(3.29 KB)
📄 sysc_readahead.stp(3.02 KB)
📄 sysc_readdir.stp(3.6 KB)
📄 sysc_readlink.stp(2.59 KB)
📄 sysc_readlinkat.stp(3.24 KB)
📄 sysc_readv.stp(3.07 KB)
📄 sysc_reboot.stp(2.77 KB)
📄 sysc_recv.stp(6.7 KB)
📄 sysc_recvfrom.stp(7.82 KB)
📄 sysc_recvmmsg.stp(5.84 KB)
📄 sysc_recvmsg.stp(10.35 KB)
📄 sysc_remap_file_pages.stp(3.37 KB)
📄 sysc_removexattr.stp(2.75 KB)
📄 sysc_rename.stp(2.48 KB)
📄 sysc_renameat.stp(3.3 KB)
📄 sysc_renameat2.stp(3.61 KB)
📄 sysc_request_key.stp(3.23 KB)
📄 sysc_restart_syscall.stp(2.5 KB)
📄 sysc_rmdir.stp(2.25 KB)
📄 sysc_rt_sigaction.stp(6.2 KB)
📄 sysc_rt_sigpending.stp(4.35 KB)
📄 sysc_rt_sigprocmask.stp(7.87 KB)
📄 sysc_rt_sigqueueinfo.stp(4.26 KB)
📄 sysc_rt_sigreturn.stp(1.6 KB)
📄 sysc_rt_sigsuspend.stp(3.45 KB)
📄 sysc_rt_sigtimedwait.stp(5.08 KB)
📄 sysc_rt_tgsigqueueinfo.stp(3.92 KB)
📄 sysc_sched_get_priority_max.stp(3.26 KB)
📄 sysc_sched_get_priority_min.stp(3.26 KB)
📄 sysc_sched_getaffinity.stp(3.62 KB)
📄 sysc_sched_getattr.stp(3.05 KB)
📄 sysc_sched_getparam.stp(2.84 KB)
📄 sysc_sched_getscheduler.stp(2.94 KB)
📄 sysc_sched_rr_get_interval.stp(4.41 KB)
📄 sysc_sched_setaffinity.stp(3.49 KB)
📄 sysc_sched_setattr.stp(2.98 KB)
📄 sysc_sched_setparam.stp(2.83 KB)
📄 sysc_sched_setscheduler.stp(3.2 KB)
📄 sysc_sched_yield.stp(2.26 KB)
📄 sysc_seccomp.stp(2.76 KB)
📄 sysc_select.stp(5.55 KB)
📄 sysc_semctl.stp(7.22 KB)
📄 sysc_semget.stp(3.79 KB)
📄 sysc_semop.stp(4.73 KB)
📄 sysc_semtimedop.stp(8.8 KB)
📄 sysc_send.stp(6.81 KB)
📄 sysc_sendfile.stp(4.38 KB)
📄 sysc_sendmmsg.stp(8.61 KB)
📄 sysc_sendmsg.stp(11.48 KB)
📄 sysc_sendto.stp(7.66 KB)
📄 sysc_set_mempolicy.stp(3.69 KB)
📄 sysc_set_robust_list.stp(3.92 KB)
📄 sysc_set_tid_address.stp(2.83 KB)
📄 sysc_setdomainname.stp(3.04 KB)
📄 sysc_setfsgid.stp(4.43 KB)
📄 sysc_setfsuid.stp(4.48 KB)
📄 sysc_setgid.stp(4.23 KB)
📄 sysc_setgroups.stp(4.1 KB)
📄 sysc_sethostname.stp(2.72 KB)
📄 sysc_setitimer.stp(5.61 KB)
📄 sysc_setns.stp(2.34 KB)
📄 sysc_setpgid.stp(2.41 KB)
📄 sysc_setpriority.stp(2.79 KB)
📄 sysc_setregid.stp(5.84 KB)
📄 sysc_setresgid.stp(6.12 KB)
📄 sysc_setresuid.stp(6.13 KB)
📄 sysc_setreuid.stp(5.84 KB)
📄 sysc_setrlimit.stp(3.61 KB)
📄 sysc_setsid.stp(2.05 KB)
📄 sysc_setsockopt.stp(7.77 KB)
📄 sysc_settimeofday.stp(6.01 KB)
📄 sysc_setuid.stp(4.23 KB)
📄 sysc_setxattr.stp(3.12 KB)
📄 sysc_sgetmask.stp(2.12 KB)
📄 sysc_shmat.stp(5.88 KB)
📄 sysc_shmctl.stp(7.23 KB)
📄 sysc_shmdt.stp(3.36 KB)
📄 sysc_shmget.stp(3.7 KB)
📄 sysc_shutdown.stp(6.46 KB)
📄 sysc_sigaction.stp(5.2 KB)
📄 sysc_sigaltstack.stp(3.83 KB)
📄 sysc_signal.stp(2.5 KB)
📄 sysc_signalfd.stp(11.53 KB)
📄 sysc_sigpending.stp(3.19 KB)
📄 sysc_sigprocmask.stp(3.69 KB)
📄 sysc_sigreturn.stp(1.43 KB)
📄 sysc_sigsuspend.stp(4.22 KB)
📄 sysc_socket.stp(6.92 KB)
📄 sysc_socketpair.stp(7.68 KB)
📄 sysc_splice.stp(2.78 KB)
📄 sysc_ssetmask.stp(2.49 KB)
📄 sysc_stat.stp(5.91 KB)
📄 sysc_statfs.stp(3.02 KB)
📄 sysc_statfs64.stp(2.93 KB)
📄 sysc_statx.stp(3.4 KB)
📄 sysc_stime.stp(2.76 KB)
📄 sysc_swapoff.stp(2.41 KB)
📄 sysc_swapon.stp(2.6 KB)
📄 sysc_symlink.stp(2.52 KB)
📄 sysc_symlinkat.stp(3.28 KB)
📄 sysc_sync.stp(1.88 KB)
📄 sysc_sync_file_range.stp(4.76 KB)
📄 sysc_syncfs.stp(2.27 KB)
📄 sysc_sysctl.stp(2.78 KB)
📄 sysc_sysfs.stp(3.22 KB)
📄 sysc_sysinfo.stp(2.95 KB)
📄 sysc_syslog.stp(2.41 KB)
📄 sysc_tee.stp(2.3 KB)
📄 sysc_tgkill.stp(2.48 KB)
📄 sysc_time.stp(3.18 KB)
📄 sysc_timer_create.stp(4.39 KB)
📄 sysc_timer_delete.stp(2.61 KB)
📄 sysc_timer_getoverrun.stp(2.86 KB)
📄 sysc_timer_gettime.stp(4.15 KB)
📄 sysc_timer_settime.stp(5.33 KB)
📄 sysc_timerfd.stp(1.79 KB)
📄 sysc_timerfd_create.stp(2.99 KB)
📄 sysc_timerfd_gettime.stp(3.79 KB)
📄 sysc_timerfd_settime.stp(4.71 KB)
📄 sysc_times.stp(2.84 KB)
📄 sysc_tkill.stp(2.35 KB)
📄 sysc_truncate.stp(5.25 KB)
📄 sysc_tux.stp(1.04 KB)
📄 sysc_umask.stp(2.22 KB)
📄 sysc_umount.stp(4.5 KB)
📄 sysc_uname.stp(4.77 KB)
📄 sysc_unlink.stp(2.38 KB)
📄 sysc_unlinkat.stp(2.79 KB)
📄 sysc_unshare.stp(2.48 KB)
📄 sysc_uselib.stp(2.39 KB)
📄 sysc_userfaultfd.stp(2.68 KB)
📄 sysc_ustat.stp(4.77 KB)
📄 sysc_utime.stp(5.37 KB)
📄 sysc_utimensat.stp(6.16 KB)
📄 sysc_utimes.stp(5.29 KB)
📄 sysc_vfork.stp(1.98 KB)
📄 sysc_vhangup.stp(2.08 KB)
📄 sysc_vmsplice.stp(5.56 KB)
📄 sysc_wait4.stp(4.55 KB)
📄 sysc_waitid.stp(3.68 KB)
📄 sysc_waitpid.stp(3.02 KB)
📄 sysc_write.stp(3.5 KB)
📄 sysc_writev.stp(3.22 KB)
📄 syscall_any.stp(1.52 KB)
📄 syscall_table.stp(1.44 KB)
📄 syscalls.stpm(13.78 KB)
📄 syscalls_cfg_trunc.stp(111 B)
📄 target_set.stp(1.73 KB)
📄 task.stp(22.21 KB)
📄 task.stpm(253 B)
📄 task_ancestry.stp(1.58 KB)
📄 task_time.stp(7.68 KB)
📄 tcp.stp(22.11 KB)
📄 tcpmib-filter-default.stp(885 B)
📄 tcpmib.stp(10.57 KB)
📄 timestamp.stp(1.72 KB)
📄 timestamp_gtod.stp(1.59 KB)
📄 timestamp_monotonic.stp(5.46 KB)
📄 tty.stp(7.18 KB)
📄 tzinfo.stp(803 B)
📄 ucontext-symbols.stp(8.63 KB)
📄 ucontext-unwind.stp(3.64 KB)
📄 ucontext.stp(2.18 KB)
📄 udp.stp(5.95 KB)
📄 utrace.stp(1.33 KB)
📄 vfs.stp(32.43 KB)
📁 x86_64

Editing: rpc.stp

// rpc tapset
// Copyright (C) 2006 IBM Corp.
// Copyright (C) 2007 Bull S.A.S
// Copyright (C) 2008, 2010-2014 Red Hat
//
// This file is part of systemtap, and is free software.  You can
// redistribute it and/or modify it under the terms of the GNU General
// Public License (GPL); either version 2, or (at your option) any
// later version.

%{
// Includes everything needed for __rpc_prot_from_protocol().
#include <linux/sunrpc/clnt.h>
%}

probe sunrpc.entry =
	sunrpc.clnt.entry,
	sunrpc.svc.entry,
	sunrpc.sched.entry
{}

probe sunrpc.return = 
	sunrpc.clnt.return,
	sunrpc.svc.return,
	sunrpc.sched.return
{}

/******************************************************************
 *                Probe points on RPC client functions            *  
 ******************************************************************/

probe sunrpc.clnt.entry = 
	sunrpc.clnt.create_client,
	sunrpc.clnt.clone_client,
	sunrpc.clnt.bind_new_program,
	sunrpc.clnt.shutdown_client,
	sunrpc.clnt.call_sync,
	sunrpc.clnt.call_async,
	sunrpc.clnt.restart_call
{}

probe sunrpc.clnt.return = 
	sunrpc.clnt.create_client.return,
	sunrpc.clnt.clone_client.return,
	sunrpc.clnt.bind_new_program.return,
	sunrpc.clnt.shutdown_client.return,
	sunrpc.clnt.call_sync.return,
	sunrpc.clnt.call_async.return,
	sunrpc.clnt.restart_call.return
{}

/*
 * Fires when an RPC client is to be created
 * 
 * kernels > 2.6.18
 *
 *  struct rpc_clnt *
 *  rpc_create(struct rpc_create_args *args)
 *	The rpc_create() function is used to create an RPC client.  It
 *	calculates some arguments (such as args->servername), then
 *	calls rpc_new_client().  We need the calculated arguments, so
 *	we'll probe rpc_new_client().  But, see discussion of
 *	sunrpc.clnt.create_client.return below.
 *
 *  static struct rpc_clnt *
 *  rpc_new_client(const struct rpc_create_args *args, struct rpc_xprt *xprt)
 *
 * kernels <= 2.6.18
 *
 *  static struct rpc_clnt * 
 *  rpc_new_client(struct rpc_xprt *xprt, char *servname, 
 *	struct rpc_program *program, u32 vers, 
 *	rpc_authflavor_t flavor)
 * 
 *  struct rpc_clnt * 
 *  rpc_create_client(struct rpc_xprt *xprt, char *servname, 
 *  	struct rpc_program *info, u32 version, 
 * 	rpc_authflavor_t authflavor)
 */

/**
 * probe sunrpc.clnt.create_client - Create an RPC client
 *
 *  @servername: the server machine name
 *  @progname:   the RPC program name
 *  @prog:       the RPC program number
 *  @vers:	 the RPC program version number
 *  @prot:	 the IP protocol number
 *  @port:	 the port number
 *  @authflavor: the authentication flavor
 */
probe sunrpc.clnt.create_client =
	_sunrpc.clnt.create_client.rpc_new_client_inline !,
	_sunrpc.clnt.create_client.rpc_new_client ?,
	_sunrpc.clnt.create_client.rpc_create_client ?
{
	name = "sunrpc.clnt.create_client"
	argstr = sprintf("%s %s %d %d %d %d %d", servername, progname, 
		prog, vers, prot, port, authflavor)
}

/*
 * Newer kernels (> 2.6.18) compiled with gcc less than version
 * 4.4.3-16, tend to have debuginfo that doesn't include location
 * information for inline function arguments.  This is a problem, since
 * we need the arguments to rpc_new_client(), which is inline.  Since
 * we can't get them for those kernels, we stash (and delete) the value
 * of the 'args' parameter of rpc_create().  We then use this value
 * when probing the inline version of rpc_new_client() (if we don't
 * have the real arguments to that inline function).
 */

@__private30 global __rpc_create_args

probe kernel.function("rpc_create").call !,
	module("sunrpc").function("rpc_create").call ?
{
	__rpc_create_args[tid()] = $args
}
	
probe kernel.function("rpc_create").return !,
	module("sunrpc").function("rpc_create").return ?
{
	delete __rpc_create_args[tid()]
}

/*
 * This function could be written in script language, but we'd need
 * embedded-C functions for XPRT_TRANSPORT_{UDP,TCP,BC_TCP} and
 * IPPROTO_{UDP,TCP}.  So, do it all in embedded-C.
 */

@__private30 function __rpc_prot_from_protocol:long(protocol:long)
%{
	switch (STAP_ARG_protocol) {
#ifdef XPRT_TRANSPORT_BC
	case XPRT_TRANSPORT_UDP:
		STAP_RETVALUE = IPPROTO_UDP;
		break;
	case XPRT_TRANSPORT_TCP:
	case XPRT_TRANSPORT_BC_TCP:
		STAP_RETVALUE = IPPROTO_TCP;
		break;
#endif
	default:
		STAP_RETVALUE = -1;
		break;
	}
%}

/*
 * The probe for the inline version of "rpc_new_client" (kernels >
 * 2.6.18) and the non-inline version of "rpc_new_client" (kernels <=
 * 2.6.18) could be combined.  However, the optimizer isn't smart
 * enough to optimize away the '__rpc_create_args' global then.
 */

probe _sunrpc.clnt.create_client.rpc_new_client_inline =
	kernel.function("rpc_new_client").inline !,
	module("sunrpc").function("rpc_new_client").inline
{
	if (@defined($args)) {		# kernel > 2.6.18 (with good debuginfo)
%(systemtap_v <= "1.7" %?
		args = $args
%)
		__args = $args
		servername = __rpc_format_servername($args->servername,
						     $args->address)
		progname = kernel_string($args->program->name)
		prog = $args->prognumber
		vers = vers_from_prog($args->program, $args->version)
		authflavor = $args->authflavor

prot = $xprt->prot
		port = @choose_defined($xprt->port, port_from_xprt($xprt))
	}
	else {				# kernel > 2.6.18 (with bad debuginfo)
%(systemtap_v <= "1.7" %?
		args = __rpc_create_args[tid()]
%)
		__args = __rpc_create_args[tid()]
		servername = __rpc_format_servername(@cast(__args, "rpc_create_args", "kernel:sunrpc")->servername,
						     @cast(__args, "rpc_create_args", "kernel:sunrpc")->address)

progname = kernel_string(@cast(__args, "rpc_create_args", "kernel:sunrpc")->program->name)
		prog = @cast(__args, "rpc_create_args", "kernel:sunrpc")->prognumber
		vers = vers_from_prog(@cast(__args, "rpc_create_args", "kernel:sunrpc")->program, @cast(__args, "rpc_create_args", "kernel:sunrpc")->version)
		authflavor = @cast(__args, "rpc_create_args", "kernel:sunrpc")->authflavor

prot = __rpc_prot_from_protocol(@cast(__args, "rpc_create_args", "kernel:sunrpc")->protocol)
		# Since we can't find $xprt, we can't know the port
		port = -1
	}
}

probe _sunrpc.clnt.create_client.rpc_new_client =
	kernel.function("rpc_new_client").call !,
	module("sunrpc").function("rpc_new_client").call ?
{
	if (@defined($args)) {
		# kernel > 2.6.18
		servername = __rpc_format_servername($args->servername,
						     $args->address)
		progname = kernel_string($args->program->name)
		prog = $args->prognumber
		vers = vers_from_prog($args->program, $args->version)
		authflavor = $args->authflavor
	}
	else {
		# kernel <= 2.6.18
		servername = __rpc_format_servername($servname, &$xprt->addr)
		progname = kernel_string($program->name)
		prog = $program->number
		vers = vers_from_prog($program, $vers)
		authflavor = $flavor
	}

prot = $xprt->prot
	port = @choose_defined($xprt->port, port_from_xprt($xprt))
}

probe _sunrpc.clnt.create_client.rpc_create_client =
	kernel.function("rpc_create_client") !,
	module("sunrpc").function("rpc_create_client") ?
{
	servername = __rpc_format_servername($servname, &$xprt->addr)
	if (@defined($info)) {
		progname = kernel_string($info->name)
		prog = $info->number
		vers = vers_from_prog($info, $version)
		authflavor = $authflavor
	}
	else {
		progname = kernel_string($program->name)
		prog = $program->number
		vers = vers_from_prog($program, $vers)
		authflavor = $flavor
	}

prot = $xprt->prot
	port = @choose_defined($xprt->port, port_from_xprt($xprt))
}

/*
 * On newer kernels, we want to probe the return of rpc_new_client()
 * here.  But because of problems with return probes on inline
 * functions (PR 4413), we have to probe the return of rpc_create()
 * instead.  So, if we find the return of rpc_create() (the only
 * caller of rpc_new_client()), we're done.
 */
probe sunrpc.clnt.create_client.return =
	_sunrpc.clnt.create_client.return.rpc_create !,
	_sunrpc.clnt.create_client.return.rpc_new_client ?,
	_sunrpc.clnt.create_client.return.rpc_create_client ?
{
	name = "sunrpc.clnt.create_client.return"
	retstr = return_str(2, $return)
}

probe _sunrpc.clnt.create_client.return.rpc_create =
	kernel.function("rpc_create").return !,
	module("sunrpc").function("rpc_create").return
{
}

probe _sunrpc.clnt.create_client.return.rpc_new_client =
	kernel.function("rpc_new_client").return !,
	module("sunrpc").function("rpc_new_client").return ?
{
}

probe _sunrpc.clnt.create_client.return.rpc_create_client = 
	kernel.function("rpc_create_client").return !,
	module("sunrpc").function("rpc_create_client").return ?
{
}

/**
 * probe sunrpc.clnt.clone_client - Clone an RPC client structure
 *
 *  @servername: the server machine name
 *  @progname:   the RPC program name
 *  @prog:       the RPC program number
 *  @vers:	 the RPC program version number
 *  @prot:	 the IP protocol number
 *  @port:	 the port number
 *  @authflavor: the authentication flavor
 */
probe sunrpc.clnt.clone_client = kernel.function("rpc_clone_client") !,
      	module("sunrpc").function("rpc_clone_client")
{
	if (@defined($clnt->cl_server))
		servername = __rpc_format_servername($clnt->cl_server,
						     &$clnt->cl_xprt->addr)
	else {
		__xprt = rcu_dereference($clnt->cl_xprt)
		servername = __rpc_format_servername(@cast(__xprt, "rpc_xprt")->servername,
						     &@cast(__xprt, "rpc_xprt")->addr)
	}
	progname = kernel_string(@choose_defined($clnt->cl_program->name,
						 $clnt->cl_protname))
	prog = prog_from_clnt($clnt)
	vers = vers_from_clnt($clnt)
	prot = prot_from_clnt($clnt)
	port = port_from_clnt($clnt)
	authflavor = $clnt->cl_auth->au_flavor
	
	name = "sunrpc.clnt.clone_client"
	argstr = sprintf("%s %s %d %d %d %d %d", servername, progname, 
			prog, vers, prot, port, authflavor)
}

probe sunrpc.clnt.clone_client.return = 
	kernel.function("rpc_clone_client").return !,
      	module("sunrpc").function("rpc_clone_client").return
{
	name = "sunrpc.clnt.clone_client.return"
	retstr = return_str(2, $return)
}

/**
 * probe sunrpc.clnt.shutdown_client - Shutdown an RPC client
 *
 *  @servername: the server machine name
 *  @progname:   the RPC program name
 *  @prog:       the RPC program number
 *  @vers:	 the RPC program version number
 *  @prot:	 the IP protocol number
 *  @port:	 the port number
 *  @authflavor: the authentication flavor
 *  @clones:     the number of clones
 *  @tasks:      the number of references
 *  @netreconn:  the count of reconnections
 *  @rpccnt:     the count of RPC calls
 *  @om_ops:      the count of operations
 *  @om_ntrans:   the count of RPC transmissions
 *  @om_bytes_sent: the count of bytes out
 *  @om_bytes_recv: the count of bytes in
 *  @om_queue:    the jiffies queued for xmit
 *  @om_rtt:      the RPC RTT jiffies
 *  @om_execute:  the RPC execution jiffies
 */
probe sunrpc.clnt.shutdown_client = kernel.function("rpc_shutdown_client") !,
      	module("sunrpc").function("rpc_shutdown_client")
{
	if (@defined($clnt->cl_server))
		servername = __rpc_format_servername($clnt->cl_server,
						     &$clnt->cl_xprt->addr)
	else {
		__xprt = rcu_dereference($clnt->cl_xprt)
		servername = __rpc_format_servername(@cast(__xprt, "rpc_xprt")->servername,
						     &@cast(__xprt, "rpc_xprt")->addr)
	}
	progname = kernel_string(@choose_defined($clnt->cl_program->name,
						 $clnt->cl_protname))
	prog = prog_from_clnt($clnt)
	vers = vers_from_clnt($clnt)
	prot = prot_from_clnt($clnt)
	port = port_from_clnt($clnt)
	authflavor = $clnt->cl_auth->au_flavor
	clones = clones_from_clnt($clnt)
	tasks = tasks_from_clnt($clnt)

/* per-program statistics */
	netreconn = $clnt->cl_stats->netreconn
	rpccnt = $clnt->cl_stats->rpccnt

/* per-client statistics */
	if (@defined($clnt->cl_metrics)) {
		om_ops = $clnt->cl_metrics->om_ops
		om_ntrans = $clnt->cl_metrics->om_ntrans
		om_bytes_sent = $clnt->cl_metrics->om_bytes_sent
		om_bytes_recv = $clnt->cl_metrics->om_bytes_recv
		if (@defined($clnt->cl_metrics->om_queue->tv64)) {
  		      om_queue = $clnt->cl_metrics->om_queue->tv64
		      om_rtt = $clnt->cl_metrics->om_rtt->tv64
		      om_execute = $clnt->cl_metrics->om_execute->tv64
		}
		else
		{
  		      om_queue = $clnt->cl_metrics->om_queue
		      om_rtt = $clnt->cl_metrics->om_rtt
		      om_execute = $clnt->cl_metrics->om_execute
		}
	}
	else {
		om_ops = -1
		om_ntrans = -1
		om_bytes_sent = -1
		om_bytes_recv = -1
		om_queue = -1
		om_rtt = -1
		om_execute = -1
	}

name = "sunrpc.clnt.shutdown_client"
	argstr = sprintf("%s %s %d %d %d %d %d %d %d", servername, progname, 
			prog, vers, prot, port, authflavor, clones, tasks)
}

probe sunrpc.clnt.shutdown_client.return = 
	kernel.function("rpc_shutdown_client").return !,
      	module("sunrpc").function("rpc_shutdown_client").return
{
	name = "sunrpc.clnt.shutdown_client.return"
	retstr = (@defined($return) ? return_str(1, $return) : "N/A")
}

/**
 * probe sunrpc.clnt.bind_new_program - Bind a new RPC program to an existing client
 *
 *  @servername:     the server machine name
 *  @old_progname:   the name of old RPC program
 *  @old_prog:       the number of old RPC program
 *  @old_vers:	     the version of old RPC program
 *  @progname:       the name of new RPC program
 *  @prog:           the number of new RPC program
 *  @vers:	     the version of new RPC program
 */
probe sunrpc.clnt.bind_new_program = 
	kernel.function("rpc_bind_new_program") !,
      	module("sunrpc").function("rpc_bind_new_program")
{
	if (@defined($old->cl_server))
		servername = __rpc_format_servername($old->cl_server,
						     &$old->cl_xprt->addr)
	else {
		__xprt = rcu_dereference($old->cl_xprt)
		servername = __rpc_format_servername(@cast(__xprt, "rpc_xprt")->servername,
						     &@cast(__xprt, "rpc_xprt")->addr)
	}
	old_progname = kernel_string(@choose_defined($old->cl_program->name,
						     $old->cl_protname))
	old_prog = prog_from_clnt($old)
	old_vers = vers_from_clnt($old)
	progname = kernel_string($program->name)
	prog = $program->number
	vers = vers_from_prog($program, $vers)

name = "sunrpc.clnt.bind_new_program"
	argstr = sprintf("%s %s %d %s %d", servername, old_progname, 
			old_vers, progname, vers)
}

probe sunrpc.clnt.bind_new_program.return = 
	kernel.function("rpc_bind_new_program").return !,
      	module("sunrpc").function("rpc_bind_new_program").return
{
	name = "sunrpc.clnt.bind_new_program.return"
	retstr = return_str(2, $return)
}

/**
 * probe sunrpc.clnt.call_sync - Make a synchronous RPC call
 *
 *  @servername: the server machine name
 *  @progname:   the RPC program name
 *  @prog:       the RPC program number
 *  @vers:	 the RPC program version number
 *  @prot:	 the IP protocol number
 *  @port:	 the port number
 *  @xid:        current transmission id
 *  @dead:       whether this client is abandoned
 *  @procname:   the procedure name in this RPC call
 *  @proc:       the procedure number in this RPC call
 *  @flags:      flags
 */
probe sunrpc.clnt.call_sync = kernel.function("rpc_call_sync") !,
      	module("sunrpc").function("rpc_call_sync")
{
	if (@defined($clnt->cl_server))
		servername = __rpc_format_servername($clnt->cl_server,
						     &$clnt->cl_xprt->addr)
	else {
		__xprt = rcu_dereference($clnt->cl_xprt)
		servername = __rpc_format_servername(@cast(__xprt, "rpc_xprt")->servername,
						     &@cast(__xprt, "rpc_xprt")->addr)
	}
	progname = kernel_string(@choose_defined($clnt->cl_program->name,
						 $clnt->cl_protname))
	prog = prog_from_clnt($clnt)
	vers = vers_from_clnt($clnt)
	prot = prot_from_clnt($clnt)
	port = port_from_clnt($clnt)
	xid  = xid_from_clnt($clnt)
	dead = @choose_defined($clnt->cl_dead,
		atomic_read(@choose_defined(&$clnt->cl_kref->refcount,
					    &$clnt->cl_count)) == 0)

proc = proc_from_msg($msg)
	procname = kernel_string(@choose_defined($msg->rpc_proc->p_name, 0), "NULL")
	flags = $flags
	
	name = "sunrpc.clnt.call_sync"
	argstr = sprintf("%s %d %s %d %s %d", servername, xid, progname, 
			vers, procname, flags)
}

probe sunrpc.clnt.call_sync.return = kernel.function("rpc_call_sync").return !,
      	module("sunrpc").function("rpc_call_sync").return
{
	name = "sunrpc.clnt.call_sync.return"
	retstr = return_str(1, $return)
}

/**
 * probe sunrpc.clnt.call_async - Make an asynchronous RPC call
 *
 *  @servername: the server machine name
 *  @progname:   the RPC program name
 *  @prog:       the RPC program number
 *  @vers:	 the RPC program version number
 *  @prot:	 the IP protocol number
 *  @port:	 the port number
 *  @xid:        current transmission id
 *  @dead:       whether this client is abandoned
 *  @procname:   the procedure name in this RPC call
 *  @proc:       the procedure number in this RPC call
 *  @flags:      flags
 */
probe sunrpc.clnt.call_async = kernel.function("rpc_call_async") !,
      	module("sunrpc").function("rpc_call_async")
{
	if (@defined($clnt->cl_server))
		servername = __rpc_format_servername($clnt->cl_server,
						     &$clnt->cl_xprt->addr)
	else {
		__xprt = rcu_dereference($clnt->cl_xprt)
		servername = __rpc_format_servername(@cast(__xprt, "rpc_xprt")->servername,
						     &@cast(__xprt, "rpc_xprt")->addr)
	}
	progname = kernel_string(@choose_defined($clnt->cl_program->name,
						 $clnt->cl_protname))
	prog = prog_from_clnt($clnt)
	vers = vers_from_clnt($clnt)
	prot = prot_from_clnt($clnt)
	port = port_from_clnt($clnt)
	xid  = xid_from_clnt($clnt)
	dead = @choose_defined($clnt->cl_dead,
		atomic_read(@choose_defined(&$clnt->cl_kref->refcount,
					    &$clnt->cl_count)) == 0)

proc = proc_from_msg($msg)
	procname = kernel_string(@choose_defined($msg->rpc_proc->p_name, 0), "NULL")
	flags = $flags
	
	name = "sunrpc.clnt.call_async"
	argstr = sprintf("%s %d %s %d %s %d", servername, xid, progname, 
			vers, procname, flags)
}

probe sunrpc.clnt.call_async.return = 
	kernel.function("rpc_call_async").return !,
      	module("sunrpc").function("rpc_call_async").return
{
	name = "sunrpc.clnt.call_async.return"
	retstr = return_str(1, $return)
}

/**
 * probe sunrpc.clnt.restart_call - Restart an asynchronous RPC call
 *
 * @servername:   the server machine name
 * @prog:         the RPC program number
 * @xid:          the transmission id
 * @tk_pid:	  the debugging aid of task
 * @tk_flags:     the task flags
 * @tk_priority:  the task priority
 * @tk_runstate:  the task run status
 */
probe sunrpc.clnt.restart_call = kernel.function("rpc_restart_call") !,
      	module("sunrpc").function("rpc_restart_call")
{
	if (@defined($task->tk_client->cl_server))
		servername = __rpc_format_servername($task->tk_client->cl_server,
						     &$task->tk_client->cl_xprt->addr)
	else {
		__xprt = rcu_dereference($task->tk_client->cl_xprt)
		servername = __rpc_format_servername(@cast(__xprt, "rpc_xprt")->servername,
						     &@cast(__xprt, "rpc_xprt")->addr)
	}
	prog = prog_from_clnt($task->tk_client)
	xid = $task->tk_rqstp->rq_xid
	tk_pid = $task->tk_pid
	tk_flags = $task->tk_flags
	tk_priority = $task->tk_priority
	tk_runstate = $task->tk_runstate

name = "sunrpc.clnt.restart_call"
	argstr = sprintf("%s %d %d %d %d %d %d", servername, prog, xid, tk_pid, 
			tk_flags, tk_priority, tk_runstate)
}

probe sunrpc.clnt.restart_call.return = 
	kernel.function("rpc_restart_call").return !,
      	module("sunrpc").function("rpc_restart_call").return
{
	name = "sunrpc.clnt.restart_call.return"
	retstr = "N/A"
}

/*********************************************
 *    Probe points on RPC server interface   *
 ********************************************/
probe sunrpc.svc.entry =
	sunrpc.svc.register,
	sunrpc.svc.create,
	sunrpc.svc.destroy,
	sunrpc.svc.process,
	sunrpc.svc.authorise,
	sunrpc.svc.recv,
	sunrpc.svc.send,
	sunrpc.svc.drop
{}

probe sunrpc.svc.return =
	sunrpc.svc.register.return,
	sunrpc.svc.create.return,
	sunrpc.svc.destroy.return,
	sunrpc.svc.process.return,
	sunrpc.svc.authorise.return,
	sunrpc.svc.recv.return,
	sunrpc.svc.send.return,
	sunrpc.svc.drop.return
{}

/**
 * probe sunrpc.svc.register - Register an RPC service with the local portmapper
 *
 * @sv_name:     the service name
 * @progname:    the name of the program
 * @prog:        the number of the program
 * @prot:	 the IP protocol number
 * @port:	 the port number
 *
 * If @proto and @port are both 0, then unregister a service.
 */
probe sunrpc.svc.register = kernel.function("svc_register") !,
      	module("sunrpc").function("svc_register")
{
	sv_name = kernel_string($serv->sv_name)
	progname = kernel_string($serv->sv_program->pg_name)
	prog = $serv->sv_program->pg_prog
	prot = $proto
	port = $port

name = "sunrpc.svc.register"
	argstr = sprintf("%s %s %d %d", sv_name, progname, prot, port)
}

probe sunrpc.svc.register.return = kernel.function("svc_register").return !,
      	module("sunrpc").function("svc_register").return
{
	name = "sunrpc.svc.register.return"
	retstr = return_str(1, $return)
}

/**
 * probe sunrpc.svc.create - Create an RPC service
 *
 * @progname:    the name of the program
 * @prog:        the number of the program
 * @pg_nvers:	 the number of supported versions
 * @bufsize:     the buffer size
 */
probe sunrpc.svc.create = kernel.function("svc_create") !,
      	module("sunrpc").function("svc_create")
{
	progname = kernel_string($prog->pg_name)
	prog = $prog->pg_prog
	pg_nvers  = $prog->pg_nvers
	bufsize = $bufsize
	
	name = "sunrpc.svc.create"
	argstr = sprintf("%s %d %d %d", progname, prog, pg_nvers, bufsize)
}

probe sunrpc.svc.create.return = kernel.function("svc_create").return !,
      	module("sunrpc").function("svc_create").return
{
	name = "sunrpc.svc.create.return"
	retstr = return_str(2, $return)
}

/**
 * probe sunrpc.svc.destroy - Destroy an RPC service
 *
 * @sv_name:     the service name
 * @sv_progname: the name of the program
 * @sv_prog:     the number of the program
 * @sv_nrthreads:the number of concurrent threads
 * @netcnt:      the count of received RPC requests
 * @nettcpconn:  the count of accepted TCP connections
 * @rpccnt:      the count of valid RPC requests
 * @rpcbadfmt:   the count of requests dropped for bad formats
 * @rpcbadauth:  the count of requests drooped for authentication failure
 */
probe sunrpc.svc.destroy = kernel.function("svc_destroy") !,
      	module("sunrpc").function("svc_destroy")
{
	sv_name = kernel_string($serv->sv_name) /* service name */
	sv_progname = kernel_string($serv->sv_program->pg_name)
	sv_prog = $serv->sv_program->pg_prog
	sv_nrthreads = $serv->sv_nrthreads

/* RPC statistics */
	netcnt = $serv->sv_stats->netcnt
	netcpconn = $serv->sv_stats->nettcpconn
	rpccnt = $serv->sv_stats->rpccnt
	rpcbadfmt = $serv->sv_stats->rpcbadfmt
	rpcbadauth = $serv->sv_stats->rpcbadauth
	
	name = "sunrpc.svc.destroy"
	argstr = sprintf("%s %d %d", sv_name, sv_prog, sv_nrthreads)
}

probe sunrpc.svc.destroy.return = kernel.function("svc_destroy").return !,
      	module("sunrpc").function("svc_destroy").return
{
	name = "sunrpc.svc.destroy.return"
	retstr = "N/A"
}

/**
 * probe sunrpc.svc.process - Process an RPC request
 *
 * @sv_name:     the service name
 * @sv_prog:     the number of the program
 * @sv_nrthreads:the number of concurrent threads
 * @peer_ip:     the peer address where the request is from
 * @rq_xid:      the transmission id in the request
 * @rq_prog:     the program number in the request
 * @rq_vers:     the program version in the request
 * @rq_proc:     the procedure number in the request
 * @rq_prot:     the IP protocol of the reqeust
 */
probe sunrpc.svc.process = kernel.function("svc_process") !,
      	module("sunrpc").function("svc_process")
{
	if (! @defined($serv)) {
		sv_name = kernel_string($rqstp->rq_server->sv_name)
		sv_prog = $rqstp->rq_server->sv_program->pg_prog
		sv_nrthreads = $rqstp->rq_server->sv_nrthreads
	}
	else {
		sv_name = kernel_string($serv->sv_name) /* service name */
		sv_prog = $serv->sv_program->pg_prog
		sv_nrthreads = $serv->sv_nrthreads
	}
	peer_ip = addr_from_rqst($rqstp)
	rq_xid = $rqstp->rq_xid
	rq_prog = $rqstp->rq_prog
	rq_vers = $rqstp->rq_vers
	rq_proc = $rqstp->rq_proc
	rq_prot = $rqstp->rq_prot
	
	name = "sunrpc.svc.process"
	argstr = sprintf("%s %d %d %d %d %d %d", sv_name, sv_prog, peer_ip,
			rq_xid, rq_prog, rq_vers, rq_proc)
}

probe sunrpc.svc.process.return = kernel.function("svc_process").return !,
      	module("sunrpc").function("svc_process").return
{
	name = "sunrpc.svc.process.return"
	retstr = return_str(1, $return)
}

/* 
 * probe sunrpc.svc.authorise - An RPC request is to be authorised
 *
 * @sv_name:     the service name
 * @peer_ip:     the peer address where the request is from
 * @rq_xid:      the transmission id in the request
 * @rq_prog:     the program number in the request
 * @rq_vers:     the program version in the request
 * @rq_proc:     the procedure number in the request
 * @rq_prot:     the IP protocol of the reqeust
 */
probe sunrpc.svc.authorise = kernel.function("svc_authorise") !,
      	module("sunrpc").function("svc_authorise")
{
	sv_name = kernel_string($rqstp->rq_server->sv_name)
	peer_ip = addr_from_rqst($rqstp)
	rq_xid  = $rqstp->rq_xid
	rq_prog = $rqstp->rq_prog
	rq_vers = $rqstp->rq_vers
	rq_proc = $rqstp->rq_proc
	rq_prot = $rqstp->rq_prot

name = "sunrpc.svc.authorise"
	argstr = sprintf("%d %d %d %d %d %d", peer_ip, rq_xid, rq_prog, 
			rq_vers, rq_proc, rq_prot)
}

probe sunrpc.svc.authorise.return = kernel.function("svc_authorise").return !,
      	module("sunrpc").function("svc_authorise").return
{
	name = "sunrpc.svc.authorise.return"
	retstr = return_str(1, $return)
}

/**
 * probe sunrpc.svc.recv - Listen for the next RPC request on any socket
 *
 * @sv_name:     the service name
 * @sv_prog:     the number of the program
 * @sv_nrthreads:the number of concurrent threads
 * @timeout:     the timeout of waiting for data
 */
probe sunrpc.svc.recv = kernel.function("svc_recv") !,
      	module("sunrpc").function("svc_recv")
{
	if (! @defined($serv)) {
	        sv_name = kernel_string($rqstp->rq_server->sv_name) 
        	sv_prog = $rqstp->rq_server->sv_program->pg_prog
	        sv_nrthreads = $rqstp->rq_server->sv_nrthreads
	}
	else {
		sv_name = kernel_string($serv->sv_name)	
		sv_prog = $serv->sv_program->pg_prog
		sv_nrthreads = $serv->sv_nrthreads
	}
	timeout = $timeout

name = "sunrpc.svc.recv"
	argstr = sprintf("%s %d", sv_name, timeout)
}

probe sunrpc.svc.recv.return = kernel.function("svc_recv").return !,
      	module("sunrpc").function("svc_recv").return
{
	name = "sunrpc.svc.recv.return"
	retstr = return_str(1, $return)
}

/**
 * probe sunrpc.svc.send  - Return reply to RPC client
 *
 * @sv_name:     the service name
 * @peer_ip:     the peer address where the request is from
 * @rq_xid:      the transmission id in the request
 * @rq_prog:     the program number in the request
 * @rq_vers:     the program version in the request
 * @rq_proc:     the procedure number in the request
 * @rq_prot:     the IP protocol of the reqeust
 */
probe sunrpc.svc.send = kernel.function("svc_send") !,
      	module("sunrpc").function("svc_send")
{
	sv_name = kernel_string($rqstp->rq_server->sv_name)
	peer_ip = addr_from_rqst($rqstp)
	rq_xid  = $rqstp->rq_xid
	rq_prog = $rqstp->rq_prog
	rq_vers = $rqstp->rq_vers
	rq_proc = $rqstp->rq_proc
	rq_prot = $rqstp->rq_prot
	
	name = "sunrpc.svc.send"
	argstr = sprintf("%s %d %d %d %d %d %d", sv_name, peer_ip, 
			rq_xid, rq_prog, rq_vers, rq_proc, rq_prot)
}

probe sunrpc.svc.send.return = kernel.function("svc_send").return !,
      	module("sunrpc").function("svc_send").return
{
	name = "sunrpc.svc.send.return"
	retstr = return_str(1, $return)
}

/**
 * probe sunrpc.svc.drop - Drop RPC request
 *
 * @sv_name:     the service name
 * @peer_ip:     the peer address where the request is from
 * @rq_xid:      the transmission id in the request
 * @rq_prog:     the program number in the request
 * @rq_vers:     the program version in the request
 * @rq_proc:     the procedure number in the request
 * @rq_prot:     the IP protocol of the reqeust
 */
probe sunrpc.svc.drop = kernel.function("svc_drop") !,
      	module("sunrpc").function("svc_drop")
{
	sv_name = kernel_string($rqstp->rq_server->sv_name)
	peer_ip = addr_from_rqst($rqstp)
	rq_xid  = $rqstp->rq_xid
	rq_prog = $rqstp->rq_prog
	rq_vers = $rqstp->rq_vers
	rq_proc = $rqstp->rq_proc
	rq_prot = $rqstp->rq_prot
	
	name = "sunrpc.svc.drop"
	argstr = sprintf("%s %d %d %d %d %d %d", sv_name, peer_ip, 
			rq_xid, rq_prog, rq_vers, rq_proc, rq_prot)
}

probe sunrpc.svc.drop.return = kernel.function("svc_drop").return !,
      	module("sunrpc").function("svc_drop").return
{
	name = "sunrpc.svc.drop.return"
	retstr = "N/A"
}

/*******************************************************************
 *                  Probe points on RPC scheduler                  *
 ******************************************************************/
probe sunrpc.sched.entry =
	sunrpc.sched.new_task,
	sunrpc.sched.release_task ?,
	sunrpc.sched.execute,
	sunrpc.sched.delay
{}

probe sunrpc.sched.return =
	sunrpc.sched.new_task.return,
	sunrpc.sched.release_task.return ?,
	sunrpc.sched.execute.return,
	sunrpc.sched.delay.return
{}

/**
 * probe sunrpc.sched.new_task - Create new task for the specified client
 *
 * @xid:         the transmission id in the RPC call
 * @prog:        the program number in the RPC call
 * @vers:        the program version in the RPC call
 * @prot:        the IP protocol in the RPC call
 * @tk_flags:    the flags of the task
 */
probe sunrpc.sched.new_task = kernel.function("rpc_new_task") !,
      	module("sunrpc").function("rpc_new_task")
{
	if (@defined($setup_data)) {
		xid = xid_from_clnt($setup_data->rpc_client)
		prog = prog_from_clnt($setup_data->rpc_client)
		vers = vers_from_clnt($setup_data->rpc_client)
		prot = prot_from_clnt($setup_data->rpc_client)
		flags = $setup_data->flags
	}
	else {
		xid = xid_from_clnt($clnt)
		prog = prog_from_clnt($clnt)
		vers = vers_from_clnt($clnt)
		prot = prot_from_clnt($clnt)
		flags = $flags
	}

name = "sunrpc.sched.new_task"
	argstr = sprintf("%d %d %d %d %d", xid, prog, vers, prot, flags)
}

probe sunrpc.sched.new_task.return = kernel.function("rpc_new_task").return !,
      	module("sunrpc").function("rpc_new_task").return
{
	name = "sunrpc.sched.new_task.return"
	retstr = return_str(2, $return)
}

/**
 * probe sunrpc.sched.release_task - Release all resources associated with a task
 *
 * @xid:         the transmission id in the RPC call
 * @prog:        the program number in the RPC call
 * @vers:        the program version in the RPC call
 * @prot:        the IP protocol in the RPC call
 * @tk_flags:    the flags of the task
 *
 * rpc_release_task() function might not be found for a particular kernel.
 *  So, if we can't find it, just return '-1' for everything.
 */
/*
 * The '.call' here is so that we're sure to grab the non-inline
 * version of rpc_release_task() (assuming it exists).  We can't find
 * the return of rpc_release_task() if it is inline (PR 4413).
 */
probe sunrpc.sched.release_task = kernel.function("rpc_release_task").call !,
      	module("sunrpc").function("rpc_release_task").call !,
	never
{
	if (@defined($task)) {
		xid = xid_from_clnt($task->tk_client)
		prog = prog_from_clnt($task->tk_client)
		vers = vers_from_clnt($task->tk_client)
		prot = prot_from_clnt($task->tk_client)
		tk_flags  = $task->tk_flags
	}
	else {
		xid = -1
		prog = -1
		vers = -1
		prot = -1
		tk_flags  = -1
	}
	name = "sunrpc.sched.release_task"
	argstr = sprintf("%d %d %d %d %d", xid, prog, vers, prot, tk_flags)
}

probe sunrpc.sched.release_task.return = 
	kernel.function("rpc_release_task").return !,
      	module("sunrpc").function("rpc_release_task").return ?
{
	name = "sunrpc.sched.release_task.return"
	retstr = "N/A"
}

/**
 * probe sunrpc.sched.execute - Execute the RPC `scheduler' 
 *
 * @xid:         the transmission id in the RPC call
 * @prog:        the program number in the RPC call
 * @vers:        the program version in the RPC call
 * @prot:        the IP protocol in the RPC call
 * @tk_pid:      the debugging id of the task
 * @tk_flags:    the flags of the task
 */
probe sunrpc.sched.execute = kernel.function("__rpc_execute") !,
      	module("sunrpc").function("__rpc_execute")
{
	xid = xid_from_clnt($task->tk_client)
	prog = prog_from_clnt($task->tk_client)
	vers = vers_from_clnt($task->tk_client)
	prot = prot_from_clnt($task->tk_client)
	tk_pid = $task->tk_pid
	tk_flags = $task->tk_flags

name = "sunrpc.sched.execute"
	argstr = sprintf("%d %d %d %d %d %d", xid, prog, vers, prot, 
			tk_pid, tk_flags)
}

probe sunrpc.sched.execute.return = kernel.function("__rpc_execute").return !,
      	module("sunrpc").function("__rpc_execute").return
{
	name = "sunrpc.sched.execute.return"

# On kernels > 2.6.20, __rpc_execute() is a void function.
	if (@defined($return)) {
		retstr = return_str(1, $return)
	}
	else {
		retstr = "N/A"
	}
}

/**
 * probe sunrpc.sched.delay - Delay an RPC task
 *
 * @xid:         the transmission id in the RPC call
 * @prog:        the program number in the RPC call
 * @vers:        the program version in the RPC call
 * @prot:        the IP protocol in the RPC call
 * @tk_pid:      the debugging id of the task
 * @tk_flags:    the flags of the task
 * @delay:       the time delayed
 */
probe sunrpc.sched.delay = kernel.function("rpc_delay") !,
      module("sunrpc").function("rpc_delay") 
{
	xid = xid_from_clnt($task->tk_client)
	prog = prog_from_clnt($task->tk_client)
	vers = vers_from_clnt($task->tk_client)
	prot = prot_from_clnt($task->tk_client)
	tk_pid = $task->tk_pid
	tk_flags = $task->tk_flags
	delay = $delay

name = "sunrpc.sched.delay"
	argstr = sprintf("%d %d %d %d %d %d %d", xid, prog, vers, 
			prot, tk_pid, tk_flags, delay)
}

probe sunrpc.sched.delay.return = kernel.function("rpc_delay").return !,
      module("sunrpc").function("rpc_delay").return
{
	name = "sunrpc.sched.delay.return"
	retstr = "N/A"
}

/******************************************************************
 *                       Helper functions                        *
 *****************************************************************/

function xid_from_clnt:long(clnt:long)
{
	if (clnt == 0)
		return 0
	return @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_xprt->xid
}

function prog_from_clnt:long(clnt:long)
{
	if (clnt == 0)
		return 0
	return @choose_defined(@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_prog,
		@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_pmap->pm_prog)
}

function vers_from_clnt:long(clnt:long)
{
	if (clnt == 0)
		return 0
	return @choose_defined(@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_vers,
		@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_pmap->pm_vers)
}

function prot_from_clnt:long(clnt:long)
{
	if (clnt == 0)
		return 0
	return @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_xprt->prot
}

function port_from_xprt:long(cl_xprt:long)
{
	if (cl_xprt == 0)
		return 0

addr = &@cast(cl_xprt, "rpc_xprt", "kernel:sunrpc")->addr
	if (addr == 0)
		return 0

/* In reality, 'cl_xprt->addr' is of 'sockaddr_storage' type
	 * (since 2.6.19). But when used, you cast it to what is
	 * inside that buffer. The 'struct sockaddr', 'struct
	 * sockaddr_in', and 'sockaddr_in6' structures all have a
	 * family type as their 1st member. */
	if (@cast(addr, "sockaddr")->sa_family
		== @const("AF_INET")) {
		return ntohs(@cast(addr, "sockaddr_in")->sin_port)
	}
	else if (@cast(addr, "sockaddr")->sa_family
		 == @const("AF_INET6")) {
		return ntohs(@cast(addr, "sockaddr_in6")->sin6_port)
	}
	return 0
}

function port_from_clnt:long(clnt:long)
{
	if (clnt == 0)
		return 0

cl_xprt = @cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_xprt
	return port_from_xprt(cl_xprt)
}

function clones_from_clnt:long(clnt:long)
{
    return (@defined(@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_count)
	    ? atomic_read(&@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_count)
	    : -1)
}

function tasks_from_clnt:long(clnt:long)
{
    return (@defined(@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_users)
	    ? atomic_read(&@cast(clnt, "rpc_clnt", "kernel:sunrpc")->cl_users)
	    : -1)
}

function proc_from_msg:long(msg:long)
{
	if (msg == 0)
		return 0
	return @cast(msg, "rpc_message", "kernel:sunrpc")->rpc_proc->p_proc
}

function vers_from_prog:long(program:long, vers:long)
{
    if (program
	&& vers < @cast(program, "rpc_program", "kernel:sunrpc")->nrvers)
	return @cast(program, "rpc_program", "kernel:sunrpc")->version[vers]->number
    return 0
}

function addr_from_rqst:long(rqstp:long)
{
    if (rqstp) {
	addr = &@cast(rqstp, "svc_rqst", "kernel:nfs")->rq_addr
	if (addr == 0)
		return 0

/* In reality, 'rq_addr' is of 'sockaddr_storage' type
	 * (since 2.6.19). But when used, you cast it to what is
	 * inside that buffer. The 'struct sockaddr', 'struct
	 * sockaddr_in', and 'sockaddr_in6' structures all have a
	 * family type as their 1st member. */
	if (@cast(addr, "sockaddr")->sa_family
		== @const("AF_INET")) {
		return @cast(addr, "sockaddr_in")->sin_addr->s_addr
	}
	else if (@cast(addr, "sockaddr")->sa_family
		 == @const("AF_INET6")) {
		return &@cast(addr, "sockaddr_in6")->sin6_addr
	}
    }
    return 0
}

function addr_from_rqst_str:string(rqstp:long)
{
	if (rqstp == 0)
		return "Null"

addr = &@cast(rqstp, "svc_rqst", "kernel:nfs")->rq_addr
	if (addr == 0)
		return "Null"

s_addr = addr_from_rqst(rqstp)
	if (s_addr == 0)
		return "Unsupported Address Family"
	if (@cast(addr, "sockaddr_in")->sin_family
		  == @const("AF_INET")) {
		return sprintf("%s:%d",
			       format_ipaddr(s_addr,
				  @const("AF_INET")), 
				  @cast(addr, "sockaddr_in")->sin_port)
	}
	return sprintf("[%s]:%d",
		       format_ipaddr(s_addr,
			  @const("AF_INET6")),
			  @cast(addr, "sockaddr_in6")->sin6_port)
}

%{
#include <linux/un.h>
#include <linux/in.h>
#include <linux/in6.h>
%}

@__private30 function __rpc_format_servername:string(servername:long, address:long)
{
	printf("__rpc_format_servername: %p\n", servername)
	if (servername != 0)
		return kernel_string(servername)

// If 'servername' is NULL, create a string representation of
	// the passed-in address.
	// 
	// Note that 'address' is a generic 'struct sockaddr'. When
	// you use it you have to cast it to the more specific
	// structure based on the family type.
	if (@cast(address, "sockaddr")->sa_family == @const("AF_LOCAL")) {
		return kernel_string(@cast(address, "sockaddr_un")->sun_path)
	}
	else if (@cast(address, "sockaddr")->sa_family == @const("AF_INET")) {
		return format_ipaddr(&@cast(address, "sockaddr_in")->sin_addr->s_addr, @const("AF_INET"))
	}
	else if (@cast(address, "sockaddr")->sa_family == @const("AF_INET6")) {
		return format_ipaddr(&@cast(address, "sockaddr_in6")->sin6_addr,
				     @const("AF_INET6"))
	}
	return "*unknown address family*"
}

X7ROOT File Manager

Editing: rpc.stp

Upload File

Create Folder