diff options
Diffstat (limited to 'tapset')
| -rw-r--r-- | tapset/ChangeLog | 6 | ||||
| -rw-r--r-- | tapset/LKET/Changelog | 10 | ||||
| -rwxr-xr-x | tapset/LKET/hookid_defs.stp | 132 | ||||
| -rwxr-xr-x | tapset/LKET/register_event.stp | 139 | ||||
| -rwxr-xr-x | tapset/LKET/rpc.stp | 796 | ||||
| -rw-r--r-- | tapset/rpc.stp | 522 |
6 files changed, 1426 insertions, 179 deletions
diff --git a/tapset/ChangeLog b/tapset/ChangeLog index 00b372d1..4e53cc01 100644 --- a/tapset/ChangeLog +++ b/tapset/ChangeLog @@ -1,3 +1,9 @@ +2006-09-19 Li Guanglei <guanglei@cn.ibm.com> + + From Gui Jian <guijian@cn.ibm.com> + + * rpc.stp: Some changes and more comments of RPC tapset + 2006-09-18 Martin Hunt <hunt@redhat.com> * logging.stp (stp_print_binary): New function. diff --git a/tapset/LKET/Changelog b/tapset/LKET/Changelog index 0bb71f14..99e8d3ab 100644 --- a/tapset/LKET/Changelog +++ b/tapset/LKET/Changelog @@ -1,3 +1,13 @@ +2006-09-19 Li Guanglei <guanglei@cn.ibm.com> + + From Gui Jian <guijian@cn.ibm.com> + + * rpc.stp: New trace hooks for RPC activities on client, + server and scheduler. + * register_event.stp: Add the register_sys_event() calls + for new RPC trace hooks + * hookid_defs.stp: Add the definitions of RPC trace hooks + 2006-09-15 Li Guanglei <guanglei@cn.ibm.com> * *.stp: Make sure all integers passed into _lket_trace() diff --git a/tapset/LKET/hookid_defs.stp b/tapset/LKET/hookid_defs.stp index 71684425..c8896a56 100755 --- a/tapset/LKET/hookid_defs.stp +++ b/tapset/LKET/hookid_defs.stp @@ -132,6 +132,50 @@ global HOOKID_SIGNAL_FLUSH_ENTRY, + /* RPC */ + GROUP_SUNRPC, + + HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY, + HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN, + HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY, + HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN, + HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY, + HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN, + HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY, + HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN, + HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY, + HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN, + HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY, + HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN, + HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY, + HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN, + + HOOKID_SUNRPC_SVC_REGISTER_ENTRY, + HOOKID_SUNRPC_SVC_REGISTER_RETURN, + HOOKID_SUNRPC_SVC_CREATE_ENTRY, + HOOKID_SUNRPC_SVC_CREATE_RETURN, + HOOKID_SUNRPC_SVC_DESTROY_ENTRY, + HOOKID_SUNRPC_SVC_DESTROY_RETURN, + HOOKID_SUNRPC_SVC_PROCESS_ENTRY, + HOOKID_SUNRPC_SVC_PROCESS_RETURN, + HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY, + HOOKID_SUNRPC_SVC_AUTHORISE_RETURN, + HOOKID_SUNRPC_SVC_RECV_ENTRY, + HOOKID_SUNRPC_SVC_RECV_RETURN, + HOOKID_SUNRPC_SVC_SEND_ENTRY, + HOOKID_SUNRPC_SVC_SEND_RETURN, + HOOKID_SUNRPC_SVC_DROP_ENTRY, + HOOKID_SUNRPC_SVC_DROP_RETURN, + + HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY, + HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN, + HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY, + HOOKID_SUNRPC_SCHED_EXECUTE_RETURN, + HOOKID_SUNRPC_SCHED_DELAY_ENTRY, + HOOKID_SUNRPC_SCHED_DELAY_RETURN, + HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY, + HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN, + /* CPU Frequency */ GROUP_CPUFREQ, @@ -304,6 +348,7 @@ global HOOKID_NFSD_PROC_CREATE_ENTRY, HOOKID_NFSD_PROC_CREATE_RETURN + %{ /* used in embedded c codes */ @@ -319,6 +364,7 @@ int _GROUP_NETDEV = 8; int _GROUP_IOSYSCALL = 9; int _GROUP_AIO = 10; int _GROUP_SIGNAL = 11; +int _GROUP_SUNRPC = 12; int _GROUP_CPUFREQ = 15; int _GROUP_NFS = 16; int _GROUP_NFSD = 17; @@ -428,6 +474,47 @@ int _HOOKID_SIGNAL_PROC_MASK_ENTRY = 13; int _HOOKID_SIGNAL_PROC_MASK_RETURN = 14; int _HOOKID_SIGNAL_FLUSH_ENTRY = 15; +int _HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY = 1; +int _HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN = 2; +int _HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY = 3; +int _HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN = 4; +int _HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY = 5; +int _HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN = 6; +int _HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY = 7; +int _HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN = 8; +int _HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY = 9; +int _HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN = 10; +int _HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY = 11; +int _HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN = 12; +int _HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY = 13; +int _HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN = 14; + +int _HOOKID_SUNRPC_SVC_REGISTER_ENTRY = 33; +int _HOOKID_SUNRPC_SVC_REGISTER_RETURN = 34; +int _HOOKID_SUNRPC_SVC_CREATE_ENTRY = 35; +int _HOOKID_SUNRPC_SVC_CREATE_RETURN = 36; +int _HOOKID_SUNRPC_SVC_DESTROY_ENTRY = 37; +int _HOOKID_SUNRPC_SVC_DESTROY_RETURN = 38; +int _HOOKID_SUNRPC_SVC_PROCESS_ENTRY = 39; +int _HOOKID_SUNRPC_SVC_PROCESS_RETURN = 40; +int _HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY = 41; +int _HOOKID_SUNRPC_SVC_AUTHORISE_RETURN = 42; +int _HOOKID_SUNRPC_SVC_RECV_ENTRY = 43; +int _HOOKID_SUNRPC_SVC_RECV_RETURN = 44; +int _HOOKID_SUNRPC_SVC_SEND_ENTRY = 45; +int _HOOKID_SUNRPC_SVC_SEND_RETURN = 46; +int _HOOKID_SUNRPC_SVC_DROP_ENTRY = 47; +int _HOOKID_SUNRPC_SVC_DROP_RETURN = 48; + +int _HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY = 65; +int _HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN = 66; +int _HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY = 67; +int _HOOKID_SUNRPC_SCHED_EXECUTE_RETURN = 68; +int _HOOKID_SUNRPC_SCHED_DELAY_ENTRY = 69; +int _HOOKID_SUNRPC_SCHED_DELAY_RETURN = 70; +int _HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY = 71; +int _HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN = 72; + int _HOOKID_SWITCH_CPUFREQ = 1; int _HOOKID_NFS_FOP_LLSEEK_ENTRY= 1; @@ -540,7 +627,6 @@ int _HOOKID_NFSD_PROC_RENAME_ENTRY= 35; int _HOOKID_NFSD_PROC_RENAME_RETURN= 36; int _HOOKID_NFSD_PROC_CREATE_ENTRY= 37; int _HOOKID_NFSD_PROC_CREATE_RETURN= 38; - %} function hookid_init() @@ -668,6 +754,49 @@ function hookid_init() HOOKID_SIGNAL_PROC_MASK_RETURN = 14 HOOKID_SIGNAL_FLUSH_ENTRY = 15 + GROUP_SUNRPC = 12 + + HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY = 1 + HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN = 2 + HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY = 3 + HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN = 4 + HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY = 5 + HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN = 6 + HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY = 7 + HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN = 8 + HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY = 9 + HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN = 10 + HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY = 11 + HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN = 12 + HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY = 13 + HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN = 14 + + HOOKID_SUNRPC_SVC_REGISTER_ENTRY = 33 + HOOKID_SUNRPC_SVC_REGISTER_RETURN = 34 + HOOKID_SUNRPC_SVC_CREATE_ENTRY = 35 + HOOKID_SUNRPC_SVC_CREATE_RETURN = 36 + HOOKID_SUNRPC_SVC_DESTROY_ENTRY = 37 + HOOKID_SUNRPC_SVC_DESTROY_RETURN = 38 + HOOKID_SUNRPC_SVC_PROCESS_ENTRY = 39 + HOOKID_SUNRPC_SVC_PROCESS_RETURN = 40 + HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY = 41 + HOOKID_SUNRPC_SVC_AUTHORISE_RETURN = 42 + HOOKID_SUNRPC_SVC_RECV_ENTRY = 43 + HOOKID_SUNRPC_SVC_RECV_RETURN = 44 + HOOKID_SUNRPC_SVC_SEND_ENTRY = 45 + HOOKID_SUNRPC_SVC_SEND_RETURN = 46 + HOOKID_SUNRPC_SVC_DROP_ENTRY = 47 + HOOKID_SUNRPC_SVC_DROP_RETURN = 48 + + HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY = 65 + HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN = 66 + HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY = 67 + HOOKID_SUNRPC_SCHED_EXECUTE_RETURN = 68 + HOOKID_SUNRPC_SCHED_DELAY_ENTRY = 69 + HOOKID_SUNRPC_SCHED_DELAY_RETURN = 70 + HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY = 71 + HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN = 72 + GROUP_CPUFREQ = 15 HOOKID_SWITCH_CPUFREQ = 2 @@ -787,7 +916,6 @@ function hookid_init() HOOKID_NFSD_PROC_RENAME_RETURN= 36 HOOKID_NFSD_PROC_CREATE_ENTRY= 37 HOOKID_NFSD_PROC_CREATE_RETURN= 38 - } diff --git a/tapset/LKET/register_event.stp b/tapset/LKET/register_event.stp index 0809146f..8579e9c3 100755 --- a/tapset/LKET/register_event.stp +++ b/tapset/LKET/register_event.stp @@ -10,8 +10,8 @@ global usr_evt_name, usr_evt_fmt %{ -#define _MAXGROUPID 20 -#define _MAXHOOKID 80 +#define _MAXGROUPID 0xFF +#define _MAXHOOKID 0xFF int get_fmtcode(char *fmt) { @@ -321,6 +321,139 @@ function register_sys_events() register_sys_event(GROUP_SIGNAL, HOOKID_SIGNAL_FLUSH_ENTRY, "INT32", "pid") + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY, + "STRING:INT64:INT8:INT16:INT16:INT8", + "server:prog:vers:prot:port:authflavor") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY, + "STRING:INT64:INT16:INT16:INT32", + "server:prog:tasks:clones:rpccount") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY, + "STRING:INT64:INT16:INT16:INT32", + "server:prog:clones:tasks:rpccount") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN, + "INT8", "void") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY, + "STRING:INT64:INT8:INT64:INT8", + "server:old_prog:old_vers:new_prog:new_vers") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY, + "STRING:INT64:INT8:INT64:INT64", + "server:prog:vers:proc:flags") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY, + "STRING:INT64:INT8:INT64:INT64", + "server:prog:vers:proc:flags") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY, + "INT64:INT64", + "tk_pid:tk_flags") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN, + "INT8", "void") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_REGISTER_ENTRY, + "STRING:INT64:INT16:INT32", + "service:program:protocol:prot") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_REGISTER_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_CREATE_ENTRY, + "INT64:INT8:INT8", + "program:high_version:num_versions") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_CREATE_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_DESTROY_ENTRY, + "STRING:INT64:INT32", + "service:program:num_threads") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_DESTROY_RETURN, + "INT8", "void") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_PROCESS_ENTRY, + "STRING:INT64:INT64:INT64:INT64:INT8:INT8", + "service:sv_prog:peer_ip:rq_xid:rq_prog:rq_vers:rq_proc") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_PROCESS_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY, + "INT64:INT64:INT64:INT8:INT64", + "peer_ip:xid:prog:vers:proc") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_AUTHORISE_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_SEND_ENTRY, + "STRING:INT64:INT64:INT64:INT64:INT8:INT64", + "sv_name:peer_ip:sv_prog:xid:prog:vers:proc") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_SEND_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_RECV_ENTRY, + "STRING:INT64", + "sv_name:timeout") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_RECV_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_DROP_ENTRY, + "STRING:INT64:INT64:INT64:INT8:INT64", + "sv_name:peer_ip:xid:prog:vers:proc") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SVC_DROP_RETURN, + "INT8", "void") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY, + "INT64:INT64:INT8:INT64:INT64", + "xid:prog:vers:prot:flags") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY, + "INT64:INT64:INT8:INT64:INT64", + "xid:prog:vers:prot:flags") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN, + "INT8", "void") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY, + "INT64:INT64:INT8:INT64:INT64:INT64", + "xid:prog:vers:prot:tk_pid:tk_flags") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SCHED_EXECUTE_RETURN, + "INT64", "return") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SCHED_DELAY_ENTRY, + "INT64:INT64:INT64:INT64:INT64", + "xid:prog:tk_pid:tk_flags:delay") + + register_sys_event(GROUP_SUNRPC, HOOKID_SUNRPC_SCHED_DELAY_RETURN, + "INT8", "void") + register_sys_event(GROUP_CPUFREQ, HOOKID_SWITCH_CPUFREQ, "INT64", "cpufreq") @@ -595,7 +728,6 @@ function register_sys_events() register_sys_event(GROUP_NFSD, HOOKID_NFSD_RENAME_RETURN, "INT32","return") - register_sys_event(GROUP_NFSD, HOOKID_NFSD_CLOSE_ENTRY, "STRING", "filename") @@ -648,6 +780,7 @@ function register_sys_events() "size:ino0:ino1:ino2:version:filename") register_sys_event(GROUP_NFSD, HOOKID_NFSD_PROC_CREATE_RETURN, "INT32","return") + reset_maxaction() } diff --git a/tapset/LKET/rpc.stp b/tapset/LKET/rpc.stp new file mode 100755 index 00000000..256df6e9 --- /dev/null +++ b/tapset/LKET/rpc.stp @@ -0,0 +1,796 @@ +# SunRPC trace hooks +# Copyright (C) 2006 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. +# +probe never +{ + printf("%d\n", GROUP_SUNRPC) +} + +probe addevent.sunrpc + = addevent.sunrpc.entry, addevent.sunrpc.return +{} + +probe addevent.sunrpc.entry + = + addevent.sunrpc.clnt.entry, + addevent.sunrpc.svc.entry, + addevent.sunrpc.sched.entry +{} + +probe addevent.sunrpc.return + = + addevent.sunrpc.clnt.return, + addevent.sunrpc.svc.return, + addevent.sunrpc.sched.return +{} + +/****************************************************************** + * trace hooks on high level RPC client functions * + ******************************************************************/ +probe addevent.sunrpc.clnt + = addevent.sunrpc.clnt.entry, addevent.sunrpc.clnt.return +{} + +probe addevent.sunrpc.clnt.entry + = + addevent.sunrpc.clnt.create_client.entry, + addevent.sunrpc.clnt.clone_client.entry, + addevent.sunrpc.clnt.bind_new_program.entry, + addevent.sunrpc.clnt.shutdown_client.entry, + addevent.sunrpc.clnt.call_sync.entry, + addevent.sunrpc.clnt.call_async.entry, + addevent.sunrpc.clnt.restart_call.entry +{} + +probe addevent.sunrpc.clnt.return + = + addevent.sunrpc.clnt.create_client.return, + addevent.sunrpc.clnt.clone_client.return, + addevent.sunrpc.clnt.bind_new_program.return, + addevent.sunrpc.clnt.shutdown_client.return, + addevent.sunrpc.clnt.call_sync.return, + addevent.sunrpc.clnt.call_async.return, + addevent.sunrpc.clnt.restart_call.return +{} + +// Fires when an RPC client is to be created +probe addevent.sunrpc.clnt.create_client.entry + += _addevent.sunrpc.clnt.create_client.entry +{ + update_record() +} + +probe _addevent.sunrpc.clnt.create_client.entry + = sunrpc.clnt.create_client +{ + log_sunrpc_client_info(HOOKID_SUNRPC_CLNT_CREATE_CLIENT_ENTRY, + servername, prog, vers, prot, port, authflavor) +} + +probe addevent.sunrpc.clnt.create_client.return + += _addevent.sunrpc.clnt.create_client.return +{ + update_record() +} + +probe _addevent.sunrpc.clnt.create_client.return + = sunrpc.clnt.create_client.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_CREATE_CLIENT_RETURN, + $return) +} + +// Fires when the RPC client structure is to be cloned +probe addevent.sunrpc.clnt.clone_client.entry + += _addevent.sunrpc.clnt.clone_client.entry +{ + update_record() +} + +probe _addevent.sunrpc.clnt.clone_client.entry + = sunrpc.clnt.clone_client +{ + log_sunrpc_client_info(HOOKID_SUNRPC_CLNT_CLONE_CLIENT_ENTRY, + servername, prog, vers, prot, port, authflavor) +} + +probe addevent.sunrpc.clnt.clone_client.return + += _addevent.sunrpc.clnt.clone_client.return +{ + update_record() +} + +probe _addevent.sunrpc.clnt.clone_client.return + = sunrpc.clnt.clone_client.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_CLONE_CLIENT_RETURN, + $return) +} + +// Fires when an RPC client is to be shut down. +probe addevent.sunrpc.clnt.shutdown_client.entry + += _addevent.sunrpc.clnt.shutdown_client.entry +{ + update_record() +} + +probe _addevent.sunrpc.clnt.shutdown_client.entry + = sunrpc.clnt.shutdown_client +{ + log_sunrpc_shutdown_client(HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_ENTRY, + servername, prog, clones, tasks, rpccnt) +} + +probe addevent.sunrpc.clnt.shutdown_client.return + += _addevent.sunrpc.clnt.shutdown_client.return +{ + update_record() +} + +probe _addevent.sunrpc.clnt.shutdown_client.return + = sunrpc.clnt.shutdown_client.return +{ + log_sunrpc_return_void(HOOKID_SUNRPC_CLNT_SHUTDOWN_CLIENT_RETURN) +} + +function log_sunrpc_shutdown_client(hookid:long, servername:string, + prog:long, clones:long, tasks:long, rpccnt:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%2b%2b%4b", + THIS->servername, (_FMT_)THIS->prog, + (_FMT_)THIS->clones, (_FMT_)THIS->tasks, + (_FMT_)THIS->rpccnt); +%} + +// Fires when a new RPC program is to be bound an existing client +probe addevent.sunrpc.clnt.bind_new_program.entry + += _addevent.sunrpc.clnt.bind_new_program.entry +{ + update_record() +} + +probe _addevent.sunrpc.clnt.bind_new_program.entry + = sunrpc.clnt.bind_new_program +{ + log_sunrpc_bind_new_program(HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_ENTRY, + servername, old_prog, old_vers, prog, vers) +} + +probe addevent.sunrpc.clnt.bind_new_program.return + += _addevent.sunrpc.clnt.bind_new_program.return +{ + update_record() +} + +probe _addevent.sunrpc.clnt.bind_new_program.return + = sunrpc.clnt.bind_new_program.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_BIND_NEW_PROGRAM_RETURN, + $return) +} + +function log_sunrpc_bind_new_program(hookid:long, servername:string, + old_prog:long, old_vers:long, prog:long, vers:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%1b%8b%1b", + THIS->servername, (_FMT_)THIS->old_prog, + (_FMT_)THIS->old_vers, (_FMT_)THIS->prog, + (_FMT_)THIS->vers); +%} + +// rpc_call_sync +probe addevent.sunrpc.clnt.call_sync.entry + += _addevent.sunrpc.clnt.call_sync.entry +{ + update_record() +} + +probe _addevent.sunrpc.clnt.call_sync.entry + = sunrpc.clnt.call_sync +{ + log_sunrpc_call_sync(HOOKID_SUNRPC_CLNT_CALL_SYNC_ENTRY, servername, + prog, vers, proc, flags) +} + +probe addevent.sunrpc.clnt.call_sync.return + += _addevent.sunrpc.clnt.call_sync.return +{ + update_record() +} + +probe _addevent.sunrpc.clnt.call_sync.return + = sunrpc.clnt.call_sync.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_CALL_SYNC_RETURN, $return) +} + +function log_sunrpc_call_sync(hookid:long, servername:string, prog:long, + vers:long, proc:long, flags:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%1b%8b%8b", + THIS->servername, (_FMT_)THIS->prog, + (_FMT_)THIS->vers, (_FMT_)THIS->proc, + (_FMT_)THIS->flags); +%} + +// rpc_call_async +probe addevent.sunrpc.clnt.call_async.entry + += _addevent.sunrpc.clnt.call_async.entry +{ + update_record() +} + +probe _addevent.sunrpc.clnt.call_async.entry + = sunrpc.clnt.call_async +{ + log_sunrpc_call_async(HOOKID_SUNRPC_CLNT_CALL_ASYNC_ENTRY, servername, + prog, vers, proc, flags) +} + +probe addevent.sunrpc.clnt.call_async.return + += _addevent.sunrpc.clnt.call_async.return +{ + update_record() +} + +probe _addevent.sunrpc.clnt.call_async.return + = sunrpc.clnt.call_async.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_CLNT_CALL_ASYNC_RETURN, $return) +} + +function log_sunrpc_call_async(hookid:long, servername:string, prog:long, + vers:long, proc:long, flags:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%1b%8b%8b", + THIS->servername, (_FMT_)THIS->prog, + (_FMT_)THIS->vers, (_FMT_)THIS->proc, + (_FMT_)THIS->flags); +%} + +// Fires when want to restart a task +probe addevent.sunrpc.clnt.restart_call.entry + += _addevent.sunrpc.clnt.restart_call.entry +{ + update_record() +} + +probe _addevent.sunrpc.clnt.restart_call.entry + = sunrpc.clnt.restart_call +{ + log_sunrpc_restart_call(HOOKID_SUNRPC_CLNT_RESTART_CALL_ENTRY, tk_pid, + tk_flags) +} + +probe addevent.sunrpc.clnt.restart_call.return + += _addevent.sunrpc.clnt.restart_call.return +{ + update_record() +} + +probe _addevent.sunrpc.clnt.restart_call.return + = sunrpc.clnt.restart_call.return +{ + log_sunrpc_return_void(HOOKID_SUNRPC_CLNT_RESTART_CALL_RETURN) //void +} + +function log_sunrpc_restart_call(hookid:long, tk_pid:long, tk_flags:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b", + (_FMT_)THIS->tk_pid, (_FMT_)THIS->tk_flags); +%} + +/********************************************* + * Probe points on RPC server interface * + ********************************************/ +probe addevent.sunrpc.svc + = addevent.sunrpc.svc.entry, addevent.sunrpc.svc.return +{} + +probe addevent.sunrpc.svc.entry + = + addevent.sunrpc.svc.register.entry, + addevent.sunrpc.svc.create.entry, + addevent.sunrpc.svc.destroy.entry, + addevent.sunrpc.svc.process.entry, + addevent.sunrpc.svc.authorise.entry, + addevent.sunrpc.svc.recv.entry, + addevent.sunrpc.svc.send.entry, + addevent.sunrpc.svc.drop.entry +{} + +probe addevent.sunrpc.svc.return + = + addevent.sunrpc.svc.register.return, + addevent.sunrpc.svc.create.return, + addevent.sunrpc.svc.destroy.return, + addevent.sunrpc.svc.process.return, + addevent.sunrpc.svc.authorise.return, + addevent.sunrpc.svc.recv.return, + addevent.sunrpc.svc.send.return, + addevent.sunrpc.svc.drop.return +{} + +// Fires when an RPC service is to be registered with the local portmapper. +probe addevent.sunrpc.svc.register.entry + += _addevent.sunrpc.svc.register.entry +{ + update_record() +} + +probe _addevent.sunrpc.svc.register.entry + = sunrpc.svc.register +{ + log_sunrpc_svc_register(HOOKID_SUNRPC_SVC_REGISTER_ENTRY, sv_name, + prog, prot, port) +} + +probe addevent.sunrpc.svc.register.return + += _addevent.sunrpc.svc.register.return +{ + update_record() +} + +probe _addevent.sunrpc.svc.register.return + = sunrpc.svc.register.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_REGISTER_RETURN, + $return) +} + +function log_sunrpc_svc_register(hookid:long, sv_name:string, + prog:long, prot:long, port:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%2b%4b", + THIS->sv_name, (_FMT_)THIS->prog, + (_FMT_)THIS->prot, (_FMT_)THIS->port); +%} + +// Fires when an RPC service is to be created +probe addevent.sunrpc.svc.create.entry + += _addevent.sunrpc.svc.create.entry +{ + update_record() +} + +probe _addevent.sunrpc.svc.create.entry + = sunrpc.svc.create +{ + log_sunrpc_svc_create(HOOKID_SUNRPC_SVC_CREATE_ENTRY, prog, + pg_nvers, bufsize) +} + +probe addevent.sunrpc.svc.create.return + += _addevent.sunrpc.svc.create.return +{ + update_record() +} + +probe _addevent.sunrpc.svc.create.return + = sunrpc.svc.create.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_CREATE_RETURN, $return) +} + +function log_sunrpc_svc_create(hookid:long, prog:long, + pg_nvers:long, bufsize:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%1b%4b", + (_FMT_)THIS->prog, (_FMT_)THIS->pg_nvers, + (_FMT_)THIS->bufsize); +%} + +// Fires when an RPC service is to be destroyed +probe addevent.sunrpc.svc.destroy.entry + += _addevent.sunrpc.svc.destroy.entry +{ + update_record() +} + +probe _addevent.sunrpc.svc.destroy.entry + = sunrpc.svc.destroy +{ + log_sunrpc_svc_destroy(HOOKID_SUNRPC_SVC_DESTROY_ENTRY, + sv_name, sv_prog, sv_nrthreads) +} + +probe addevent.sunrpc.svc.destroy.return + += _addevent.sunrpc.svc.destroy.return +{ + update_record() +} + +probe _addevent.sunrpc.svc.destroy.return + = sunrpc.svc.destroy.return +{ + log_sunrpc_return_void(HOOKID_SUNRPC_SVC_DESTROY_RETURN) +} + +function log_sunrpc_svc_destroy(hookid:long, sv_name:string, + sv_prog:long, sv_nrthreads:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%4b", THIS->sv_name, + (_FMT_)THIS->sv_prog, (_FMT_)THIS->sv_nrthreads); +%} + +// Fires when an RPC request is to be processed +probe addevent.sunrpc.svc.process.entry + += _addevent.sunrpc.svc.process.entry +{ + update_record() +} +probe _addevent.sunrpc.svc.process.entry + = sunrpc.svc.process +{ + log_sunrpc_task_info(HOOKID_SUNRPC_SVC_PROCESS_ENTRY, sv_name, + sv_prog, peer_ip, rq_xid, rq_prog, rq_vers, rq_proc) +} + +probe addevent.sunrpc.svc.process.return + += _addevent.sunrpc.svc.process.return +{ + update_record() +} + +probe _addevent.sunrpc.svc.process.return + = sunrpc.svc.process.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_PROCESS_RETURN, $return) +} + +// Fires when an RPC request is to be authorised +probe addevent.sunrpc.svc.authorise.entry + += _addevent.sunrpc.svc.authorise.entry +{ + update_record() +} + +probe _addevent.sunrpc.svc.authorise.entry + = sunrpc.svc.authorise +{ + log_sunrpc_svc_authorise(HOOKID_SUNRPC_SVC_AUTHORISE_ENTRY, sv_name, + peer_ip, rq_xid, rq_prog, rq_vers, rq_proc) +} + +probe addevent.sunrpc.svc.authorise.return + += _addevent.sunrpc.svc.authorise.return +{ + update_record() +} + +probe _addevent.sunrpc.svc.authorise.return + = sunrpc.svc.authorise.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_AUTHORISE_RETURN, $return) +} + +function log_sunrpc_svc_authorise(hookid:long, sv_name:string, peer_ip:long, + rq_xid:long, rq_prog:long, rq_vers:long, rq_proc:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%s%8b%8b%8b%1b%8b", + THIS->sv_name, (_FMT_)THIS->peer_ip, + (_FMT_)THIS->rq_xid, (_FMT_)THIS->rq_prog, + (_FMT_)THIS->rq_vers, (_FMT_)THIS->rq_proc); +%} + +/* + * Fires when receiving the next request on any socket. + */ +probe addevent.sunrpc.svc.recv.entry + += _addevent.sunrpc.svc.recv.entry +{ + update_record() +} + +probe _addevent.sunrpc.svc.recv.entry + = sunrpc.svc.recv +{ + log_sunrpc_svc_recv(HOOKID_SUNRPC_SVC_SEND_ENTRY, sv_name, timeout) +} + +probe addevent.sunrpc.svc.recv.return + += _addevent.sunrpc.svc.recv.return +{ + update_record() +} + +probe _addevent.sunrpc.svc.recv.return + = sunrpc.svc.recv.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_SEND_RETURN, $return) +} + +function log_sunrpc_svc_recv(hookid:long, sv_name:string, timeout:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%s%8b", THIS->sv_name, + (_FMT_)THIS->timeout); +%} + +// Fires when want to return reply to client. +probe addevent.sunrpc.svc.send.entry + += _addevent.sunrpc.svc.send.entry +{ + update_record() +} + +probe _addevent.sunrpc.svc.send.entry + = sunrpc.svc.send +{ + log_sunrpc_svc_send(HOOKID_SUNRPC_SVC_SEND_ENTRY, sv_name, peer_ip, + rq_xid, rq_prog, rq_vers, rq_proc) +} + +probe addevent.sunrpc.svc.send.return + += _addevent.sunrpc.svc.send.return +{ + update_record() +} + +probe _addevent.sunrpc.svc.send.return + = sunrpc.svc.send.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_SVC_SEND_RETURN, $return) +} + +function log_sunrpc_svc_send(hookid:long, sv_name:string, peer_ip:long, + rq_xid:long, rq_prog:long, rq_vers:long, rq_proc:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%s%8b%8b%8b%8b%1b%8b", + THIS->sv_name, (_FMT_)THIS->peer_ip, + (_FMT_)THIS->rq_xid, (_FMT_)THIS->rq_prog, + (_FMT_)THIS->rq_vers, (_FMT_)THIS->rq_proc); +%} + +// Fires when a request is to be dropped +probe addevent.sunrpc.svc.drop.entry + += _addevent.sunrpc.svc.drop.entry +{ + update_record() +} + +probe _addevent.sunrpc.svc.drop.entry + = sunrpc.svc.drop +{ + log_sunrpc_svc_drop(HOOKID_SUNRPC_SVC_DROP_ENTRY, sv_name, peer_ip, + rq_xid, rq_prog, rq_vers, rq_proc) +} + +probe addevent.sunrpc.svc.drop.return + += _addevent.sunrpc.svc.drop.return +{ + update_record() +} + +probe _addevent.sunrpc.svc.drop.return + = sunrpc.svc.drop.return +{ + log_sunrpc_return_void(HOOKID_SUNRPC_SVC_DROP_RETURN) +} + +function log_sunrpc_svc_drop(hookid:long, sv_name:string, peer_ip:long, + rq_xid:long, rq_prog:long, rq_vers:long, rq_proc:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%s%8b%8b%8b%1b%8b", + THIS->sv_name, (_FMT_)THIS->peer_ip, + (_FMT_)THIS->rq_xid, (_FMT_)THIS->rq_prog, + (_FMT_)THIS->rq_vers, (_FMT_)THIS->rq_proc); +%} + +/******************************************************************* + * Probe points on RPC scheduler * + ******************************************************************/ +probe addevent.sunrpc.sched + = addevent.sunrpc.sched.entry, addevent.sunrpc.sched.return +{} + +probe addevent.sunrpc.sched.entry + = + addevent.sunrpc.sched.new_task.entry, + addevent.sunrpc.sched.execute.entry, + addevent.sunrpc.sched.delay.entry, + addevent.sunrpc.sched.release_task.entry +{} + +probe addevent.sunrpc.sched.return + = + addevent.sunrpc.sched.new_task.return, + addevent.sunrpc.sched.execute.return, + addevent.sunrpc.sched.delay.return, + addevent.sunrpc.sched.release_task.return +{} + +// Fires when creating a new task for the specified client +probe addevent.sunrpc.sched.new_task.entry + += _addevent.sunrpc.sched.new_task.entry +{ + update_record() +} + +probe _addevent.sunrpc.sched.new_task.entry + = sunrpc.sched.new_task +{ + log_sunrpc_new_task(HOOKID_SUNRPC_SCHED_NEW_TASK_ENTRY, xid, prog, + vers, prot, flags) +} + +probe addevent.sunrpc.sched.new_task.return + += _addevent.sunrpc.sched.new_task.return +{ + update_record() +} + +probe _addevent.sunrpc.sched.new_task.return + = sunrpc.sched.new_task.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_SCHED_NEW_TASK_RETURN, $return) +} + +function log_sunrpc_new_task(hookid:long, xid:long, prog:long, vers:long, + prot:long, flags:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b%1b%8b%8b", + (_FMT_)THIS->xid, (_FMT_)THIS->prog, + (_FMT_)THIS->vers, (_FMT_)THIS->prot, + (_FMT_)THIS->flags); +%} + +// Fires when releasing a task +probe addevent.sunrpc.sched.release_task.entry + += _addevent.sunrpc.sched.release_task.entry +{ + update_record() +} + +probe _addevent.sunrpc.sched.release_task.entry + = sunrpc.sched.release_task +{ + log_sunrpc_release_task(HOOKID_SUNRPC_SCHED_RELEASE_TASK_ENTRY, + xid, prog, vers, prot, tk_flags) +} + +probe addevent.sunrpc.sched.release_task.return + += _addevent.sunrpc.sched.release_task.return +{ + update_record() +} + +probe _addevent.sunrpc.sched.release_task.return + = sunrpc.sched.release_task.return +{ + log_sunrpc_return_void(HOOKID_SUNRPC_SCHED_RELEASE_TASK_RETURN) +} + +function log_sunrpc_release_task(hookid:long, xid:long, prog:long, vers:long, + prot:long, flags:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b%1b%8b%8b", + (_FMT_)THIS->xid, (_FMT_)THIS->prog, + (_FMT_)THIS->vers, (_FMT_)THIS->prot, + (_FMT_)THIS->flags); +%} + +// Fires when an RPC request is to be executed +probe addevent.sunrpc.sched.execute.entry + += _addevent.sunrpc.sched.execute.entry +{ + update_record() +} + +probe _addevent.sunrpc.sched.execute.entry + = sunrpc.sched.execute +{ + log_sunrpc_execute(HOOKID_SUNRPC_SCHED_EXECUTE_ENTRY, xid, prog, + vers, prot, tk_pid, tk_flags) +} + +probe addevent.sunrpc.sched.execute.return + += _addevent.sunrpc.sched.execute.return +{ + update_record() +} + +probe _addevent.sunrpc.sched.execute.return + = sunrpc.sched.execute.return +{ + log_sunrpc_return_int64(HOOKID_SUNRPC_SCHED_EXECUTE_RETURN, $return) +} + +function log_sunrpc_execute(hookid:long, xid:long, prog:long, vers:long, + prot:long, tk_pid:long, tk_flags:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b%1b%8b%8b%8b", + (_FMT_)THIS->xid, (_FMT_)THIS->prog, + (_FMT_)THIS->vers, (_FMT_)THIS->prot, + (_FMT_)THIS->tk_pid, (_FMT_)THIS->tk_flags); +%} + +// Fires when want to delay an RPC request +probe addevent.sunrpc.sched.delay.entry + += _addevent.sunrpc.sched.delay.entry +{ + update_record() +} + +probe _addevent.sunrpc.sched.delay.entry + = sunrpc.sched.delay +{ + log_sunrpc_delay(HOOKID_SUNRPC_SCHED_DELAY_ENTRY, xid, prog, + tk_pid, tk_flags, delay) +} + +probe addevent.sunrpc.sched.delay.return + += _addevent.sunrpc.sched.delay.return +{ + update_record() +} + +probe _addevent.sunrpc.sched.delay.return + = sunrpc.sched.delay.return +{ + log_sunrpc_return_void(HOOKID_SUNRPC_SCHED_DELAY_RETURN) +} + +function log_sunrpc_delay(hookid:long, xid:long, prog:long, tk_pid:long, + tk_flags:long, delay:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b%8b%8b%8b%8b", + (_FMT_)THIS->xid, (_FMT_)THIS->prog, + (_FMT_)THIS->tk_pid, (_FMT_)THIS->tk_flags, + (_FMT_)THIS->delay); +%} + +/****************************************************************** + * Helper functions * + *****************************************************************/ +function log_sunrpc_client_info(hookid:long, servername:string, + prog:long, vers:long, prot:long, + port:long, authflavor:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%1b%2b%2b%1b", + THIS->servername, (_FMT_)THIS->prog, + (_FMT_)THIS->vers, (_FMT_)THIS->prot, + (_FMT_)THIS->port, (_FMT_)THIS->authflavor); +%} + +function log_sunrpc_task_info(hookid:long, sv_name:string, + sv_prog:long, peer_ip:long, rq_xid:long, + rq_prog:long, rq_vers:long, rq_proc:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%0s%8b%8b%8b%8b%1b%1b", + THIS->sv_name, (_FMT_)THIS->sv_prog, + (_FMT_)THIS->peer_ip, (_FMT_)THIS->rq_xid, + (_FMT_)THIS->rq_prog, (_FMT_)THIS->rq_vers, + (_FMT_)THIS->rq_proc); +%} + +function log_sunrpc_return_int64(hookid:long, ret:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%8b", (_FMT_)THIS->ret); +%} + +function log_sunrpc_return_int32(hookid:long, ret:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%4b", (_FMT_)THIS->ret); +%} + +function log_sunrpc_return_int16(hookid:long, ret:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%2b", (_FMT_)THIS->ret); +%} + +function log_sunrpc_return_int8(hookid:long, ret:long) +%{ + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%1b", (_FMT_)THIS->ret); +%} + +function log_sunrpc_return_void(hookid:long) +%{ +#define VOIDRETURN 0 + _lket_trace(_GROUP_SUNRPC, THIS->hookid, "%1b", (_FMT_)VOIDRETURN); +%} + diff --git a/tapset/rpc.stp b/tapset/rpc.stp index de54c122..c300b5e4 100644 --- a/tapset/rpc.stp +++ b/tapset/rpc.stp @@ -54,18 +54,25 @@ probe sunrpc.clnt.return = * rpc_create_client(struct rpc_xprt *xprt, char *servname, * struct rpc_program *info, u32 version, * rpc_authflavor_t authflavor) - * + * + * @servername: the server machine name + * @progname: the RPC program name + * @prog: the RPC program number + * @vers: the RPC program version number + * @prot: the IP protocol number + * @port: the port number + * @authflavor: the authentication flavor */ probe sunrpc.clnt.create_client = kernel.function("rpc_create_client") ?, module("sunrpc").function("rpc_create_client") ? { - servername = kernel_string($servname) /* server name */ - progname = kernel_string($info->name) /* program name */ - prog = $info->number /* program number */ - vers = vers_from_prog($info, $version) /* program version */ - prot = $xprt->prot /* IP protocol */ - port = $xprt->port /* port number */ - authflavor = $authflavor /* authentication flavor */ + servername = kernel_string($servname) + progname = kernel_string($info->name) + prog = $info->number + vers = vers_from_prog($info, $version) + prot = $xprt->prot + port = $xprt->port + authflavor = $authflavor name = "sunrpc.clnt.create_client" argstr = sprintf("%s %s %d %d %d %d %d", servername, progname, @@ -77,17 +84,26 @@ probe sunrpc.clnt.create_client.return = module("sunrpc").function("rpc_create_client").return ? { name = "sunrpc.clnt.create_client" + retstr = returnstr($return) } /* * Fires when the RPC client structure is to be cloned * * struct rpc_clnt * rpc_clone_client(struct rpc_clnt *clnt) + * + * @servername: the server machine name + * @progname: the RPC program name + * @prog: the RPC program number + * @vers: the RPC program version number + * @prot: the IP protocol number + * @port: the port number + * @authflavor: the authentication flavor */ probe sunrpc.clnt.clone_client = kernel.function("rpc_clone_client") ?, module("sunrpc").function("rpc_clone_client") ? { - servname = kernel_string($clnt->cl_server) + servername = kernel_string($clnt->cl_server) progname = kernel_string($clnt->cl_protname) prog = prog_from_clnt($clnt) vers = vers_from_clnt($clnt) @@ -96,7 +112,7 @@ probe sunrpc.clnt.clone_client = kernel.function("rpc_clone_client") ?, authflavor = $clnt->cl_auth->au_flavor name = "sunrpc.clnt.clone_client" - argstr = sprintf("%s %s %d %d %d %d %d", servname, progname, + argstr = sprintf("%s %s %d %d %d %d %d", servername, progname, prog, vers, prot, port, authflavor) } @@ -105,6 +121,71 @@ probe sunrpc.clnt.clone_client.return = module("sunrpc").function("rpc_clone_client").return ? { name = "sunrpc.clnt.clone_client" + retstr = returnstr($return) +} + +/* + * Fires when an RPC client is to be shut down. + * + * int rpc_shutdown_client(struct rpc_clnt *clnt) + * + * @servername: the server machine name + * @progname: the RPC program name + * @prog: the RPC program number + * @vers: the RPC program version number + * @prot: the IP protocol number + * @port: the port number + * @authflavor: the authentication flavor + * + * @clones: the number of clones + * @tasks: the number of references + * + * @netreconn: the count of reconnections + * @rpccnt: the count of RPC calls + * @om_ops: the count of operations + * @om_ntrans: the count of RPC transmissions + * @om_bytes_sent: the count of bytes out + * @om_bytes_recv: the count of bytes in + * @om_queue: the jiffies queued for xmit + * @om_rtt: the RPC RTT jiffies + * @om_execute: the RPC execution jiffies + */ +probe sunrpc.clnt.shutdown_client = kernel.function("rpc_shutdown_client") ?, + module("sunrpc").function("rpc_shutdown_client") ? +{ + servername = kernel_string($clnt->cl_server) + prog = prog_from_clnt($clnt) + vers = vers_from_clnt($clnt) + prot = prot_from_clnt($clnt) + port = port_from_clnt($clnt) + authflavor = $clnt->cl_auth->au_flavor + clones = clones_from_clnt($clnt) + tasks = tasks_from_clnt($clnt) + + /* per-program statistics */ + netreconn = $clnt->cl_stats->netreconn + rpccnt = $clnt->cl_stats->rpccnt + + /* per-client statistics */ + om_ops = $clnt->cl_metrics->om_ops + om_ntrans = $clnt->cl_metrics->om_ntrans + om_bytes_sent = $clnt->cl_metrics->om_bytes_sent + om_bytes_recv = $clnt->cl_metrics->om_bytes_recv + om_queue = $clnt->cl_metrics->om_queue + om_rtt = $clnt->cl_metrics->om_rtt + om_execute = $clnt->cl_metrics->om_execute + + name = "sunrpc.clnt.shutdown_client" + argstr = sprintf("%s %s %d %d %d %d %d %d", servername, progname, + vers, prot, port, authflavor, clones, tasks) +} + +probe sunrpc.clnt.shutdown_client.return = + kernel.function("rpc_shutdown_client").return ?, + module("sunrpc").function("rpc_shutdown_client").return ? +{ + name = "sunrpc.clnt.shutdown_client" + retstr = returnstr($return) } /* @@ -112,22 +193,29 @@ probe sunrpc.clnt.clone_client.return = * * struct rpc_clnt * rpc_bind_new_program(struct rpc_clnt *old, * struct rpc_program *program, int vers) + * + * @servername: the server machine name + * @old_progname: the name of old RPC program + * @old_prog: the number of old RPC program + * @old_vers: the version of old RPC program + * @progname: the name of new RPC program + * @prog: the number of new RPC program + * @vers: the version of new RPC program */ probe sunrpc.clnt.bind_new_program = kernel.function("rpc_bind_new_program") ?, module("sunrpc").function("rpc_bind_new_program") ? { - servname = kernel_string($old->cl_server) + servername = kernel_string($old->cl_server) old_progname = kernel_string($old->cl_protname) old_prog = prog_from_clnt($old) old_vers = vers_from_clnt($old) - progname = kernel_string($program->name) prog = $program->number vers = vers_from_prog($program, $vers) name = "sunrpc.clnt.bind_new_program" - argstr = sprintf("%s %s %d %s %d", servname, old_progname, + argstr = sprintf("%s %s %d %s %d", servername, old_progname, old_vers, progname, vers) } @@ -136,56 +224,29 @@ probe sunrpc.clnt.bind_new_program.return = module("sunrpc").function("rpc_bind_new_program").return ? { name = "sunrpc.clnt.bind_new_program" -} - -/* - * Fires when an RPC client is to be shut down. - * - * int rpc_shutdown_client(struct rpc_clnt *clnt) - */ -probe sunrpc.clnt.shutdown_client = kernel.function("rpc_shutdown_client") ?, - module("sunrpc").function("rpc_shutdown_client") ? -{ - servname = kernel_string($clnt->cl_server) - progname = kernel_string($clnt->cl_protname) - vers = vers_from_clnt($clnt) - tasks = tasks_from_clnt($clnt) - - /* per-program statistics */ - netcnt = $clnt->cl_stats->netcnt - netreconn = $clnt->cl_stats->netreconn - rpccnt = $clnt->cl_stats->rpccnt - rpcgarbage = $clnt->cl_stats->rpcgarbage - - /* per-client statistics */ - om_ops = $clnt->cl_metrics->om_ops /* count of operations */ - om_ntrans = $clnt->cl_metrics->om_ntrans/* count of RPC transmissions */ - om_bytes_sent = $clnt->cl_metrics->om_bytes_sent /* count of bytes out*/ - om_bytes_recv = $clnt->cl_metrics->om_bytes_recv /* count of bytes in */ - om_queue = $clnt->cl_metrics->om_queue /* jiffies queued for xmit */ - om_rtt = $clnt->cl_metrics->om_rtt /* RPC RTT jiffies */ - om_execute = $clnt->cl_metrics->om_execute /* RPC execution jiffies */ - - name = "sunrpc.clnt.shutdown_client" - argstr = sprintf("%s %s %d %d", servname, progname, vers, tasks) -} - -probe sunrpc.clnt.shutdown_client.return = - kernel.function("rpc_shutdown_client").return ?, - module("sunrpc").function("rpc_shutdown_client").return ? -{ - name = "sunrpc.clnt.shutdown_client" retstr = returnstr($return) } /* * int rpc_call_sync(struct rpc_clnt *clnt, struct rpc_message *msg, * int flags) + * + * @servername: the server machine name + * @progname: the RPC program name + * @prog: the RPC program number + * @vers: the RPC program version number + * @prot: the IP protocol number + * @port: the port number + * @xid: current transmission id + * @dead: whether this client is abandoned + * @procname: the procedure name in this RPC call + * @proc: the procedure number in this RPC call + * @flags: flags */ probe sunrpc.clnt.call_sync = kernel.function("rpc_call_sync") ?, module("sunrpc").function("rpc_call_sync") ? { - servname = kernel_string($clnt->cl_server) + servername = kernel_string($clnt->cl_server) progname = kernel_string($clnt->cl_protname) prog = prog_from_clnt($clnt) vers = vers_from_clnt($clnt) @@ -194,13 +255,13 @@ probe sunrpc.clnt.call_sync = kernel.function("rpc_call_sync") ?, xid = xid_from_clnt($clnt) dead = $clnt->cl_dead - proc = proc_from_msg($msg) procname= $msg->rpc_proc->p_name ? kernel_string($msg->rpc_proc->p_name) : "NULL" + proc = proc_from_msg($msg) flags = $flags name = "sunrpc.clnt.call_sync" - argstr = sprintf("%s %d %s %d %s 0x%x", servname, xid, progname, + argstr = sprintf("%s %d %s %d %s 0x%x", servername, xid, progname, vers, procname, flags) } @@ -214,11 +275,23 @@ probe sunrpc.clnt.call_sync.return = kernel.function("rpc_call_sync").return ?, /* * int rpc_call_async(struct rpc_clnt *clnt, struct rpc_message *msg, * int flags, const struct rpc_call_ops *tk_ops, void *data) + * + * @servername: the server machine name + * @progname: the RPC program name + * @prog: the RPC program number + * @vers: the RPC program version number + * @prot: the IP protocol number + * @port: the port number + * @xid: current transmission id + * @dead: whether this client is abandoned + * @procname: the procedure name in this RPC call + * @proc: the procedure number in this RPC call + * @flags: flags */ probe sunrpc.clnt.call_async = kernel.function("rpc_call_async") ?, module("sunrpc").function("rpc_call_async") ? { - servname = kernel_string($clnt->cl_server) + servername = kernel_string($clnt->cl_server) progname = kernel_string($clnt->cl_protname) prog = prog_from_clnt($clnt) vers = vers_from_clnt($clnt) @@ -234,7 +307,7 @@ probe sunrpc.clnt.call_async = kernel.function("rpc_call_async") ?, flags = $flags name = "sunrpc.clnt.call_async" - argstr = sprintf("%s %d %s %d %s 0x%x", servname, xid, progname, + argstr = sprintf("%s %d %s %d %s 0x%x", servername, xid, progname, vers, procname, flags) } @@ -250,20 +323,29 @@ probe sunrpc.clnt.call_async.return = * Fires when an (async) RPC call is to be restarted * * void rpc_restart_call(struct rpc_task *task) + * + * @servername: the server machine name + * @prog: the RPC program number + * @xid: the transmission id + * @tk_pid: the debugging aid of task + * @tk_flags: the task flags + * @tk_priority: the task priority + * @tk_runstate: the task run status */ probe sunrpc.clnt.restart_call = kernel.function("rpc_restart_call") ?, module("sunrpc").function("rpc_restart_call") ? { - xid = $task->tk_rqstp->rq_xid + servername = kernel_string($task->tk_client->cl_server) prog = prog_from_clnt($task->tk_client) - vers = vers_from_clnt($task->tk_client) - + xid = $task->tk_rqstp->rq_xid tk_pid = $task->tk_pid tk_flags = $task->tk_flags + tk_priority = $task->tk_priority + tk_runstate = $task->tk_runstate name = "sunrpc.clnt.restart_call" - argstr = sprintf("%d %d %d %d %d", xid, prog, vers, - tk_pid, tk_flags) + argstr = sprintf("%s %d %d %d %d %d %d", servername, prog, xid, tk_pid, + tk_flags, tk_priority, tk_runstate) } probe sunrpc.clnt.restart_call.return = @@ -276,7 +358,6 @@ probe sunrpc.clnt.restart_call.return = /********************************************* * Probe points on RPC server interface * ********************************************/ - probe sunrpc.svc.entry = sunrpc.svc.register, sunrpc.svc.create, @@ -304,6 +385,12 @@ probe sunrpc.svc.return = * If proto and port == 0, it means to unregister a service. * * int svc_register(struct svc_serv *serv, int proto, unsigned short port) + * + * @sv_name: the service name + * @progname: the name of the program + * @prog: the number of the program + * @prot: the IP protocol number + * @port: the port number */ probe sunrpc.svc.register = kernel.function("svc_register") ?, module("sunrpc").function("svc_register") ? @@ -330,19 +417,22 @@ probe sunrpc.svc.register.return = kernel.function("svc_register").return ?, * * struct svc_serv * * svc_create(struct svc_program *prog, unsigned int bufsize) + * + * @progname: the name of the program + * @prog: the number of the program + * @pg_nvers: the number of supported versions + * @bufsize: the buffer size */ probe sunrpc.svc.create = kernel.function("svc_create") ?, module("sunrpc").function("svc_create") ? { - pg_name = kernel_string($prog->pg_name) - pg_prog = $prog->pg_prog - pg_hivers = $prog->pg_hivers + progname = kernel_string($prog->pg_name) + prog = $prog->pg_prog pg_nvers = $prog->pg_nvers bufsize = $bufsize name = "sunrpc.svc.create" - argstr = sprintf("%s %d %d %d %d", pg_name, pg_prog, - pg_hivers, pg_nvers, bufsize) + argstr = sprintf("%s %d %d %d", progname, prog, pg_nvers, bufsize) } probe sunrpc.svc.create.return = kernel.function("svc_create").return ?, @@ -355,6 +445,16 @@ probe sunrpc.svc.create.return = kernel.function("svc_create").return ?, * Fires when an RPC service is to be destroyed * * void svc_destroy(struct svc_serv *serv) + * + * @sv_name: the service name + * @sv_progname: the name of the program + * @sv_prog: the number of the program + * @sv_nrthreads:the number of concurrent threads + * @netcnt: the count of received RPC requests + * @nettcpconn: the count of accepted TCP connections + * @rpccnt: the count of valid RPC requests + * @rpcbadfmt: the count of requests dropped for bad formats + * @rpcbadauth: the count of requests drooped for authentication failure */ probe sunrpc.svc.destroy = kernel.function("svc_destroy") ?, module("sunrpc").function("svc_destroy") ? @@ -368,7 +468,8 @@ probe sunrpc.svc.destroy = kernel.function("svc_destroy") ?, netcnt = $serv->sv_stats->netcnt netcpconn = $serv->sv_stats->nettcpconn rpccnt = $serv->sv_stats->rpccnt - rpcbadclnt = $serv->sv_stats->rpcbadclnt + rpcbadfmt = $serv->sv_stats->rpcbadfmt + rpcbadauth = $serv->sv_stats->rpcbadauth name = "sunrpc.svc.destroy" argstr = sprintf("%s %d %d", sv_name, sv_prog, sv_nrthreads) @@ -384,19 +485,30 @@ probe sunrpc.svc.destroy.return = kernel.function("svc_destroy").return ?, * Fires when an RPC request is to be processed * * int svc_process(struct svc_serv *serv, struct svc_rqst *rqstp) + * + * @sv_name: the service name + * @sv_prog: the number of the program + * @sv_nrthreads:the number of concurrent threads + * @peer_ip: the peer address where the request is from + * @rq_xid: the transmission id in the request + * @rq_prog: the program number in the request + * @rq_vers: the program version in the request + * @rq_proc: the procedure number in the request + * @rq_prot: the IP protocol of the reqeust */ probe sunrpc.svc.process = kernel.function("svc_process") ?, module("sunrpc").function("svc_process") ? { sv_name = kernel_string($serv->sv_name) /* service name */ sv_prog = $serv->sv_program->pg_prog + sv_nrthreads = $serv->sv_nrthreads - peer_ip = addr_from_rqst($rqstp)/* peer address */ - rq_xid = $rqstp->rq_xid /* transmission id */ - rq_prog = $rqstp->rq_prog /* program number */ - rq_vers = $rqstp->rq_vers /* program version */ - rq_proc = $rqstp->rq_proc /* procedure number */ - rq_prot = $rqstp->rq_prot /* IP protocol */ + peer_ip = addr_from_rqst($rqstp) + rq_xid = $rqstp->rq_xid + rq_prog = $rqstp->rq_prog + rq_vers = $rqstp->rq_vers + rq_proc = $rqstp->rq_proc + rq_prot = $rqstp->rq_prot name = "sunrpc.svc.process" argstr = sprintf("%s %d %d %d %d %d %d", sv_name, sv_prog, peer_ip, @@ -411,21 +523,32 @@ probe sunrpc.svc.process.return = kernel.function("svc_process").return ?, } /* + * Fires when an RPC request is to be authorised + * * int svc_authorise(struct svc_rqst *rqstp) + * + * @sv_name: the service name + * @peer_ip: the peer address where the request is from + * @rq_xid: the transmission id in the request + * @rq_prog: the program number in the request + * @rq_vers: the program version in the request + * @rq_proc: the procedure number in the request + * @rq_prot: the IP protocol of the reqeust */ probe sunrpc.svc.authorise = kernel.function("svc_authorise")?, module("sunrpc").function("svc_authorise")? { - peer_ip = addr_from_rqst($rqstp) /* peer address */ - xid = $rqstp->rq_xid /* transmission id */ - prog = $rqstp->rq_prog /* program number */ - vers = $rqstp->rq_vers /* program version */ - proc = $rqstp->rq_proc /* procedure number */ - prot = $rqstp->rq_prot /* IP protocol */ + sv_name = kernel_string($rqstp->rq_server->sv_name) + peer_ip = addr_from_rqst($rqstp) + rq_xid = $rqstp->rq_xid + rq_prog = $rqstp->rq_prog + rq_vers = $rqstp->rq_vers + rq_proc = $rqstp->rq_proc + rq_prot = $rqstp->rq_prot name = "sunrpc.svc.authorise" - argstr = sprintf("%d %d %d %d %d %d %d", peer_ip, xid, prog, - vers, proc, prot, addr) + argstr = sprintf("%d %d %d %d %d %d", peer_ip, rq_xid, rq_prog, + rq_vers, rq_proc, rq_prot) } probe sunrpc.svc.authorise.return = kernel.function("svc_authorise").return ?, @@ -436,14 +559,21 @@ probe sunrpc.svc.authorise.return = kernel.function("svc_authorise").return ?, } /* - * Fires when receiving the next request on any socket. + * Fires when the server is to receive the next request on any socket. * * int svc_recv(struct svc_serv *serv, struct svc_rqst *rqstp, long timeout) + * + * @sv_name: the service name + * @sv_prog: the number of the program + * @sv_nrthreads:the number of concurrent threads + * @timeout: the timeout of waiting for data */ probe sunrpc.svc.recv = kernel.function("svc_recv")?, module("sunrpc").function("svc_recv")? { sv_name = kernel_string($serv->sv_name) + sv_prog = $serv->sv_program->pg_prog + sv_nrthreads = $serv->sv_nrthreads timeout = $timeout name = "sunrpc.svc.recv" @@ -461,23 +591,29 @@ probe sunrpc.svc.recv.return = kernel.function("svc_recv").return ?, * Fires when want to return reply to client. * * int svc_send(struct svc_rqst *rqstp) + * + * @sv_name: the service name + * @peer_ip: the peer address where the request is from + * @rq_xid: the transmission id in the request + * @rq_prog: the program number in the request + * @rq_vers: the program version in the request + * @rq_proc: the procedure number in the request + * @rq_prot: the IP protocol of the reqeust */ probe sunrpc.svc.send = kernel.function("svc_send")?, module("sunrpc").function("svc_send")? { sv_name = kernel_string($rqstp->rq_server->sv_name) - sv_prog = $rqstp->rq_server->sv_program->pg_prog - - peer_ip = addr_from_rqst($rqstp) /* peer address */ - xid = $rqstp->rq_xid /* transmission id */ - prog = $rqstp->rq_prog /* program number */ - vers = $rqstp->rq_vers /* program version */ - proc = $rqstp->rq_proc /* procedure number */ - prot = $rqstp->rq_prot /* IP protocol */ + peer_ip = addr_from_rqst($rqstp) + rq_xid = $rqstp->rq_xid + rq_prog = $rqstp->rq_prog + rq_vers = $rqstp->rq_vers + rq_proc = $rqstp->rq_proc + rq_prot = $rqstp->rq_prot name = "sunrpc.svc.send" - argstr = sprintf("%s %d %d %d %d %d %d %d", sv_name, sv_prog, - peer_ip, xid, prog, vers, proc, prot) + argstr = sprintf("%s %d %d %d %d %d %d", sv_name, peer_ip, + rq_xid, rq_prog, rq_vers, rq_proc, rq_prot) } probe sunrpc.svc.send.return = kernel.function("svc_send").return ?, @@ -491,23 +627,29 @@ probe sunrpc.svc.send.return = kernel.function("svc_send").return ?, * Fires when a request is to be dropped * * void svc_drop(struct svc_rqst *rqstp) + * + * @sv_name: the service name + * @peer_ip: the peer address where the request is from + * @rq_xid: the transmission id in the request + * @rq_prog: the program number in the request + * @rq_vers: the program version in the request + * @rq_proc: the procedure number in the request + * @rq_prot: the IP protocol of the reqeust */ probe sunrpc.svc.drop = kernel.function("svc_drop")?, module("sunrpc").function("svc_drop")? { sv_name = kernel_string($rqstp->rq_server->sv_name) - sv_prog = $rqstp->rq_server->sv_program->pg_prog - - peer_ip = addr_from_rqst($rqstp) /* peer address */ - xid = $rqstp->rq_xid /* transmission id */ - prog = $rqstp->rq_prog /* program number */ - vers = $rqstp->rq_vers /* program version */ - proc = $rqstp->rq_proc /* procedure number */ - prot = $rqstp->rq_prot /* IP protocol */ + peer_ip = addr_from_rqst($rqstp) + rq_xid = $rqstp->rq_xid + rq_prog = $rqstp->rq_prog + rq_vers = $rqstp->rq_vers + rq_proc = $rqstp->rq_proc + rq_prot = $rqstp->rq_prot name = "sunrpc.svc.drop" - argstr = sprintf("%s %d %d %d %d %d %d %d", sv_name, sv_prog, - peer_ip, xid, prog, vers, proc, prot) + argstr = sprintf("%s %d %d %d %d %d %d", sv_name, peer_ip, + rq_xid, rq_prog, rq_vers, rq_proc, rq_prot) } probe sunrpc.svc.drop.return = kernel.function("svc_drop").return ?, @@ -519,26 +661,94 @@ probe sunrpc.svc.drop.return = kernel.function("svc_drop").return ?, /******************************************************************* * Probe points on RPC scheduler * ******************************************************************/ - probe sunrpc.sched.entry = sunrpc.sched.new_task, + sunrpc.sched.release_task, sunrpc.sched.execute, - sunrpc.sched.delay, - sunrpc.sched.release_task + sunrpc.sched.delay {} probe sunrpc.sched.return = sunrpc.sched.new_task.return, + sunrpc.sched.release_task.return, sunrpc.sched.execute.return, - sunrpc.sched.delay.return, - sunrpc.sched.release_task.return + sunrpc.sched.delay.return {} /* + * Fires when a new task is to be created for the specified client. + * + * struct rpc_task * rpc_new_task(struct rpc_clnt *clnt, int flags, + * const struct rpc_call_ops *tk_ops, void *calldata) + * + * @xid: the transmission id in the RPC call + * @prog: the program number in the RPC call + * @vers: the program version in the RPC call + * @prot: the IP protocol in the RPC call + * @tk_flags: the flags of the task + */ +probe sunrpc.sched.new_task = kernel.function("rpc_new_task") ?, + module("sunrpc").function("rpc_new_task") ? +{ + xid = xid_from_clnt($clnt) + prog = prog_from_clnt($clnt) + vers = vers_from_clnt($clnt) + prot = prot_from_clnt($clnt) + flags = $flags + + name = "sunrpc.sched.new_task" + argstr = sprintf("%d %d %d %d %d", xid, prog, vers, prot, flags) +} + +probe sunrpc.sched.new_task.return = kernel.function("rpc_new_task").return ?, + module("sunrpc").function("rpc_new_task").return ? +{ + name = "sunrpc.sched.new_task" +} + +/* + * Fires when all resources associated with a task are to be released + * + * void rpc_release_task(struct rpc_task *task) + * + * @xid: the transmission id in the RPC call + * @prog: the program number in the RPC call + * @vers: the program version in the RPC call + * @prot: the IP protocol in the RPC call + * @tk_flags: the flags of the task + */ +probe sunrpc.sched.release_task = kernel.function("rpc_release_task") ?, + module("sunrpc").function("rpc_release_task") ? +{ + xid = xid_from_clnt($task->tk_client) + prog = prog_from_clnt($task->tk_client) + vers = vers_from_clnt($task->tk_client) + prot = prot_from_clnt($task->tk_client) + tk_flags = $task->tk_flags + + name = "sunrpc.sched.release_task" + argstr = sprintf("%d %d %d %d %d", xid, prog, vers, prot, tk_flags) +} + +probe sunrpc.sched.release_task.return = + kernel.function("rpc_release_task").return ?, + module("sunrpc").function("rpc_release_task").return ? +{ + name = "sunrpc.sched.release_task" +} + +/* * Fires when the RPC `scheduler'(or rather, the finite state machine) * is to be executed * * static int __rpc_execute(struct rpc_task *task) + * + * @xid: the transmission id in the RPC call + * @prog: the program number in the RPC call + * @vers: the program version in the RPC call + * @prot: the IP protocol in the RPC call + * @tk_pid: the debugging id of the task + * @tk_flags: the flags of the task */ probe sunrpc.sched.execute = kernel.function("__rpc_execute") ?, module("sunrpc").function("__rpc_execute") ? @@ -551,8 +761,8 @@ probe sunrpc.sched.execute = kernel.function("__rpc_execute") ?, tk_flags = $task->tk_flags name = "sunrpc.sched.execute" - argstr = sprintf("%d %d %d %d %d %d", xid, prog, - vers, prot, tk_pid, tk_flags) + argstr = sprintf("%d %d %d %d %d %d", xid, prog, vers, prot, + tk_pid, tk_flags) } probe sunrpc.sched.execute.return = kernel.function("__rpc_execute").return ?, @@ -566,6 +776,14 @@ probe sunrpc.sched.execute.return = kernel.function("__rpc_execute").return ?, * Fires when a task is to be delayed * * void rpc_delay(struct rpc_task *task, unsigned long delay) + * + * @xid: the transmission id in the RPC call + * @prog: the program number in the RPC call + * @vers: the program version in the RPC call + * @prot: the IP protocol in the RPC call + * @tk_pid: the debugging id of the task + * @tk_flags: the flags of the task + * @delay: the time delayed */ probe sunrpc.sched.delay = kernel.function("rpc_delay") ?, module("sunrpc").function("rpc_delay") ? @@ -579,8 +797,8 @@ probe sunrpc.sched.delay = kernel.function("rpc_delay") ?, delay = $delay name = "sunrpc.clnt.delay" - argstr = sprintf("%d %d %d %d %d %d", xid, prog, vers, - prot, tk_pid, tk_flags) + argstr = sprintf("%d %d %d %d %d %d %d", xid, prog, vers, + prot, tk_pid, tk_flags, delay) } probe sunrpc.sched.delay.return = kernel.function("rpc_delay").return ?, @@ -589,105 +807,61 @@ probe sunrpc.sched.delay.return = kernel.function("rpc_delay").return ?, name = "sunrpc.clnt.delay" } -/* - * Fires when a new task is to be created for the specified client. - * - * struct rpc_task * rpc_new_task(struct rpc_clnt *clnt, int flags, - * const struct rpc_call_ops *tk_ops, void *calldata) - */ -probe sunrpc.sched.new_task = kernel.function("rpc_new_task") ?, - module("sunrpc").function("rpc_new_task") ? -{ - xid = xid_from_clnt($clnt) - prog = prog_from_clnt($clnt) - vers = vers_from_clnt($clnt) - prot = prot_from_clnt($clnt) - flags = $flags - - name = "sunrpc.sched.new_task" - argstr = sprintf("%d %d %d %d %d", xid, prog, vers, prot, flags) -} - -probe sunrpc.sched.new_task.return = kernel.function("rpc_new_task").return ?, - module("sunrpc").function("rpc_new_task").return ? -{ - name = "sunrpc.sched.new_task" -} - -/* - * Fires when all resources associated with a task are to be released - * - * void rpc_release_task(struct rpc_task *task) - */ -probe sunrpc.sched.release_task = kernel.function("rpc_release_task") ?, - module("sunrpc").function("rpc_release_task") ? -{ - xid = xid_from_clnt($task->tk_client) - prog = prog_from_clnt($task->tk_client) - vers = vers_from_clnt($task->tk_client) - prot = prot_from_clnt($task->tk_client) - flags = $task->tk_flags - - name = "sunrpc.sched.release_task" - argstr = sprintf("%d %d %d %d %d", xid, prog, vers, prot, flags) -} - -probe sunrpc.sched.release_task.return = - kernel.function("rpc_release_task").return ?, - module("sunrpc").function("rpc_release_task").return ? -{ - name = "sunrpc.sched.release_task" -} - /****************************************************************** - * Helpler functions * + * Helper functions * *****************************************************************/ function xid_from_clnt:long(clnt:long) %{ - struct rpc_clnt *clnt = (struct rpc_clnt *)THIS->clnt; - THIS->__retvalue = clnt ? clnt->cl_xprt->tcp_xid : 0; + struct rpc_clnt *clnt = (struct rpc_clnt *)(long)THIS->clnt; + THIS->__retvalue = clnt ? clnt->cl_xprt->xid : 0; %} function prog_from_clnt:long(clnt:long) %{ - struct rpc_clnt *clnt = (struct rpc_clnt *)THIS->clnt; + struct rpc_clnt *clnt = (struct rpc_clnt *)(long)THIS->clnt; THIS->__retvalue = clnt ? clnt->cl_pmap->pm_prog : 0; %} function vers_from_clnt:long(clnt:long) %{ - struct rpc_clnt *clnt = (struct rpc_clnt *)THIS->clnt; + struct rpc_clnt *clnt = (struct rpc_clnt *)(long)THIS->clnt; THIS->__retvalue = clnt ? clnt->cl_pmap->pm_vers : 0; %} function prot_from_clnt:long(clnt:long) %{ - struct rpc_clnt *clnt = (struct rpc_clnt *)THIS->clnt; + struct rpc_clnt *clnt = (struct rpc_clnt *)(long)THIS->clnt; THIS->__retvalue = clnt ? clnt->cl_pmap->pm_prot : 0; %} function port_from_clnt:long(clnt:long) %{ - struct rpc_clnt *clnt = (struct rpc_clnt *)THIS->clnt; + struct rpc_clnt *clnt = (struct rpc_clnt *)(long)THIS->clnt; THIS->__retvalue = clnt ? clnt->cl_pmap->pm_port : 0; %} +function clones_from_clnt:long(clnt:long) +%{ + struct rpc_clnt *clnt = (struct rpc_clnt *)(long)THIS->clnt; + THIS->__retvalue = atomic_read(&clnt->cl_count); +%} + function tasks_from_clnt:long(clnt:long) %{ - struct rpc_clnt *clnt = (struct rpc_clnt *)THIS->clnt; + struct rpc_clnt *clnt = (struct rpc_clnt *)(long)THIS->clnt; THIS->__retvalue = atomic_read(&clnt->cl_users); %} function proc_from_msg:long(msg:long) %{ - struct rpc_message *msg = (struct rpc_message *)THIS->msg; + struct rpc_message *msg = (struct rpc_message *)(long)THIS->msg; THIS->__retvalue = msg ? msg->rpc_proc->p_proc : 0; %} function vers_from_prog:long(program:long, vers:long) %{ - struct rpc_program *program = (struct rpc_program *)THIS->program; + struct rpc_program *program = (struct rpc_program *)(long)THIS->program; if (!program || THIS->vers >= program->nrvers || !program->version[THIS->vers]) THIS->__retvalue = 0; else @@ -696,7 +870,7 @@ function vers_from_prog:long(program:long, vers:long) function addr_from_rqst:long(rqstp:long) %{ - struct svc_rqst *rqstp = (struct svc_rqst *)THIS->rqstp; + struct svc_rqst *rqstp = (struct svc_rqst *)(long)THIS->rqstp; THIS->__retvalue = rqstp ? rqstp->rq_addr.sin_addr.s_addr : 0; %} |