From aaa6513f6db3a54691cfa7022bfbd979db42672e Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Tue, 5 May 2009 17:48:24 -0400 Subject: Added rpc_call_status trace points --- tapset/sunrpc_task.stp | 63 +++++++++++++++++++++++++++++++++++++++++ tracepoints/rpc_call_status.stp | 32 +++++++++++++++++++++ 2 files changed, 95 insertions(+) create mode 100644 tapset/sunrpc_task.stp create mode 100644 tracepoints/rpc_call_status.stp diff --git a/tapset/sunrpc_task.stp b/tapset/sunrpc_task.stp new file mode 100644 index 0000000..47cc178 --- /dev/null +++ b/tapset/sunrpc_task.stp @@ -0,0 +1,63 @@ +%{ +#include +#include +#include +%} + +function cl_prog:string(_task:long) +%{ + struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); + struct rpc_clnt *clnt = (struct rpc_clnt *)(long) kread(&(task->tk_client)); + struct rpc_procinfo *proc = + (struct rpc_procinfo *)(long) kread(&(clnt->cl_procinfo)); + char *p_name = kread(&(proc->p_name)); + static struct { + int prog; + char *string; + } prog_progtbl[] = { + {100000, "rpcbind"}, + {100024, "statd"}, + {100011, "rquotad"}, + {100003, "nfsd"}, + {100021, "nlockmgr"}, + {100005, "mountd"}, + {100227, "nfs_acl"}, + }; + int i; + int tabsz = (sizeof(prog_progtbl)/sizeof(prog_progtbl[0])); + + for (i = 0; i < tabsz; i++) { + if (prog_progtbl[i].prog == clnt->cl_prog) { + break; + } + } + if (i == tabsz) + snprintf(THIS->__retvalue, MAXSTRINGLEN, "0x%x[%d]:%d", + clnt->cl_prog, clnt->cl_vers, proc->p_proc); + else + snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s[%d]:%d", + prog_progtbl[i].string, clnt->cl_vers, proc->p_proc); + + CATCH_DEREF_FAULT(); +%} +function cl_server:string(_task:long) +%{ + struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); + struct rpc_clnt *clnt = (struct rpc_clnt *)(long) kread(&(task->tk_client)); + char *cl_server = kread(&(clnt->cl_server)); + + snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s", + cl_server ? cl_server : "NULL"); + + CATCH_DEREF_FAULT(); +%} + +function task_status:long(_task:long) +%{ + struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); + + THIS->__retvalue = task->tk_status; + + CATCH_DEREF_FAULT(); +%} + diff --git a/tracepoints/rpc_call_status.stp b/tracepoints/rpc_call_status.stp new file mode 100644 index 0000000..8018559 --- /dev/null +++ b/tracepoints/rpc_call_status.stp @@ -0,0 +1,32 @@ +/* + * stap -g -I ../tapset rpc_call_status.stp + */ +%{ +#include +#include +#include +%} + +probe kernel.trace("rpc_bind_status") +{ + terror = task_status($task); + if (terror) + printf("rpc_bind_status:%s:%s: error %d (%s)\n", + cl_server($task), cl_prog($task), terror, errno_str(terror)); +} +probe kernel.trace("rpc_connect_status") +{ + terror = task_status($task); + if (terror) + printf("call_connect_status:%s:%s: error %d (%s)\n", + cl_server($task), cl_prog($task), terror, errno_str(terror)); +} +probe kernel.trace("rpc_call_status") +{ + terror = task_status($task); + if (terror) + printf("call_status:%s:%s: error %d (%s)\n", + cl_server($task), cl_prog($task), terror, errno_str(terror)); +} +probe begin { log("starting rpc call status probe") } +probe end { log("ending rpc call status probe") } -- cgit From dfdce363041b4fb72910837174bf40019923c9bc Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Wed, 10 Jun 2009 11:21:37 -0400 Subject: Reorganised scripts into local directories Signed-off-by: Steve Dickson --- bind.stp | 58 ----------- cacheio.stp | 147 ---------------------------- exports.stp | 89 ----------------- ext3calltimes | 160 ------------------------------ funccount.sh | 57 ----------- kernelcalltimes | 177 --------------------------------- lockd/lockd_listener.stp | 61 ++++++++++++ lockd_listener.stp | 61 ------------ mnt.stp | 14 --- net/inet_bind.stp | 102 +++++++++++++++++++ net/ipv6_bind.stp | 58 +++++++++++ nfs/nfs4_lck.stp | 131 +++++++++++++++++++++++++ nfs/nfs4_lookup_root.stp | 19 ++++ nfs/nfs4_xattr.stp | 55 +++++++++++ nfs/nfs_auth.stp | 11 +++ nfs/nfs_get_sb.stp | 10 ++ nfs/nfs_umount.stp | 39 ++++++++ nfs/nfs_unlink.stp | 23 +++++ nfs/nfsd_mount_opts.stp | 14 +++ nfs4_lck.stp | 131 ------------------------- nfs4_lookup_root.stp | 19 ---- nfs4_xattr.stp | 55 ----------- nfs_auth.stp | 11 --- nfs_get_sb.stp | 10 -- nfs_umount.stp | 39 -------- nfsd/nfsd4_acl.stp | 56 +++++++++++ nfsd/nfsd4_callback.stp | 32 ++++++ nfsd/nfsd4_secinfo.stp | 72 ++++++++++++++ nfsd/nfsd_auth.stp | 29 ++++++ nfsd/nfsd_cacheio.stp | 147 ++++++++++++++++++++++++++++ nfsd/nfsd_deleg.stp | 48 +++++++++ nfsd/nfsd_dispatch.stp | 47 +++++++++ nfsd/nfsd_exports.stp | 89 +++++++++++++++++ nfsd/nfsd_fh.stp | 101 +++++++++++++++++++ nfsd/nfsd_lookup.stp | 100 +++++++++++++++++++ nfsd/nfsd_permission.stp | 16 +++ nfsd/nfsd_setattr.stp | 19 ++++ nfsd/svc_export.stp | 49 ++++++++++ nfsd4_acl.stp | 56 ----------- nfsd4_secinfo.stp | 72 -------------- nfsd_auth.stp | 29 ------ nfsd_deleg.stp | 48 --------- nfsd_dispatch.stp | 47 --------- nfsd_fh.stp | 101 ------------------- nfsd_lookup.stp | 100 ------------------- nfsd_permission.stp | 16 --- nfsd_setattr.stp | 19 ---- nfsunlink.stp | 23 ----- open_namei.stp | 18 ---- prob.stp | 32 ------ rpc.stp | 16 --- sunrpc/rpc_killall.stp | 16 +++ sunrpc/xprt.stp | 44 +++++++++ svc_export.stp | 49 ---------- sys/open_namei.stp | 18 ++++ sys/sysmount.stp | 47 +++++++++ sys_bind/inet_bind.stp | 102 ------------------- syscalltimes | 248 ----------------------------------------------- sysmount.stp | 47 --------- xprt.stp | 44 --------- 60 files changed, 1453 insertions(+), 2095 deletions(-) delete mode 100644 bind.stp delete mode 100644 cacheio.stp delete mode 100644 exports.stp delete mode 100755 ext3calltimes delete mode 100755 funccount.sh delete mode 100755 kernelcalltimes create mode 100644 lockd/lockd_listener.stp delete mode 100644 lockd_listener.stp delete mode 100644 mnt.stp create mode 100644 net/inet_bind.stp create mode 100644 net/ipv6_bind.stp create mode 100644 nfs/nfs4_lck.stp create mode 100644 nfs/nfs4_lookup_root.stp create mode 100644 nfs/nfs4_xattr.stp create mode 100644 nfs/nfs_auth.stp create mode 100644 nfs/nfs_get_sb.stp create mode 100644 nfs/nfs_umount.stp create mode 100644 nfs/nfs_unlink.stp create mode 100644 nfs/nfsd_mount_opts.stp delete mode 100644 nfs4_lck.stp delete mode 100644 nfs4_lookup_root.stp delete mode 100644 nfs4_xattr.stp delete mode 100644 nfs_auth.stp delete mode 100644 nfs_get_sb.stp delete mode 100644 nfs_umount.stp create mode 100644 nfsd/nfsd4_acl.stp create mode 100644 nfsd/nfsd4_callback.stp create mode 100644 nfsd/nfsd4_secinfo.stp create mode 100644 nfsd/nfsd_auth.stp create mode 100644 nfsd/nfsd_cacheio.stp create mode 100644 nfsd/nfsd_deleg.stp create mode 100644 nfsd/nfsd_dispatch.stp create mode 100644 nfsd/nfsd_exports.stp create mode 100644 nfsd/nfsd_fh.stp create mode 100644 nfsd/nfsd_lookup.stp create mode 100644 nfsd/nfsd_permission.stp create mode 100644 nfsd/nfsd_setattr.stp create mode 100644 nfsd/svc_export.stp delete mode 100644 nfsd4_acl.stp delete mode 100644 nfsd4_secinfo.stp delete mode 100644 nfsd_auth.stp delete mode 100644 nfsd_deleg.stp delete mode 100644 nfsd_dispatch.stp delete mode 100644 nfsd_fh.stp delete mode 100644 nfsd_lookup.stp delete mode 100644 nfsd_permission.stp delete mode 100644 nfsd_setattr.stp delete mode 100644 nfsunlink.stp delete mode 100644 open_namei.stp delete mode 100644 prob.stp delete mode 100644 rpc.stp create mode 100644 sunrpc/rpc_killall.stp create mode 100644 sunrpc/xprt.stp delete mode 100644 svc_export.stp create mode 100644 sys/open_namei.stp create mode 100644 sys/sysmount.stp delete mode 100644 sys_bind/inet_bind.stp delete mode 100755 syscalltimes delete mode 100644 sysmount.stp delete mode 100644 xprt.stp diff --git a/bind.stp b/bind.stp deleted file mode 100644 index 2a9db1c..0000000 --- a/bind.stp +++ /dev/null @@ -1,58 +0,0 @@ -probe syscall.bind -{ - printf("sys_bind: %s\n", argstr); -} -probe syscall.bind.return -{ - if ($return) - printf("sys_bind: (%s)\n", retstr); -} -probe module("ipv6").function("inet6_bind") -{ - printf(" inet6_bind: %s\n %s\n %s\n", - struct_socket($sock), struct_sock($sock->sk), struct_sockaddr($uaddr, $addr_len)); -} -probe module("ipv6").function("inet6_bind").return -{ - if ($return) - printf(" inet6_bind: %d (%s)\n", $return, errno_str($return)); -} -probe module("ipv6").function("tcp_v6_get_port") -{ - printf(" tcp_v6_get_port: sk %p\n", $sk); -} -probe module("ipv6").function("tcp_v6_get_port").return -{ - if ($return) - printf(" tcp_v6_get_port: %d (%s)\n", $return, errno_str($return)); -} -probe module("ipv6").function("inet6_csk_bind_conflict") -{ - printf(" inet6_csk_bind_conflict: sk %p\n", $sk); -} -probe module("ipv6").function("inet6_csk_bind_conflict").return -{ - if ($return) - printf(" inet6_csk_bind_conflict: %d (%s)\n", $return, errno_str($return)); -} -probe module("ipv6").function("ipv6_rcv_saddr_equal") -{ - printf(" ipv6_rcv_saddr_equal: sk %p sk2 %p\n", $sk, $sk2); -} -probe module("ipv6").function("ipv6_rcv_saddr_equal").return -{ - if ($return) - printf(" ipv6_rcv_saddr_equal: %d (%s)\n", $return, errno_str($return)); -} -probe kernel.function("inet_bind") -{ - printf(" inet_bind: %s\n %s\n %s\n", - struct_socket($sock), struct_sock($sock->sk), struct_sockaddr($uaddr, $addr_len)); -} -probe kernel.function("inet_bind").return -{ - if ($return) - printf(" inet_bind: %d (%s)\n", $return, errno_str($return)); -} -probe begin { log("starting bind probe") } -probe end { log("ending bind probe") } diff --git a/cacheio.stp b/cacheio.stp deleted file mode 100644 index 3dc0a8d..0000000 --- a/cacheio.stp +++ /dev/null @@ -1,147 +0,0 @@ -#!/usr/bin/env stap - -probe module("nfsd").function("exp_pseudoroot") -{ - printf("exp_pseudoroot: rqstp %p fhp %p\n", $rqstp, $fhp); -} -probe module("nfsd").function("exp_pseudoroot").return -{ - printf("exp_pseudoroot: %s\n", nfsderror($return)); -} -probe module("sunrpc").function("cache_write") -{ - if (!isinstr("rpc.idmapd", file2name($filp))) { - printf("cache_write(%s): cnt %d %s\n", execname(), - $count, file2name($filp)); - } - //printf("cache_write(%s): filp %p cnt %d\n", execname(), $filp, $count); - //printf(" : name %s\n", file2name($filp)); -} -probe module("sunrpc").function("cache_write").return -{ - if ($return < 0) { - printf("cache_write: error %s\n", errno_str($return)); - } else { - printf("cache_write: cnt %d\n", $return); - } -} -probe module("nfsd").function("svc_export_lookup") -{ - printf(" svc_export_lookup: %p\n", $exp); -} -probe module("nfsd").function("svc_export_lookup").return -{ - if ($return > 0) { - printf(" svc_export_lookup: %s\n", svc_export_dump($return)); - } else { - printf(" svc_export_lookup: return %p\n", $return); - } -} -probe module("nfsd").function("svc_export_parse") -{ - printf(" svc_export_parse: cd %p(%s) mlen %d\n", - $cd, kernel_string($cd->name), $mlen); - printf(" %s\n", - svc_export_data(kernel_string($mesg))); -} -probe module("nfsd").function("svc_export_parse").return -{ - if ($return < 0) - printf(" svc_export_parse: error %s\n", errno_str($return)); -} -probe module("nfsd").function("exp_get_by_name") -{ - printf("exp_get_by_name: clp %p mnt %p dentry %p reqp %p\n", - $clp, $mnt, $dentry, $reqp); -} -probe module("nfsd").function("exp_get_by_name").return -{ - printf("exp_get_by_name: return %p\n", $return); -} -probe module("nfsd").function("exp_export") -{ - printf("exp_export: %p\n", $nxp); -} -probe module("nfsd").function("exp_export").return -{ - printf("exp_export: return %p\n", $return); -} -/* -probe module("sunrpc").function("cache_read") -{ - printf("cache_read(%s): %s\n", execname(), file2name($filp)); - //printf("cache_write(%s): filp %p cnt %d\n", execname(), $filp, $count); - //printf(" : name %s\n", file2name($filp)); -} -probe module("sunrpc").function("cache_read").return -{ - if ($return < 0) - printf("cache_read: error %s\n", errno_str($return)); -} -*/ -probe module("nfsd").function("svc_export_parse") -{ - printf(" svc_export_parse: cd %p(%s) mlen %d\n", - $cd, kernel_string($cd->name), $mlen); - printf(" %s\n", - svc_export_data(kernel_string($mesg))); -} -probe module("nfsd").function("svc_export_parse").return -{ - if ($return < 0) - printf(" svc_export_parse: error %s\n", errno_str($return)); -} -probe module("sunrpc").function("ip_map_parse") -{ - printf(" ip_map_parse: cd %p(%s) mlen %d\n", - $cd, kernel_string($cd->name), $mlen); - printf(" %s\n", ip_map_data(kernel_string($mesg))); -} -probe module("sunrpc").function("ip_map_parse").return -{ - if ($return < 0) - printf(" ip_map_parse: error %s\n", errno_str($return)); -} -probe module("nfsd").function("expkey_parse") -{ - printf(" expkey_parse: cd %p(%s) mlen %d\n", - $cd, kernel_string($cd->name), $mlen); - printf(" %s\n", expkey_data(kernel_string($mesg))); -} -probe module("nfsd").function("expkey_parse").return -{ - if ($return < 0) - printf(" expkey_parse: error %s\n", errno_str($return)); -} -/* -probe module("nfsd").function("idtoname_parse") -{ - printf(" idtoname_parse: cd %p(%s) buflen %d\n", - $cd, kernel_string($cd->name), $buflen); - printf(" %s\n", idtoname_data(kernel_string($buf))); -} -probe module("nfsd").function("idtoname_parse").return -{ - if ($return < 0) - printf(" idtoname_parse: error %s\n", errno_str($return)); -} -*/ -probe module("nfsd").function("expkey_request") -{ - printf(" expkey_request: cd %p(%s)\n", - $cd, kernel_string($cd->name)); - //print_stack(backtrace()); - //printf(" %s\n", expkey_data(kernel_string($mesg))); -} -probe module("nfsd").function("check_export") -{ - printf(" check_export: inode %p flags 0x%x uuid %p\n", - $inode, $flags, $uuid); -} -probe module("nfsd").function("check_export").return -{ - if ($return < 0) - printf(" check_export: error %s\n", errno_str($return)); -} -probe begin { log("starting cachio probe") } -probe end { log("ending cachio probe") } diff --git a/exports.stp b/exports.stp deleted file mode 100644 index ec73af8..0000000 --- a/exports.stp +++ /dev/null @@ -1,89 +0,0 @@ -global check_exp, check_rqstp_flavor - -probe module("nfsd").function("exp_pseudoroot") -{ - printf("exp_pseudoroot: rqstp %p fhp %p\n", $rqstp, $fhp); -} -probe module("nfsd").function("exp_pseudoroot").return -{ - printf("exp_pseudoroot: %s\n", nfsderror($return)); -} -/* -probe module("nfsd").function("exp_find") -{ - printf(" exp_find: clp %p fsid %d fsdiv %p\n", - $clp, $fsid_type, $fsidv); -} -probe module("nfsd").function("exp_find").return -{ - printf(" exp_find: %p\n", $return); -} -*/ -probe module("nfsd").function("rqst_exp_find") -{ - printf(" rqst_exp_find: rqstp %p fsid_type %d fsidv %p\n", - $rqstp, $fsid_type, $fsidv); -} -probe module("nfsd").function("rqst_exp_find").return -{ - printf(" rqst_exp_find: %p\n", $return); -} -probe module("nfsd").function("fh_compose") -{ - printf(" fh_compose: fhp %p exp %p dentry %p ref_fh %p\n", - $fhp, $exp, $dentry, $ref_fh); -} -probe module("nfsd").function("fh_compose").return -{ - printf(" fh_compose: %s\n", nfsderror($return)); -} -probe module("nfsd").function("svc_export_lookup") -{ - printf(" svc_export_lookup: %p\n", $exp); -} -probe module("nfsd").function("svc_export_lookup").return -{ - printf(" svc_export_lookup: return %p\n", $return); - if ($return > 0) - printf(" : %s\n", - svc_export_dump($return)); -} -probe module("sunrpc").function("cache_check") -{ - printf(" cache_check: detail %p h %p rqstp %p\n", - $detail, $h, $rqstp); - printf(" : %s\n", cache_head_dump($detail, $h)); -} -probe module("sunrpc").function("cache_check").return -{ - if ($return) - printf(" cache_check: %s\n", errno_str($return)); -} -probe module("sunrpc").function("cache_make_upcall") -{ - printf(" cache_make_upcall: detail %p h %p \n", - $detail, $h); - printf(" : %s\n", cache_head_dump($detail, $h)); -} -probe module("sunrpc").function("cache_make_upcall").return -{ - if ($return) - printf(" cache_make_upcall: %s\n", errno_str($return)); -} -/* -probe module("nfsd").function("check_nfsd_access") -{ - check_exp = $exp; - check_rqstp_flavor = $rqstp->rq_flavor; -} -probe module("nfsd").function("check_nfsd_access").return -{ - if ($return != 0) { - printf(" check_nfsd_access: %s\n", nfsderror($return)); - printf(" : rq_flavor %d %s\n", - check_rqstp_flavor, svc_export_flavors(check_exp)); - } -} -*/ -probe begin { log("starting exports probe") } -probe end { log("ending exports probe") } diff --git a/ext3calltimes b/ext3calltimes deleted file mode 100755 index 675c9ab..0000000 --- a/ext3calltimes +++ /dev/null @@ -1,160 +0,0 @@ -#!/bin/bash -do_sort=0 -sort_ave=0 -sort_cnt=0 -sort_min=0 -sort_max=0 -sort_tot=0 -show_all=1 -pname="" -verbose="" -function usage { - echo "Usage: ext3calltimes [-Aachnmtv]" - echo " -A - Do all possible sorting" - echo " -a - sort by Ave ns" - echo " -c - sort by Count" - echo " -n - sort by Min ns" - echo " -m - sort by Max ns" - echo " -p - process name to monitor" - echo " -t - sort by Total ns" - echo " -v - turn on SystemTap debugging" - echo " -h - print this help text" -} -while getopts Aachnmp:tv option; do - case $option in - A) sort_ave=1; sort_cnt=1; sort_min=1; - sort_max=1; sort_tot=1; do_sort=1;; - a) sort_ave=1; do_sort=1;; - c) sort_cnt=1; do_sort=1 ;; - n) sort_min=1; do_sort=1 ;; - m) sort_max=1; do_sort=1 ;; - p) pname=$OPTARG;; - t) sort_tot=1; do_sort=1 ;; - v) verbose="-v "$verbose ;; - h|?|*) usage - exit 1;; - esac -done - -if [ $do_sort -eq 1 ]; then - show_all=0 -fi -echo "Creating and building SystemTap module..." - -stap "$verbose" -e ' -global timebyfunc, top -global start, pname_str - -probe begin { - pname_str = "'$pname'" - if (pname_str != "") { - printf("Collecting ext3 data on '%s' - type Ctrl-C to print output and exit...\n", pname_str); - } else - printf("Collecting ext3 data - type Ctrl-C to print output and exit...\n") -} - -probe module("ext3").function("*@fs/ext3/*") -{ - if (pname_str != "") { - if (execname() == pname_str) - start[probefunc(), tid()] = gettimeofday_ns() - } else - start[probefunc(), tid()] = gettimeofday_ns() -} -probe module("ext3").function("*@fs/ext3/*").return -{ - if (!([probefunc(), tid()] in start)) next - - delta = gettimeofday_ns() - start[probefunc(), tid()] - timebyfunc[probefunc()] <<< delta - - delete start[probefunc(), tid()] -} -function print_header() { - printf("%-26s %10s %12s %12s %12s %12s\n", - "Call", "Count", "Total ns", - "Avg ns", "Min ns", "Max ns") -} -probe end { - if ('$sort_ave' != 0) { - printf("\nSorted ext3 data by Avg ns \n") - print_header() - foreach (call in timebyfunc) - top[call] = @avg(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$sort_cnt' != 0) { - printf("\nSorted ext3 data by Count\n") - print_header() - foreach (call in timebyfunc) - top[call] = @count(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$sort_tot' != 0) { - printf("\nSorted ext3 data by Total ns\n") - print_header() - foreach (call in timebyfunc) - top[call] = @sum(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$sort_min' != 0) { - printf("\nSorted ext3 data by Min ns\n") - print_header() - foreach (call in timebyfunc) - top[call] = @min(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$sort_max' != 0) { - printf("\nSorted ext3 data by Max ns\n") - print_header() - foreach (call in timebyfunc) - top[call] = @min(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$show_all' != 0) { - print_header() - foreach (call in timebyfunc) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - } - delete timebyfunc -}' diff --git a/funccount.sh b/funccount.sh deleted file mode 100755 index 0ba1ee4..0000000 --- a/funccount.sh +++ /dev/null @@ -1,57 +0,0 @@ -#!/bin/bash -pname="" -verbose="" - -function usage { - echo "Usage: funccount [process]" -} -if [ $# -eq 1 ]; then - pname=$1 -fi - -echo "Creating and building SystemTap module..." - -stap "$verbose" -e ' -global timebyfunc, pages, page_sz -global start, pname_str, totcalls - -probe begin { - pname_str = "'$pname'" - printf("Collecting data for %s - type Ctrl-C to print output and exit...\n", pname_str); -} - -probe kernel.function("mpage_readpages") -{ - if ($nr_pages && execname() == pname_str) { - start[$nr_pages] = gettimeofday_ns() - pages=$nr_pages - } -} -probe kernel.function("mpage_readpages").return -{ - if (pages == 0) - next - - delta = gettimeofday_ns() - start[pages] - timebyfunc[pages] <<< delta - page_sz[pages] = pages - - delete start[pages] - pages=0 -} -function print_header() { - printf("%-19s %10s %12s\n", - "Call", "Count", "Total ns") -} -probe end { - print_header() - foreach (page in page_sz-) { - printf("mpage_readpages(%d) %10d %12d\n", page_sz[page], - @count(timebyfunc[page]), @sum(timebyfunc[page])) - totcalls += @count(timebyfunc[page]) - } - printf("Total Calls: %d\n", totcalls); - - delete page_sz - delete timebyfunc -}' diff --git a/kernelcalltimes b/kernelcalltimes deleted file mode 100755 index 0f88caf..0000000 --- a/kernelcalltimes +++ /dev/null @@ -1,177 +0,0 @@ -#!/bin/bash -do_sort=0 -sort_ave=0 -sort_cnt=0 -sort_min=0 -sort_max=0 -sort_tot=0 -show_all=1 -pname="" -verbose="" -function usage { - echo "Usage: ext3calltimes [-Aachnmtv]" - echo " -A - Do all possible sorting" - echo " -a - sort by Ave ns" - echo " -c - sort by Count" - echo " -n - sort by Min ns" - echo " -m - sort by Max ns" - echo " -p - process name to monitor" - echo " -t - sort by Total ns" - echo " -v - turn on SystemTap debugging" - echo " -h - print this help text" -} -while getopts Aachnmp:tv option; do - case $option in - A) sort_ave=1; sort_cnt=1; sort_min=1; - sort_max=1; sort_tot=1; do_sort=1;; - a) sort_ave=1; do_sort=1;; - c) sort_cnt=1; do_sort=1 ;; - n) sort_min=1; do_sort=1 ;; - m) sort_max=1; do_sort=1 ;; - p) pname=$OPTARG;; - t) sort_tot=1; do_sort=1 ;; - v) verbose="-v "$verbose ;; - h|?|*) usage - exit 1;; - esac -done - -if [ $do_sort -eq 1 ]; then - show_all=0 -fi -echo "Creating and building SystemTap module..." - -stap "$verbose" -e ' -global timebyfunc, top -global start, pname_str - -probe begin { - pname_str = "'$pname'" - if (pname_str != "") { - printf("Collecting ext3 data on '%s' - type Ctrl-C to print output and exit...\n", pname_str); - } else - printf("Collecting ext3 data - type Ctrl-C to print output and exit...\n") -} - -probe kernel.function("*@mm/readahead.c") -{ - if (pname_str != "") { - if (execname() == pname_str) - start[probefunc(), tid()] = gettimeofday_ns() - } else - start[probefunc(), tid()] = gettimeofday_ns() -} -probe kernel.function("*@mm/readahead.c").return -{ - if (!([probefunc(), tid()] in start)) next - - delta = gettimeofday_ns() - start[probefunc(), tid()] - timebyfunc[probefunc()] <<< delta - - delete start[probefunc(), tid()] -} -probe kernel.function("*@mm/filemap.c") -{ - if (pname_str != "") { - if (execname() == pname_str) - start[probefunc(), tid()] = gettimeofday_ns() - } else - start[probefunc(), tid()] = gettimeofday_ns() -} -probe kernel.function("*@mm/filemap.c").return -{ - if (!([probefunc(), tid()] in start)) next - - delta = gettimeofday_ns() - start[probefunc(), tid()] - timebyfunc[probefunc()] <<< delta - - delete start[probefunc(), tid()] -} -function print_header() { - printf("%-26s %10s %12s %12s %12s %12s\n", - "Call", "Count", "Total ns", - "Avg ns", "Min ns", "Max ns") -} -probe end { - if ('$sort_ave' != 0) { - printf("\nSorted ext3 data by Avg ns \n") - print_header() - foreach (call in timebyfunc) - top[call] = @avg(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$sort_cnt' != 0) { - printf("\nSorted ext3 data by Count\n") - print_header() - foreach (call in timebyfunc) - top[call] = @count(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$sort_tot' != 0) { - printf("\nSorted ext3 data by Total ns\n") - print_header() - foreach (call in timebyfunc) - top[call] = @sum(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$sort_min' != 0) { - printf("\nSorted ext3 data by Min ns\n") - print_header() - foreach (call in timebyfunc) - top[call] = @min(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$sort_max' != 0) { - printf("\nSorted ext3 data by Max ns\n") - print_header() - foreach (call in timebyfunc) - top[call] = @min(timebyfunc[call]) - foreach (call in top- limit 20) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - delete top - } - if ('$show_all' != 0) { - print_header() - foreach (call in timebyfunc) - printf("%-26s %10d %12d %12d %12d %12d\n", call, - @count(timebyfunc[call]), - @sum(timebyfunc[call]), - @avg(timebyfunc[call]), - @min(timebyfunc[call]), - @max(timebyfunc[call])) - } - delete timebyfunc -}' diff --git a/lockd/lockd_listener.stp b/lockd/lockd_listener.stp new file mode 100644 index 0000000..ff845e6 --- /dev/null +++ b/lockd/lockd_listener.stp @@ -0,0 +1,61 @@ +probe module("lockd").function("create_lockd_listener") +{ + printf("create_lockd_listener: serv [%s] name %s port %d\n", + svc_serv_dump($serv), kernel_string($name), $port); +} +probe module("lockd").function("create_lockd_listener").return +{ + if ($return) + printf("svc_export_show: error %d\n", $return); +} +probe module("sunrpc").function("svc_find_xprt").return +{ + printf("svc_find_xprt: %p\n", $return); +} +/* +probe module("sunrpc").function("__svc_xpo_create").return +{ + printf("svc_find_xprt: %p\n", $return); +} +*/ +probe module("sunrpc").function("svc_xprt_local_port").return +{ + printf("svc_find_xprt: %d\n", $return); +} +probe module("sunrpc").function("svc_create_socket").return +{ + printf("svc_create_socket: %p\n", $return); +} +probe module("sunrpc").function("svc_setup_socket").return +{ + printf("svc_create_socket: %p\n", $return); +} +probe kernel.function("kernel_bind").return +{ + if ($return) + printf("kernel_bind: %d\n", $return); +} +probe kernel.function("sock_create_kern").return +{ + if ($return) + printf("sock_create_kern: %d\n", $return); +} +probe kernel.function("__sock_create").return +{ + if ($return) + printf("__sock_create: %d\n", $return); +} +probe kernel.function("kernel_getsockname").return +{ + if ($return) + printf("kernel_getsockname: %d\n", $return); +} +probe kernel.function("kernel_listen").return +{ + if ($return) + printf("kernel_listen: %d\n", $return); +} + +probe begin { log("starting create_lockd_listener probe") } +probe end { log("ending create_lockd_listener probe") } + diff --git a/lockd_listener.stp b/lockd_listener.stp deleted file mode 100644 index ff845e6..0000000 --- a/lockd_listener.stp +++ /dev/null @@ -1,61 +0,0 @@ -probe module("lockd").function("create_lockd_listener") -{ - printf("create_lockd_listener: serv [%s] name %s port %d\n", - svc_serv_dump($serv), kernel_string($name), $port); -} -probe module("lockd").function("create_lockd_listener").return -{ - if ($return) - printf("svc_export_show: error %d\n", $return); -} -probe module("sunrpc").function("svc_find_xprt").return -{ - printf("svc_find_xprt: %p\n", $return); -} -/* -probe module("sunrpc").function("__svc_xpo_create").return -{ - printf("svc_find_xprt: %p\n", $return); -} -*/ -probe module("sunrpc").function("svc_xprt_local_port").return -{ - printf("svc_find_xprt: %d\n", $return); -} -probe module("sunrpc").function("svc_create_socket").return -{ - printf("svc_create_socket: %p\n", $return); -} -probe module("sunrpc").function("svc_setup_socket").return -{ - printf("svc_create_socket: %p\n", $return); -} -probe kernel.function("kernel_bind").return -{ - if ($return) - printf("kernel_bind: %d\n", $return); -} -probe kernel.function("sock_create_kern").return -{ - if ($return) - printf("sock_create_kern: %d\n", $return); -} -probe kernel.function("__sock_create").return -{ - if ($return) - printf("__sock_create: %d\n", $return); -} -probe kernel.function("kernel_getsockname").return -{ - if ($return) - printf("kernel_getsockname: %d\n", $return); -} -probe kernel.function("kernel_listen").return -{ - if ($return) - printf("kernel_listen: %d\n", $return); -} - -probe begin { log("starting create_lockd_listener probe") } -probe end { log("ending create_lockd_listener probe") } - diff --git a/mnt.stp b/mnt.stp deleted file mode 100644 index 7a6df87..0000000 --- a/mnt.stp +++ /dev/null @@ -1,14 +0,0 @@ -probe module("nfs").function("nfs_compare_mount_options") -{ - printf("nfs_compare_mount_options: a %p b %p\n", $a, $b); - printf("clnt %p/%p\n", $a->nfs_client, $b->nfs_client); - printf("flags %x/%x\n", $a->flags, $b->flags); - printf("wsize %d/%d\n", $a->wsize, $b->wsize); - printf("rsize %d/%d\n", $a->rsize, $b->rsize); - printf("acregmin %d/%d\n", $a->acregmin, $b->acregmin); - printf("acregmax %d/%d\n", $a->acregmax, $b->acregmax); - printf("acdirmin %d/%d\n", $a->acdirmin, $b->acdirmin); - printf("acdirmax %d/%d\n", $a->acdirmax, $b->acdirmax); -} -probe begin { log("starting probe") } -probe end { log("ending probe") } diff --git a/net/inet_bind.stp b/net/inet_bind.stp new file mode 100644 index 0000000..621473a --- /dev/null +++ b/net/inet_bind.stp @@ -0,0 +1,102 @@ +%{ +#include +#include +#include +%} + +function _inet_ntoa:string (_uaddr:long) %{ + struct sockaddr_in *addr; + unsigned char *bytes; + + addr = (struct sockaddr_in *)(long)kread(&THIS->_uaddr); + bytes = (unsigned char *)&addr->sin_addr.s_addr; + + snprintf(THIS->__retvalue, MAXSTRINGLEN, + "%d.%d.%d.%d:%d", bytes[0], bytes[1], bytes[2], bytes[3], + addr->sin_port); + + CATCH_DEREF_FAULT(); +%} +function _socket_dump:string (_sock:long) %{ + struct socket *sock; + + sock = (struct socket *)(long)kread(&THIS->_sock); + snprintf(THIS->__retvalue, MAXSTRINGLEN, + "state %d type %d", sock->state, sock->type); + + CATCH_DEREF_FAULT(); +%} +function _sock_dump:string (_sk:long) %{ + struct sock *sk; + + sk = (struct sock *)(long)kread(&THIS->_sk); + snprintf(THIS->__retvalue, MAXSTRINGLEN, + "reuse %d state %d", sk->sk_reuse, sk->sk_state); + + CATCH_DEREF_FAULT(); +%} +function _tb_dump:string (_tp:long) %{ + struct inet_bind_bucket *tp; + + tp = (struct inet_bind_bucket *)(long)kread(&THIS->_tp); + snprintf(THIS->__retvalue, MAXSTRINGLEN, + "port %d fastreuse %d", tp->port, tp->fastreuse); + + CATCH_DEREF_FAULT(); +%} + +probe kernel.function("inet_bind") { + if (isinstr(execname(), "rpc.nfsd")) { + printf("inet_bind(%s): socket [%s] uaddr %s addr_len %d\n", + execname(), _socket_dump($sock), _inet_ntoa($uaddr), $addr_len); + } +} +probe kernel.function("inet_bind").return { + if (isinstr(execname(), "rpc.nfsd")) + printf("inet_bind: return %d (%s)\n", $return, errno_str($return)); +} +probe kernel.function("inet_listen") { + if (isinstr(execname(), "rpc.nfsd")) { + printf("inet_listen(%s): socket [%s] backlog %d\n", + execname(), _socket_dump($sock), $backlog); + } +} +probe kernel.function("inet_listen").return { + if (isinstr(execname(), "rpc.nfsd")) + printf("inet_listen: return %d (%s)\n", $return, errno_str($return)); +} +probe kernel.function("udp_v4_get_port") { + if (isinstr(execname(), "rpc.nfsd")) { + printf(" udp_v4_get_port(%s): sock %p snum %d\n", + execname(), $sk, $snum); + } +} +probe kernel.function("udp_v4_get_port").return { + if (isinstr(execname(), "rpc.nfsd")) + printf(" udp_v4_get_port: return %d (%s)\n", + $return, errno_str($return)); +} +probe kernel.function("tcp_v4_get_port") { + if (isinstr(execname(), "rpc.nfsd")) { + printf(" tcp_v4_get_port(%s): sock [%s] snum %d\n", + execname(), _sock_dump($sk), $snum); + } +} +probe kernel.function("tcp_v4_get_port").return { + if (isinstr(execname(), "rpc.nfsd")) + printf(" tcp_v4_get_port: return %d (%s)\n", + $return, errno_str($return)); +} +probe kernel.function("inet_csk_bind_conflict") { + if (isinstr(execname(), "rpc.nfsd")) { + printf(" bind_conflict(%s): sock [%s] tb [%s]\n", + execname(), _sock_dump($sk), _tb_dump($tb)); + } +} +probe kernel.function("inet_csk_bind_conflict").return { + if (isinstr(execname(), "rpc.nfsd")) + printf(" bind_conflict: return %d (%s)\n", + $return, errno_str($return)); +} +probe begin { log("starting inet_bind probe") } +probe end { log("ending inet_bind probe") } diff --git a/net/ipv6_bind.stp b/net/ipv6_bind.stp new file mode 100644 index 0000000..2a9db1c --- /dev/null +++ b/net/ipv6_bind.stp @@ -0,0 +1,58 @@ +probe syscall.bind +{ + printf("sys_bind: %s\n", argstr); +} +probe syscall.bind.return +{ + if ($return) + printf("sys_bind: (%s)\n", retstr); +} +probe module("ipv6").function("inet6_bind") +{ + printf(" inet6_bind: %s\n %s\n %s\n", + struct_socket($sock), struct_sock($sock->sk), struct_sockaddr($uaddr, $addr_len)); +} +probe module("ipv6").function("inet6_bind").return +{ + if ($return) + printf(" inet6_bind: %d (%s)\n", $return, errno_str($return)); +} +probe module("ipv6").function("tcp_v6_get_port") +{ + printf(" tcp_v6_get_port: sk %p\n", $sk); +} +probe module("ipv6").function("tcp_v6_get_port").return +{ + if ($return) + printf(" tcp_v6_get_port: %d (%s)\n", $return, errno_str($return)); +} +probe module("ipv6").function("inet6_csk_bind_conflict") +{ + printf(" inet6_csk_bind_conflict: sk %p\n", $sk); +} +probe module("ipv6").function("inet6_csk_bind_conflict").return +{ + if ($return) + printf(" inet6_csk_bind_conflict: %d (%s)\n", $return, errno_str($return)); +} +probe module("ipv6").function("ipv6_rcv_saddr_equal") +{ + printf(" ipv6_rcv_saddr_equal: sk %p sk2 %p\n", $sk, $sk2); +} +probe module("ipv6").function("ipv6_rcv_saddr_equal").return +{ + if ($return) + printf(" ipv6_rcv_saddr_equal: %d (%s)\n", $return, errno_str($return)); +} +probe kernel.function("inet_bind") +{ + printf(" inet_bind: %s\n %s\n %s\n", + struct_socket($sock), struct_sock($sock->sk), struct_sockaddr($uaddr, $addr_len)); +} +probe kernel.function("inet_bind").return +{ + if ($return) + printf(" inet_bind: %d (%s)\n", $return, errno_str($return)); +} +probe begin { log("starting bind probe") } +probe end { log("ending bind probe") } diff --git a/nfs/nfs4_lck.stp b/nfs/nfs4_lck.stp new file mode 100644 index 0000000..b170a95 --- /dev/null +++ b/nfs/nfs4_lck.stp @@ -0,0 +1,131 @@ +global __posix_lock_file_conf_inode + +probe kernel.function("__posix_lock_file_conf") +{ + __posix_lock_file_conf_inode = $inode +} +probe kernel.function("__posix_lock_file_conf").return +{ + if ($return) + printf(" __posix_lock_file_conf: inode %p %d\n", __posix_lock_file_conf_inode, $return); +} +probe module("nfs").function("do_vfs_lock") +{ + printf(" do_vfs_lock: file %s fl_flags %x (%s) fl_type %d\n", file2name($file), $fl->fl_flags, + (($fl->fl_flags & (1|2)) == 1 ? "POSIX" : "FLOCK"), $fl->fl_type); +} +probe module("nfs").function("do_vfs_lock").return +{ + if ($return) + printf(" do_vfs_lock: %d\n", $return); +} +probe module("nfs").function("nfs4_proc_getlk") +{ + printf("nfs4_proc_getlk: state %d cmd %d request %p\n", $state, $cmd, $request); +} +probe module("nfs").function("nfs4_proc_getlk").return +{ + printf("nfs4_proc_getlk: %d\n", $return); +} +probe module("nfs").function("nfs4_lock_reclaim") +{ + printf("nfs4_lock_reclaim: state %d request %p\n", $state, $request); +} +probe module("nfs").function("nfs4_lock_reclaim").return +{ + printf("nfs4_lock_reclaim: %d\n", $return); +} +probe module("nfs").function("_nfs4_proc_setlk") +{ + printf("_nfs4_proc_setlk: state 0x%x cmd %d request %p\n", $state, $cmd, $request); +} +probe module("nfs").function("_nfs4_proc_setlk").return +{ + if ($return) + printf("_nfs4_proc_setlk: %d\n", $return); +} +probe module("nfs").function("nfs4_proc_setlk") +{ + printf("nfs4_proc_setlk: state 0x%x cmd %d request %p\n", $state, $cmd, $request); +} +probe module("nfs").function("nfs4_proc_setlk").return +{ + if ($return) + printf("nfs4_proc_setlk: %d\n", $return); +} + +probe module("nfs").function("nfs4_proc_lock") +{ + printf("nfs4_proc_lock: file 0x%x(%s) cmd %d request %p\n", $filp, file2name($filp), + $cmd, $request); +} +probe module("nfs").function("nfs4_proc_lock").return +{ + printf("nfs4_proc_lock: %d\n", $return); +} +probe module("nfs").function("nfs4_lock_delegation_recall") +{ + printf("nfs4_lock_delegation_recall: state %d fl %p\n", $state, $fl); +} +probe module("nfs").function("nfs4_lock_delegation_recall").return +{ + printf("nfs4_lock_delegation_recall: %d\n", $return); +} +probe module("nfs").function("_nfs4_do_setlk") +{ + printf(" _nfs4_do_setlk: state %d cmd %d fl %p reclaim %d\n", $state, $cmd, $fl, $reclaim); +} +probe module("nfs").function("_nfs4_do_setlk").return +{ + if ($return) + printf(" _nfs4_do_setlk: %d\n", $return); +} +probe module("nfs").function("nfs4_lock_done") +{ + printf(" nfs4_lock_done: task 0x%x status %d calldata %p\n", $task, $task->tk_status, $calldata); +} +probe module("nfs").function("nfs4_lock_expired") +{ + printf("nfs4_lock_expired: state %d request %p\n", $state, $request); +} +probe module("nfs").function("nfs4_lock_expired").return +{ + printf("nfs4_lock_expired: %d\n", $return); +} +probe module("nfs").function("nfs4_reclaim_open_state") +{ + printf("nfs4_reclaim_open_state: ops 0x%x sp %p\n", $ops, $ops); +} +probe module("nfs").function("nfs4_reclaim_open_state").return +{ + printf("nfs4_reclaim_open_state: %d\n", $return); +} +probe module("nfs").function("nfs4_open_expired") +{ + printf(" nfs4_open_expired: sp %p state %p\n", $sp, $state); +} +probe module("nfs").function("nfs4_open_expired").return +{ + if ($return) + printf(" nfs4_open_expired: %d\n", $return); +} +probe module("nfs").function("nfs4_lock_expired") +{ + printf(" nfs4_lock_expired: state %p request %p\n", $state, $request); +} +probe module("nfs").function("nfs4_lock_expired").return +{ + if ($return) + printf(" nfs4_lock_expired: %d\n", $return); +} +probe module("nfs").function("reclaimer") +{ + printf("nfs reclaimer: clp %p \n", $ptr); +} +probe module("nfs").function("reclaimer").return +{ + printf("nfs reclaimer: %d\n", $return); +} +probe begin { log("starting nfs4_lck probe") } + +probe end { log("ending nfs4_lck probe") } diff --git a/nfs/nfs4_lookup_root.stp b/nfs/nfs4_lookup_root.stp new file mode 100644 index 0000000..592af25 --- /dev/null +++ b/nfs/nfs4_lookup_root.stp @@ -0,0 +1,19 @@ +global lookup_root_fh + +probe module("nfs").function("nfs4_lookup_root") +{ + printf("nfs4_lookup_root: server %p fhandle %p info %p\n", + $server, $fhandle, $info); + lookup_root_fh = $fhandle; +} +probe module("nfs").function("nfs4_lookup_root").return +{ + if ($return) { + printf("nfs4_lookup_root: %d\n", $return); + } else { + printf("nfs4_lookup_root: %s\n", nfsfh(lookup_root_fh)); + } +} + +probe begin { log("starting nfs4_lookup_root probe") } +probe end { log("ending nfs4_lookup_root probe") } diff --git a/nfs/nfs4_xattr.stp b/nfs/nfs4_xattr.stp new file mode 100644 index 0000000..59b2280 --- /dev/null +++ b/nfs/nfs4_xattr.stp @@ -0,0 +1,55 @@ +global nfs4err + +probe kernel.function("vfs_setxattr") +{ + printf("vfs_setxattr: dentry %p name %s buf(%d) %p flags %x\n", + $dentry, kernel_string($name), $size, $value, $flags); +} +probe kernel.function("vfs_setxattr").return +{ + printf("vfs_setxattr: return %d(%s)\n", $return, errno_str($return)); +} +probe module("nfs").function("nfs4_getxattr") +{ + printf("nfs4_getxattr: dentry %p key %s buf(%d) %p\n", + $dentry, kernel_string($key), $buflen, $buf); +} +probe module("nfs").function("nfs4_getxattr").return +{ + printf("nfs4_getxattr: return %d(%s)\n", $return, errno_str($return)); +} +probe module("nfs").function("nfs4_setxattr") +{ + printf("nfs4_setxattr: dentry %p key %s buf(%d) %p flags %x\n", + $dentry, kernel_string($key), $buflen, $buf, $flags); +} +probe module("nfs").function("nfs4_setxattr").return +{ + printf("nfs4_setxattr: return %d(%s)\n", $return, errno_str($return)); +} +probe module("nfs").function("nfs4_xdr_enc_setacl").return +{ + printf("nfs4_xdr_enc_setacl: return %d(%s)\n", $return, errno_str($return)); +} +probe module("nfs").function("nfs4_xdr_dec_setacl").return +{ + printf("nfs4_xdr_dec_setacl: return %d(%s)\n", $return, errno_str($return)); +} +probe module("nfs").function("decode_setattr").return +{ + printf("decode_setattr: return %d(%s)\n", $return, errno_str($return)); +} +probe module("nfs").function("nfs4_stat_to_errno") +{ + nfs4err = $stat; + //printf("nfs4_stat_to_errno: stat %d\n", $stat); + //print_backtrace(); +} +probe module("nfs").function("nfs4_stat_to_errno").return +{ + printf("nfs4_stat_to_errno: %s errno %d(%s)\n", + nfs4error(nfs4err), $return, errno_str($return)); +} + +probe begin { log("starting nfs4_xattr probe") } +probe end { log("ending nfs4_xattr probe") } diff --git a/nfs/nfs_auth.stp b/nfs/nfs_auth.stp new file mode 100644 index 0000000..c7fc739 --- /dev/null +++ b/nfs/nfs_auth.stp @@ -0,0 +1,11 @@ +probe module("auth_rpcgss").function("gss_create") +{ + printf("gss_create: clnt %p flavor %d\n", $clnt, $flavor); +} +probe module("auth_rpcgss").function("gss_create").return +{ + printf("gss_create: %p\n", $return); +} + +probe begin { log("starting nfs_auth probe") } +probe end { log("ending nfs_auth probe") } diff --git a/nfs/nfs_get_sb.stp b/nfs/nfs_get_sb.stp new file mode 100644 index 0000000..fed1c8e --- /dev/null +++ b/nfs/nfs_get_sb.stp @@ -0,0 +1,10 @@ + +probe module("nfs").function("nfs_get_sb") +{ + printf("nfs_get_sb: fs_type %p flags 0x%x dev %p data %p mnt %p\n", + $fs_type, $flags, $dev_name, $raw_data, $mnt); + + printf(" : flags %s\n", nfs_mntflags($raw_data)); +} +probe begin { log("starting probe") } +probe end { log("ending probe") } diff --git a/nfs/nfs_umount.stp b/nfs/nfs_umount.stp new file mode 100644 index 0000000..e5f1164 --- /dev/null +++ b/nfs/nfs_umount.stp @@ -0,0 +1,39 @@ +probe kernel.function("sys_umount") +{ + printf("sys_umount: flags %d\n", $flags); +} +probe kernel.function("sys_umount").return +{ + printf("sys_umount: %d (%s)\n", $return, errno_str($return)); +} +probe kernel.function("deactivate_super") +{ + printf("deactivate_super: sb %p\n", $s); +} +probe kernel.function("sys_umount").return +{ + printf("sys_umount: %d (%s)\n", $return, errno_str($return)); +} +probe module("nfs").function("nfs_kill_super") +{ + printf("nfs_kill_super: super %p\n", $s); +} +probe module("nfs").function("nfs4_kill_super") +{ + printf("nfs4_kill_super: super %p\n", $sb); +} +probe module("nfs").function("nfs_free_server") +{ + printf("nfs_free_server: server %p\n", $server); +} +probe module("nfs").function("nfs_umount_begin") +{ + printf("nfs_umount_begin: vfsmnt %p flags 0x%x\n", $vfsmnt, flags); +} +probe module("sunrpc").function("rpc_killall_tasks") +{ + printf("rpc_killall_tasks: clnt %p\n", $clnt); +} +probe begin { log("starting nfs_umount probe") } +probe end { log("ending nfs_umount probe") } + diff --git a/nfs/nfs_unlink.stp b/nfs/nfs_unlink.stp new file mode 100644 index 0000000..7fc417c --- /dev/null +++ b/nfs/nfs_unlink.stp @@ -0,0 +1,23 @@ +probe module("nfs").function("nfs3_proc_unlink_done") +{ + printf("nfs3_proc_unlink_done: dir %p task %p\n", $dir, $task); +} +probe module("nfs").function("nfs3_proc_unlink_done").return +{ + printf("nfs3_proc_unlink_done: status %d\n", $return); +} +probe module("nfs").function("nfs_async_unlink_init") +{ + printf("nfs_async_unlink_init: task %p calldata %p\n", $task, $calldata); + nfs_unlinkdata($calldata); +} +probe module("nfs").function("nfs_async_unlink_done") +{ + printf("nfs_async_unlink_done: task %p calldata %p\n", $task, $calldata); +} +probe module("nfs").function("nfs_async_unlink_release") +{ + printf("nfs_async_unlink_release: calldata %p\n", $calldata); +} +probe begin { log("starting NFS probe") } +probe end { log("ending NFS probe") } diff --git a/nfs/nfsd_mount_opts.stp b/nfs/nfsd_mount_opts.stp new file mode 100644 index 0000000..cd2ed96 --- /dev/null +++ b/nfs/nfsd_mount_opts.stp @@ -0,0 +1,14 @@ +probe module("nfs").function("nfs_compare_mount_options") +{ + printf("nfs_compare_mount_options: a %p b %p\n", $a, $b); + printf("clnt %p/%p\n", $a->nfs_client, $b->nfs_client); + printf("flags %x/%x\n", $a->flags, $b->flags); + printf("wsize %d/%d\n", $a->wsize, $b->wsize); + printf("rsize %d/%d\n", $a->rsize, $b->rsize); + printf("acregmin %d/%d\n", $a->acregmin, $b->acregmin); + printf("acregmax %d/%d\n", $a->acregmax, $b->acregmax); + printf("acdirmin %d/%d\n", $a->acdirmin, $b->acdirmin); + printf("acdirmax %d/%d\n", $a->acdirmax, $b->acdirmax); +} +probe begin { log("starting nfs_mount_opts") } +probe end { log("ending nfs_mount_opts probe") } diff --git a/nfs4_lck.stp b/nfs4_lck.stp deleted file mode 100644 index b170a95..0000000 --- a/nfs4_lck.stp +++ /dev/null @@ -1,131 +0,0 @@ -global __posix_lock_file_conf_inode - -probe kernel.function("__posix_lock_file_conf") -{ - __posix_lock_file_conf_inode = $inode -} -probe kernel.function("__posix_lock_file_conf").return -{ - if ($return) - printf(" __posix_lock_file_conf: inode %p %d\n", __posix_lock_file_conf_inode, $return); -} -probe module("nfs").function("do_vfs_lock") -{ - printf(" do_vfs_lock: file %s fl_flags %x (%s) fl_type %d\n", file2name($file), $fl->fl_flags, - (($fl->fl_flags & (1|2)) == 1 ? "POSIX" : "FLOCK"), $fl->fl_type); -} -probe module("nfs").function("do_vfs_lock").return -{ - if ($return) - printf(" do_vfs_lock: %d\n", $return); -} -probe module("nfs").function("nfs4_proc_getlk") -{ - printf("nfs4_proc_getlk: state %d cmd %d request %p\n", $state, $cmd, $request); -} -probe module("nfs").function("nfs4_proc_getlk").return -{ - printf("nfs4_proc_getlk: %d\n", $return); -} -probe module("nfs").function("nfs4_lock_reclaim") -{ - printf("nfs4_lock_reclaim: state %d request %p\n", $state, $request); -} -probe module("nfs").function("nfs4_lock_reclaim").return -{ - printf("nfs4_lock_reclaim: %d\n", $return); -} -probe module("nfs").function("_nfs4_proc_setlk") -{ - printf("_nfs4_proc_setlk: state 0x%x cmd %d request %p\n", $state, $cmd, $request); -} -probe module("nfs").function("_nfs4_proc_setlk").return -{ - if ($return) - printf("_nfs4_proc_setlk: %d\n", $return); -} -probe module("nfs").function("nfs4_proc_setlk") -{ - printf("nfs4_proc_setlk: state 0x%x cmd %d request %p\n", $state, $cmd, $request); -} -probe module("nfs").function("nfs4_proc_setlk").return -{ - if ($return) - printf("nfs4_proc_setlk: %d\n", $return); -} - -probe module("nfs").function("nfs4_proc_lock") -{ - printf("nfs4_proc_lock: file 0x%x(%s) cmd %d request %p\n", $filp, file2name($filp), - $cmd, $request); -} -probe module("nfs").function("nfs4_proc_lock").return -{ - printf("nfs4_proc_lock: %d\n", $return); -} -probe module("nfs").function("nfs4_lock_delegation_recall") -{ - printf("nfs4_lock_delegation_recall: state %d fl %p\n", $state, $fl); -} -probe module("nfs").function("nfs4_lock_delegation_recall").return -{ - printf("nfs4_lock_delegation_recall: %d\n", $return); -} -probe module("nfs").function("_nfs4_do_setlk") -{ - printf(" _nfs4_do_setlk: state %d cmd %d fl %p reclaim %d\n", $state, $cmd, $fl, $reclaim); -} -probe module("nfs").function("_nfs4_do_setlk").return -{ - if ($return) - printf(" _nfs4_do_setlk: %d\n", $return); -} -probe module("nfs").function("nfs4_lock_done") -{ - printf(" nfs4_lock_done: task 0x%x status %d calldata %p\n", $task, $task->tk_status, $calldata); -} -probe module("nfs").function("nfs4_lock_expired") -{ - printf("nfs4_lock_expired: state %d request %p\n", $state, $request); -} -probe module("nfs").function("nfs4_lock_expired").return -{ - printf("nfs4_lock_expired: %d\n", $return); -} -probe module("nfs").function("nfs4_reclaim_open_state") -{ - printf("nfs4_reclaim_open_state: ops 0x%x sp %p\n", $ops, $ops); -} -probe module("nfs").function("nfs4_reclaim_open_state").return -{ - printf("nfs4_reclaim_open_state: %d\n", $return); -} -probe module("nfs").function("nfs4_open_expired") -{ - printf(" nfs4_open_expired: sp %p state %p\n", $sp, $state); -} -probe module("nfs").function("nfs4_open_expired").return -{ - if ($return) - printf(" nfs4_open_expired: %d\n", $return); -} -probe module("nfs").function("nfs4_lock_expired") -{ - printf(" nfs4_lock_expired: state %p request %p\n", $state, $request); -} -probe module("nfs").function("nfs4_lock_expired").return -{ - if ($return) - printf(" nfs4_lock_expired: %d\n", $return); -} -probe module("nfs").function("reclaimer") -{ - printf("nfs reclaimer: clp %p \n", $ptr); -} -probe module("nfs").function("reclaimer").return -{ - printf("nfs reclaimer: %d\n", $return); -} -probe begin { log("starting nfs4_lck probe") } - -probe end { log("ending nfs4_lck probe") } diff --git a/nfs4_lookup_root.stp b/nfs4_lookup_root.stp deleted file mode 100644 index 592af25..0000000 --- a/nfs4_lookup_root.stp +++ /dev/null @@ -1,19 +0,0 @@ -global lookup_root_fh - -probe module("nfs").function("nfs4_lookup_root") -{ - printf("nfs4_lookup_root: server %p fhandle %p info %p\n", - $server, $fhandle, $info); - lookup_root_fh = $fhandle; -} -probe module("nfs").function("nfs4_lookup_root").return -{ - if ($return) { - printf("nfs4_lookup_root: %d\n", $return); - } else { - printf("nfs4_lookup_root: %s\n", nfsfh(lookup_root_fh)); - } -} - -probe begin { log("starting nfs4_lookup_root probe") } -probe end { log("ending nfs4_lookup_root probe") } diff --git a/nfs4_xattr.stp b/nfs4_xattr.stp deleted file mode 100644 index 59b2280..0000000 --- a/nfs4_xattr.stp +++ /dev/null @@ -1,55 +0,0 @@ -global nfs4err - -probe kernel.function("vfs_setxattr") -{ - printf("vfs_setxattr: dentry %p name %s buf(%d) %p flags %x\n", - $dentry, kernel_string($name), $size, $value, $flags); -} -probe kernel.function("vfs_setxattr").return -{ - printf("vfs_setxattr: return %d(%s)\n", $return, errno_str($return)); -} -probe module("nfs").function("nfs4_getxattr") -{ - printf("nfs4_getxattr: dentry %p key %s buf(%d) %p\n", - $dentry, kernel_string($key), $buflen, $buf); -} -probe module("nfs").function("nfs4_getxattr").return -{ - printf("nfs4_getxattr: return %d(%s)\n", $return, errno_str($return)); -} -probe module("nfs").function("nfs4_setxattr") -{ - printf("nfs4_setxattr: dentry %p key %s buf(%d) %p flags %x\n", - $dentry, kernel_string($key), $buflen, $buf, $flags); -} -probe module("nfs").function("nfs4_setxattr").return -{ - printf("nfs4_setxattr: return %d(%s)\n", $return, errno_str($return)); -} -probe module("nfs").function("nfs4_xdr_enc_setacl").return -{ - printf("nfs4_xdr_enc_setacl: return %d(%s)\n", $return, errno_str($return)); -} -probe module("nfs").function("nfs4_xdr_dec_setacl").return -{ - printf("nfs4_xdr_dec_setacl: return %d(%s)\n", $return, errno_str($return)); -} -probe module("nfs").function("decode_setattr").return -{ - printf("decode_setattr: return %d(%s)\n", $return, errno_str($return)); -} -probe module("nfs").function("nfs4_stat_to_errno") -{ - nfs4err = $stat; - //printf("nfs4_stat_to_errno: stat %d\n", $stat); - //print_backtrace(); -} -probe module("nfs").function("nfs4_stat_to_errno").return -{ - printf("nfs4_stat_to_errno: %s errno %d(%s)\n", - nfs4error(nfs4err), $return, errno_str($return)); -} - -probe begin { log("starting nfs4_xattr probe") } -probe end { log("ending nfs4_xattr probe") } diff --git a/nfs_auth.stp b/nfs_auth.stp deleted file mode 100644 index c7fc739..0000000 --- a/nfs_auth.stp +++ /dev/null @@ -1,11 +0,0 @@ -probe module("auth_rpcgss").function("gss_create") -{ - printf("gss_create: clnt %p flavor %d\n", $clnt, $flavor); -} -probe module("auth_rpcgss").function("gss_create").return -{ - printf("gss_create: %p\n", $return); -} - -probe begin { log("starting nfs_auth probe") } -probe end { log("ending nfs_auth probe") } diff --git a/nfs_get_sb.stp b/nfs_get_sb.stp deleted file mode 100644 index fed1c8e..0000000 --- a/nfs_get_sb.stp +++ /dev/null @@ -1,10 +0,0 @@ - -probe module("nfs").function("nfs_get_sb") -{ - printf("nfs_get_sb: fs_type %p flags 0x%x dev %p data %p mnt %p\n", - $fs_type, $flags, $dev_name, $raw_data, $mnt); - - printf(" : flags %s\n", nfs_mntflags($raw_data)); -} -probe begin { log("starting probe") } -probe end { log("ending probe") } diff --git a/nfs_umount.stp b/nfs_umount.stp deleted file mode 100644 index e5f1164..0000000 --- a/nfs_umount.stp +++ /dev/null @@ -1,39 +0,0 @@ -probe kernel.function("sys_umount") -{ - printf("sys_umount: flags %d\n", $flags); -} -probe kernel.function("sys_umount").return -{ - printf("sys_umount: %d (%s)\n", $return, errno_str($return)); -} -probe kernel.function("deactivate_super") -{ - printf("deactivate_super: sb %p\n", $s); -} -probe kernel.function("sys_umount").return -{ - printf("sys_umount: %d (%s)\n", $return, errno_str($return)); -} -probe module("nfs").function("nfs_kill_super") -{ - printf("nfs_kill_super: super %p\n", $s); -} -probe module("nfs").function("nfs4_kill_super") -{ - printf("nfs4_kill_super: super %p\n", $sb); -} -probe module("nfs").function("nfs_free_server") -{ - printf("nfs_free_server: server %p\n", $server); -} -probe module("nfs").function("nfs_umount_begin") -{ - printf("nfs_umount_begin: vfsmnt %p flags 0x%x\n", $vfsmnt, flags); -} -probe module("sunrpc").function("rpc_killall_tasks") -{ - printf("rpc_killall_tasks: clnt %p\n", $clnt); -} -probe begin { log("starting nfs_umount probe") } -probe end { log("ending nfs_umount probe") } - diff --git a/nfsd/nfsd4_acl.stp b/nfsd/nfsd4_acl.stp new file mode 100644 index 0000000..e46403f --- /dev/null +++ b/nfsd/nfsd4_acl.stp @@ -0,0 +1,56 @@ +global nfs4err + +probe module("nfsd").function("nfs4_acl_new") +{ + printf("nfs4_acl_new: n %d\n", $n); +} +probe module("nfsd").function("nfs4_acl_new").return +{ + printf("nfs4_acl_new: nfs4_acl * %p \n", $return); +} +probe module("nfsd").function("nfs4_acl_get_whotype") +{ + printf("nfs4_acl_get_whotype: p %p(%s) len %d\n", + $p, kernel_string($p), $len); +} +probe module("nfsd").function("nfs4_acl_get_whotype").return +{ + if ( $return == 0) + printf("nfs4_acl_get_whotype: return NFS4_ACL_WHO_NAMED\n"); + if ( $return == 1) + printf("nfs4_acl_get_whotype: return NFS4_ACL_WHO_OWNER\n"); + if ( $return == 2) + printf("nfs4_acl_get_whotype: return NFS4_ACL_WHO_GROUP\n"); + if ( $return == 3) + printf("nfs4_acl_get_whotype: return NFS4_ACL_WHO_EVERYONE\n"); +} +probe module("nfsd").function("nfs4_acl_write_who") +{ + printf("nfs4_acl_write_who: who %d p %p(%s)\n", + $who, $p, kernel_string($p)); +} +probe module("nfsd").function("nfs4_acl_write_who").return +{ + printf("nfs4_acl_write_who: return %d\n", $return); +} +probe module("nfsd").function("idmap_name_to_id") +{ + printf("idmap_name_to_id: rqstp %d type %d name(%d) %s\n", + $rqstp, $type, $namelen, kernel_string($name)); +} +probe module("nfsd").function("idmap_name_to_id").return +{ + printf("idmap_name_to_id: return %d(%s)\n", $return, errno_str($return)); +} +probe module("nfs").function("nfs4_stat_to_errno") +{ + nfs4err = $stat; +} +probe module("nfs").function("nfs4_stat_to_errno").return +{ + printf("nfs4_stat_to_errno: %s errno %d(%s)\n", + nfs4error(nfs4err), $return, errno_str($return)); +} + +probe begin { log("starting nfsd4_acl probe") } +probe end { log("ending nfsd4_acl probe") } diff --git a/nfsd/nfsd4_callback.stp b/nfsd/nfsd4_callback.stp new file mode 100644 index 0000000..b0defc6 --- /dev/null +++ b/nfsd/nfsd4_callback.stp @@ -0,0 +1,32 @@ +probe module("nfsd").function("nfsd4_probe_callback") +{ + printf("nfsd4_probe_callback: clp %p\n", $clp); +} +probe module("nfsd").function("nfsd4_setclientid_confirm") +{ + printf("nfsd4_setclientid_confirm: hellow\n"); +} +/* +probe module("nfsd").function("*@fs/nfsd/nfs4state.c:3318") +{ + printf("nfsd4_setclientid_confirm: hellow\n"); +} +*/ +probe module("nfsd").function("nfsd4_setclientid_confirm").return +{ + printf("nfsd4_setclientid_confirm: status %d\n", $return); +} +probe module("nfsd").function("nfsd4_process_open2").return +{ + printf("nfsd4_process_open2: status %d\n", $return); +} +probe module("nfsd").function("svc_export_parse").return +{ + printf("svc_export_parse: status %d\n", $return); +} +probe module("sunrpc").function("rpc_exit_task") +{ + printf("rpc_exit_task: task 0x%p\n", $task); +} +probe begin { log("starting probe") } +probe end { log("ending probe") } diff --git a/nfsd/nfsd4_secinfo.stp b/nfsd/nfsd4_secinfo.stp new file mode 100644 index 0000000..aa91a26 --- /dev/null +++ b/nfsd/nfsd4_secinfo.stp @@ -0,0 +1,72 @@ +global check_exp, check_rqstp_flavor + +probe module("nfsd").function("nfsd4_secinfo") +{ + printf("nfsd4_secinfo: rqstp %p fh %p secinfo %p\n", + $rqstp, $current_fh, $secinfo); + printf(" : %s\n", nfsd4_secinfo_dump($secinfo)); +} +probe module("nfsd").function("nfsd4_secinfo").return +{ + printf("nfsd4_secinfo: %s\n", nfsderror($return)); +} +/* +probe module("nfsd").function("nfsd_lookup_dentry") +{ + printf(" nfsd_lookup_dentry: rqstp %p fh %p\n", $rqstp, $fhp); +} +*/ +probe module("nfsd").function("nfsd_lookup_dentry").return +{ + if ($return != 0) + printf(" nfsd_lookup_dentry: %s\n", nfsderror($return)); +} +probe module("nfsd").function("nfsd4_encode_secinfo") +{ + if ($nfserr != 0) { + printf("nfsd4_encode_secinfo: error %s\n", nfsderror($nfserr)); + } else { + printf("nfsd4_encode_secinfo: %s\n", svc_export_flavors($secinfo->si_exp)); + } +} +probe module("nfsd").function("nfsd4_decode_secinfo") +{ + printf("nfsd4_decode_secinfo: argp %p secinfo %p\n", $argp, $secinfo); +} +probe module("nfsd").function("nfsd4_decode_secinfo").return +{ + printf("nfsd4_decode_secinfo: %s\n", nfsderror($return)); +} +probe module("nfsd").function("secinfo_parse") +{ + printf("secinfo_parse: %s\n", svc_export_dump($exp)); +} +probe module("nfsd").function("secinfo_parse").return +{ + printf("secinfo_parse: %s\n", nfsderror($return)); +} +probe module("nfsd").function("nfsd_lookup") +{ + printf("nfsd_lookup: rqstp %p fhp %p name %s\n", + $rqstp, $fhp, kernel_string($name)); +} +probe module("nfsd").function("nfsd_lookup").return +{ + printf("nfsd_lookup: %s\n", nfsderror($return)); +} +probe module("nfsd").function("check_nfsd_access") +{ + check_exp = $exp; + check_rqstp_flavor = $rqstp->rq_flavor; +} +probe module("nfsd").function("check_nfsd_access").return +{ + if ($return != 0) { + printf(" check_nfsd_access: %s\n", nfsderror($return)); + printf(" : rq_flavor %d %s\n", + check_rqstp_flavor, svc_export_flavors(check_exp)); + } +} +probe begin { log("starting nfsd4_secinfo probe") } +probe end { log("ending nfsd4_secinfo probe") } + diff --git a/nfsd/nfsd_auth.stp b/nfsd/nfsd_auth.stp new file mode 100644 index 0000000..6e2b4d2 --- /dev/null +++ b/nfsd/nfsd_auth.stp @@ -0,0 +1,29 @@ +probe module("sunrpc").function("svc_authenticate") +{ + printf("svc_authenticate: rqstp %p authp %p\n", $rqstp, $authp); +} +probe module("sunrpc").function("svc_authenticate").return +{ + printf("svc_authenticate: %s\n", svcerror($return)); +} +probe module("auth_rpcgss").function("svcauth_gss_set_client") +{ + printf("svcauth_gss_set_client: rqstp %p\n", $rqstp); +} +probe module("auth_rpcgss").function("svcauth_gss_set_client").return +{ + printf("svcauth_gss_set_client: %s\n", svcerror($return)); +} +probe module("sunrpc").function("svcauth_unix_set_client") +{ + printf("svcauth_unix_set_client: rqstp %p\n", $rqstp); +} +probe module("sunrpc").function("svcauth_unix_set_client").return +{ + printf("svcauth_unix_set_client: %s\n", svcerror($return)); +} + + +probe begin { log("starting nfsd_auth probe") } +probe end { log("ending nfsd_auth probe") } + diff --git a/nfsd/nfsd_cacheio.stp b/nfsd/nfsd_cacheio.stp new file mode 100644 index 0000000..3dc0a8d --- /dev/null +++ b/nfsd/nfsd_cacheio.stp @@ -0,0 +1,147 @@ +#!/usr/bin/env stap + +probe module("nfsd").function("exp_pseudoroot") +{ + printf("exp_pseudoroot: rqstp %p fhp %p\n", $rqstp, $fhp); +} +probe module("nfsd").function("exp_pseudoroot").return +{ + printf("exp_pseudoroot: %s\n", nfsderror($return)); +} +probe module("sunrpc").function("cache_write") +{ + if (!isinstr("rpc.idmapd", file2name($filp))) { + printf("cache_write(%s): cnt %d %s\n", execname(), + $count, file2name($filp)); + } + //printf("cache_write(%s): filp %p cnt %d\n", execname(), $filp, $count); + //printf(" : name %s\n", file2name($filp)); +} +probe module("sunrpc").function("cache_write").return +{ + if ($return < 0) { + printf("cache_write: error %s\n", errno_str($return)); + } else { + printf("cache_write: cnt %d\n", $return); + } +} +probe module("nfsd").function("svc_export_lookup") +{ + printf(" svc_export_lookup: %p\n", $exp); +} +probe module("nfsd").function("svc_export_lookup").return +{ + if ($return > 0) { + printf(" svc_export_lookup: %s\n", svc_export_dump($return)); + } else { + printf(" svc_export_lookup: return %p\n", $return); + } +} +probe module("nfsd").function("svc_export_parse") +{ + printf(" svc_export_parse: cd %p(%s) mlen %d\n", + $cd, kernel_string($cd->name), $mlen); + printf(" %s\n", + svc_export_data(kernel_string($mesg))); +} +probe module("nfsd").function("svc_export_parse").return +{ + if ($return < 0) + printf(" svc_export_parse: error %s\n", errno_str($return)); +} +probe module("nfsd").function("exp_get_by_name") +{ + printf("exp_get_by_name: clp %p mnt %p dentry %p reqp %p\n", + $clp, $mnt, $dentry, $reqp); +} +probe module("nfsd").function("exp_get_by_name").return +{ + printf("exp_get_by_name: return %p\n", $return); +} +probe module("nfsd").function("exp_export") +{ + printf("exp_export: %p\n", $nxp); +} +probe module("nfsd").function("exp_export").return +{ + printf("exp_export: return %p\n", $return); +} +/* +probe module("sunrpc").function("cache_read") +{ + printf("cache_read(%s): %s\n", execname(), file2name($filp)); + //printf("cache_write(%s): filp %p cnt %d\n", execname(), $filp, $count); + //printf(" : name %s\n", file2name($filp)); +} +probe module("sunrpc").function("cache_read").return +{ + if ($return < 0) + printf("cache_read: error %s\n", errno_str($return)); +} +*/ +probe module("nfsd").function("svc_export_parse") +{ + printf(" svc_export_parse: cd %p(%s) mlen %d\n", + $cd, kernel_string($cd->name), $mlen); + printf(" %s\n", + svc_export_data(kernel_string($mesg))); +} +probe module("nfsd").function("svc_export_parse").return +{ + if ($return < 0) + printf(" svc_export_parse: error %s\n", errno_str($return)); +} +probe module("sunrpc").function("ip_map_parse") +{ + printf(" ip_map_parse: cd %p(%s) mlen %d\n", + $cd, kernel_string($cd->name), $mlen); + printf(" %s\n", ip_map_data(kernel_string($mesg))); +} +probe module("sunrpc").function("ip_map_parse").return +{ + if ($return < 0) + printf(" ip_map_parse: error %s\n", errno_str($return)); +} +probe module("nfsd").function("expkey_parse") +{ + printf(" expkey_parse: cd %p(%s) mlen %d\n", + $cd, kernel_string($cd->name), $mlen); + printf(" %s\n", expkey_data(kernel_string($mesg))); +} +probe module("nfsd").function("expkey_parse").return +{ + if ($return < 0) + printf(" expkey_parse: error %s\n", errno_str($return)); +} +/* +probe module("nfsd").function("idtoname_parse") +{ + printf(" idtoname_parse: cd %p(%s) buflen %d\n", + $cd, kernel_string($cd->name), $buflen); + printf(" %s\n", idtoname_data(kernel_string($buf))); +} +probe module("nfsd").function("idtoname_parse").return +{ + if ($return < 0) + printf(" idtoname_parse: error %s\n", errno_str($return)); +} +*/ +probe module("nfsd").function("expkey_request") +{ + printf(" expkey_request: cd %p(%s)\n", + $cd, kernel_string($cd->name)); + //print_stack(backtrace()); + //printf(" %s\n", expkey_data(kernel_string($mesg))); +} +probe module("nfsd").function("check_export") +{ + printf(" check_export: inode %p flags 0x%x uuid %p\n", + $inode, $flags, $uuid); +} +probe module("nfsd").function("check_export").return +{ + if ($return < 0) + printf(" check_export: error %s\n", errno_str($return)); +} +probe begin { log("starting cachio probe") } +probe end { log("ending cachio probe") } diff --git a/nfsd/nfsd_deleg.stp b/nfsd/nfsd_deleg.stp new file mode 100644 index 0000000..02c7590 --- /dev/null +++ b/nfsd/nfsd_deleg.stp @@ -0,0 +1,48 @@ + +probe module("nfsd").function("nfs4_open_delegation") +{ + printf("nfs4_open_delegation: fh %p open %p (type: %d) stp %d\n", + $fh, $open, $open->op_claim_type, $stp); + printf(" : %s\n", nfs4_callback($stp)); +} +probe module("nfsd").function("alloc_init_deleg") +{ + printf(" alloc_init_deleg: clp %p stp %p current_fh %p, type %d\n", + $clp, $stp, $current_fh, $type); +} +probe module("nfsd").function("alloc_init_deleg").return +{ + printf(" alloc_init_deleg: %p\n", $return); +} +probe kernel.function("setlease") +{ + printf(" setlease: filp %p arg %p\n", $filp, $arg); +} +probe kernel.function("setlease").return +{ + printf(" setlease: return %d (%s)\n", $return, errno_str($return)); +} +/* +probe kernel.function("security_file_lock") +{ + printf(" security_file_lock: filp %p arg %p\n", $filp, $arg); +} +probe kernel.function("security_file_lock").return +{ + printf(" security_file_lock: return %d (%s)\n", + $return, errno_str($return)); +} +*/ +probe kernel.function("__setlease") +{ + printf(" __setlease: filp %p arg %p\n", $filp, $arg); +} +probe kernel.function("__setlease").return +{ + printf(" __setlease: return %d (%s)\n", + $return, errno_str($return)); +} + +probe begin { log("starting nfsd_deleg probe") } +probe end { log("ending nfsd_deleg probe") } + diff --git a/nfsd/nfsd_dispatch.stp b/nfsd/nfsd_dispatch.stp new file mode 100644 index 0000000..15f9e6f --- /dev/null +++ b/nfsd/nfsd_dispatch.stp @@ -0,0 +1,47 @@ +/* +probe module("nfsd").function("nfsd_setattr") +{ + printf("nfsd_setattr: rqstp %p fhp %p iap %p check_guard %d\n", + $rqstp, $fhp, $iap, $check_guard); +} +probe module("nfsd").function("nfsd_setattr").return +{ + printf("nfsd_setattr: %s\n", nfsderror($return)); +} +probe nfsd.dispatch +{ + printf("prog %d proc %d\n", prog, proc); +} +probe nfsd.dispatch.return +{ + printf("return %s\n", retstr); +} +probe nfsd.proc.compound +{ + printf("cnt %d proc %p\n", num, op); +} +global lookupname + +probe nfsd.proc3.lookup +{ + lookupname = filename; + +} +probe nfsd.proc3.lookup.return +{ + printf("nfsd_lookup %s %s\n", lookupname, nfsderror($return)); +} +*/ +probe module("nfsd").function("nfsd4_proc_compound") +{ + printf("nfsd4_proc_compound: %s\n", nfs4ops($args)); +} +probe module("nfsd").function("nfsd4_proc_compound").return +{ + if ($return != 0) + printf("nfsd4_proc_compound: %s\n", nfsderror($return)); +} + +probe begin { log("starting nfsd4_dispatch probe") } +probe end { log("ending nfsd4_dispatch probe") } + diff --git a/nfsd/nfsd_exports.stp b/nfsd/nfsd_exports.stp new file mode 100644 index 0000000..ec73af8 --- /dev/null +++ b/nfsd/nfsd_exports.stp @@ -0,0 +1,89 @@ +global check_exp, check_rqstp_flavor + +probe module("nfsd").function("exp_pseudoroot") +{ + printf("exp_pseudoroot: rqstp %p fhp %p\n", $rqstp, $fhp); +} +probe module("nfsd").function("exp_pseudoroot").return +{ + printf("exp_pseudoroot: %s\n", nfsderror($return)); +} +/* +probe module("nfsd").function("exp_find") +{ + printf(" exp_find: clp %p fsid %d fsdiv %p\n", + $clp, $fsid_type, $fsidv); +} +probe module("nfsd").function("exp_find").return +{ + printf(" exp_find: %p\n", $return); +} +*/ +probe module("nfsd").function("rqst_exp_find") +{ + printf(" rqst_exp_find: rqstp %p fsid_type %d fsidv %p\n", + $rqstp, $fsid_type, $fsidv); +} +probe module("nfsd").function("rqst_exp_find").return +{ + printf(" rqst_exp_find: %p\n", $return); +} +probe module("nfsd").function("fh_compose") +{ + printf(" fh_compose: fhp %p exp %p dentry %p ref_fh %p\n", + $fhp, $exp, $dentry, $ref_fh); +} +probe module("nfsd").function("fh_compose").return +{ + printf(" fh_compose: %s\n", nfsderror($return)); +} +probe module("nfsd").function("svc_export_lookup") +{ + printf(" svc_export_lookup: %p\n", $exp); +} +probe module("nfsd").function("svc_export_lookup").return +{ + printf(" svc_export_lookup: return %p\n", $return); + if ($return > 0) + printf(" : %s\n", + svc_export_dump($return)); +} +probe module("sunrpc").function("cache_check") +{ + printf(" cache_check: detail %p h %p rqstp %p\n", + $detail, $h, $rqstp); + printf(" : %s\n", cache_head_dump($detail, $h)); +} +probe module("sunrpc").function("cache_check").return +{ + if ($return) + printf(" cache_check: %s\n", errno_str($return)); +} +probe module("sunrpc").function("cache_make_upcall") +{ + printf(" cache_make_upcall: detail %p h %p \n", + $detail, $h); + printf(" : %s\n", cache_head_dump($detail, $h)); +} +probe module("sunrpc").function("cache_make_upcall").return +{ + if ($return) + printf(" cache_make_upcall: %s\n", errno_str($return)); +} +/* +probe module("nfsd").function("check_nfsd_access") +{ + check_exp = $exp; + check_rqstp_flavor = $rqstp->rq_flavor; +} +probe module("nfsd").function("check_nfsd_access").return +{ + if ($return != 0) { + printf(" check_nfsd_access: %s\n", nfsderror($return)); + printf(" : rq_flavor %d %s\n", + check_rqstp_flavor, svc_export_flavors(check_exp)); + } +} +*/ +probe begin { log("starting exports probe") } +probe end { log("ending exports probe") } diff --git a/nfsd/nfsd_fh.stp b/nfsd/nfsd_fh.stp new file mode 100644 index 0000000..7c7fdbe --- /dev/null +++ b/nfsd/nfsd_fh.stp @@ -0,0 +1,101 @@ +#!/usr/bin/env stap + +global _putfh_cstate, _putrootfh_cstate, pseudoroot_cstate + +probe module("nfsd").function("nfsd4_putrootfh") +{ + _putrootfh_cstate = $cstate; +} +probe module("nfsd").function("nfsd4_putrootfh").return +{ + if ($return) { + printf("nfsd4_putrootfh: %s\n", nfsderror($return)); + } else { + printf("nfsd4_putrootfh: %s\n", cstate_pr(_putrootfh_cstate)); + } +} +probe module("nfsd").function("exp_pseudoroot") +{ + /* + printf("exp_pseudoroot: rqstp %p fhp %p\n", $rqstp, $fhp); + */ + pseudoroot_cstate = $fhp; +} +probe module("nfsd").function("exp_pseudoroot").return +{ + if ($return) { + printf("exp_pseudoroot: %s\n", nfsderror($return)); + } else { + printf("exp_pseudoroot: %s\n", svcfhfmt(pseudoroot_cstate)); + } +} +probe module("nfsd").function("nfsd4_putfh") +{ + printf("nfsd4_putfh: rqstp %p cstate %p putfh %p\n", + $rqstp, $cstate, $putfh); + _putfh_cstate = $cstate; +} +probe module("nfsd").function("nfsd4_putfh").return +{ + if ($return) { + printf("nfsd4_putfh: %s\n", nfsderror($return)); + } else { + printf("nfsd4_putfh: %s\n", cstate_pr(_putfh_cstate)); + } +} +probe module("nfsd").function("nfsd4_getfh") +{ + printf("nfsd4_getfh: rqstp %p cstate %p \n", $rqstp, $cstate); + printf(" %s\n", cstate_pr($cstate)); +} +probe module("nfsd").function("nfsd4_getfh").return +{ + printf("nfsd4_getfh: %s\n", nfsderror($return)); +} +probe module("nfsd").function("fh_verify") +{ + printf(" fh_verify: rqstp %p fhp %p type %d access %d\n", + $rqstp, $fhp, $type, $access); + printf(" %s\n", svcfhfmt($fhp)); +} +probe module("nfsd").function("fh_verify").return +{ + printf(" fh_verify: %s\n", nfsderror($return)); +} +probe module("nfsd").function("fh_compose") +{ + printf(" fh_compose: fhp %p exp %p dentry %p ref_fh %p\n", + $fhp, $exp, $dentry, $ref_fh); + printf(" : %s\n", svc_export_dump($exp)); +} +probe module("nfsd").function("fh_compose").return +{ + printf(" fh_compose: %s\n", nfsderror($return)); +} +probe module("nfsd").function("rqst_exp_find") +{ + printf(" rqst_exp_find: rqstp %p fsid_type %d fsidv %p\n", + $rqstp, $fsid_type, $fsidv); +} +probe module("nfsd").function("rqst_exp_find").return +{ + if ($return != 0) + printf(" rqst_exp_find: %p\n", $return); +} +/* +probe module("nfsd").function("exp_find_key").return +{ + printf("exp_find_key: %p\n", $return); +} +probe module("nfsd").function("exp_get_by_name").return +{ + printf("exp_get_by_name: %p\n", $return); +} +probe module("nfsd").function("svc_expkey_lookup").return +{ + printf("svc_expkey_lookup: %p\n", $return); +} +*/ +probe begin { log("starting nfsd_fh probe") } +probe end { log("ending nfsd_fh probe") } + diff --git a/nfsd/nfsd_lookup.stp b/nfsd/nfsd_lookup.stp new file mode 100644 index 0000000..1c9e9b4 --- /dev/null +++ b/nfsd/nfsd_lookup.stp @@ -0,0 +1,100 @@ +global check_exp, check_rqstp_flavor + +probe module("nfsd").function("nfsd_lookup") +{ + printf("nfsd_lookup: rqstp %p fhp %p name %s\n", + $rqstp, $fhp, kernel_string($name)); +} +probe module("nfsd").function("nfsd_lookup").return +{ + if ($return) + printf("nfsd_lookup: %s\n", nfsderror($return)); +} +probe module("nfsd").function("nfsd_lookup_dentry").return +{ + if ($return != 0) + printf(" nfsd_lookup_dentry: %s\n", nfsderror($return)); +} +probe module("nfsd").function("check_nfsd_access") +{ + check_exp = $exp; + check_rqstp_flavor = $rqstp->rq_flavor; +} +probe module("nfsd").function("check_nfsd_access").return +{ + if ($return != 0) { + printf(" check_nfsd_access: %s\n", nfsderror($return)); + printf(" : rq_flavor %d %s\n", + check_rqstp_flavor, svc_export_flavors(check_exp)); + } +} +probe module("nfsd").function("fh_verify") +{ + printf(" fh_verify: rqstp %p fhp %p type %d access %d\n", + $rqstp, $fhp, $type, $access); + printf(" %s\n", svcfhfmt($fhp)); +} +probe module("nfsd").function("fh_verify").return +{ + if ($return) + printf(" fh_verify: %s\n", nfsderror($return)); +} +probe module("nfsd").function("nfsd_setuser_and_check_port") +{ + printf(" nfsd_setuser_and_check_port: rqstp %p exp %p \n", + $rqstp, $exp); +} +probe module("nfsd").function("nfsd_setuser_and_check_port").return +{ + if ($return) + printf(" nfsd_setuser_and_check_port: %s\n", nfsderror($return)); +} +probe module("nfsd").function("check_nfsd_access") +{ + printf(" check_nfsd_access: rqstp %p exp %p \n", + $rqstp, $exp); +} +probe module("nfsd").function("check_nfsd_access").return +{ + if ($return) + printf(" check_nfsd_access: %s\n", nfsderror($return)); +} +probe module("nfsd").function("rqst_exp_parent") +{ + printf(" rqst_exp_parent: rqstp %p mnt %d dentry %d\n", + $rqstp, $mnt, $dentry); +} +probe module("nfsd").function("rqst_exp_parent").return +{ + printf(" rqst_exp_parent: %p\n", $return); +} +probe kernel.function("lookup_one_len") +{ + printf(" lookup_one_len: name %p dentry %p len %d\n", + $name, $base, $len); +} +probe kernel.function("lookup_one_len").return +{ + printf(" lookup_one_len: %p\n", $return); +} +probe module("nfsd").function("nfsd_cross_mnt") +{ + printf(" nfsd_cross_mnt: rqstp %p\n", $rqstp); +} +probe module("nfsd").function("nfsd_cross_mnt").return +{ + if ($return) + printf(" nfsd_cross_mnt: %s\n", nfsderror($return)); +} +probe module("nfsd").function("rqst_exp_get_by_name") +{ + printf(" rqst_exp_get_by_name: rqstp %p mnt %p dentry %p\n", + $rqstp, $mnt, $dentry); +} +probe module("nfsd").function("rqst_exp_get_by_name").return +{ + printf(" rqst_exp_get_by_name: %p\n", $return); +} +probe begin { log("starting nfsd_lookup probe") } +probe end { log("ending nfsd_lookup probe") } + diff --git a/nfsd/nfsd_permission.stp b/nfsd/nfsd_permission.stp new file mode 100644 index 0000000..7e27ca5 --- /dev/null +++ b/nfsd/nfsd_permission.stp @@ -0,0 +1,16 @@ +#!/usr/bin/env stap + +probe module("nfsd").function("nfsd_permission") +{ + printf("nfsd_permission: rqstp %p exp %p dentry %p acc 0x%x\n", + $rqstp, $exp, $dentry, $acc); + printf(" : %s\n", svc_export_dump($exp)); +} +probe module("nfsd").function("nfsd_permission").return +{ + printf("nfsd_permission: %s\n", nfsderror($return)); +} +probe begin { log("starting nfsd_permission probe") } +probe end { log("ending nfsd_permission probe") } + + diff --git a/nfsd/nfsd_setattr.stp b/nfsd/nfsd_setattr.stp new file mode 100644 index 0000000..b0cd7e0 --- /dev/null +++ b/nfsd/nfsd_setattr.stp @@ -0,0 +1,19 @@ +#!/usr/bin/env stap + +probe module("nfsd").function("nfsd_setattr") +{ + printf("nfsd_setattr: rqstp %p fhp %p iap %p check_guard %d\n", + $rqstp, $fhp, $iap, $check_guard); +} +probe module("nfsd").function("nfsd_setattr").return +{ + printf("nfsd_setattr: %s\n", nfsderror($return)); +} +probe module("nfsd").function("fh_verify").return +{ + if ($return) + printf(" fh_verify: %s\n", nfsderror($return)); +} +probe begin { log("starting nfsd_setattr probe") } +probe end { log("ending nfsd_setattr probe") } + diff --git a/nfsd/svc_export.stp b/nfsd/svc_export.stp new file mode 100644 index 0000000..eb36538 --- /dev/null +++ b/nfsd/svc_export.stp @@ -0,0 +1,49 @@ +probe module("nfsd").function("svc_export_show") +{ + printf("svc_export_show: m 0x%p cd 0x%p h 0x%p\n", $m, $cd, $h); +} +probe module("nfsd").function("svc_export_show").return +{ + if ($return) + printf("svc_export_show: %s\n", nfsderror($return)); +} + +probe module("nfsd").function("export_update") +{ + printf("export_update: cnew 0x%p citem 0x%p\n", $cnew, $citem); +} + +probe module("nfsd").function("svc_export_match") +{ + printf("svc_export_match: a 0x%p b 0x%p\n", $a, $b); +} +probe module("nfsd").function("svc_export_match").return +{ + printf("svc_export_match: %d\n", $return); +} +probe module("nfsd").function("svc_export_request") +{ + printf("svc_export_request: cd 0x%p h 0x%p\n", $cd, $h); +} +probe module("nfsd").function("svc_export_put") +{ + printf("svc_export_put: ref 0x%p \n", $ref); +} +probe module("nfsd").function("svc_export_parse") +{ + printf(" svc_export_parse: cd %p(%s) mlen %d\n", + $cd, kernel_string($cd->name), $mlen); + printf(" %s\n", + svc_export_data(kernel_string($mesg))); +} +probe module("nfsd").function("svc_export_parse").return +{ + if ($return < 0) { + printf(" svc_export_parse: error %s\n", errno_str($return)); + } else { + printf(" svc_export_parse: count %d\n", $return); + } +} +probe begin { log("starting svc_export probe") } +probe end { log("ending svc_export probe") } + diff --git a/nfsd4_acl.stp b/nfsd4_acl.stp deleted file mode 100644 index e46403f..0000000 --- a/nfsd4_acl.stp +++ /dev/null @@ -1,56 +0,0 @@ -global nfs4err - -probe module("nfsd").function("nfs4_acl_new") -{ - printf("nfs4_acl_new: n %d\n", $n); -} -probe module("nfsd").function("nfs4_acl_new").return -{ - printf("nfs4_acl_new: nfs4_acl * %p \n", $return); -} -probe module("nfsd").function("nfs4_acl_get_whotype") -{ - printf("nfs4_acl_get_whotype: p %p(%s) len %d\n", - $p, kernel_string($p), $len); -} -probe module("nfsd").function("nfs4_acl_get_whotype").return -{ - if ( $return == 0) - printf("nfs4_acl_get_whotype: return NFS4_ACL_WHO_NAMED\n"); - if ( $return == 1) - printf("nfs4_acl_get_whotype: return NFS4_ACL_WHO_OWNER\n"); - if ( $return == 2) - printf("nfs4_acl_get_whotype: return NFS4_ACL_WHO_GROUP\n"); - if ( $return == 3) - printf("nfs4_acl_get_whotype: return NFS4_ACL_WHO_EVERYONE\n"); -} -probe module("nfsd").function("nfs4_acl_write_who") -{ - printf("nfs4_acl_write_who: who %d p %p(%s)\n", - $who, $p, kernel_string($p)); -} -probe module("nfsd").function("nfs4_acl_write_who").return -{ - printf("nfs4_acl_write_who: return %d\n", $return); -} -probe module("nfsd").function("idmap_name_to_id") -{ - printf("idmap_name_to_id: rqstp %d type %d name(%d) %s\n", - $rqstp, $type, $namelen, kernel_string($name)); -} -probe module("nfsd").function("idmap_name_to_id").return -{ - printf("idmap_name_to_id: return %d(%s)\n", $return, errno_str($return)); -} -probe module("nfs").function("nfs4_stat_to_errno") -{ - nfs4err = $stat; -} -probe module("nfs").function("nfs4_stat_to_errno").return -{ - printf("nfs4_stat_to_errno: %s errno %d(%s)\n", - nfs4error(nfs4err), $return, errno_str($return)); -} - -probe begin { log("starting nfsd4_acl probe") } -probe end { log("ending nfsd4_acl probe") } diff --git a/nfsd4_secinfo.stp b/nfsd4_secinfo.stp deleted file mode 100644 index aa91a26..0000000 --- a/nfsd4_secinfo.stp +++ /dev/null @@ -1,72 +0,0 @@ -global check_exp, check_rqstp_flavor - -probe module("nfsd").function("nfsd4_secinfo") -{ - printf("nfsd4_secinfo: rqstp %p fh %p secinfo %p\n", - $rqstp, $current_fh, $secinfo); - printf(" : %s\n", nfsd4_secinfo_dump($secinfo)); -} -probe module("nfsd").function("nfsd4_secinfo").return -{ - printf("nfsd4_secinfo: %s\n", nfsderror($return)); -} -/* -probe module("nfsd").function("nfsd_lookup_dentry") -{ - printf(" nfsd_lookup_dentry: rqstp %p fh %p\n", $rqstp, $fhp); -} -*/ -probe module("nfsd").function("nfsd_lookup_dentry").return -{ - if ($return != 0) - printf(" nfsd_lookup_dentry: %s\n", nfsderror($return)); -} -probe module("nfsd").function("nfsd4_encode_secinfo") -{ - if ($nfserr != 0) { - printf("nfsd4_encode_secinfo: error %s\n", nfsderror($nfserr)); - } else { - printf("nfsd4_encode_secinfo: %s\n", svc_export_flavors($secinfo->si_exp)); - } -} -probe module("nfsd").function("nfsd4_decode_secinfo") -{ - printf("nfsd4_decode_secinfo: argp %p secinfo %p\n", $argp, $secinfo); -} -probe module("nfsd").function("nfsd4_decode_secinfo").return -{ - printf("nfsd4_decode_secinfo: %s\n", nfsderror($return)); -} -probe module("nfsd").function("secinfo_parse") -{ - printf("secinfo_parse: %s\n", svc_export_dump($exp)); -} -probe module("nfsd").function("secinfo_parse").return -{ - printf("secinfo_parse: %s\n", nfsderror($return)); -} -probe module("nfsd").function("nfsd_lookup") -{ - printf("nfsd_lookup: rqstp %p fhp %p name %s\n", - $rqstp, $fhp, kernel_string($name)); -} -probe module("nfsd").function("nfsd_lookup").return -{ - printf("nfsd_lookup: %s\n", nfsderror($return)); -} -probe module("nfsd").function("check_nfsd_access") -{ - check_exp = $exp; - check_rqstp_flavor = $rqstp->rq_flavor; -} -probe module("nfsd").function("check_nfsd_access").return -{ - if ($return != 0) { - printf(" check_nfsd_access: %s\n", nfsderror($return)); - printf(" : rq_flavor %d %s\n", - check_rqstp_flavor, svc_export_flavors(check_exp)); - } -} -probe begin { log("starting nfsd4_secinfo probe") } -probe end { log("ending nfsd4_secinfo probe") } - diff --git a/nfsd_auth.stp b/nfsd_auth.stp deleted file mode 100644 index 6e2b4d2..0000000 --- a/nfsd_auth.stp +++ /dev/null @@ -1,29 +0,0 @@ -probe module("sunrpc").function("svc_authenticate") -{ - printf("svc_authenticate: rqstp %p authp %p\n", $rqstp, $authp); -} -probe module("sunrpc").function("svc_authenticate").return -{ - printf("svc_authenticate: %s\n", svcerror($return)); -} -probe module("auth_rpcgss").function("svcauth_gss_set_client") -{ - printf("svcauth_gss_set_client: rqstp %p\n", $rqstp); -} -probe module("auth_rpcgss").function("svcauth_gss_set_client").return -{ - printf("svcauth_gss_set_client: %s\n", svcerror($return)); -} -probe module("sunrpc").function("svcauth_unix_set_client") -{ - printf("svcauth_unix_set_client: rqstp %p\n", $rqstp); -} -probe module("sunrpc").function("svcauth_unix_set_client").return -{ - printf("svcauth_unix_set_client: %s\n", svcerror($return)); -} - - -probe begin { log("starting nfsd_auth probe") } -probe end { log("ending nfsd_auth probe") } - diff --git a/nfsd_deleg.stp b/nfsd_deleg.stp deleted file mode 100644 index 02c7590..0000000 --- a/nfsd_deleg.stp +++ /dev/null @@ -1,48 +0,0 @@ - -probe module("nfsd").function("nfs4_open_delegation") -{ - printf("nfs4_open_delegation: fh %p open %p (type: %d) stp %d\n", - $fh, $open, $open->op_claim_type, $stp); - printf(" : %s\n", nfs4_callback($stp)); -} -probe module("nfsd").function("alloc_init_deleg") -{ - printf(" alloc_init_deleg: clp %p stp %p current_fh %p, type %d\n", - $clp, $stp, $current_fh, $type); -} -probe module("nfsd").function("alloc_init_deleg").return -{ - printf(" alloc_init_deleg: %p\n", $return); -} -probe kernel.function("setlease") -{ - printf(" setlease: filp %p arg %p\n", $filp, $arg); -} -probe kernel.function("setlease").return -{ - printf(" setlease: return %d (%s)\n", $return, errno_str($return)); -} -/* -probe kernel.function("security_file_lock") -{ - printf(" security_file_lock: filp %p arg %p\n", $filp, $arg); -} -probe kernel.function("security_file_lock").return -{ - printf(" security_file_lock: return %d (%s)\n", - $return, errno_str($return)); -} -*/ -probe kernel.function("__setlease") -{ - printf(" __setlease: filp %p arg %p\n", $filp, $arg); -} -probe kernel.function("__setlease").return -{ - printf(" __setlease: return %d (%s)\n", - $return, errno_str($return)); -} - -probe begin { log("starting nfsd_deleg probe") } -probe end { log("ending nfsd_deleg probe") } - diff --git a/nfsd_dispatch.stp b/nfsd_dispatch.stp deleted file mode 100644 index 15f9e6f..0000000 --- a/nfsd_dispatch.stp +++ /dev/null @@ -1,47 +0,0 @@ -/* -probe module("nfsd").function("nfsd_setattr") -{ - printf("nfsd_setattr: rqstp %p fhp %p iap %p check_guard %d\n", - $rqstp, $fhp, $iap, $check_guard); -} -probe module("nfsd").function("nfsd_setattr").return -{ - printf("nfsd_setattr: %s\n", nfsderror($return)); -} -probe nfsd.dispatch -{ - printf("prog %d proc %d\n", prog, proc); -} -probe nfsd.dispatch.return -{ - printf("return %s\n", retstr); -} -probe nfsd.proc.compound -{ - printf("cnt %d proc %p\n", num, op); -} -global lookupname - -probe nfsd.proc3.lookup -{ - lookupname = filename; - -} -probe nfsd.proc3.lookup.return -{ - printf("nfsd_lookup %s %s\n", lookupname, nfsderror($return)); -} -*/ -probe module("nfsd").function("nfsd4_proc_compound") -{ - printf("nfsd4_proc_compound: %s\n", nfs4ops($args)); -} -probe module("nfsd").function("nfsd4_proc_compound").return -{ - if ($return != 0) - printf("nfsd4_proc_compound: %s\n", nfsderror($return)); -} - -probe begin { log("starting nfsd4_dispatch probe") } -probe end { log("ending nfsd4_dispatch probe") } - diff --git a/nfsd_fh.stp b/nfsd_fh.stp deleted file mode 100644 index 7c7fdbe..0000000 --- a/nfsd_fh.stp +++ /dev/null @@ -1,101 +0,0 @@ -#!/usr/bin/env stap - -global _putfh_cstate, _putrootfh_cstate, pseudoroot_cstate - -probe module("nfsd").function("nfsd4_putrootfh") -{ - _putrootfh_cstate = $cstate; -} -probe module("nfsd").function("nfsd4_putrootfh").return -{ - if ($return) { - printf("nfsd4_putrootfh: %s\n", nfsderror($return)); - } else { - printf("nfsd4_putrootfh: %s\n", cstate_pr(_putrootfh_cstate)); - } -} -probe module("nfsd").function("exp_pseudoroot") -{ - /* - printf("exp_pseudoroot: rqstp %p fhp %p\n", $rqstp, $fhp); - */ - pseudoroot_cstate = $fhp; -} -probe module("nfsd").function("exp_pseudoroot").return -{ - if ($return) { - printf("exp_pseudoroot: %s\n", nfsderror($return)); - } else { - printf("exp_pseudoroot: %s\n", svcfhfmt(pseudoroot_cstate)); - } -} -probe module("nfsd").function("nfsd4_putfh") -{ - printf("nfsd4_putfh: rqstp %p cstate %p putfh %p\n", - $rqstp, $cstate, $putfh); - _putfh_cstate = $cstate; -} -probe module("nfsd").function("nfsd4_putfh").return -{ - if ($return) { - printf("nfsd4_putfh: %s\n", nfsderror($return)); - } else { - printf("nfsd4_putfh: %s\n", cstate_pr(_putfh_cstate)); - } -} -probe module("nfsd").function("nfsd4_getfh") -{ - printf("nfsd4_getfh: rqstp %p cstate %p \n", $rqstp, $cstate); - printf(" %s\n", cstate_pr($cstate)); -} -probe module("nfsd").function("nfsd4_getfh").return -{ - printf("nfsd4_getfh: %s\n", nfsderror($return)); -} -probe module("nfsd").function("fh_verify") -{ - printf(" fh_verify: rqstp %p fhp %p type %d access %d\n", - $rqstp, $fhp, $type, $access); - printf(" %s\n", svcfhfmt($fhp)); -} -probe module("nfsd").function("fh_verify").return -{ - printf(" fh_verify: %s\n", nfsderror($return)); -} -probe module("nfsd").function("fh_compose") -{ - printf(" fh_compose: fhp %p exp %p dentry %p ref_fh %p\n", - $fhp, $exp, $dentry, $ref_fh); - printf(" : %s\n", svc_export_dump($exp)); -} -probe module("nfsd").function("fh_compose").return -{ - printf(" fh_compose: %s\n", nfsderror($return)); -} -probe module("nfsd").function("rqst_exp_find") -{ - printf(" rqst_exp_find: rqstp %p fsid_type %d fsidv %p\n", - $rqstp, $fsid_type, $fsidv); -} -probe module("nfsd").function("rqst_exp_find").return -{ - if ($return != 0) - printf(" rqst_exp_find: %p\n", $return); -} -/* -probe module("nfsd").function("exp_find_key").return -{ - printf("exp_find_key: %p\n", $return); -} -probe module("nfsd").function("exp_get_by_name").return -{ - printf("exp_get_by_name: %p\n", $return); -} -probe module("nfsd").function("svc_expkey_lookup").return -{ - printf("svc_expkey_lookup: %p\n", $return); -} -*/ -probe begin { log("starting nfsd_fh probe") } -probe end { log("ending nfsd_fh probe") } - diff --git a/nfsd_lookup.stp b/nfsd_lookup.stp deleted file mode 100644 index 1c9e9b4..0000000 --- a/nfsd_lookup.stp +++ /dev/null @@ -1,100 +0,0 @@ -global check_exp, check_rqstp_flavor - -probe module("nfsd").function("nfsd_lookup") -{ - printf("nfsd_lookup: rqstp %p fhp %p name %s\n", - $rqstp, $fhp, kernel_string($name)); -} -probe module("nfsd").function("nfsd_lookup").return -{ - if ($return) - printf("nfsd_lookup: %s\n", nfsderror($return)); -} -probe module("nfsd").function("nfsd_lookup_dentry").return -{ - if ($return != 0) - printf(" nfsd_lookup_dentry: %s\n", nfsderror($return)); -} -probe module("nfsd").function("check_nfsd_access") -{ - check_exp = $exp; - check_rqstp_flavor = $rqstp->rq_flavor; -} -probe module("nfsd").function("check_nfsd_access").return -{ - if ($return != 0) { - printf(" check_nfsd_access: %s\n", nfsderror($return)); - printf(" : rq_flavor %d %s\n", - check_rqstp_flavor, svc_export_flavors(check_exp)); - } -} -probe module("nfsd").function("fh_verify") -{ - printf(" fh_verify: rqstp %p fhp %p type %d access %d\n", - $rqstp, $fhp, $type, $access); - printf(" %s\n", svcfhfmt($fhp)); -} -probe module("nfsd").function("fh_verify").return -{ - if ($return) - printf(" fh_verify: %s\n", nfsderror($return)); -} -probe module("nfsd").function("nfsd_setuser_and_check_port") -{ - printf(" nfsd_setuser_and_check_port: rqstp %p exp %p \n", - $rqstp, $exp); -} -probe module("nfsd").function("nfsd_setuser_and_check_port").return -{ - if ($return) - printf(" nfsd_setuser_and_check_port: %s\n", nfsderror($return)); -} -probe module("nfsd").function("check_nfsd_access") -{ - printf(" check_nfsd_access: rqstp %p exp %p \n", - $rqstp, $exp); -} -probe module("nfsd").function("check_nfsd_access").return -{ - if ($return) - printf(" check_nfsd_access: %s\n", nfsderror($return)); -} -probe module("nfsd").function("rqst_exp_parent") -{ - printf(" rqst_exp_parent: rqstp %p mnt %d dentry %d\n", - $rqstp, $mnt, $dentry); -} -probe module("nfsd").function("rqst_exp_parent").return -{ - printf(" rqst_exp_parent: %p\n", $return); -} -probe kernel.function("lookup_one_len") -{ - printf(" lookup_one_len: name %p dentry %p len %d\n", - $name, $base, $len); -} -probe kernel.function("lookup_one_len").return -{ - printf(" lookup_one_len: %p\n", $return); -} -probe module("nfsd").function("nfsd_cross_mnt") -{ - printf(" nfsd_cross_mnt: rqstp %p\n", $rqstp); -} -probe module("nfsd").function("nfsd_cross_mnt").return -{ - if ($return) - printf(" nfsd_cross_mnt: %s\n", nfsderror($return)); -} -probe module("nfsd").function("rqst_exp_get_by_name") -{ - printf(" rqst_exp_get_by_name: rqstp %p mnt %p dentry %p\n", - $rqstp, $mnt, $dentry); -} -probe module("nfsd").function("rqst_exp_get_by_name").return -{ - printf(" rqst_exp_get_by_name: %p\n", $return); -} -probe begin { log("starting nfsd_lookup probe") } -probe end { log("ending nfsd_lookup probe") } - diff --git a/nfsd_permission.stp b/nfsd_permission.stp deleted file mode 100644 index 7e27ca5..0000000 --- a/nfsd_permission.stp +++ /dev/null @@ -1,16 +0,0 @@ -#!/usr/bin/env stap - -probe module("nfsd").function("nfsd_permission") -{ - printf("nfsd_permission: rqstp %p exp %p dentry %p acc 0x%x\n", - $rqstp, $exp, $dentry, $acc); - printf(" : %s\n", svc_export_dump($exp)); -} -probe module("nfsd").function("nfsd_permission").return -{ - printf("nfsd_permission: %s\n", nfsderror($return)); -} -probe begin { log("starting nfsd_permission probe") } -probe end { log("ending nfsd_permission probe") } - - diff --git a/nfsd_setattr.stp b/nfsd_setattr.stp deleted file mode 100644 index b0cd7e0..0000000 --- a/nfsd_setattr.stp +++ /dev/null @@ -1,19 +0,0 @@ -#!/usr/bin/env stap - -probe module("nfsd").function("nfsd_setattr") -{ - printf("nfsd_setattr: rqstp %p fhp %p iap %p check_guard %d\n", - $rqstp, $fhp, $iap, $check_guard); -} -probe module("nfsd").function("nfsd_setattr").return -{ - printf("nfsd_setattr: %s\n", nfsderror($return)); -} -probe module("nfsd").function("fh_verify").return -{ - if ($return) - printf(" fh_verify: %s\n", nfsderror($return)); -} -probe begin { log("starting nfsd_setattr probe") } -probe end { log("ending nfsd_setattr probe") } - diff --git a/nfsunlink.stp b/nfsunlink.stp deleted file mode 100644 index 7fc417c..0000000 --- a/nfsunlink.stp +++ /dev/null @@ -1,23 +0,0 @@ -probe module("nfs").function("nfs3_proc_unlink_done") -{ - printf("nfs3_proc_unlink_done: dir %p task %p\n", $dir, $task); -} -probe module("nfs").function("nfs3_proc_unlink_done").return -{ - printf("nfs3_proc_unlink_done: status %d\n", $return); -} -probe module("nfs").function("nfs_async_unlink_init") -{ - printf("nfs_async_unlink_init: task %p calldata %p\n", $task, $calldata); - nfs_unlinkdata($calldata); -} -probe module("nfs").function("nfs_async_unlink_done") -{ - printf("nfs_async_unlink_done: task %p calldata %p\n", $task, $calldata); -} -probe module("nfs").function("nfs_async_unlink_release") -{ - printf("nfs_async_unlink_release: calldata %p\n", $calldata); -} -probe begin { log("starting NFS probe") } -probe end { log("ending NFS probe") } diff --git a/open_namei.stp b/open_namei.stp deleted file mode 100644 index 3dda40a..0000000 --- a/open_namei.stp +++ /dev/null @@ -1,18 +0,0 @@ -function pname:string (name:long) %{ - /*char *pathname = (char *)kread(&(THIS->name)); */ - - deref_string(THIS->__retvalue, THIS->name, MAXSTRINGLEN); - - CATCH_DEREF_FAULT(); -%} -probe kernel.function("open_namei") -{ - /* printf("pathname %s\n", kernel_string($pathname)); */ - printf("pathname %s\n", pname($pathname)); -} -probe kernel.function("open_namei").return -{ - printf("return %d\n", $return); -} -probe begin { log("starting open_namei probe") } -probe end { log("ending open_namei probe") } diff --git a/prob.stp b/prob.stp deleted file mode 100644 index b0defc6..0000000 --- a/prob.stp +++ /dev/null @@ -1,32 +0,0 @@ -probe module("nfsd").function("nfsd4_probe_callback") -{ - printf("nfsd4_probe_callback: clp %p\n", $clp); -} -probe module("nfsd").function("nfsd4_setclientid_confirm") -{ - printf("nfsd4_setclientid_confirm: hellow\n"); -} -/* -probe module("nfsd").function("*@fs/nfsd/nfs4state.c:3318") -{ - printf("nfsd4_setclientid_confirm: hellow\n"); -} -*/ -probe module("nfsd").function("nfsd4_setclientid_confirm").return -{ - printf("nfsd4_setclientid_confirm: status %d\n", $return); -} -probe module("nfsd").function("nfsd4_process_open2").return -{ - printf("nfsd4_process_open2: status %d\n", $return); -} -probe module("nfsd").function("svc_export_parse").return -{ - printf("svc_export_parse: status %d\n", $return); -} -probe module("sunrpc").function("rpc_exit_task") -{ - printf("rpc_exit_task: task 0x%p\n", $task); -} -probe begin { log("starting probe") } -probe end { log("ending probe") } diff --git a/rpc.stp b/rpc.stp deleted file mode 100644 index 03d2bfa..0000000 --- a/rpc.stp +++ /dev/null @@ -1,16 +0,0 @@ -probe module("sunrpc").function("rpc_killall_tasks") -{ - printf("rpc_killall_tasks: clnt %p\n", $clnt); - //print_backtrace(); -} -probe module("sunrpc").function("rpc_shutdown_client") -{ - printf("rpc_shutdown_client: clnt %p\n", $clnt); -} -probe module("sunrpc").function("rpc_release_calldata") -{ - printf("rpc_release_calldata: ops %p calldata %p\n", $ops, $calldata); -} -probe begin { log("starting probe") } -probe end { log("ending probe") } - diff --git a/sunrpc/rpc_killall.stp b/sunrpc/rpc_killall.stp new file mode 100644 index 0000000..7da2eb6 --- /dev/null +++ b/sunrpc/rpc_killall.stp @@ -0,0 +1,16 @@ +probe module("sunrpc").function("rpc_killall_tasks") +{ + printf("rpc_killall_tasks: clnt %p\n", $clnt); + //print_backtrace(); +} +probe module("sunrpc").function("rpc_shutdown_client") +{ + printf("rpc_shutdown_client: clnt %p\n", $clnt); +} +probe module("sunrpc").function("rpc_release_calldata") +{ + printf("rpc_release_calldata: ops %p calldata %p\n", $ops, $calldata); +} +probe begin { log("starting rpc_killall probe") } +probe end { log("ending rpc_killall probe") } + diff --git a/sunrpc/xprt.stp b/sunrpc/xprt.stp new file mode 100644 index 0000000..b6a0c73 --- /dev/null +++ b/sunrpc/xprt.stp @@ -0,0 +1,44 @@ +global xs_task, trans_task, udp_send_task + +probe module("sunrpc").function("xs_connect") +{ + printf("xs_connect: task %p\n", $task); + xs_task = $task; + //print_backtrace(); +} +probe module("sunrpc").function("xs_tcp_connect") +{ + printf("xs_tcp_connect: task %p\n", $task); + //print_backtrace(); + xs_task = $task; +} +probe module("sunrpc").function("xprt_connect_status") +{ + printf("xprt_connect_status: task %p\n", $task); +} +probe module("sunrpc").function("xprt_connect_status").return +{ + printf("xprt_connect_status: %s", task_dump(xs_task)); +} +probe module("sunrpc").function("xprt_transmit") +{ + printf("xprt_transmit: task %p\n", $task); + trans_task = $task; +} +probe module("sunrpc").function("xprt_transmit").return +{ + printf("xprt_transmit: %s", task_dump(trans_task)); +} +probe module("sunrpc").function("xs_udp_send_request") +{ + printf("xs_udp_send_request: task %p\n", $task); + udp_send_task = $task; +} +probe module("sunrpc").function("xs_udp_send_request").return +{ + if ($return) + printf("xs_udp_send_request: %d (%s)\n", $return, errno_str($return)); +} +probe begin { log("starting xprt probe") } +probe end { log("ending xprt probe") } + diff --git a/svc_export.stp b/svc_export.stp deleted file mode 100644 index eb36538..0000000 --- a/svc_export.stp +++ /dev/null @@ -1,49 +0,0 @@ -probe module("nfsd").function("svc_export_show") -{ - printf("svc_export_show: m 0x%p cd 0x%p h 0x%p\n", $m, $cd, $h); -} -probe module("nfsd").function("svc_export_show").return -{ - if ($return) - printf("svc_export_show: %s\n", nfsderror($return)); -} - -probe module("nfsd").function("export_update") -{ - printf("export_update: cnew 0x%p citem 0x%p\n", $cnew, $citem); -} - -probe module("nfsd").function("svc_export_match") -{ - printf("svc_export_match: a 0x%p b 0x%p\n", $a, $b); -} -probe module("nfsd").function("svc_export_match").return -{ - printf("svc_export_match: %d\n", $return); -} -probe module("nfsd").function("svc_export_request") -{ - printf("svc_export_request: cd 0x%p h 0x%p\n", $cd, $h); -} -probe module("nfsd").function("svc_export_put") -{ - printf("svc_export_put: ref 0x%p \n", $ref); -} -probe module("nfsd").function("svc_export_parse") -{ - printf(" svc_export_parse: cd %p(%s) mlen %d\n", - $cd, kernel_string($cd->name), $mlen); - printf(" %s\n", - svc_export_data(kernel_string($mesg))); -} -probe module("nfsd").function("svc_export_parse").return -{ - if ($return < 0) { - printf(" svc_export_parse: error %s\n", errno_str($return)); - } else { - printf(" svc_export_parse: count %d\n", $return); - } -} -probe begin { log("starting svc_export probe") } -probe end { log("ending svc_export probe") } - diff --git a/sys/open_namei.stp b/sys/open_namei.stp new file mode 100644 index 0000000..3dda40a --- /dev/null +++ b/sys/open_namei.stp @@ -0,0 +1,18 @@ +function pname:string (name:long) %{ + /*char *pathname = (char *)kread(&(THIS->name)); */ + + deref_string(THIS->__retvalue, THIS->name, MAXSTRINGLEN); + + CATCH_DEREF_FAULT(); +%} +probe kernel.function("open_namei") +{ + /* printf("pathname %s\n", kernel_string($pathname)); */ + printf("pathname %s\n", pname($pathname)); +} +probe kernel.function("open_namei").return +{ + printf("return %d\n", $return); +} +probe begin { log("starting open_namei probe") } +probe end { log("ending open_namei probe") } diff --git a/sys/sysmount.stp b/sys/sysmount.stp new file mode 100644 index 0000000..24a5190 --- /dev/null +++ b/sys/sysmount.stp @@ -0,0 +1,47 @@ +probe syscall.mount +{ + printf("sys_mount: %s\n", argstr); +} +probe syscall.mount.return +{ + printf("sys_mount: return %s\n", retstr); +} +/* +probe kernel.function("get_fs_type") +{ + name = user_string($name); + printf(" get_fs_type: fstype %s name %s\n", fstype, name); +} +probe kernel.function("get_fs_type").return +{ + printf(" get_fs_type: return %p\n", $fs); +} +*/ +probe kernel.function("do_add_mount") +{ + printf(" do_add_mount: newmnt %p\n", $newmnt); +} +probe kernel.function("do_add_mount").return +{ + printf(" do_add_mount: return %d\n", $return); +} +probe kernel.function("graft_tree") +{ + printf(" graft_tree: mnt %p\n", $mnt); +} +probe kernel.function("graft_tree").return +{ + printf(" graft_tree: return %d\n", $return); +} + +probe kernel.function("vfs_kern_mount") +{ + name = user_string($name); + printf(" vfs_kern_mount: %s\n", name); +} +probe kernel.function("vfs_kern_mount").return +{ + printf(" vfs_kern_mount: return %p\n", $error); +} +probe begin { log("sys_mount probe") } +probe end { log("sys_mount probe") } diff --git a/sys_bind/inet_bind.stp b/sys_bind/inet_bind.stp deleted file mode 100644 index 621473a..0000000 --- a/sys_bind/inet_bind.stp +++ /dev/null @@ -1,102 +0,0 @@ -%{ -#include -#include -#include -%} - -function _inet_ntoa:string (_uaddr:long) %{ - struct sockaddr_in *addr; - unsigned char *bytes; - - addr = (struct sockaddr_in *)(long)kread(&THIS->_uaddr); - bytes = (unsigned char *)&addr->sin_addr.s_addr; - - snprintf(THIS->__retvalue, MAXSTRINGLEN, - "%d.%d.%d.%d:%d", bytes[0], bytes[1], bytes[2], bytes[3], - addr->sin_port); - - CATCH_DEREF_FAULT(); -%} -function _socket_dump:string (_sock:long) %{ - struct socket *sock; - - sock = (struct socket *)(long)kread(&THIS->_sock); - snprintf(THIS->__retvalue, MAXSTRINGLEN, - "state %d type %d", sock->state, sock->type); - - CATCH_DEREF_FAULT(); -%} -function _sock_dump:string (_sk:long) %{ - struct sock *sk; - - sk = (struct sock *)(long)kread(&THIS->_sk); - snprintf(THIS->__retvalue, MAXSTRINGLEN, - "reuse %d state %d", sk->sk_reuse, sk->sk_state); - - CATCH_DEREF_FAULT(); -%} -function _tb_dump:string (_tp:long) %{ - struct inet_bind_bucket *tp; - - tp = (struct inet_bind_bucket *)(long)kread(&THIS->_tp); - snprintf(THIS->__retvalue, MAXSTRINGLEN, - "port %d fastreuse %d", tp->port, tp->fastreuse); - - CATCH_DEREF_FAULT(); -%} - -probe kernel.function("inet_bind") { - if (isinstr(execname(), "rpc.nfsd")) { - printf("inet_bind(%s): socket [%s] uaddr %s addr_len %d\n", - execname(), _socket_dump($sock), _inet_ntoa($uaddr), $addr_len); - } -} -probe kernel.function("inet_bind").return { - if (isinstr(execname(), "rpc.nfsd")) - printf("inet_bind: return %d (%s)\n", $return, errno_str($return)); -} -probe kernel.function("inet_listen") { - if (isinstr(execname(), "rpc.nfsd")) { - printf("inet_listen(%s): socket [%s] backlog %d\n", - execname(), _socket_dump($sock), $backlog); - } -} -probe kernel.function("inet_listen").return { - if (isinstr(execname(), "rpc.nfsd")) - printf("inet_listen: return %d (%s)\n", $return, errno_str($return)); -} -probe kernel.function("udp_v4_get_port") { - if (isinstr(execname(), "rpc.nfsd")) { - printf(" udp_v4_get_port(%s): sock %p snum %d\n", - execname(), $sk, $snum); - } -} -probe kernel.function("udp_v4_get_port").return { - if (isinstr(execname(), "rpc.nfsd")) - printf(" udp_v4_get_port: return %d (%s)\n", - $return, errno_str($return)); -} -probe kernel.function("tcp_v4_get_port") { - if (isinstr(execname(), "rpc.nfsd")) { - printf(" tcp_v4_get_port(%s): sock [%s] snum %d\n", - execname(), _sock_dump($sk), $snum); - } -} -probe kernel.function("tcp_v4_get_port").return { - if (isinstr(execname(), "rpc.nfsd")) - printf(" tcp_v4_get_port: return %d (%s)\n", - $return, errno_str($return)); -} -probe kernel.function("inet_csk_bind_conflict") { - if (isinstr(execname(), "rpc.nfsd")) { - printf(" bind_conflict(%s): sock [%s] tb [%s]\n", - execname(), _sock_dump($sk), _tb_dump($tb)); - } -} -probe kernel.function("inet_csk_bind_conflict").return { - if (isinstr(execname(), "rpc.nfsd")) - printf(" bind_conflict: return %d (%s)\n", - $return, errno_str($return)); -} -probe begin { log("starting inet_bind probe") } -probe end { log("ending inet_bind probe") } diff --git a/syscalltimes b/syscalltimes deleted file mode 100755 index 84ca77a..0000000 --- a/syscalltimes +++ /dev/null @@ -1,248 +0,0 @@ -#!/bin/bash - -# Syscalltimes systemtap script -# Copyright (C) 2007 IBM Corp. -# -# 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. - -### -### syscalltime - Combination shell/systemtap script to measure system call -### counts and times. Can be filtered by process IDs, process -### names and users. -### - -# Filter options -F_PIDSTR=""; F_PID=0 # Filter by process ID -F_EXECSTR=""; F_EXEC=0 # Filter by process name -F_UIDSTR=""; F_UID=0 # Filter by user -FILTER=0 # Any filters specified? - -# Print options -P_TOTALS=0 # Print totals -P_VERBOSE_STR="" # Print verbose build output - -DELIM="," - -function usage { - echo "USAGE: syscalltimes [-n pname]... [-p pid]... [-u username]..." - echo " [-v]... [-t] [-h]" - echo " -n pname # filter by this process name" - echo " -p pid # filter by this process ID" - echo " -u username # filter by this user" - echo " -t # print totals (default with filters: OFF" - echo " default without filters: ON)" - echo " -v # print verbose output during SystemTap module creation" - echo " -h # print this help text" - echo "" - echo "NOTE: This script can take long time to build. Use -v[vv] to monitor" - echo " the module creation and build process." -} - -# Process options -while getopts n:p:u:vth option; do - case $option in - n) let "F_EXEC++" - F_EXECSTR=$OPTARG$DELIM$F_EXECSTR ;; - - p) let "F_PID++" - F_PIDSTR=$OPTARG$DELIM$F_PIDSTR ;; - - u) uid=`awk -F: '$1 == name {print $3}' name=$OPTARG /etc/passwd` - if [[ $uid != "" ]]; then - let "F_UID++" - F_UIDSTR=$uid$DELIM$F_UIDSTR - else - echo "ERROR: Unknown user:" $OPTARG - let "ERROR++" - fi ;; - - v) P_VERBOSE_STR="-v "$P_VERBOSE_STR ;; - - t) P_TOTALS=1 ;; - - h|?|*) usage - exit 1 ;; - esac -done - -if [[ $ERROR > 0 ]]; then - exit 1 -fi - -if [[ $F_EXEC > 0 || $F_PID > 0 || $F_UID > 0 ]]; then - FILTER=1 -fi - -echo "Creating and building SystemTap module..." - -# -# SystemTap script -# -stap $P_VERBOSE_STR -e ' -global start, timebycall, timebypid, timebyuid, timebyexec -global f_exec_str, f_pid_str, f_uid_str -global f_exec, f_pid, f_uid -global prt_totals, filter_str - -probe begin { - printf("Collecting data - type Ctrl-C to print output and exit...\n") - - # If no filters specified, skip filter processing - if ('$FILTER' == 0) { - filter_str = " (unfiltered)" - prt_totals = 1 // On by default if no filtering - next - } else - filter_str = " (filtered)" - - prt_totals = '$P_TOTALS' - f_exec_str = "'$F_EXECSTR'" - f_pid_str = "'$F_PIDSTR'" - f_uid_str = "'$F_UIDSTR'" - - delim = "'$DELIM'" - - # Process names - if ('$F_EXEC') { - pname = tokenize(f_exec_str, delim) - while (pname != "") { - f_exec[pname] = 1 - pname = tokenize("", delim) - } - } - - # Process IDs - if ('$F_PID') { - pid = tokenize(f_pid_str, delim) - while (pid != "") { - f_pid[strtol(pid, 10)] = 1 - pid = tokenize("", delim) - } - } - - # User IDs - if ('$F_UID') { - uid = tokenize(f_uid_str, delim) - while (uid != "") { - f_uid[strtol(uid, 10)] = 1 - uid = tokenize("", delim) - } - } -} - -probe syscall.* { - start[name, tid()] = gettimeofday_ns() -} - -probe syscall.*.return { - # Skip if we have not seen this before - if (!([name, tid()] in start)) next - - delta = gettimeofday_ns() - start[name, tid()] - - # Check filters - if ('$FILTER') { - target = 0 - if (pid() in f_pid) { - timebypid[name, pid()] <<< delta - target = 1 - } - if (uid() in f_uid) { - timebyuid[name, uid()] <<< delta - target = 1 - } - if (execname() in f_exec) { - timebyexec[name, execname()] <<< delta - target = 1 - } - } else - target = 1 - - # Totals - if (target && prt_totals) - timebycall[name] <<< delta - - delete start[name, tid()] -} - -function print_header() { - printf("%22s %10s %12s %12s %12s %12s\n", - "System Call", "Count", "Total ns", - "Avg ns", "Min ns", "Max ns") -} - -probe end { - if (prt_totals) { - printf("\nTimes for all processes%s:\n\n", filter_str) - print_header() - foreach (call in timebycall) - printf("%22s %10d %12d %12d %12d %12d\n", call, - @count(timebycall[call]), - @sum(timebycall[call]), - @avg(timebycall[call]), - @min(timebycall[call]), - @max(timebycall[call])) - } - - if ('$F_PID') { - curpid = -1 - foreach ([call, pid-] in timebypid) { - if (curpid != pid) { - curpid = pid - printf("\nTimes for process ID %d:\n\n", curpid) - print_header() - } - printf("%22s %10d %12d %12d %12d %12d\n", call, - @count(timebypid[call, pid]), - @sum(timebypid[call, pid]), - @avg(timebypid[call, pid]), - @min(timebypid[call, pid]), - @max(timebypid[call, pid])) - } - printf("\n") - } - - if ('$F_EXEC') { - curexec = "" - foreach ([call, exec-] in timebyexec) { - if (curexec != exec) { - curexec = exec - printf("\nTimes for process name %s:\n\n", curexec) - print_header() - } - printf("%22s %10d %12d %12d %12d %12d\n", call, - @count(timebyexec[call, exec]), - @sum(timebyexec[call, exec]), - @avg(timebyexec[call, exec]), - @min(timebyexec[call, exec]), - @max(timebyexec[call, exec])) - } - printf("\n") - } - - if ('$F_UID') { - curuid = -1 - foreach ([call, uid-] in timebyuid) { - if (curuid != uid) { - curuid = uid - printf("\nTimes for user ID %d:\n\n", curuid) - print_header() - } - printf("%22s %10d %12d %12d %12d %12d\n", call, - @count(timebyuid[call, uid]), - @sum(timebyuid[call, uid]), - @avg(timebyuid[call, uid]), - @min(timebyuid[call, uid]), - @max(timebyuid[call, uid])) - } - printf("\n") - } - - delete timebycall - delete timebypid - delete timebyuid - delete timebyexec -}' diff --git a/sysmount.stp b/sysmount.stp deleted file mode 100644 index 24a5190..0000000 --- a/sysmount.stp +++ /dev/null @@ -1,47 +0,0 @@ -probe syscall.mount -{ - printf("sys_mount: %s\n", argstr); -} -probe syscall.mount.return -{ - printf("sys_mount: return %s\n", retstr); -} -/* -probe kernel.function("get_fs_type") -{ - name = user_string($name); - printf(" get_fs_type: fstype %s name %s\n", fstype, name); -} -probe kernel.function("get_fs_type").return -{ - printf(" get_fs_type: return %p\n", $fs); -} -*/ -probe kernel.function("do_add_mount") -{ - printf(" do_add_mount: newmnt %p\n", $newmnt); -} -probe kernel.function("do_add_mount").return -{ - printf(" do_add_mount: return %d\n", $return); -} -probe kernel.function("graft_tree") -{ - printf(" graft_tree: mnt %p\n", $mnt); -} -probe kernel.function("graft_tree").return -{ - printf(" graft_tree: return %d\n", $return); -} - -probe kernel.function("vfs_kern_mount") -{ - name = user_string($name); - printf(" vfs_kern_mount: %s\n", name); -} -probe kernel.function("vfs_kern_mount").return -{ - printf(" vfs_kern_mount: return %p\n", $error); -} -probe begin { log("sys_mount probe") } -probe end { log("sys_mount probe") } diff --git a/xprt.stp b/xprt.stp deleted file mode 100644 index b6a0c73..0000000 --- a/xprt.stp +++ /dev/null @@ -1,44 +0,0 @@ -global xs_task, trans_task, udp_send_task - -probe module("sunrpc").function("xs_connect") -{ - printf("xs_connect: task %p\n", $task); - xs_task = $task; - //print_backtrace(); -} -probe module("sunrpc").function("xs_tcp_connect") -{ - printf("xs_tcp_connect: task %p\n", $task); - //print_backtrace(); - xs_task = $task; -} -probe module("sunrpc").function("xprt_connect_status") -{ - printf("xprt_connect_status: task %p\n", $task); -} -probe module("sunrpc").function("xprt_connect_status").return -{ - printf("xprt_connect_status: %s", task_dump(xs_task)); -} -probe module("sunrpc").function("xprt_transmit") -{ - printf("xprt_transmit: task %p\n", $task); - trans_task = $task; -} -probe module("sunrpc").function("xprt_transmit").return -{ - printf("xprt_transmit: %s", task_dump(trans_task)); -} -probe module("sunrpc").function("xs_udp_send_request") -{ - printf("xs_udp_send_request: task %p\n", $task); - udp_send_task = $task; -} -probe module("sunrpc").function("xs_udp_send_request").return -{ - if ($return) - printf("xs_udp_send_request: %d (%s)\n", $return, errno_str($return)); -} -probe begin { log("starting xprt probe") } -probe end { log("ending xprt probe") } - -- cgit From e1c9b2542a4a7e72c7f3a876db09986d43f8c252 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Thu, 11 Jun 2009 13:19:24 -0400 Subject: Added nfs/nfs_mount.stp --- nfs/nfs_get_sb.stp | 10 ---------- nfs/nfs_mount.stp | 10 ++++++++++ tapset/fs_type.stp | 16 ++++++++++++++++ tapset/nfs_mnt_rq.stp | 30 ++++++++++++++++++++++++++++++ 4 files changed, 56 insertions(+), 10 deletions(-) delete mode 100644 nfs/nfs_get_sb.stp create mode 100644 nfs/nfs_mount.stp create mode 100644 tapset/fs_type.stp create mode 100644 tapset/nfs_mnt_rq.stp diff --git a/nfs/nfs_get_sb.stp b/nfs/nfs_get_sb.stp deleted file mode 100644 index fed1c8e..0000000 --- a/nfs/nfs_get_sb.stp +++ /dev/null @@ -1,10 +0,0 @@ - -probe module("nfs").function("nfs_get_sb") -{ - printf("nfs_get_sb: fs_type %p flags 0x%x dev %p data %p mnt %p\n", - $fs_type, $flags, $dev_name, $raw_data, $mnt); - - printf(" : flags %s\n", nfs_mntflags($raw_data)); -} -probe begin { log("starting probe") } -probe end { log("ending probe") } diff --git a/nfs/nfs_mount.stp b/nfs/nfs_mount.stp new file mode 100644 index 0000000..0eee85b --- /dev/null +++ b/nfs/nfs_mount.stp @@ -0,0 +1,10 @@ + +probe module("nfs").function("nfs_get_sb") +{ + printf("nfs_get_sb: fs_type %p flags 0x%x dev %p data %p mnt %p\n", + $fs_type, $flags, $dev_name, $raw_data, $mnt); + + printf(" : flags %s\n", nfs_mntflags($raw_data)); +} +probe begin { log("starting nfs_mount probe") } +probe end { log("ending nfs_mount probe") } diff --git a/tapset/fs_type.stp b/tapset/fs_type.stp new file mode 100644 index 0000000..a71bfd7 --- /dev/null +++ b/tapset/fs_type.stp @@ -0,0 +1,16 @@ +%{ +#include +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) +#include +#endif +%} + +function fs_name:string(_fs:long) +%{ + struct file_system_type *fs = + (struct file_system_type *)(long) kread(&(THIS->_fs)); + + snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s", fs->name); + + CATCH_DEREF_FAULT(); +%} diff --git a/tapset/nfs_mnt_rq.stp b/tapset/nfs_mnt_rq.stp new file mode 100644 index 0000000..4f638a8 --- /dev/null +++ b/tapset/nfs_mnt_rq.stp @@ -0,0 +1,30 @@ +%{ +#include +#include +#include +#include + +struct nfs_mount_request { + struct sockaddr *sap; + size_t salen; + char *hostname; + char *dirpath; + u32 version; + unsigned short protocol; + struct nfs_fh *fh; + int noresvport; +}; + +%} +function mnt_req:string(_req:long) +%{ + struct nfs_mount_request *req = + (struct nfs_mount_request *)(long) kread(&(THIS->_req)); + + snprintf(THIS->__retvalue, MAXSTRINGLEN, + "server: %s export: %s vers: %d proto: %d", + req->hostname, req->dirpath, req->version, req->protocol); + + CATCH_DEREF_FAULT(); +%} + -- cgit From 82467982439f83074e8810bd13ce5a2a83f1e7bc Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Sat, 13 Jun 2009 06:21:26 -0400 Subject: Moved task_staus into tapset/task.stp Signed-off-by: Steve Dickson --- lockd/lockd_clnt.stp | 16 ++++----- sunrpc/force_rebind.stp | 66 ++----------------------------------- sunrpc/sunrpc-xprtsock.stp | 11 ++----- tapset/task.stp | 82 ++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 94 insertions(+), 81 deletions(-) diff --git a/lockd/lockd_clnt.stp b/lockd/lockd_clnt.stp index 0769650..6a6537f 100644 --- a/lockd/lockd_clnt.stp +++ b/lockd/lockd_clnt.stp @@ -1,3 +1,7 @@ +/* + * stap -g -I../tapset lockd_clnt.stp + */ + %{ #include #include @@ -17,7 +21,7 @@ enum { }; %} -function task_error:string(_task:long) +function task_nlm_error:string(_task:long) %{ struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); char *errstr; @@ -47,14 +51,6 @@ function task_error:string(_task:long) CATCH_DEREF_FAULT(); %} -function task_status:long(_task:long) -%{ - struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); - - THIS->__retvalue = task->tk_status; - - CATCH_DEREF_FAULT(); -%} /* function rpcprocnum:long(_msg:long) %{ @@ -247,7 +243,7 @@ probe module("lockd").function("nlmclnt_unlock_callback") { if (task_status($task)) { printf("%s(%d): nlmclnt_unlock_callback: ERROR: %s \n", - execname(), pid(), task_error($task)); + execname(), pid(), task_nlm_error($task)); } } probe module("lockd").function("nlm_rebind_host") diff --git a/sunrpc/force_rebind.stp b/sunrpc/force_rebind.stp index cd288a2..2fa92c7 100644 --- a/sunrpc/force_rebind.stp +++ b/sunrpc/force_rebind.stp @@ -1,66 +1,6 @@ -%{ -#include -#include -#include -%} - -function cl_prog:string(_task:long) -%{ - struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); - struct rpc_clnt *clnt = (struct rpc_clnt *)(long) kread(&(task->tk_client)); - struct rpc_procinfo *proc = - (struct rpc_procinfo *)(long) kread(&(clnt->cl_procinfo)); - char *p_name = kread(&(proc->p_name)); - static struct { - int prog; - char *string; - } prog_progtbl[] = { - {100000, "rpcbind"}, - {100024, "statd"}, - {100011, "rquotad"}, - {100003, "nfsd"}, - {100021, "nlockmgr"}, - {100005, "mountd"}, - {100227, "nfs_acl"}, - }; - int i; - int tabsz = (sizeof(prog_progtbl)/sizeof(prog_progtbl[0])); - - for (i = 0; i < tabsz; i++) { - if (prog_progtbl[i].prog == clnt->cl_prog) { - break; - } - } - if (i == tabsz) - snprintf(THIS->__retvalue, MAXSTRINGLEN, "0x%x[%d]:%d", - clnt->cl_prog, clnt->cl_vers, proc->p_proc); - else - snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s[%d]:%d", - prog_progtbl[i].string, clnt->cl_vers, proc->p_proc); - - CATCH_DEREF_FAULT(); -%} -function cl_server:string(_task:long) -%{ - struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); - struct rpc_clnt *clnt = (struct rpc_clnt *)(long) kread(&(task->tk_client)); - char *cl_server = kread(&(clnt->cl_server)); - - snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s", - cl_server ? cl_server : "NULL"); - - CATCH_DEREF_FAULT(); -%} - -function task_status:long(_task:long) -%{ - struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); - - THIS->__retvalue = task->tk_status; - - CATCH_DEREF_FAULT(); -%} - +/* + * stap -g -I../tapset force_rebind.stp + */ probe module("sunrpc").function("call_connect_status") { terror = task_status($task); diff --git a/sunrpc/sunrpc-xprtsock.stp b/sunrpc/sunrpc-xprtsock.stp index a6433d6..e070208 100644 --- a/sunrpc/sunrpc-xprtsock.stp +++ b/sunrpc/sunrpc-xprtsock.stp @@ -1,3 +1,6 @@ +/* + * stap -g -I../tapset sunrpc-xprtsock.stp + */ %{ #include #include @@ -37,14 +40,6 @@ function rpcb_proc:string(_rpc:long) CATCH_DEREF_FAULT(); %} -function task_status:long(_task:long) -%{ - struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); - - THIS->__retvalue = task->tk_status; - - CATCH_DEREF_FAULT(); -%} probe kernel.function("tcp_sendpage").return { if ($return == -107) /* ENOTCONN */ diff --git a/tapset/task.stp b/tapset/task.stp index d409a96..76e7c71 100644 --- a/tapset/task.stp +++ b/tapset/task.stp @@ -1,6 +1,7 @@ %{ #include #include +#include #include %} @@ -21,3 +22,84 @@ function task_dump:string(_task:long) CATCH_DEREF_FAULT(); %} +function task_status:long(_task:long) +%{ + struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); + + THIS->__retvalue = task->tk_status; + + CATCH_DEREF_FAULT(); +%} + +function cl_prog:string(_task:long) +%{ + struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); + struct rpc_clnt *clnt = (struct rpc_clnt *)(long) kread(&(task->tk_client)); + struct rpc_procinfo *proc = + (struct rpc_procinfo *)(long) kread(&(clnt->cl_procinfo)); + char *p_name = kread(&(proc->p_name)); + static struct { + int prog; + char *string; + } prog_progtbl[] = { + {100000, "rpcbind"}, + {100024, "statd"}, + {100011, "rquotad"}, + {100003, "nfsd"}, + {100021, "nlockmgr"}, + {100005, "mountd"}, + {100227, "nfs_acl"}, + }; + int i; + int tabsz = (sizeof(prog_progtbl)/sizeof(prog_progtbl[0])); + + for (i = 0; i < tabsz; i++) { + if (prog_progtbl[i].prog == clnt->cl_prog) { + break; + } + } + if (i == tabsz) + snprintf(THIS->__retvalue, MAXSTRINGLEN, "0x%x[%d]:%d", + clnt->cl_prog, clnt->cl_vers, proc->p_proc); + else + snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s[%d]:%d", + prog_progtbl[i].string, clnt->cl_vers, proc->p_proc); + + CATCH_DEREF_FAULT(); +%} +function cl_server:string(_task:long) +%{ + struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); + struct rpc_clnt *clnt = (struct rpc_clnt *)(long) kread(&(task->tk_client)); + char *cl_server = kread(&(clnt->cl_server)); + + snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s", + cl_server ? cl_server : "NULL"); + + CATCH_DEREF_FAULT(); +%} +/* +function rpcprocnum:long(_msg:long) +%{ + struct rpc_message *msg = (struct rpc_message *)(long) kread(&(THIS->_msg)); + struct rpc_procinfo *rpc_proc = + (struct rpc_procinfo *)(long) kread(&(msg->rpc_proc)); + + THIS->__retvalue = rpc_proc->p_proc; + + CATCH_DEREF_FAULT(); +%} +function rpcprocname:string(_msg:long) +%{ + struct rpc_message *msg = (struct rpc_message *)(long) kread(&(THIS->_msg)); + struct rpc_procinfo *rpc_proc = + (struct rpc_procinfo *)(long) kread(&(msg->rpc_proc)); + char *p_name = kread(&(rpc_proc->p_name)); + char buf[MAXSTRINGLEN]; + + snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s(%d)", + p_name ? p_name : "NULL" , rpc_proc->p_proc); + + CATCH_DEREF_FAULT(); +%} +*/ -- cgit From f3ff2ff055a175d88f364693e3cb9cfc857a784e Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Sat, 13 Jun 2009 06:32:19 -0400 Subject: added rpciod/rpciod.stp Signed-off-by: Steve Dickson --- rpciod/rpciod.stp | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 rpciod/rpciod.stp diff --git a/rpciod/rpciod.stp b/rpciod/rpciod.stp new file mode 100644 index 0000000..37e5aec --- /dev/null +++ b/rpciod/rpciod.stp @@ -0,0 +1,11 @@ +/* + * stap -g -I../tapset rpciod.stp + */ +probe module("sunrpc").function("rpc_execute") +{ + if (task_status($task)) + printf("rpc_execute: task %p\n", $task); +} +probe begin { log("starting rpciod probe") } +probe end { log("ending rpciod probe") } + -- cgit From 7a521887b42c51f98994d811a2a1e8475a49cba1 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Tue, 16 Jun 2009 13:27:02 -0400 Subject: sunrpc/call_connect_status.stp Signed-off-by: Steve Dickson --- sunrpc/call_connect_status.stp | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 sunrpc/call_connect_status.stp diff --git a/sunrpc/call_connect_status.stp b/sunrpc/call_connect_status.stp new file mode 100644 index 0000000..9e4d330 --- /dev/null +++ b/sunrpc/call_connect_status.stp @@ -0,0 +1,10 @@ +/* + * stap -g -I../tapset force_rebind.stp + */ +probe module("sunrpc").function("call_connect_status") +{ + terror = task_status($task); + if (terror) + printf("call_connect_status:%s:%s: error %d (%s)\n", + cl_server($task), cl_prog($task), terror, errno_str(terror)); +} -- cgit From 7bf74fa2175f1fbdf976e4ae5c8e6acb870c1a27 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Tue, 16 Jun 2009 13:36:01 -0400 Subject: call_connect_status Signed-off-by: Steve Dickson --- sunrpc/call_connect_status.stp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/sunrpc/call_connect_status.stp b/sunrpc/call_connect_status.stp index 9e4d330..b6d8354 100644 --- a/sunrpc/call_connect_status.stp +++ b/sunrpc/call_connect_status.stp @@ -1,10 +1,12 @@ /* - * stap -g -I../tapset force_rebind.stp + * stap -g -I../tapset call_connect_status.stp */ probe module("sunrpc").function("call_connect_status") { terror = task_status($task); - if (terror) + if (terror && terror == -107) printf("call_connect_status:%s:%s: error %d (%s)\n", cl_server($task), cl_prog($task), terror, errno_str(terror)); } +probe begin { log("starting call_connect_status probe (ENOCONN)") } +probe end { log("ending call_connect_status probe (ENOCONN)") } -- cgit From 5b0e9ed86dfa2754ffe770fb81ec362fa4da0de6 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Tue, 16 Jun 2009 18:02:23 -0400 Subject: added sunrpc/call_status.stp Signed-off-by: Steve Dickson --- sunrpc/call_status.stp | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 sunrpc/call_status.stp diff --git a/sunrpc/call_status.stp b/sunrpc/call_status.stp new file mode 100644 index 0000000..56976cd --- /dev/null +++ b/sunrpc/call_status.stp @@ -0,0 +1,32 @@ +/* + * stap -g -I../tapset call_status.stp + */ +probe module("sunrpc").function("call_connect_status") +{ + terror = task_status($task); + if (terror) + printf("call_connect_status:%s:%s: error %d (%s)\n", + cl_server($task), cl_prog($task), terror, errno_str(terror)); +} +probe module("sunrpc").function("call_bind_status") +{ + terror = task_status($task); + if (terror) + printf("call_bind_status:%s:%s: error %d (%s)\n", + cl_server($task), cl_prog($task), terror, errno_str(terror)); +} +probe module("sunrpc").function("call_connect_status") +{ + terror = task_status($task); + if (terror) + printf("call_connect_status:%s:%s: error %d (%s)\n", + cl_server($task), cl_prog($task), terror, errno_str(terror)); +} +probe module("sunrpc").function("xs_tcp_finish_connecting").return +{ + if ($return) + printf("xs_tcp_finish_connecting: error %d (%s)\n", + $return, errno_str($return)); +} +probe begin { log("starting call_status probe") } +probe end { log("ending call_status probe") } -- cgit From 228e373b9e92910293b332b15f8cfd0876cd5bda Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Tue, 14 Jul 2009 11:16:34 -0400 Subject: Added in some ext3, acl, and inode scripts Signed-off-by: Steve Dickson --- ext3/ext3_acl.stp | 25 ++++++++++++++++++++++ nfsd/nfsd4_open.stp | 49 ++++++++++++++++++++++++++++++++++++++++++ nfsd/nfsd4_set_nfs4_acl.stp | 29 +++++++++++++++++++++++++ tapset/acl.stp | 27 +++++++++++++++++++++++ tapset/inode.stp | 13 ++++++++++++ tracemarks/nfs_mount.stp | 52 +++++++++++++++++++++++++++++++++++++++++++++ tracemarks/sched.stp | 3 +++ 7 files changed, 198 insertions(+) create mode 100644 ext3/ext3_acl.stp create mode 100644 nfsd/nfsd4_open.stp create mode 100644 nfsd/nfsd4_set_nfs4_acl.stp create mode 100644 tapset/acl.stp create mode 100644 tapset/inode.stp create mode 100644 tracemarks/nfs_mount.stp create mode 100644 tracemarks/sched.stp diff --git a/ext3/ext3_acl.stp b/ext3/ext3_acl.stp new file mode 100644 index 0000000..904e146 --- /dev/null +++ b/ext3/ext3_acl.stp @@ -0,0 +1,25 @@ +/* + * To run: + * stap -g -I../tapset ext3_acl.stp + */ +probe module("ext3").function("ext3_get_acl") +{ + printf(" ext3_get_acl: inode %p\n", $inode); +} +probe module("ext3").function("ext3_get_acl").return +{ + if ($return) + printf(" ext3_get_acl: %s\n", acl_dump($return)); +} +probe module("ext3").function("ext3_check_acl") +{ + printf("ext3_check_acl: %s mask 0x%x\n", + inode_uid($inode), $mask); +} +probe module("ext3").function("ext3_check_acl").return +{ + printf("ext3_check_acl: %d\n", $return); +} +probe begin { log("starting ext3_acl probe") } +probe end { log("ending ext3_acl probe") } + diff --git a/nfsd/nfsd4_open.stp b/nfsd/nfsd4_open.stp new file mode 100644 index 0000000..73a14a6 --- /dev/null +++ b/nfsd/nfsd4_open.stp @@ -0,0 +1,49 @@ +/* + * To run: + * stap -g -I../tapset nfsd4_open.stp + */ +probe module("nfsd").function("nfsd4_process_open1") +{ + printf("nfsd4_process_open1: open %p\n", $open); +} +probe module("nfsd").function("nfsd4_process_open1").return +{ + printf("nfsd4_process_open1: %s\n", nfsderror($return)); +} + +probe module("nfsd").function("do_open_permission") +{ + printf("do_open_permission: open %p\n", $open); +} +probe module("nfsd").function("do_open_permission").return +{ + printf("do_open_permission: %s\n", nfsderror($return)); +} + +probe module("nfsd").function("nfsd4_process_open2") +{ + printf("nfsd4_process_open2: open %p\n", $open); +} +probe module("nfsd").function("nfsd4_process_open2").return +{ + printf("nfsd4_process_open2: %s\n", nfsderror($return)); +} +probe module("nfsd").function("nfsd_permission") +{ + printf("nfsd_permission: exp 0x%x\n", $acc); +} +probe module("nfsd").function("nfsd_permission").return +{ + printf("nfsd_permission: %s\n", nfsderror($return)); +} +probe module("ext3").function("ext3_check_acl") +{ + printf("ext3_check_acl: mask 0x%x\n", $mask); +} +probe module("ext3").function("ext3_check_acl").return +{ + printf("ext3_check_acl: %d\n", $return); +} +probe begin { log("starting nfsd4_open probe") } +probe end { log("ending nfsd4_open probe") } + diff --git a/nfsd/nfsd4_set_nfs4_acl.stp b/nfsd/nfsd4_set_nfs4_acl.stp new file mode 100644 index 0000000..45fcd85 --- /dev/null +++ b/nfsd/nfsd4_set_nfs4_acl.stp @@ -0,0 +1,29 @@ +#!/usr/bin/env stap +/* + * To run: + * stap -g -I../tapset nfsd4_set_nfs4_acl.stp + */ + +probe module("nfsd").function("nfsd4_set_nfs4_acl") +{ + printf("nfsd4_set_nfs4_acl: rqstp %p \n", $rqstp); +} +probe module("nfsd").function("nfsd4_set_nfs4_acl").return +{ + printf("nfsd4_set_nfs4_acl: %s\n", nfsderror($return)); +} +probe module("nfsd").function("nfs4_acl_nfsv4_to_posix").return +{ + printf(" nfs4_acl_nfsv4_to_posix: %d(%s)\n", $return, errno_str($return)); +} +probe module("nfsd").function("set_nfsv4_acl_one").return +{ + printf(" set_nfsv4_acl_one: %s\n", nfsderror($return)); +} +probe module("nfsd").function("_nfsv4_to_posix_one").return +{ + printf(" _nfsv4_to_posix_one: %p\n", $return); +} +probe begin { log("starting nfsd4_set_nfs4_acl probe") } +probe end { log("ending nfsd4_set_nfs4_acl probe") } + diff --git a/tapset/acl.stp b/tapset/acl.stp new file mode 100644 index 0000000..ad9f88d --- /dev/null +++ b/tapset/acl.stp @@ -0,0 +1,27 @@ +%{ +#include +#include +%} + +function acl_dump:string(_acl:long) +%{ + struct posix_acl *acl = (struct posix_acl *)(long) kread(&(THIS->_acl)); + struct posix_acl_entry *pa; + char buf[MAXSTRINGLEN]; + int cc=0, i; + + sprintf(buf+cc, "acl(%d) ", acl->a_count); + cc = strlen(buf); + pa = acl->a_entries; + + for (i=0; i < acl->a_count; i++) { + + sprintf(buf+cc, "[%d,%d,%d] ", pa->e_tag, pa->e_perm, pa->e_id); + cc = strlen(buf); + + pa++; + } + snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s", buf); + + CATCH_DEREF_FAULT(); +%} diff --git a/tapset/inode.stp b/tapset/inode.stp new file mode 100644 index 0000000..106cba1 --- /dev/null +++ b/tapset/inode.stp @@ -0,0 +1,13 @@ +%{ +#include +%} + +function inode_uid:string(_ino:long) +%{ + struct inode *inode = (struct inode *)(long) kread(&(THIS->_ino)); + + snprintf(THIS->__retvalue, MAXSTRINGLEN, "uid=%d gid=%d", + inode->i_uid, inode->i_gid); + + CATCH_DEREF_FAULT(); +%} diff --git a/tracemarks/nfs_mount.stp b/tracemarks/nfs_mount.stp new file mode 100644 index 0000000..b20e920 --- /dev/null +++ b/tracemarks/nfs_mount.stp @@ -0,0 +1,52 @@ +%{ +#include +#include +%} + +function _fstype_name:string (_fstype:long) %{ + struct file_system_type *fstype; + char *name; + + fstype = (struct file_system_type *)(long)kread(&(THIS->_fstype)); + name = (char *)(long)kread(&fstype->name); + + snprintf(THIS->__retvalue, MAXSTRINGLEN, "name %s flags 0x%x", + name, fstype->fs_flags); + + CATCH_DEREF_FAULT(); +%} +function _vfsmnt_dump:string (_vfsmnt:long) %{ + struct vfsmount *vfsmnt; + char *dev; + + vfsmnt = (struct vfsmount *)(long)kread(&(THIS->_vfsmnt)); + dev = (char *)(long)kread(&vfsmnt->mnt_devname); + + snprintf(THIS->__retvalue, MAXSTRINGLEN, "dev %s flags=0x%x", + vfsmnt->mnt_devname, vfsmnt->mnt_flags); + + CATCH_DEREF_FAULT(); +%} +function _nfsmnt_dump:string (_nfsmnt:long) %{ + struct nfs_mount_data *data; + unsigned char *bytes; + + data = (struct nfs_mount_data *)(long)kread(&(THIS->_nfsmnt)); + bytes = (unsigned char *)&data->addr.sin_addr.s_addr; + + snprintf(THIS->__retvalue, MAXSTRINGLEN, + "vers %d flags 0x%x flavor %d hostname %s(%d.%d.%d.%d)", + data->version, data->flags, data->pseudoflavor, + data->hostname, bytes[0], bytes[1], bytes[2], bytes[3]); + + CATCH_DEREF_FAULT(); +%} + +probe kernel.mark("nfs_mount") { + printf("nfs_mount:entry: fstype (%s) flags %x dev %s\n", + _fstype_name($arg1), $arg2, kernel_string($arg3)); + printf("\tdata: %s\n\tmnt: %s\n", + _nfsmnt_dump($arg4), _vfsmnt_dump($arg5)); + +} + diff --git a/tracemarks/sched.stp b/tracemarks/sched.stp new file mode 100644 index 0000000..0b3ffa2 --- /dev/null +++ b/tracemarks/sched.stp @@ -0,0 +1,3 @@ +probe kernel.mark("kernel_sched_schedule") { + printf("kernel_sched_schedule: pid %d\n", $arg1) +} -- cgit From 235dd6db7e13ace096e46df9b78dcec36a3163a4 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Mon, 27 Jul 2009 11:01:11 -0400 Subject: Updated nfsd_permission Signed-off-by: Steve Dickson --- nfsd/nfsd_permission.stp | 27 ++++++++++++++++++++++++--- tapset/fs.stp | 8 ++++++++ 2 files changed, 32 insertions(+), 3 deletions(-) diff --git a/nfsd/nfsd_permission.stp b/nfsd/nfsd_permission.stp index 7e27ca5..d73e615 100644 --- a/nfsd/nfsd_permission.stp +++ b/nfsd/nfsd_permission.stp @@ -2,13 +2,34 @@ probe module("nfsd").function("nfsd_permission") { - printf("nfsd_permission: rqstp %p exp %p dentry %p acc 0x%x\n", - $rqstp, $exp, $dentry, $acc); + printf("nfsd_permission: rqstp %p exp %p dentry '%s' acc 0x%x\n", + $rqstp, $exp, dentry2name($dentry), $acc); printf(" : %s\n", svc_export_dump($exp)); } +probe kernel.function("inode_permission").return +{ + if ($return) + printf(" inode_permission: error: %d\n", $return); +} +probe kernel.function("security_inode_permission").return +{ + if ($return) + printf(" security_inode_permission: error: %d\n", $return); +} +probe kernel.function("devcgroup_inode_permission").return +{ + if ($return) + printf(" devcgroup_inode_permission: error: %d\n", $return); +} +probe kernel.function("generic_permission").return +{ + if ($return) + printf(" generic_permission: error: %d\n", $return); +} probe module("nfsd").function("nfsd_permission").return { - printf("nfsd_permission: %s\n", nfsderror($return)); + if ($return) + printf("nfsd_permission: error: %s\n", nfsderror($return)); } probe begin { log("starting nfsd_permission probe") } probe end { log("ending nfsd_permission probe") } diff --git a/tapset/fs.stp b/tapset/fs.stp index 85956e9..f8122bf 100644 --- a/tapset/fs.stp +++ b/tapset/fs.stp @@ -31,3 +31,11 @@ function file2name:string(filep:long) CATCH_DEREF_FAULT(); %} +function dentry2name:string(dentry_:long) +%{ + struct dentry *dentry = (struct dentry *)(long) kread(&(THIS->dentry_)); + + strlcpy(THIS->__retvalue, dentry->d_name.name, MAXSTRINGLEN); + + CATCH_DEREF_FAULT(); +%} -- cgit From acc153b757eb0988c9cdae8ab4cb41d53425bd75 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Mon, 10 Aug 2009 12:14:30 -0400 Subject: Added execname() and pid() calls to rpc_bind_status() point Added cl_prognum and cl_vers to the task.stp tap set. Signed-off-by: Steve Dickson --- tapset/task.stp | 22 +++++++++++++++++++++- tracepoints/rpc_call_status.stp | 20 +++++++++++++------- 2 files changed, 34 insertions(+), 8 deletions(-) diff --git a/tapset/task.stp b/tapset/task.stp index 76e7c71..6b121be 100644 --- a/tapset/task.stp +++ b/tapset/task.stp @@ -31,6 +31,26 @@ function task_status:long(_task:long) CATCH_DEREF_FAULT(); %} +function cl_prognum:long(_task:long) +%{ + struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); + struct rpc_clnt *clnt = (struct rpc_clnt *)(long) kread(&(task->tk_client)); + + THIS->__retvalue = clnt->cl_prog; + + CATCH_DEREF_FAULT(); +%} + +function cl_vers:long(_task:long) +%{ + struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); + struct rpc_clnt *clnt = (struct rpc_clnt *)(long) kread(&(task->tk_client)); + + THIS->__retvalue = clnt->cl_vers; + + CATCH_DEREF_FAULT(); +%} + function cl_prog:string(_task:long) %{ struct rpc_task *task = (struct rpc_task *)(long) kread(&(THIS->_task)); @@ -45,7 +65,7 @@ function cl_prog:string(_task:long) {100000, "rpcbind"}, {100024, "statd"}, {100011, "rquotad"}, - {100003, "nfsd"}, + {100003, "nfs"}, {100021, "nlockmgr"}, {100005, "mountd"}, {100227, "nfs_acl"}, diff --git a/tracepoints/rpc_call_status.stp b/tracepoints/rpc_call_status.stp index 8018559..37ac5e2 100644 --- a/tracepoints/rpc_call_status.stp +++ b/tracepoints/rpc_call_status.stp @@ -11,22 +11,28 @@ probe kernel.trace("rpc_bind_status") { terror = task_status($task); if (terror) - printf("rpc_bind_status:%s:%s: error %d (%s)\n", - cl_server($task), cl_prog($task), terror, errno_str(terror)); + printf("%s[%d]:rpc_bind_status:%s:%s: error %d (%s)\n", + execname(), pid(), cl_server($task), cl_prog($task), + terror, errno_str(terror)); } probe kernel.trace("rpc_connect_status") { terror = task_status($task); if (terror) - printf("call_connect_status:%s:%s: error %d (%s)\n", - cl_server($task), cl_prog($task), terror, errno_str(terror)); + printf("%s[%d]:call_connect_status:%s:%s: error %d (%s)\n", + execname(), pid(), cl_server($task), cl_prog($task), + terror, errno_str(terror)); } probe kernel.trace("rpc_call_status") { terror = task_status($task); - if (terror) - printf("call_status:%s:%s: error %d (%s)\n", - cl_server($task), cl_prog($task), terror, errno_str(terror)); + /* ingore EAGAIN and ETIMEDOUT */ + if (terror) { + printf("%s[%d]:call_status:%s:%s: error %d (%s)\n", + execname(), pid(), cl_server($task), cl_prog($task), + terror, errno_str(terror)); + } } + probe begin { log("starting rpc call status probe") } probe end { log("ending rpc call status probe") } -- cgit From 0f38db8abb84c7a315762c9831dfcca101e50258 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Thu, 13 Aug 2009 10:41:07 -0400 Subject: Added top-nfsclient.stp Signed-off-by: Steve Dickson --- top-nfscalls.stp | 6 +-- top-nfsclient.stp | 145 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ top-nfsdcalls.stp | 6 +-- 3 files changed, 151 insertions(+), 6 deletions(-) create mode 100644 top-nfsclient.stp diff --git a/top-nfscalls.stp b/top-nfscalls.stp index 62fe9d0..90586e0 100755 --- a/top-nfscalls.stp +++ b/top-nfscalls.stp @@ -3,11 +3,11 @@ global nfscalls probe begin { - printf("Collecting data...\n") + printf("Collecting top NFS procs...\n") } -probe kernel.function("*@fs/nfs") ?, - module("nfs").function("*@fs/nfs/*") ? +probe kernel.function("*@fs/nfs/*proc.c") ?, + module("nfs").function("*@fs/nfs/*proc.c") ? { nfscalls[probefunc()]++ } diff --git a/top-nfsclient.stp b/top-nfsclient.stp new file mode 100644 index 0000000..7d187c8 --- /dev/null +++ b/top-nfsclient.stp @@ -0,0 +1,145 @@ +#!/usr/bin/env stap + +global entry, timings + +probe begin { + printf("Collecting data... Hit to stop..\n") +} + +function collect_entry() { entry[probefunc(),pid()] = gettimeofday_us() } +function collect_exit() { timings[probefunc()] <<< (gettimeofday_us() - entry[probefunc(),pid()]) } + +probe module("nfs").function("*@fs/nfs/*proc.c") { collect_entry(); } +probe module("nfs").function("*@fs/nfs/*proc.c").return { collect_exit(); } +/* +# Filename: nfs_v3_clientops_functions Line: 1 +probe module("nfs").function("nfs3_proc_get_root") { collect_entry(); } +probe module("nfs").function("nfs3_proc_get_root").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 2 +probe module("nfs").function("nfs3_proc_getattr") { collect_entry(); } +probe module("nfs").function("nfs3_proc_getattr").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 3 +probe module("nfs").function("nfs3_proc_setattr") { collect_entry(); } +probe module("nfs").function("nfs3_proc_setattr").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 4 +probe module("nfs").function("nfs3_proc_lookup") { collect_entry(); } +probe module("nfs").function("nfs3_proc_lookup").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 5 +probe module("nfs").function("nfs3_proc_access") { collect_entry(); } +probe module("nfs").function("nfs3_proc_access").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 6 +probe module("nfs").function("nfs3_proc_readlink") { collect_entry(); } +probe module("nfs").function("nfs3_proc_readlink").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 10 +probe module("nfs").function("nfs3_proc_create") { collect_entry(); } +probe module("nfs").function("nfs3_proc_create").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 11 +probe module("nfs").function("nfs3_proc_remove") { collect_entry(); } +probe module("nfs").function("nfs3_proc_remove").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 12 +probe module("nfs").function("nfs3_proc_unlink_setup") { collect_entry(); } +probe module("nfs").function("nfs3_proc_unlink_setup").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 13 +probe module("nfs").function("nfs3_proc_unlink_done") { collect_entry(); } +probe module("nfs").function("nfs3_proc_unlink_done").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 14 +probe module("nfs").function("nfs3_proc_rename") { collect_entry(); } +probe module("nfs").function("nfs3_proc_rename").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 15 +probe module("nfs").function("nfs3_proc_link") { collect_entry(); } +probe module("nfs").function("nfs3_proc_link").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 16 +probe module("nfs").function("nfs3_proc_symlink") { collect_entry(); } +probe module("nfs").function("nfs3_proc_symlink").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 17 +probe module("nfs").function("nfs3_proc_mkdir") { collect_entry(); } +probe module("nfs").function("nfs3_proc_mkdir").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 18 +probe module("nfs").function("nfs3_proc_rmdir") { collect_entry(); } +probe module("nfs").function("nfs3_proc_rmdir").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 19 +probe module("nfs").function("nfs3_proc_readdir") { collect_entry(); } +probe module("nfs").function("nfs3_proc_readdir").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 20 +probe module("nfs").function("nfs3_proc_mknod") { collect_entry(); } +probe module("nfs").function("nfs3_proc_mknod").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 21 +probe module("nfs").function("nfs3_proc_statfs") { collect_entry(); } +probe module("nfs").function("nfs3_proc_statfs").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 22 +probe module("nfs").function("nfs3_proc_fsinfo") { collect_entry(); } +probe module("nfs").function("nfs3_proc_fsinfo").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 23 +probe module("nfs").function("nfs3_proc_pathconf") { collect_entry(); } +probe module("nfs").function("nfs3_proc_pathconf").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 24 +probe module("nfs").function("nfs3_decode_dirent") { collect_entry(); } +probe module("nfs").function("nfs3_decode_dirent").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 25 +probe module("nfs").function("nfs3_proc_read_setup") { collect_entry(); } +probe module("nfs").function("nfs3_proc_read_setup").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 26 +probe module("nfs").function("nfs3_read_done") { collect_entry(); } +probe module("nfs").function("nfs3_read_done").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 27 +probe module("nfs").function("nfs3_proc_write_setup") { collect_entry(); } +probe module("nfs").function("nfs3_proc_write_setup").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 28 +probe module("nfs").function("nfs3_write_done") { collect_entry(); } +probe module("nfs").function("nfs3_write_done").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 29 +probe module("nfs").function("nfs3_proc_commit_setup") { collect_entry(); } +probe module("nfs").function("nfs3_proc_commit_setup").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 30 +probe module("nfs").function("nfs3_commit_done") { collect_entry(); } +probe module("nfs").function("nfs3_commit_done").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 31 +probe module("nfs").function("nfs_open") { collect_entry(); } +probe module("nfs").function("nfs_open").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 32 +probe module("nfs").function("nfs_release") { collect_entry(); } +probe module("nfs").function("nfs_release").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 33 +probe module("nfs").function("nfs3_proc_lock") { collect_entry(); } +probe module("nfs").function("nfs3_proc_lock").return { collect_exit(); } + +# Filename: nfs_v3_clientops_functions Line: 34 +probe module("nfs").function("nfs3_forget_cached_acls") { collect_entry(); } +probe module("nfs").function("nfs3_forget_cached_acls").return { collect_exit(); } +*/ +probe end { + printf("function count min_us avg_us max_us\n") + foreach (i+ in timings) { + printf("%-25s %7d %8d %8d %8d\n", i, @count(timings[i]), + @min(timings[i]), @avg(timings[i]), @max(timings[i])) + } +} diff --git a/top-nfsdcalls.stp b/top-nfsdcalls.stp index 7bfdf03..8b5dbdb 100755 --- a/top-nfsdcalls.stp +++ b/top-nfsdcalls.stp @@ -3,11 +3,11 @@ global nfsdcalls probe begin { - printf("Collecting data...\n") + printf("Collecting top NFSD procs...\n") } -probe kernel.function("*@fs/nfsd") ?, - module("nfsd").function("*@fs/nfsd/*") ? +probe kernel.function("*@fs/nfsd/*proc.c") ?, + module("nfsd").function("*@fs/nfsd/*proc.c*") ? { nfsdcalls[probefunc()]++ } -- cgit From 4c2e068baa02379a1c93e962237bd3ebdb6844c9 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Fri, 2 Oct 2009 09:48:27 -0400 Subject: Added dentry2name() Signed-off-by: Steve Dickson --- tapset/fs.stp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tapset/fs.stp b/tapset/fs.stp index f8122bf..c80e9cb 100644 --- a/tapset/fs.stp +++ b/tapset/fs.stp @@ -39,3 +39,11 @@ function dentry2name:string(dentry_:long) CATCH_DEREF_FAULT(); %} +function dentry2name:string(dentry_:long) +%{ + struct dentry *dentry = (struct dentry *)(long) kread(&(THIS->dentry_)); + + strlcpy(THIS->__retvalue, dentry->d_name.name, MAXSTRINGLEN); + + CATCH_DEREF_FAULT(); +%} -- cgit From 9ee2ff20970057642b8f08407ac47252619bea04 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Tue, 13 Oct 2009 11:05:42 -0400 Subject: Remove the second definition of dentry2name() Signed-off-by: Steve Dickson --- tapset/fs.stp | 8 -------- 1 file changed, 8 deletions(-) diff --git a/tapset/fs.stp b/tapset/fs.stp index c80e9cb..f8122bf 100644 --- a/tapset/fs.stp +++ b/tapset/fs.stp @@ -39,11 +39,3 @@ function dentry2name:string(dentry_:long) CATCH_DEREF_FAULT(); %} -function dentry2name:string(dentry_:long) -%{ - struct dentry *dentry = (struct dentry *)(long) kread(&(THIS->dentry_)); - - strlcpy(THIS->__retvalue, dentry->d_name.name, MAXSTRINGLEN); - - CATCH_DEREF_FAULT(); -%} -- cgit From 6e6288680658609527f52a876ff40587a2b21b3f Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Wed, 4 Nov 2009 14:30:04 -0500 Subject: Added more callback and mounting routines --- nfs/nfs_mount.stp | 72 ++++++++++++++++++++++++++++++++++++++++++++++-- nfsd/nfsd4_callback.stp | 28 +++++++++++-------- nfsd/nfsd_exports.stp | 2 +- tapset/nfs4_callback.stp | 15 ++++++++++ tapset/nfsmntflags.stp | 1 - 5 files changed, 102 insertions(+), 16 deletions(-) diff --git a/nfs/nfs_mount.stp b/nfs/nfs_mount.stp index 0eee85b..32e41f7 100644 --- a/nfs/nfs_mount.stp +++ b/nfs/nfs_mount.stp @@ -1,10 +1,76 @@ probe module("nfs").function("nfs_get_sb") { - printf("nfs_get_sb: fs_type %p flags 0x%x dev %p data %p mnt %p\n", - $fs_type, $flags, $dev_name, $raw_data, $mnt); + printf("nfs_mount: fs_name %s dev %s \n", + fs_name($fs_type), kernel_string($dev_name)); - printf(" : flags %s\n", nfs_mntflags($raw_data)); + printf(" : flags=[%s]\n", nfs_mntflags($raw_data)); +} +probe module("nfs").function("nfs_get_sb").return +{ + if ($return) + printf("nfs_mount: ERROR %d (%s)", $return, errno_str($return)); +} +/* +probe module("nfs").function("nfs_validate_mount_data") +{ + printf(" nfs_validate_mount_data: raw_data %p data %p\n", + $raw_data, $data); + + printf(" : flags=[%s]\n", nfs_mntflags($raw_data)); +} +probe module("nfs").function("nfs_validate_mount_data").return +{ + if ($return) + printf(" nfs_validate_mount_data: ERROR %d (%s)", $return, errno_str($return)); +} +*/ +probe module("nfs").function("nfs_parse_mount_options") +{ + printf(" nfs_parse_mount_options: raw [%s]\n", kernel_string($raw)); +} +probe module("nfs").function("nfs_parse_mount_options").return +{ + if ($return == 0) + printf(" nfs_parse_mount_options: Failed\n"); +} +probe module("nfs").function("nfs_parse_devname").return +{ + if ($return) + printf(" nfs_parse_devname: ERROR %d (%s)", $return, errno_str($return)); +} +/* +probe module("nfs").function("nfs_try_mount") +{ + printf(" nfs_try_mount: args %p root_fh %p\n", $args, $root_fh); +} +*/ +probe module("nfs").function("nfs_mount") +{ + printf(" nfs_mount: %s\n", mnt_req($info)); +} +probe module("nfs").function("nfs_mount").return +{ + if ($return) + printf(" nfs_mount: ERROR %d (%s)", $return, errno_str($return)); +} +probe module("nfs").function("nfs_get_root") +{ + printf(" nfs_get_root: sb %p mntfh %p\n", $sb, $mntfh); +} +probe module("nfs").function("nfs_get_root").return +{ + printf(" nfs_get_root: returns %p\n", $return); +} +/* +probe module("nfs").function("nfs_fill_super") +{ + printf(" nfs_fill_super: sb %p data %p \n", $sb, $data); +} +*/ +probe module("nfs").function("nfs_initialise_sb") +{ + printf(" nfs_initialise_sb: sb %p\n", $sb); } probe begin { log("starting nfs_mount probe") } probe end { log("ending nfs_mount probe") } diff --git a/nfsd/nfsd4_callback.stp b/nfsd/nfsd4_callback.stp index b0defc6..3853271 100644 --- a/nfsd/nfsd4_callback.stp +++ b/nfsd/nfsd4_callback.stp @@ -1,32 +1,38 @@ probe module("nfsd").function("nfsd4_probe_callback") { - printf("nfsd4_probe_callback: clp %p\n", $clp); + printf("nfsd4_probe_callback: client %s\n", nfs4_callback_addr($clp)); } +/* probe module("nfsd").function("nfsd4_setclientid_confirm") { printf("nfsd4_setclientid_confirm: hellow\n"); } -/* probe module("nfsd").function("*@fs/nfsd/nfs4state.c:3318") { printf("nfsd4_setclientid_confirm: hellow\n"); } -*/ -probe module("nfsd").function("nfsd4_setclientid_confirm").return +probe module("nfsd").function("*@fs/nfsd/nfs4callback.c") { - printf("nfsd4_setclientid_confirm: status %d\n", $return); + printf("%s\n", probefunc()); } -probe module("nfsd").function("nfsd4_process_open2").return +*/ +probe module("nfsd").function("nfsd4_cb_probe_done") { - printf("nfsd4_process_open2: status %d\n", $return); + terror = task_status($task); + if (terror) + printf("nfsd4_cb_probe_done: client %s: error %d (%s)\n", + cl_server($task), terror, errno_str(terror)); } -probe module("nfsd").function("svc_export_parse").return +probe module("nfsd").function("nfsd4_setclientid_confirm").return { - printf("svc_export_parse: status %d\n", $return); + if ($return) + printf("nfsd4_setclientid_confirm: status %d\n", $return); } -probe module("sunrpc").function("rpc_exit_task") +probe module("nfsd").function("nfsd4_process_open2").return { - printf("rpc_exit_task: task 0x%p\n", $task); + if ($return) + printf("nfsd4_process_open2: status %d\n", $return); } + probe begin { log("starting probe") } probe end { log("ending probe") } diff --git a/nfsd/nfsd_exports.stp b/nfsd/nfsd_exports.stp index ec73af8..fb0cacb 100644 --- a/nfsd/nfsd_exports.stp +++ b/nfsd/nfsd_exports.stp @@ -59,6 +59,7 @@ probe module("sunrpc").function("cache_check").return if ($return) printf(" cache_check: %s\n", errno_str($return)); } +/* probe module("sunrpc").function("cache_make_upcall") { printf(" cache_make_upcall: detail %p h %p \n", @@ -70,7 +71,6 @@ probe module("sunrpc").function("cache_make_upcall").return if ($return) printf(" cache_make_upcall: %s\n", errno_str($return)); } -/* probe module("nfsd").function("check_nfsd_access") { check_exp = $exp; diff --git a/tapset/nfs4_callback.stp b/tapset/nfs4_callback.stp index 351f0f2..7330beb 100644 --- a/tapset/nfs4_callback.stp +++ b/tapset/nfs4_callback.stp @@ -2,6 +2,7 @@ #include #include #include +#include #include @@ -33,3 +34,17 @@ function nfs4_callback:string(_stp:long) CATCH_DEREF_FAULT(); %} +function nfs4_callback_addr:string(_clp:long) +%{ + struct nfs4_client *clp = (struct nfs4_client *) + (long)kread(&(THIS->_clp)); + + char buf[MAXSTRINGLEN]; + int cc=0; + + snprintf(THIS->__retvalue, MAXSTRINGLEN, + NIPQUAD_FMT, NIPQUAD(clp->cl_addr)); + + CATCH_DEREF_FAULT(); + +%} diff --git a/tapset/nfsmntflags.stp b/tapset/nfsmntflags.stp index 98f4bb5..62519c1 100644 --- a/tapset/nfsmntflags.stp +++ b/tapset/nfsmntflags.stp @@ -24,7 +24,6 @@ function nfs_mntflags:string(rawdata) { NFS_MOUNT_NOACL, ",noacl", "" }, { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" }, { NFS_MOUNT_UNSHARED, ",nosharecache", "" }, - { NFS_MOUNT_FSCACHE, ",fsc", "" }, { 0, "", "" } }; struct nfs_mount_data *data = (struct nfs_mount_data *)(long) THIS->rawdata; -- cgit From cb5673a68373d2f4340e9a6c26e195c1b1978988 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Fri, 6 Nov 2009 08:45:52 -0500 Subject: Added more delegation debugging Signed-off-by: Steve Dickson --- nfsd/nfsd_deleg.stp | 20 +++++++++++++++++--- tapset/nfs4_callback.stp | 23 +++++++++++++++++++++-- 2 files changed, 38 insertions(+), 5 deletions(-) diff --git a/nfsd/nfsd_deleg.stp b/nfsd/nfsd_deleg.stp index 02c7590..679d9ba 100644 --- a/nfsd/nfsd_deleg.stp +++ b/nfsd/nfsd_deleg.stp @@ -1,10 +1,24 @@ probe module("nfsd").function("nfs4_open_delegation") { - printf("nfs4_open_delegation: fh %p open %p (type: %d) stp %d\n", + printf("nfs4_open_delegation: fh %p open %p (type: %d) stp %p\n", $fh, $open, $open->op_claim_type, $stp); printf(" : %s\n", nfs4_callback($stp)); } +global open_confirm + +probe module("nfsd").function("nfsd4_open_confirm") +{ + open_confirm = $oc +} +probe module("nfsd").function("nfsd4_open_confirm").return +{ + if ($return) { + printf("nfsd4_open_confirm: status %d\n", $return); + } else { + printf("nfsd4_open_confirm: %s\n", nfs4_openconf(open_confirm)); + } +} probe module("nfsd").function("alloc_init_deleg") { printf(" alloc_init_deleg: clp %p stp %p current_fh %p, type %d\n", @@ -14,6 +28,7 @@ probe module("nfsd").function("alloc_init_deleg").return { printf(" alloc_init_deleg: %p\n", $return); } +/* probe kernel.function("setlease") { printf(" setlease: filp %p arg %p\n", $filp, $arg); @@ -22,7 +37,6 @@ probe kernel.function("setlease").return { printf(" setlease: return %d (%s)\n", $return, errno_str($return)); } -/* probe kernel.function("security_file_lock") { printf(" security_file_lock: filp %p arg %p\n", $filp, $arg); @@ -32,7 +46,6 @@ probe kernel.function("security_file_lock").return printf(" security_file_lock: return %d (%s)\n", $return, errno_str($return)); } -*/ probe kernel.function("__setlease") { printf(" __setlease: filp %p arg %p\n", $filp, $arg); @@ -42,6 +55,7 @@ probe kernel.function("__setlease").return printf(" __setlease: return %d (%s)\n", $return, errno_str($return)); } +*/ probe begin { log("starting nfsd_deleg probe") } probe end { log("ending nfsd_deleg probe") } diff --git a/tapset/nfs4_callback.stp b/tapset/nfs4_callback.stp index 7330beb..01070e1 100644 --- a/tapset/nfs4_callback.stp +++ b/tapset/nfs4_callback.stp @@ -9,6 +9,8 @@ #include #include #include +#include +#include %} function nfs4_callback:string(_stp:long) @@ -19,14 +21,18 @@ function nfs4_callback:string(_stp:long) (long) kread(&stp->st_stateowner); struct nfs4_client *so_client = (struct nfs4_client *) (long)kread(&sop->so_client); + /* struct nfs4_callback *cb = (struct nfs4_callback *) &so_client->cl_callback; + */ + struct nfs4_cb_conn *cb = (struct nfs4_cb_conn *) + &so_client->cl_cb_conn; char buf[MAXSTRINGLEN]; int cc=0; - snprintf(buf+cc, MAXSTRINGLEN, "cb: cb_set %d so_confirmed %d", - cb->cb_set.counter, sop->so_confirmed); + snprintf(buf+cc, MAXSTRINGLEN, "cb: cb_set %d sop %p so_confirmed %d", + cb->cb_set.counter, sop, sop->so_confirmed); cc = strlen(buf); snprintf(THIS->__retvalue, MAXSTRINGLEN, "%s", buf); @@ -48,3 +54,16 @@ function nfs4_callback_addr:string(_clp:long) CATCH_DEREF_FAULT(); %} +function nfs4_openconf:string(_oc:long) +%{ + struct nfsd4_open_confirm *oc = (struct nfsd4_open_confirm *) + (long)kread(&(THIS->_oc)); + struct nfs4_stateowner *sop = (struct nfs4_stateowner *) + (long) kread(&oc->oc_stateowner); + + snprintf(THIS->__retvalue, MAXSTRINGLEN, + "sop %p so_confirmed %d", sop, sop->so_confirmed); + + CATCH_DEREF_FAULT(); + +%} -- cgit From 3e5a76b2d190f780b4089641b5a59e93c450cdf9 Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Fri, 6 Nov 2009 13:06:24 -0500 Subject: ported the nfsd_lookup routines forward to f-12 Signed-off-by: Steve Dickson --- nfsd/nfsd_lookup.stp | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/nfsd/nfsd_lookup.stp b/nfsd/nfsd_lookup.stp index 1c9e9b4..91e7ed4 100644 --- a/nfsd/nfsd_lookup.stp +++ b/nfsd/nfsd_lookup.stp @@ -15,6 +15,7 @@ probe module("nfsd").function("nfsd_lookup_dentry").return if ($return != 0) printf(" nfsd_lookup_dentry: %s\n", nfsderror($return)); } +/* probe module("nfsd").function("check_nfsd_access") { check_exp = $exp; @@ -28,6 +29,7 @@ probe module("nfsd").function("check_nfsd_access").return check_rqstp_flavor, svc_export_flavors(check_exp)); } } +*/ probe module("nfsd").function("fh_verify") { printf(" fh_verify: rqstp %p fhp %p type %d access %d\n", @@ -49,21 +51,29 @@ probe module("nfsd").function("nfsd_setuser_and_check_port").return if ($return) printf(" nfsd_setuser_and_check_port: %s\n", nfsderror($return)); } +/* probe module("nfsd").function("check_nfsd_access") { printf(" check_nfsd_access: rqstp %p exp %p \n", $rqstp, $exp); } +*/ probe module("nfsd").function("check_nfsd_access").return { if ($return) printf(" check_nfsd_access: %s\n", nfsderror($return)); } +/* probe module("nfsd").function("rqst_exp_parent") { printf(" rqst_exp_parent: rqstp %p mnt %d dentry %d\n", $rqstp, $mnt, $dentry); } +*/ +probe module("nfsd").function("rqst_exp_parent") +{ + printf(" rqst_exp_parent: rqstp %p path %p \n", $rqstp, $path); +} probe module("nfsd").function("rqst_exp_parent").return { printf(" rqst_exp_parent: %p\n", $return); @@ -87,10 +97,16 @@ probe module("nfsd").function("nfsd_cross_mnt").return printf(" nfsd_cross_mnt: %s\n", nfsderror($return)); } probe module("nfsd").function("rqst_exp_get_by_name") +{ + printf(" rqst_exp_get_by_name: rqstp %p path %p \n", $rqstp, $path); +} +/* +probe module("nfsd").function("rqst_exp_get_by_name") { printf(" rqst_exp_get_by_name: rqstp %p mnt %p dentry %p\n", $rqstp, $mnt, $dentry); } +*/ probe module("nfsd").function("rqst_exp_get_by_name").return { printf(" rqst_exp_get_by_name: %p\n", $return); -- cgit From 536fe50ff10ac2048dd5d6a3b175c9a1cc384b7a Mon Sep 17 00:00:00 2001 From: Steve Dickson Date: Sat, 7 Nov 2009 11:50:50 -0500 Subject: Fixed a stack overflow problem Added more detail to nfsd_lookup failuers Signed-off-by: Steve Dickson --- nfsd/nfsd_cacheio.stp | 7 +++++++ nfsd/nfsd_lookup.stp | 7 +++++-- tapset/cachiodata.stp | 8 ++++---- 3 files changed, 16 insertions(+), 6 deletions(-) diff --git a/nfsd/nfsd_cacheio.stp b/nfsd/nfsd_cacheio.stp index 3dc0a8d..62e65f8 100644 --- a/nfsd/nfsd_cacheio.stp +++ b/nfsd/nfsd_cacheio.stp @@ -49,11 +49,18 @@ probe module("nfsd").function("svc_export_parse").return if ($return < 0) printf(" svc_export_parse: error %s\n", errno_str($return)); } +/* probe module("nfsd").function("exp_get_by_name") { printf("exp_get_by_name: clp %p mnt %p dentry %p reqp %p\n", $clp, $mnt, $dentry, $reqp); } +*/ +probe module("nfsd").function("exp_get_by_name") +{ + printf("exp_get_by_name: clp %p path %p reqp %p\n", + $clp, $path, $reqp); +} probe module("nfsd").function("exp_get_by_name").return { printf("exp_get_by_name: return %p\n", $return); diff --git a/nfsd/nfsd_lookup.stp b/nfsd/nfsd_lookup.stp index 91e7ed4..5230248 100644 --- a/nfsd/nfsd_lookup.stp +++ b/nfsd/nfsd_lookup.stp @@ -15,21 +15,23 @@ probe module("nfsd").function("nfsd_lookup_dentry").return if ($return != 0) printf(" nfsd_lookup_dentry: %s\n", nfsderror($return)); } -/* probe module("nfsd").function("check_nfsd_access") { +/* check_exp = $exp; check_rqstp_flavor = $rqstp->rq_flavor; +*/ } probe module("nfsd").function("check_nfsd_access").return { if ($return != 0) { printf(" check_nfsd_access: %s\n", nfsderror($return)); +/* printf(" : rq_flavor %d %s\n", check_rqstp_flavor, svc_export_flavors(check_exp)); +*/ } } -*/ probe module("nfsd").function("fh_verify") { printf(" fh_verify: rqstp %p fhp %p type %d access %d\n", @@ -45,6 +47,7 @@ probe module("nfsd").function("nfsd_setuser_and_check_port") { printf(" nfsd_setuser_and_check_port: rqstp %p exp %p \n", $rqstp, $exp); + printf(" : %s\n", svc_export_dump($exp)); } probe module("nfsd").function("nfsd_setuser_and_check_port").return { diff --git a/tapset/cachiodata.stp b/tapset/cachiodata.stp index 441e9fa..4b7ac1a 100644 --- a/tapset/cachiodata.stp +++ b/tapset/cachiodata.stp @@ -2,7 +2,7 @@ function svc_export_data:string(msg:string) %{ char *tmp, *ptr, *str; - char buf[1024], cc; + char buf[512], cc; str = ptr = THIS->msg; tmp = buf; @@ -71,7 +71,7 @@ function svc_export_data:string(msg:string) function ip_map_data:string(msg:string) %{ char *tmp, *ptr, *str; - char buf[1024], cc; + char buf[512], cc; str = ptr = THIS->msg; tmp = buf; @@ -99,7 +99,7 @@ function ip_map_data:string(msg:string) function expkey_data:string(msg:string) %{ char *tmp, *ptr, *str; - char buf[1024], cc; + char buf[512], cc; str = ptr = THIS->msg; tmp = buf; @@ -134,7 +134,7 @@ function expkey_data:string(msg:string) function idtoname_data:string(msg:string) %{ char *tmp, *ptr, *str; - char buf[1024], cc; + char buf[512], cc; str = ptr = THIS->msg; tmp = buf; -- cgit