Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #undef TRACE_SYSTEM
0003 #define TRACE_SYSTEM sunrpc
0004 
0005 #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
0006 #define _TRACE_SUNRPC_H
0007 
0008 #include <linux/sunrpc/sched.h>
0009 #include <linux/sunrpc/clnt.h>
0010 #include <linux/sunrpc/svc.h>
0011 #include <linux/sunrpc/xprtsock.h>
0012 #include <linux/sunrpc/svc_xprt.h>
0013 #include <net/tcp_states.h>
0014 #include <linux/net.h>
0015 #include <linux/tracepoint.h>
0016 
0017 #include <trace/events/sunrpc_base.h>
0018 
0019 TRACE_DEFINE_ENUM(SOCK_STREAM);
0020 TRACE_DEFINE_ENUM(SOCK_DGRAM);
0021 TRACE_DEFINE_ENUM(SOCK_RAW);
0022 TRACE_DEFINE_ENUM(SOCK_RDM);
0023 TRACE_DEFINE_ENUM(SOCK_SEQPACKET);
0024 TRACE_DEFINE_ENUM(SOCK_DCCP);
0025 TRACE_DEFINE_ENUM(SOCK_PACKET);
0026 
0027 #define show_socket_type(type)                  \
0028     __print_symbolic(type,                  \
0029         { SOCK_STREAM,      "STREAM" },     \
0030         { SOCK_DGRAM,       "DGRAM" },      \
0031         { SOCK_RAW,     "RAW" },        \
0032         { SOCK_RDM,     "RDM" },        \
0033         { SOCK_SEQPACKET,   "SEQPACKET" },      \
0034         { SOCK_DCCP,        "DCCP" },       \
0035         { SOCK_PACKET,      "PACKET" })
0036 
0037 /* This list is known to be incomplete, add new enums as needed. */
0038 TRACE_DEFINE_ENUM(AF_UNSPEC);
0039 TRACE_DEFINE_ENUM(AF_UNIX);
0040 TRACE_DEFINE_ENUM(AF_LOCAL);
0041 TRACE_DEFINE_ENUM(AF_INET);
0042 TRACE_DEFINE_ENUM(AF_INET6);
0043 
0044 #define rpc_show_address_family(family)             \
0045     __print_symbolic(family,                \
0046         { AF_UNSPEC,        "AF_UNSPEC" },      \
0047         { AF_UNIX,      "AF_UNIX" },        \
0048         { AF_LOCAL,     "AF_LOCAL" },       \
0049         { AF_INET,      "AF_INET" },        \
0050         { AF_INET6,     "AF_INET6" })
0051 
0052 DECLARE_EVENT_CLASS(rpc_xdr_buf_class,
0053     TP_PROTO(
0054         const struct rpc_task *task,
0055         const struct xdr_buf *xdr
0056     ),
0057 
0058     TP_ARGS(task, xdr),
0059 
0060     TP_STRUCT__entry(
0061         __field(unsigned int, task_id)
0062         __field(unsigned int, client_id)
0063         __field(const void *, head_base)
0064         __field(size_t, head_len)
0065         __field(const void *, tail_base)
0066         __field(size_t, tail_len)
0067         __field(unsigned int, page_base)
0068         __field(unsigned int, page_len)
0069         __field(unsigned int, msg_len)
0070     ),
0071 
0072     TP_fast_assign(
0073         __entry->task_id = task->tk_pid;
0074         __entry->client_id = task->tk_client ?
0075                      task->tk_client->cl_clid : -1;
0076         __entry->head_base = xdr->head[0].iov_base;
0077         __entry->head_len = xdr->head[0].iov_len;
0078         __entry->tail_base = xdr->tail[0].iov_base;
0079         __entry->tail_len = xdr->tail[0].iov_len;
0080         __entry->page_base = xdr->page_base;
0081         __entry->page_len = xdr->page_len;
0082         __entry->msg_len = xdr->len;
0083     ),
0084 
0085     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0086           " head=[%p,%zu] page=%u(%u) tail=[%p,%zu] len=%u",
0087         __entry->task_id, __entry->client_id,
0088         __entry->head_base, __entry->head_len,
0089         __entry->page_len, __entry->page_base,
0090         __entry->tail_base, __entry->tail_len,
0091         __entry->msg_len
0092     )
0093 );
0094 
0095 #define DEFINE_RPCXDRBUF_EVENT(name)                    \
0096         DEFINE_EVENT(rpc_xdr_buf_class,             \
0097                 rpc_xdr_##name,             \
0098                 TP_PROTO(               \
0099                     const struct rpc_task *task,    \
0100                     const struct xdr_buf *xdr   \
0101                 ),                  \
0102                 TP_ARGS(task, xdr))
0103 
0104 DEFINE_RPCXDRBUF_EVENT(sendto);
0105 DEFINE_RPCXDRBUF_EVENT(recvfrom);
0106 DEFINE_RPCXDRBUF_EVENT(reply_pages);
0107 
0108 
0109 DECLARE_EVENT_CLASS(rpc_clnt_class,
0110     TP_PROTO(
0111         const struct rpc_clnt *clnt
0112     ),
0113 
0114     TP_ARGS(clnt),
0115 
0116     TP_STRUCT__entry(
0117         __field(unsigned int, client_id)
0118     ),
0119 
0120     TP_fast_assign(
0121         __entry->client_id = clnt->cl_clid;
0122     ),
0123 
0124     TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER, __entry->client_id)
0125 );
0126 
0127 #define DEFINE_RPC_CLNT_EVENT(name)                 \
0128         DEFINE_EVENT(rpc_clnt_class,                \
0129                 rpc_clnt_##name,            \
0130                 TP_PROTO(               \
0131                     const struct rpc_clnt *clnt \
0132                 ),                  \
0133                 TP_ARGS(clnt))
0134 
0135 DEFINE_RPC_CLNT_EVENT(free);
0136 DEFINE_RPC_CLNT_EVENT(killall);
0137 DEFINE_RPC_CLNT_EVENT(shutdown);
0138 DEFINE_RPC_CLNT_EVENT(release);
0139 DEFINE_RPC_CLNT_EVENT(replace_xprt);
0140 DEFINE_RPC_CLNT_EVENT(replace_xprt_err);
0141 
0142 TRACE_EVENT(rpc_clnt_new,
0143     TP_PROTO(
0144         const struct rpc_clnt *clnt,
0145         const struct rpc_xprt *xprt,
0146         const char *program,
0147         const char *server
0148     ),
0149 
0150     TP_ARGS(clnt, xprt, program, server),
0151 
0152     TP_STRUCT__entry(
0153         __field(unsigned int, client_id)
0154         __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
0155         __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
0156         __string(program, program)
0157         __string(server, server)
0158     ),
0159 
0160     TP_fast_assign(
0161         __entry->client_id = clnt->cl_clid;
0162         __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
0163         __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
0164         __assign_str(program, program);
0165         __assign_str(server, server);
0166     ),
0167 
0168     TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER
0169           " peer=[%s]:%s program=%s server=%s",
0170         __entry->client_id, __get_str(addr), __get_str(port),
0171         __get_str(program), __get_str(server))
0172 );
0173 
0174 TRACE_EVENT(rpc_clnt_new_err,
0175     TP_PROTO(
0176         const char *program,
0177         const char *server,
0178         int error
0179     ),
0180 
0181     TP_ARGS(program, server, error),
0182 
0183     TP_STRUCT__entry(
0184         __field(int, error)
0185         __string(program, program)
0186         __string(server, server)
0187     ),
0188 
0189     TP_fast_assign(
0190         __entry->error = error;
0191         __assign_str(program, program);
0192         __assign_str(server, server);
0193     ),
0194 
0195     TP_printk("program=%s server=%s error=%d",
0196         __get_str(program), __get_str(server), __entry->error)
0197 );
0198 
0199 TRACE_EVENT(rpc_clnt_clone_err,
0200     TP_PROTO(
0201         const struct rpc_clnt *clnt,
0202         int error
0203     ),
0204 
0205     TP_ARGS(clnt, error),
0206 
0207     TP_STRUCT__entry(
0208         __field(unsigned int, client_id)
0209         __field(int, error)
0210     ),
0211 
0212     TP_fast_assign(
0213         __entry->client_id = clnt->cl_clid;
0214         __entry->error = error;
0215     ),
0216 
0217     TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER " error=%d",
0218         __entry->client_id, __entry->error)
0219 );
0220 
0221 
0222 TRACE_DEFINE_ENUM(RPC_AUTH_OK);
0223 TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
0224 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
0225 TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
0226 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
0227 TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
0228 TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
0229 TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);
0230 
0231 #define rpc_show_auth_stat(status)                  \
0232     __print_symbolic(status,                    \
0233         { RPC_AUTH_OK,          "AUTH_OK" },        \
0234         { RPC_AUTH_BADCRED,     "BADCRED" },        \
0235         { RPC_AUTH_REJECTEDCRED,    "REJECTEDCRED" },   \
0236         { RPC_AUTH_BADVERF,     "BADVERF" },        \
0237         { RPC_AUTH_REJECTEDVERF,    "REJECTEDVERF" },   \
0238         { RPC_AUTH_TOOWEAK,     "TOOWEAK" },        \
0239         { RPCSEC_GSS_CREDPROBLEM,   "GSS_CREDPROBLEM" },    \
0240         { RPCSEC_GSS_CTXPROBLEM,    "GSS_CTXPROBLEM" }) \
0241 
0242 DECLARE_EVENT_CLASS(rpc_task_status,
0243 
0244     TP_PROTO(const struct rpc_task *task),
0245 
0246     TP_ARGS(task),
0247 
0248     TP_STRUCT__entry(
0249         __field(unsigned int, task_id)
0250         __field(unsigned int, client_id)
0251         __field(int, status)
0252     ),
0253 
0254     TP_fast_assign(
0255         __entry->task_id = task->tk_pid;
0256         __entry->client_id = task->tk_client->cl_clid;
0257         __entry->status = task->tk_status;
0258     ),
0259 
0260     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d",
0261         __entry->task_id, __entry->client_id,
0262         __entry->status)
0263 );
0264 #define DEFINE_RPC_STATUS_EVENT(name) \
0265     DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
0266             TP_PROTO( \
0267                 const struct rpc_task *task \
0268             ), \
0269             TP_ARGS(task))
0270 
0271 DEFINE_RPC_STATUS_EVENT(call);
0272 DEFINE_RPC_STATUS_EVENT(connect);
0273 DEFINE_RPC_STATUS_EVENT(timeout);
0274 DEFINE_RPC_STATUS_EVENT(retry_refresh);
0275 DEFINE_RPC_STATUS_EVENT(refresh);
0276 
0277 TRACE_EVENT(rpc_request,
0278     TP_PROTO(const struct rpc_task *task),
0279 
0280     TP_ARGS(task),
0281 
0282     TP_STRUCT__entry(
0283         __field(unsigned int, task_id)
0284         __field(unsigned int, client_id)
0285         __field(int, version)
0286         __field(bool, async)
0287         __string(progname, task->tk_client->cl_program->name)
0288         __string(procname, rpc_proc_name(task))
0289     ),
0290 
0291     TP_fast_assign(
0292         __entry->task_id = task->tk_pid;
0293         __entry->client_id = task->tk_client->cl_clid;
0294         __entry->version = task->tk_client->cl_vers;
0295         __entry->async = RPC_IS_ASYNC(task);
0296         __assign_str(progname, task->tk_client->cl_program->name);
0297         __assign_str(procname, rpc_proc_name(task));
0298     ),
0299 
0300     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " %sv%d %s (%ssync)",
0301         __entry->task_id, __entry->client_id,
0302         __get_str(progname), __entry->version,
0303         __get_str(procname), __entry->async ? "a": ""
0304         )
0305 );
0306 
0307 #define rpc_show_task_flags(flags)                  \
0308     __print_flags(flags, "|",                   \
0309         { RPC_TASK_ASYNC, "ASYNC" },                \
0310         { RPC_TASK_SWAPPER, "SWAPPER" },            \
0311         { RPC_TASK_MOVEABLE, "MOVEABLE" },          \
0312         { RPC_TASK_NULLCREDS, "NULLCREDS" },            \
0313         { RPC_CALL_MAJORSEEN, "MAJORSEEN" },            \
0314         { RPC_TASK_DYNAMIC, "DYNAMIC" },            \
0315         { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" },      \
0316         { RPC_TASK_SOFT, "SOFT" },              \
0317         { RPC_TASK_SOFTCONN, "SOFTCONN" },          \
0318         { RPC_TASK_SENT, "SENT" },              \
0319         { RPC_TASK_TIMEOUT, "TIMEOUT" },            \
0320         { RPC_TASK_NOCONNECT, "NOCONNECT" },            \
0321         { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" },       \
0322         { RPC_TASK_CRED_NOREF, "CRED_NOREF" })
0323 
0324 #define rpc_show_runstate(flags)                    \
0325     __print_flags(flags, "|",                   \
0326         { (1UL << RPC_TASK_RUNNING), "RUNNING" },       \
0327         { (1UL << RPC_TASK_QUEUED), "QUEUED" },         \
0328         { (1UL << RPC_TASK_ACTIVE), "ACTIVE" },         \
0329         { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" },       \
0330         { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" },       \
0331         { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" }, \
0332         { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
0333 
0334 DECLARE_EVENT_CLASS(rpc_task_running,
0335 
0336     TP_PROTO(const struct rpc_task *task, const void *action),
0337 
0338     TP_ARGS(task, action),
0339 
0340     TP_STRUCT__entry(
0341         __field(unsigned int, task_id)
0342         __field(unsigned int, client_id)
0343         __field(const void *, action)
0344         __field(unsigned long, runstate)
0345         __field(int, status)
0346         __field(unsigned short, flags)
0347         ),
0348 
0349     TP_fast_assign(
0350         __entry->client_id = task->tk_client ?
0351                      task->tk_client->cl_clid : -1;
0352         __entry->task_id = task->tk_pid;
0353         __entry->action = action;
0354         __entry->runstate = task->tk_runstate;
0355         __entry->status = task->tk_status;
0356         __entry->flags = task->tk_flags;
0357         ),
0358 
0359     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0360           " flags=%s runstate=%s status=%d action=%ps",
0361         __entry->task_id, __entry->client_id,
0362         rpc_show_task_flags(__entry->flags),
0363         rpc_show_runstate(__entry->runstate),
0364         __entry->status,
0365         __entry->action
0366         )
0367 );
0368 #define DEFINE_RPC_RUNNING_EVENT(name) \
0369     DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
0370             TP_PROTO( \
0371                 const struct rpc_task *task, \
0372                 const void *action \
0373             ), \
0374             TP_ARGS(task, action))
0375 
0376 DEFINE_RPC_RUNNING_EVENT(begin);
0377 DEFINE_RPC_RUNNING_EVENT(run_action);
0378 DEFINE_RPC_RUNNING_EVENT(sync_sleep);
0379 DEFINE_RPC_RUNNING_EVENT(sync_wake);
0380 DEFINE_RPC_RUNNING_EVENT(complete);
0381 DEFINE_RPC_RUNNING_EVENT(timeout);
0382 DEFINE_RPC_RUNNING_EVENT(signalled);
0383 DEFINE_RPC_RUNNING_EVENT(end);
0384 DEFINE_RPC_RUNNING_EVENT(call_done);
0385 
0386 DECLARE_EVENT_CLASS(rpc_task_queued,
0387 
0388     TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
0389 
0390     TP_ARGS(task, q),
0391 
0392     TP_STRUCT__entry(
0393         __field(unsigned int, task_id)
0394         __field(unsigned int, client_id)
0395         __field(unsigned long, timeout)
0396         __field(unsigned long, runstate)
0397         __field(int, status)
0398         __field(unsigned short, flags)
0399         __string(q_name, rpc_qname(q))
0400         ),
0401 
0402     TP_fast_assign(
0403         __entry->client_id = task->tk_client ?
0404                      task->tk_client->cl_clid : -1;
0405         __entry->task_id = task->tk_pid;
0406         __entry->timeout = rpc_task_timeout(task);
0407         __entry->runstate = task->tk_runstate;
0408         __entry->status = task->tk_status;
0409         __entry->flags = task->tk_flags;
0410         __assign_str(q_name, rpc_qname(q));
0411         ),
0412 
0413     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0414           " flags=%s runstate=%s status=%d timeout=%lu queue=%s",
0415         __entry->task_id, __entry->client_id,
0416         rpc_show_task_flags(__entry->flags),
0417         rpc_show_runstate(__entry->runstate),
0418         __entry->status,
0419         __entry->timeout,
0420         __get_str(q_name)
0421         )
0422 );
0423 #define DEFINE_RPC_QUEUED_EVENT(name) \
0424     DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
0425             TP_PROTO( \
0426                 const struct rpc_task *task, \
0427                 const struct rpc_wait_queue *q \
0428             ), \
0429             TP_ARGS(task, q))
0430 
0431 DEFINE_RPC_QUEUED_EVENT(sleep);
0432 DEFINE_RPC_QUEUED_EVENT(wakeup);
0433 
0434 DECLARE_EVENT_CLASS(rpc_failure,
0435 
0436     TP_PROTO(const struct rpc_task *task),
0437 
0438     TP_ARGS(task),
0439 
0440     TP_STRUCT__entry(
0441         __field(unsigned int, task_id)
0442         __field(unsigned int, client_id)
0443     ),
0444 
0445     TP_fast_assign(
0446         __entry->task_id = task->tk_pid;
0447         __entry->client_id = task->tk_client->cl_clid;
0448     ),
0449 
0450     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER,
0451         __entry->task_id, __entry->client_id)
0452 );
0453 
0454 #define DEFINE_RPC_FAILURE(name)                    \
0455     DEFINE_EVENT(rpc_failure, rpc_bad_##name,           \
0456             TP_PROTO(                   \
0457                 const struct rpc_task *task     \
0458             ),                      \
0459             TP_ARGS(task))
0460 
0461 DEFINE_RPC_FAILURE(callhdr);
0462 DEFINE_RPC_FAILURE(verifier);
0463 
0464 DECLARE_EVENT_CLASS(rpc_reply_event,
0465 
0466     TP_PROTO(
0467         const struct rpc_task *task
0468     ),
0469 
0470     TP_ARGS(task),
0471 
0472     TP_STRUCT__entry(
0473         __field(unsigned int, task_id)
0474         __field(unsigned int, client_id)
0475         __field(u32, xid)
0476         __string(progname, task->tk_client->cl_program->name)
0477         __field(u32, version)
0478         __string(procname, rpc_proc_name(task))
0479         __string(servername, task->tk_xprt->servername)
0480     ),
0481 
0482     TP_fast_assign(
0483         __entry->task_id = task->tk_pid;
0484         __entry->client_id = task->tk_client->cl_clid;
0485         __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
0486         __assign_str(progname, task->tk_client->cl_program->name);
0487         __entry->version = task->tk_client->cl_vers;
0488         __assign_str(procname, rpc_proc_name(task));
0489         __assign_str(servername, task->tk_xprt->servername);
0490     ),
0491 
0492     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0493           " server=%s xid=0x%08x %sv%d %s",
0494         __entry->task_id, __entry->client_id, __get_str(servername),
0495         __entry->xid, __get_str(progname), __entry->version,
0496         __get_str(procname))
0497 )
0498 
0499 #define DEFINE_RPC_REPLY_EVENT(name)                    \
0500     DEFINE_EVENT(rpc_reply_event, rpc__##name,          \
0501             TP_PROTO(                   \
0502                 const struct rpc_task *task     \
0503             ),                      \
0504             TP_ARGS(task))
0505 
0506 DEFINE_RPC_REPLY_EVENT(prog_unavail);
0507 DEFINE_RPC_REPLY_EVENT(prog_mismatch);
0508 DEFINE_RPC_REPLY_EVENT(proc_unavail);
0509 DEFINE_RPC_REPLY_EVENT(garbage_args);
0510 DEFINE_RPC_REPLY_EVENT(unparsable);
0511 DEFINE_RPC_REPLY_EVENT(mismatch);
0512 DEFINE_RPC_REPLY_EVENT(stale_creds);
0513 DEFINE_RPC_REPLY_EVENT(bad_creds);
0514 DEFINE_RPC_REPLY_EVENT(auth_tooweak);
0515 
0516 #define DEFINE_RPCB_ERROR_EVENT(name)                   \
0517     DEFINE_EVENT(rpc_reply_event, rpcb_##name##_err,        \
0518             TP_PROTO(                   \
0519                 const struct rpc_task *task     \
0520             ),                      \
0521             TP_ARGS(task))
0522 
0523 DEFINE_RPCB_ERROR_EVENT(prog_unavail);
0524 DEFINE_RPCB_ERROR_EVENT(timeout);
0525 DEFINE_RPCB_ERROR_EVENT(bind_version);
0526 DEFINE_RPCB_ERROR_EVENT(unreachable);
0527 DEFINE_RPCB_ERROR_EVENT(unrecognized);
0528 
0529 TRACE_EVENT(rpc_buf_alloc,
0530     TP_PROTO(
0531         const struct rpc_task *task,
0532         int status
0533     ),
0534 
0535     TP_ARGS(task, status),
0536 
0537     TP_STRUCT__entry(
0538         __field(unsigned int, task_id)
0539         __field(unsigned int, client_id)
0540         __field(size_t, callsize)
0541         __field(size_t, recvsize)
0542         __field(int, status)
0543     ),
0544 
0545     TP_fast_assign(
0546         __entry->task_id = task->tk_pid;
0547         __entry->client_id = task->tk_client->cl_clid;
0548         __entry->callsize = task->tk_rqstp->rq_callsize;
0549         __entry->recvsize = task->tk_rqstp->rq_rcvsize;
0550         __entry->status = status;
0551     ),
0552 
0553     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0554           " callsize=%zu recvsize=%zu status=%d",
0555         __entry->task_id, __entry->client_id,
0556         __entry->callsize, __entry->recvsize, __entry->status
0557     )
0558 );
0559 
0560 TRACE_EVENT(rpc_call_rpcerror,
0561     TP_PROTO(
0562         const struct rpc_task *task,
0563         int tk_status,
0564         int rpc_status
0565     ),
0566 
0567     TP_ARGS(task, tk_status, rpc_status),
0568 
0569     TP_STRUCT__entry(
0570         __field(unsigned int, task_id)
0571         __field(unsigned int, client_id)
0572         __field(int, tk_status)
0573         __field(int, rpc_status)
0574     ),
0575 
0576     TP_fast_assign(
0577         __entry->client_id = task->tk_client->cl_clid;
0578         __entry->task_id = task->tk_pid;
0579         __entry->tk_status = tk_status;
0580         __entry->rpc_status = rpc_status;
0581     ),
0582 
0583     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0584           " tk_status=%d rpc_status=%d",
0585         __entry->task_id, __entry->client_id,
0586         __entry->tk_status, __entry->rpc_status)
0587 );
0588 
0589 TRACE_EVENT(rpc_stats_latency,
0590 
0591     TP_PROTO(
0592         const struct rpc_task *task,
0593         ktime_t backlog,
0594         ktime_t rtt,
0595         ktime_t execute
0596     ),
0597 
0598     TP_ARGS(task, backlog, rtt, execute),
0599 
0600     TP_STRUCT__entry(
0601         __field(unsigned int, task_id)
0602         __field(unsigned int, client_id)
0603         __field(u32, xid)
0604         __field(int, version)
0605         __string(progname, task->tk_client->cl_program->name)
0606         __string(procname, rpc_proc_name(task))
0607         __field(unsigned long, backlog)
0608         __field(unsigned long, rtt)
0609         __field(unsigned long, execute)
0610     ),
0611 
0612     TP_fast_assign(
0613         __entry->client_id = task->tk_client->cl_clid;
0614         __entry->task_id = task->tk_pid;
0615         __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
0616         __entry->version = task->tk_client->cl_vers;
0617         __assign_str(progname, task->tk_client->cl_program->name);
0618         __assign_str(procname, rpc_proc_name(task));
0619         __entry->backlog = ktime_to_us(backlog);
0620         __entry->rtt = ktime_to_us(rtt);
0621         __entry->execute = ktime_to_us(execute);
0622     ),
0623 
0624     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0625           " xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
0626         __entry->task_id, __entry->client_id, __entry->xid,
0627         __get_str(progname), __entry->version, __get_str(procname),
0628         __entry->backlog, __entry->rtt, __entry->execute)
0629 );
0630 
0631 TRACE_EVENT(rpc_xdr_overflow,
0632     TP_PROTO(
0633         const struct xdr_stream *xdr,
0634         size_t requested
0635     ),
0636 
0637     TP_ARGS(xdr, requested),
0638 
0639     TP_STRUCT__entry(
0640         __field(unsigned int, task_id)
0641         __field(unsigned int, client_id)
0642         __field(int, version)
0643         __field(size_t, requested)
0644         __field(const void *, end)
0645         __field(const void *, p)
0646         __field(const void *, head_base)
0647         __field(size_t, head_len)
0648         __field(const void *, tail_base)
0649         __field(size_t, tail_len)
0650         __field(unsigned int, page_len)
0651         __field(unsigned int, len)
0652         __string(progname, xdr->rqst ?
0653              xdr->rqst->rq_task->tk_client->cl_program->name : "unknown")
0654         __string(procedure, xdr->rqst ?
0655              xdr->rqst->rq_task->tk_msg.rpc_proc->p_name : "unknown")
0656     ),
0657 
0658     TP_fast_assign(
0659         if (xdr->rqst) {
0660             const struct rpc_task *task = xdr->rqst->rq_task;
0661 
0662             __entry->task_id = task->tk_pid;
0663             __entry->client_id = task->tk_client->cl_clid;
0664             __assign_str(progname,
0665                      task->tk_client->cl_program->name);
0666             __entry->version = task->tk_client->cl_vers;
0667             __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
0668         } else {
0669             __entry->task_id = -1;
0670             __entry->client_id = -1;
0671             __assign_str(progname, "unknown");
0672             __entry->version = 0;
0673             __assign_str(procedure, "unknown");
0674         }
0675         __entry->requested = requested;
0676         __entry->end = xdr->end;
0677         __entry->p = xdr->p;
0678         __entry->head_base = xdr->buf->head[0].iov_base,
0679         __entry->head_len = xdr->buf->head[0].iov_len,
0680         __entry->page_len = xdr->buf->page_len,
0681         __entry->tail_base = xdr->buf->tail[0].iov_base,
0682         __entry->tail_len = xdr->buf->tail[0].iov_len,
0683         __entry->len = xdr->buf->len;
0684     ),
0685 
0686     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0687           " %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
0688         __entry->task_id, __entry->client_id,
0689         __get_str(progname), __entry->version, __get_str(procedure),
0690         __entry->requested, __entry->p, __entry->end,
0691         __entry->head_base, __entry->head_len,
0692         __entry->page_len,
0693         __entry->tail_base, __entry->tail_len,
0694         __entry->len
0695     )
0696 );
0697 
0698 TRACE_EVENT(rpc_xdr_alignment,
0699     TP_PROTO(
0700         const struct xdr_stream *xdr,
0701         size_t offset,
0702         unsigned int copied
0703     ),
0704 
0705     TP_ARGS(xdr, offset, copied),
0706 
0707     TP_STRUCT__entry(
0708         __field(unsigned int, task_id)
0709         __field(unsigned int, client_id)
0710         __field(int, version)
0711         __field(size_t, offset)
0712         __field(unsigned int, copied)
0713         __field(const void *, head_base)
0714         __field(size_t, head_len)
0715         __field(const void *, tail_base)
0716         __field(size_t, tail_len)
0717         __field(unsigned int, page_len)
0718         __field(unsigned int, len)
0719         __string(progname,
0720              xdr->rqst->rq_task->tk_client->cl_program->name)
0721         __string(procedure,
0722              xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
0723     ),
0724 
0725     TP_fast_assign(
0726         const struct rpc_task *task = xdr->rqst->rq_task;
0727 
0728         __entry->task_id = task->tk_pid;
0729         __entry->client_id = task->tk_client->cl_clid;
0730         __assign_str(progname,
0731                  task->tk_client->cl_program->name);
0732         __entry->version = task->tk_client->cl_vers;
0733         __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
0734 
0735         __entry->offset = offset;
0736         __entry->copied = copied;
0737         __entry->head_base = xdr->buf->head[0].iov_base,
0738         __entry->head_len = xdr->buf->head[0].iov_len,
0739         __entry->page_len = xdr->buf->page_len,
0740         __entry->tail_base = xdr->buf->tail[0].iov_base,
0741         __entry->tail_len = xdr->buf->tail[0].iov_len,
0742         __entry->len = xdr->buf->len;
0743     ),
0744 
0745     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0746           " %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
0747         __entry->task_id, __entry->client_id,
0748         __get_str(progname), __entry->version, __get_str(procedure),
0749         __entry->offset, __entry->copied,
0750         __entry->head_base, __entry->head_len,
0751         __entry->page_len,
0752         __entry->tail_base, __entry->tail_len,
0753         __entry->len
0754     )
0755 );
0756 
0757 /*
0758  * First define the enums in the below macros to be exported to userspace
0759  * via TRACE_DEFINE_ENUM().
0760  */
0761 #undef EM
0762 #undef EMe
0763 #define EM(a, b)    TRACE_DEFINE_ENUM(a);
0764 #define EMe(a, b)   TRACE_DEFINE_ENUM(a);
0765 
0766 #define RPC_SHOW_SOCKET             \
0767     EM( SS_FREE, "FREE" )           \
0768     EM( SS_UNCONNECTED, "UNCONNECTED" ) \
0769     EM( SS_CONNECTING, "CONNECTING" )   \
0770     EM( SS_CONNECTED, "CONNECTED" )     \
0771     EMe( SS_DISCONNECTING, "DISCONNECTING" )
0772 
0773 #define rpc_show_socket_state(state) \
0774     __print_symbolic(state, RPC_SHOW_SOCKET)
0775 
0776 RPC_SHOW_SOCKET
0777 
0778 #define RPC_SHOW_SOCK               \
0779     EM( TCP_ESTABLISHED, "ESTABLISHED" )    \
0780     EM( TCP_SYN_SENT, "SYN_SENT" )      \
0781     EM( TCP_SYN_RECV, "SYN_RECV" )      \
0782     EM( TCP_FIN_WAIT1, "FIN_WAIT1" )    \
0783     EM( TCP_FIN_WAIT2, "FIN_WAIT2" )    \
0784     EM( TCP_TIME_WAIT, "TIME_WAIT" )    \
0785     EM( TCP_CLOSE, "CLOSE" )        \
0786     EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" )  \
0787     EM( TCP_LAST_ACK, "LAST_ACK" )      \
0788     EM( TCP_LISTEN, "LISTEN" )      \
0789     EMe( TCP_CLOSING, "CLOSING" )
0790 
0791 #define rpc_show_sock_state(state) \
0792     __print_symbolic(state, RPC_SHOW_SOCK)
0793 
0794 RPC_SHOW_SOCK
0795 
0796 
0797 #include <trace/events/net_probe_common.h>
0798 
0799 /*
0800  * Now redefine the EM() and EMe() macros to map the enums to the strings
0801  * that will be printed in the output.
0802  */
0803 #undef EM
0804 #undef EMe
0805 #define EM(a, b)    {a, b},
0806 #define EMe(a, b)   {a, b}
0807 
0808 DECLARE_EVENT_CLASS(xs_socket_event,
0809 
0810         TP_PROTO(
0811             struct rpc_xprt *xprt,
0812             struct socket *socket
0813         ),
0814 
0815         TP_ARGS(xprt, socket),
0816 
0817         TP_STRUCT__entry(
0818             __field(unsigned int, socket_state)
0819             __field(unsigned int, sock_state)
0820             __field(unsigned long long, ino)
0821             __array(__u8, saddr, sizeof(struct sockaddr_in6))
0822             __array(__u8, daddr, sizeof(struct sockaddr_in6))
0823         ),
0824 
0825         TP_fast_assign(
0826             struct inode *inode = SOCK_INODE(socket);
0827             const struct sock *sk = socket->sk;
0828             const struct inet_sock *inet = inet_sk(sk);
0829 
0830             memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
0831             memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
0832 
0833             TP_STORE_ADDR_PORTS(__entry, inet, sk);
0834 
0835             __entry->socket_state = socket->state;
0836             __entry->sock_state = socket->sk->sk_state;
0837             __entry->ino = (unsigned long long)inode->i_ino;
0838 
0839         ),
0840 
0841         TP_printk(
0842             "socket:[%llu] srcaddr=%pISpc dstaddr=%pISpc "
0843             "state=%u (%s) sk_state=%u (%s)",
0844             __entry->ino,
0845             __entry->saddr,
0846             __entry->daddr,
0847             __entry->socket_state,
0848             rpc_show_socket_state(__entry->socket_state),
0849             __entry->sock_state,
0850             rpc_show_sock_state(__entry->sock_state)
0851         )
0852 );
0853 #define DEFINE_RPC_SOCKET_EVENT(name) \
0854     DEFINE_EVENT(xs_socket_event, name, \
0855             TP_PROTO( \
0856                 struct rpc_xprt *xprt, \
0857                 struct socket *socket \
0858             ), \
0859             TP_ARGS(xprt, socket))
0860 
0861 DECLARE_EVENT_CLASS(xs_socket_event_done,
0862 
0863         TP_PROTO(
0864             struct rpc_xprt *xprt,
0865             struct socket *socket,
0866             int error
0867         ),
0868 
0869         TP_ARGS(xprt, socket, error),
0870 
0871         TP_STRUCT__entry(
0872             __field(int, error)
0873             __field(unsigned int, socket_state)
0874             __field(unsigned int, sock_state)
0875             __field(unsigned long long, ino)
0876             __array(__u8, saddr, sizeof(struct sockaddr_in6))
0877             __array(__u8, daddr, sizeof(struct sockaddr_in6))
0878         ),
0879 
0880         TP_fast_assign(
0881             struct inode *inode = SOCK_INODE(socket);
0882             const struct sock *sk = socket->sk;
0883             const struct inet_sock *inet = inet_sk(sk);
0884 
0885             memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
0886             memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
0887 
0888             TP_STORE_ADDR_PORTS(__entry, inet, sk);
0889 
0890             __entry->socket_state = socket->state;
0891             __entry->sock_state = socket->sk->sk_state;
0892             __entry->ino = (unsigned long long)inode->i_ino;
0893             __entry->error = error;
0894         ),
0895 
0896         TP_printk(
0897             "error=%d socket:[%llu] srcaddr=%pISpc dstaddr=%pISpc "
0898             "state=%u (%s) sk_state=%u (%s)",
0899             __entry->error,
0900             __entry->ino,
0901             __entry->saddr,
0902             __entry->daddr,
0903             __entry->socket_state,
0904             rpc_show_socket_state(__entry->socket_state),
0905             __entry->sock_state,
0906             rpc_show_sock_state(__entry->sock_state)
0907         )
0908 );
0909 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
0910     DEFINE_EVENT(xs_socket_event_done, name, \
0911             TP_PROTO( \
0912                 struct rpc_xprt *xprt, \
0913                 struct socket *socket, \
0914                 int error \
0915             ), \
0916             TP_ARGS(xprt, socket, error))
0917 
0918 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
0919 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
0920 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
0921 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
0922 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
0923 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
0924 
0925 TRACE_EVENT(rpc_socket_nospace,
0926     TP_PROTO(
0927         const struct rpc_rqst *rqst,
0928         const struct sock_xprt *transport
0929     ),
0930 
0931     TP_ARGS(rqst, transport),
0932 
0933     TP_STRUCT__entry(
0934         __field(unsigned int, task_id)
0935         __field(unsigned int, client_id)
0936         __field(unsigned int, total)
0937         __field(unsigned int, remaining)
0938     ),
0939 
0940     TP_fast_assign(
0941         __entry->task_id = rqst->rq_task->tk_pid;
0942         __entry->client_id = rqst->rq_task->tk_client->cl_clid;
0943         __entry->total = rqst->rq_slen;
0944         __entry->remaining = rqst->rq_slen - transport->xmit.offset;
0945     ),
0946 
0947     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
0948           " total=%u remaining=%u",
0949         __entry->task_id, __entry->client_id,
0950         __entry->total, __entry->remaining
0951     )
0952 );
0953 
0954 #define rpc_show_xprt_state(x)                      \
0955     __print_flags(x, "|",                       \
0956         { BIT(XPRT_LOCKED),     "LOCKED" },     \
0957         { BIT(XPRT_CONNECTED),      "CONNECTED" },      \
0958         { BIT(XPRT_CONNECTING),     "CONNECTING" },     \
0959         { BIT(XPRT_CLOSE_WAIT),     "CLOSE_WAIT" },     \
0960         { BIT(XPRT_BOUND),      "BOUND" },      \
0961         { BIT(XPRT_BINDING),        "BINDING" },        \
0962         { BIT(XPRT_CLOSING),        "CLOSING" },        \
0963         { BIT(XPRT_OFFLINE),        "OFFLINE" },        \
0964         { BIT(XPRT_REMOVE),     "REMOVE" },     \
0965         { BIT(XPRT_CONGESTED),      "CONGESTED" },      \
0966         { BIT(XPRT_CWND_WAIT),      "CWND_WAIT" },      \
0967         { BIT(XPRT_WRITE_SPACE),    "WRITE_SPACE" },    \
0968         { BIT(XPRT_SND_IS_COOKIE),  "SND_IS_COOKIE" })
0969 
0970 DECLARE_EVENT_CLASS(rpc_xprt_lifetime_class,
0971     TP_PROTO(
0972         const struct rpc_xprt *xprt
0973     ),
0974 
0975     TP_ARGS(xprt),
0976 
0977     TP_STRUCT__entry(
0978         __field(unsigned long, state)
0979         __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
0980         __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
0981     ),
0982 
0983     TP_fast_assign(
0984         __entry->state = xprt->state;
0985         __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
0986         __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
0987     ),
0988 
0989     TP_printk("peer=[%s]:%s state=%s",
0990         __get_str(addr), __get_str(port),
0991         rpc_show_xprt_state(__entry->state))
0992 );
0993 
0994 #define DEFINE_RPC_XPRT_LIFETIME_EVENT(name) \
0995     DEFINE_EVENT(rpc_xprt_lifetime_class, \
0996             xprt_##name, \
0997             TP_PROTO( \
0998                 const struct rpc_xprt *xprt \
0999             ), \
1000             TP_ARGS(xprt))
1001 
1002 DEFINE_RPC_XPRT_LIFETIME_EVENT(create);
1003 DEFINE_RPC_XPRT_LIFETIME_EVENT(connect);
1004 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto);
1005 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done);
1006 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force);
1007 DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy);
1008 
1009 DECLARE_EVENT_CLASS(rpc_xprt_event,
1010     TP_PROTO(
1011         const struct rpc_xprt *xprt,
1012         __be32 xid,
1013         int status
1014     ),
1015 
1016     TP_ARGS(xprt, xid, status),
1017 
1018     TP_STRUCT__entry(
1019         __field(u32, xid)
1020         __field(int, status)
1021         __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
1022         __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
1023     ),
1024 
1025     TP_fast_assign(
1026         __entry->xid = be32_to_cpu(xid);
1027         __entry->status = status;
1028         __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1029         __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1030     ),
1031 
1032     TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
1033             __get_str(port), __entry->xid,
1034             __entry->status)
1035 );
1036 #define DEFINE_RPC_XPRT_EVENT(name) \
1037     DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
1038             TP_PROTO( \
1039                 const struct rpc_xprt *xprt, \
1040                 __be32 xid, \
1041                 int status \
1042             ), \
1043             TP_ARGS(xprt, xid, status))
1044 
1045 DEFINE_RPC_XPRT_EVENT(timer);
1046 DEFINE_RPC_XPRT_EVENT(lookup_rqst);
1047 
1048 TRACE_EVENT(xprt_transmit,
1049     TP_PROTO(
1050         const struct rpc_rqst *rqst,
1051         int status
1052     ),
1053 
1054     TP_ARGS(rqst, status),
1055 
1056     TP_STRUCT__entry(
1057         __field(unsigned int, task_id)
1058         __field(unsigned int, client_id)
1059         __field(u32, xid)
1060         __field(u32, seqno)
1061         __field(int, status)
1062     ),
1063 
1064     TP_fast_assign(
1065         __entry->task_id = rqst->rq_task->tk_pid;
1066         __entry->client_id = rqst->rq_task->tk_client ?
1067             rqst->rq_task->tk_client->cl_clid : -1;
1068         __entry->xid = be32_to_cpu(rqst->rq_xid);
1069         __entry->seqno = rqst->rq_seqno;
1070         __entry->status = status;
1071     ),
1072 
1073     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1074           " xid=0x%08x seqno=%u status=%d",
1075         __entry->task_id, __entry->client_id, __entry->xid,
1076         __entry->seqno, __entry->status)
1077 );
1078 
1079 TRACE_EVENT(xprt_retransmit,
1080     TP_PROTO(
1081         const struct rpc_rqst *rqst
1082     ),
1083 
1084     TP_ARGS(rqst),
1085 
1086     TP_STRUCT__entry(
1087         __field(unsigned int, task_id)
1088         __field(unsigned int, client_id)
1089         __field(u32, xid)
1090         __field(int, ntrans)
1091         __field(int, version)
1092         __field(unsigned long, timeout)
1093         __string(progname,
1094              rqst->rq_task->tk_client->cl_program->name)
1095         __string(procname, rpc_proc_name(rqst->rq_task))
1096     ),
1097 
1098     TP_fast_assign(
1099         struct rpc_task *task = rqst->rq_task;
1100 
1101         __entry->task_id = task->tk_pid;
1102         __entry->client_id = task->tk_client ?
1103             task->tk_client->cl_clid : -1;
1104         __entry->xid = be32_to_cpu(rqst->rq_xid);
1105         __entry->ntrans = rqst->rq_ntrans;
1106         __entry->timeout = task->tk_timeout;
1107         __assign_str(progname,
1108                  task->tk_client->cl_program->name);
1109         __entry->version = task->tk_client->cl_vers;
1110         __assign_str(procname, rpc_proc_name(task));
1111     ),
1112 
1113     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1114           " xid=0x%08x %sv%d %s ntrans=%d timeout=%lu",
1115         __entry->task_id, __entry->client_id, __entry->xid,
1116         __get_str(progname), __entry->version, __get_str(procname),
1117         __entry->ntrans, __entry->timeout
1118     )
1119 );
1120 
1121 TRACE_EVENT(xprt_ping,
1122     TP_PROTO(const struct rpc_xprt *xprt, int status),
1123 
1124     TP_ARGS(xprt, status),
1125 
1126     TP_STRUCT__entry(
1127         __field(int, status)
1128         __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
1129         __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
1130     ),
1131 
1132     TP_fast_assign(
1133         __entry->status = status;
1134         __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1135         __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1136     ),
1137 
1138     TP_printk("peer=[%s]:%s status=%d",
1139             __get_str(addr), __get_str(port), __entry->status)
1140 );
1141 
1142 DECLARE_EVENT_CLASS(xprt_writelock_event,
1143     TP_PROTO(
1144         const struct rpc_xprt *xprt, const struct rpc_task *task
1145     ),
1146 
1147     TP_ARGS(xprt, task),
1148 
1149     TP_STRUCT__entry(
1150         __field(unsigned int, task_id)
1151         __field(unsigned int, client_id)
1152         __field(unsigned int, snd_task_id)
1153     ),
1154 
1155     TP_fast_assign(
1156         if (task) {
1157             __entry->task_id = task->tk_pid;
1158             __entry->client_id = task->tk_client ?
1159                          task->tk_client->cl_clid : -1;
1160         } else {
1161             __entry->task_id = -1;
1162             __entry->client_id = -1;
1163         }
1164         if (xprt->snd_task &&
1165             !test_bit(XPRT_SND_IS_COOKIE, &xprt->state))
1166             __entry->snd_task_id = xprt->snd_task->tk_pid;
1167         else
1168             __entry->snd_task_id = -1;
1169     ),
1170 
1171     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1172           " snd_task:" SUNRPC_TRACE_PID_SPECIFIER,
1173             __entry->task_id, __entry->client_id,
1174             __entry->snd_task_id)
1175 );
1176 
1177 #define DEFINE_WRITELOCK_EVENT(name) \
1178     DEFINE_EVENT(xprt_writelock_event, xprt_##name, \
1179             TP_PROTO( \
1180                 const struct rpc_xprt *xprt, \
1181                 const struct rpc_task *task \
1182             ), \
1183             TP_ARGS(xprt, task))
1184 
1185 DEFINE_WRITELOCK_EVENT(reserve_xprt);
1186 DEFINE_WRITELOCK_EVENT(release_xprt);
1187 
1188 DECLARE_EVENT_CLASS(xprt_cong_event,
1189     TP_PROTO(
1190         const struct rpc_xprt *xprt, const struct rpc_task *task
1191     ),
1192 
1193     TP_ARGS(xprt, task),
1194 
1195     TP_STRUCT__entry(
1196         __field(unsigned int, task_id)
1197         __field(unsigned int, client_id)
1198         __field(unsigned int, snd_task_id)
1199         __field(unsigned long, cong)
1200         __field(unsigned long, cwnd)
1201         __field(bool, wait)
1202     ),
1203 
1204     TP_fast_assign(
1205         if (task) {
1206             __entry->task_id = task->tk_pid;
1207             __entry->client_id = task->tk_client ?
1208                          task->tk_client->cl_clid : -1;
1209         } else {
1210             __entry->task_id = -1;
1211             __entry->client_id = -1;
1212         }
1213         if (xprt->snd_task &&
1214             !test_bit(XPRT_SND_IS_COOKIE, &xprt->state))
1215             __entry->snd_task_id = xprt->snd_task->tk_pid;
1216         else
1217             __entry->snd_task_id = -1;
1218 
1219         __entry->cong = xprt->cong;
1220         __entry->cwnd = xprt->cwnd;
1221         __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
1222     ),
1223 
1224     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1225           " snd_task:" SUNRPC_TRACE_PID_SPECIFIER
1226           " cong=%lu cwnd=%lu%s",
1227             __entry->task_id, __entry->client_id,
1228             __entry->snd_task_id, __entry->cong, __entry->cwnd,
1229             __entry->wait ? " (wait)" : "")
1230 );
1231 
1232 #define DEFINE_CONG_EVENT(name) \
1233     DEFINE_EVENT(xprt_cong_event, xprt_##name, \
1234             TP_PROTO( \
1235                 const struct rpc_xprt *xprt, \
1236                 const struct rpc_task *task \
1237             ), \
1238             TP_ARGS(xprt, task))
1239 
1240 DEFINE_CONG_EVENT(reserve_cong);
1241 DEFINE_CONG_EVENT(release_cong);
1242 DEFINE_CONG_EVENT(get_cong);
1243 DEFINE_CONG_EVENT(put_cong);
1244 
1245 TRACE_EVENT(xprt_reserve,
1246     TP_PROTO(
1247         const struct rpc_rqst *rqst
1248     ),
1249 
1250     TP_ARGS(rqst),
1251 
1252     TP_STRUCT__entry(
1253         __field(unsigned int, task_id)
1254         __field(unsigned int, client_id)
1255         __field(u32, xid)
1256     ),
1257 
1258     TP_fast_assign(
1259         __entry->task_id = rqst->rq_task->tk_pid;
1260         __entry->client_id = rqst->rq_task->tk_client->cl_clid;
1261         __entry->xid = be32_to_cpu(rqst->rq_xid);
1262     ),
1263 
1264     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x",
1265         __entry->task_id, __entry->client_id, __entry->xid
1266     )
1267 );
1268 
1269 TRACE_EVENT(xs_data_ready,
1270     TP_PROTO(
1271         const struct rpc_xprt *xprt
1272     ),
1273 
1274     TP_ARGS(xprt),
1275 
1276     TP_STRUCT__entry(
1277         __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
1278         __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
1279     ),
1280 
1281     TP_fast_assign(
1282         __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1283         __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1284     ),
1285 
1286     TP_printk("peer=[%s]:%s", __get_str(addr), __get_str(port))
1287 );
1288 
1289 TRACE_EVENT(xs_stream_read_data,
1290     TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
1291 
1292     TP_ARGS(xprt, err, total),
1293 
1294     TP_STRUCT__entry(
1295         __field(ssize_t, err)
1296         __field(size_t, total)
1297         __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
1298                 "(null)")
1299         __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
1300                 "(null)")
1301     ),
1302 
1303     TP_fast_assign(
1304         __entry->err = err;
1305         __entry->total = total;
1306         __assign_str(addr, xprt ?
1307             xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
1308         __assign_str(port, xprt ?
1309             xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
1310     ),
1311 
1312     TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
1313             __get_str(port), __entry->err, __entry->total)
1314 );
1315 
1316 TRACE_EVENT(xs_stream_read_request,
1317     TP_PROTO(struct sock_xprt *xs),
1318 
1319     TP_ARGS(xs),
1320 
1321     TP_STRUCT__entry(
1322         __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
1323         __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
1324         __field(u32, xid)
1325         __field(unsigned long, copied)
1326         __field(unsigned int, reclen)
1327         __field(unsigned int, offset)
1328     ),
1329 
1330     TP_fast_assign(
1331         __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
1332         __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
1333         __entry->xid = be32_to_cpu(xs->recv.xid);
1334         __entry->copied = xs->recv.copied;
1335         __entry->reclen = xs->recv.len;
1336         __entry->offset = xs->recv.offset;
1337     ),
1338 
1339     TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
1340             __get_str(addr), __get_str(port), __entry->xid,
1341             __entry->copied, __entry->reclen, __entry->offset)
1342 );
1343 
1344 TRACE_EVENT(rpcb_getport,
1345     TP_PROTO(
1346         const struct rpc_clnt *clnt,
1347         const struct rpc_task *task,
1348         unsigned int bind_version
1349     ),
1350 
1351     TP_ARGS(clnt, task, bind_version),
1352 
1353     TP_STRUCT__entry(
1354         __field(unsigned int, task_id)
1355         __field(unsigned int, client_id)
1356         __field(unsigned int, program)
1357         __field(unsigned int, version)
1358         __field(int, protocol)
1359         __field(unsigned int, bind_version)
1360         __string(servername, task->tk_xprt->servername)
1361     ),
1362 
1363     TP_fast_assign(
1364         __entry->task_id = task->tk_pid;
1365         __entry->client_id = clnt->cl_clid;
1366         __entry->program = clnt->cl_prog;
1367         __entry->version = clnt->cl_vers;
1368         __entry->protocol = task->tk_xprt->prot;
1369         __entry->bind_version = bind_version;
1370         __assign_str(servername, task->tk_xprt->servername);
1371     ),
1372 
1373     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1374           " server=%s program=%u version=%u protocol=%d bind_version=%u",
1375         __entry->task_id, __entry->client_id, __get_str(servername),
1376         __entry->program, __entry->version, __entry->protocol,
1377         __entry->bind_version
1378     )
1379 );
1380 
1381 TRACE_EVENT(rpcb_setport,
1382     TP_PROTO(
1383         const struct rpc_task *task,
1384         int status,
1385         unsigned short port
1386     ),
1387 
1388     TP_ARGS(task, status, port),
1389 
1390     TP_STRUCT__entry(
1391         __field(unsigned int, task_id)
1392         __field(unsigned int, client_id)
1393         __field(int, status)
1394         __field(unsigned short, port)
1395     ),
1396 
1397     TP_fast_assign(
1398         __entry->task_id = task->tk_pid;
1399         __entry->client_id = task->tk_client->cl_clid;
1400         __entry->status = status;
1401         __entry->port = port;
1402     ),
1403 
1404     TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d port=%u",
1405         __entry->task_id, __entry->client_id,
1406         __entry->status, __entry->port
1407     )
1408 );
1409 
1410 TRACE_EVENT(pmap_register,
1411     TP_PROTO(
1412         u32 program,
1413         u32 version,
1414         int protocol,
1415         unsigned short port
1416     ),
1417 
1418     TP_ARGS(program, version, protocol, port),
1419 
1420     TP_STRUCT__entry(
1421         __field(unsigned int, program)
1422         __field(unsigned int, version)
1423         __field(int, protocol)
1424         __field(unsigned int, port)
1425     ),
1426 
1427     TP_fast_assign(
1428         __entry->program = program;
1429         __entry->version = version;
1430         __entry->protocol = protocol;
1431         __entry->port = port;
1432     ),
1433 
1434     TP_printk("program=%u version=%u protocol=%d port=%u",
1435         __entry->program, __entry->version,
1436         __entry->protocol, __entry->port
1437     )
1438 );
1439 
1440 TRACE_EVENT(rpcb_register,
1441     TP_PROTO(
1442         u32 program,
1443         u32 version,
1444         const char *addr,
1445         const char *netid
1446     ),
1447 
1448     TP_ARGS(program, version, addr, netid),
1449 
1450     TP_STRUCT__entry(
1451         __field(unsigned int, program)
1452         __field(unsigned int, version)
1453         __string(addr, addr)
1454         __string(netid, netid)
1455     ),
1456 
1457     TP_fast_assign(
1458         __entry->program = program;
1459         __entry->version = version;
1460         __assign_str(addr, addr);
1461         __assign_str(netid, netid);
1462     ),
1463 
1464     TP_printk("program=%u version=%u addr=%s netid=%s",
1465         __entry->program, __entry->version,
1466         __get_str(addr), __get_str(netid)
1467     )
1468 );
1469 
1470 TRACE_EVENT(rpcb_unregister,
1471     TP_PROTO(
1472         u32 program,
1473         u32 version,
1474         const char *netid
1475     ),
1476 
1477     TP_ARGS(program, version, netid),
1478 
1479     TP_STRUCT__entry(
1480         __field(unsigned int, program)
1481         __field(unsigned int, version)
1482         __string(netid, netid)
1483     ),
1484 
1485     TP_fast_assign(
1486         __entry->program = program;
1487         __entry->version = version;
1488         __assign_str(netid, netid);
1489     ),
1490 
1491     TP_printk("program=%u version=%u netid=%s",
1492         __entry->program, __entry->version, __get_str(netid)
1493     )
1494 );
1495 
1496 /* Record an xdr_buf containing a fully-formed RPC message */
1497 DECLARE_EVENT_CLASS(svc_xdr_msg_class,
1498     TP_PROTO(
1499         const struct xdr_buf *xdr
1500     ),
1501 
1502     TP_ARGS(xdr),
1503 
1504     TP_STRUCT__entry(
1505         __field(u32, xid)
1506         __field(const void *, head_base)
1507         __field(size_t, head_len)
1508         __field(const void *, tail_base)
1509         __field(size_t, tail_len)
1510         __field(unsigned int, page_len)
1511         __field(unsigned int, msg_len)
1512     ),
1513 
1514     TP_fast_assign(
1515         __be32 *p = (__be32 *)xdr->head[0].iov_base;
1516 
1517         __entry->xid = be32_to_cpu(*p);
1518         __entry->head_base = p;
1519         __entry->head_len = xdr->head[0].iov_len;
1520         __entry->tail_base = xdr->tail[0].iov_base;
1521         __entry->tail_len = xdr->tail[0].iov_len;
1522         __entry->page_len = xdr->page_len;
1523         __entry->msg_len = xdr->len;
1524     ),
1525 
1526     TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
1527         __entry->xid,
1528         __entry->head_base, __entry->head_len, __entry->page_len,
1529         __entry->tail_base, __entry->tail_len, __entry->msg_len
1530     )
1531 );
1532 
1533 #define DEFINE_SVCXDRMSG_EVENT(name)                    \
1534         DEFINE_EVENT(svc_xdr_msg_class,             \
1535                 svc_xdr_##name,             \
1536                 TP_PROTO(               \
1537                     const struct xdr_buf *xdr   \
1538                 ),                  \
1539                 TP_ARGS(xdr))
1540 
1541 DEFINE_SVCXDRMSG_EVENT(recvfrom);
1542 
1543 /* Record an xdr_buf containing arbitrary data, tagged with an XID */
1544 DECLARE_EVENT_CLASS(svc_xdr_buf_class,
1545     TP_PROTO(
1546         __be32 xid,
1547         const struct xdr_buf *xdr
1548     ),
1549 
1550     TP_ARGS(xid, xdr),
1551 
1552     TP_STRUCT__entry(
1553         __field(u32, xid)
1554         __field(const void *, head_base)
1555         __field(size_t, head_len)
1556         __field(const void *, tail_base)
1557         __field(size_t, tail_len)
1558         __field(unsigned int, page_base)
1559         __field(unsigned int, page_len)
1560         __field(unsigned int, msg_len)
1561     ),
1562 
1563     TP_fast_assign(
1564         __entry->xid = be32_to_cpu(xid);
1565         __entry->head_base = xdr->head[0].iov_base;
1566         __entry->head_len = xdr->head[0].iov_len;
1567         __entry->tail_base = xdr->tail[0].iov_base;
1568         __entry->tail_len = xdr->tail[0].iov_len;
1569         __entry->page_base = xdr->page_base;
1570         __entry->page_len = xdr->page_len;
1571         __entry->msg_len = xdr->len;
1572     ),
1573 
1574     TP_printk("xid=0x%08x head=[%p,%zu] page=%u(%u) tail=[%p,%zu] len=%u",
1575         __entry->xid,
1576         __entry->head_base, __entry->head_len,
1577         __entry->page_len, __entry->page_base,
1578         __entry->tail_base, __entry->tail_len,
1579         __entry->msg_len
1580     )
1581 );
1582 
1583 #define DEFINE_SVCXDRBUF_EVENT(name)                    \
1584         DEFINE_EVENT(svc_xdr_buf_class,             \
1585                 svc_xdr_##name,             \
1586                 TP_PROTO(               \
1587                     __be32 xid,         \
1588                     const struct xdr_buf *xdr   \
1589                 ),                  \
1590                 TP_ARGS(xid, xdr))
1591 
1592 DEFINE_SVCXDRBUF_EVENT(sendto);
1593 
1594 /*
1595  * from include/linux/sunrpc/svc.h
1596  */
1597 #define SVC_RQST_FLAG_LIST                      \
1598     svc_rqst_flag(SECURE)                       \
1599     svc_rqst_flag(LOCAL)                        \
1600     svc_rqst_flag(USEDEFERRAL)                  \
1601     svc_rqst_flag(DROPME)                       \
1602     svc_rqst_flag(SPLICE_OK)                    \
1603     svc_rqst_flag(VICTIM)                       \
1604     svc_rqst_flag(BUSY)                     \
1605     svc_rqst_flag_end(DATA)
1606 
1607 #undef svc_rqst_flag
1608 #undef svc_rqst_flag_end
1609 #define svc_rqst_flag(x)    TRACE_DEFINE_ENUM(RQ_##x);
1610 #define svc_rqst_flag_end(x)    TRACE_DEFINE_ENUM(RQ_##x);
1611 
1612 SVC_RQST_FLAG_LIST
1613 
1614 #undef svc_rqst_flag
1615 #undef svc_rqst_flag_end
1616 #define svc_rqst_flag(x)    { BIT(RQ_##x), #x },
1617 #define svc_rqst_flag_end(x)    { BIT(RQ_##x), #x }
1618 
1619 #define show_rqstp_flags(flags)                     \
1620         __print_flags(flags, "|", SVC_RQST_FLAG_LIST)
1621 
1622 TRACE_DEFINE_ENUM(SVC_GARBAGE);
1623 TRACE_DEFINE_ENUM(SVC_SYSERR);
1624 TRACE_DEFINE_ENUM(SVC_VALID);
1625 TRACE_DEFINE_ENUM(SVC_NEGATIVE);
1626 TRACE_DEFINE_ENUM(SVC_OK);
1627 TRACE_DEFINE_ENUM(SVC_DROP);
1628 TRACE_DEFINE_ENUM(SVC_CLOSE);
1629 TRACE_DEFINE_ENUM(SVC_DENIED);
1630 TRACE_DEFINE_ENUM(SVC_PENDING);
1631 TRACE_DEFINE_ENUM(SVC_COMPLETE);
1632 
1633 #define svc_show_status(status)             \
1634     __print_symbolic(status,            \
1635         { SVC_GARBAGE,  "SVC_GARBAGE" },    \
1636         { SVC_SYSERR,   "SVC_SYSERR" },     \
1637         { SVC_VALID,    "SVC_VALID" },      \
1638         { SVC_NEGATIVE, "SVC_NEGATIVE" },   \
1639         { SVC_OK,   "SVC_OK" },     \
1640         { SVC_DROP, "SVC_DROP" },       \
1641         { SVC_CLOSE,    "SVC_CLOSE" },      \
1642         { SVC_DENIED,   "SVC_DENIED" },     \
1643         { SVC_PENDING,  "SVC_PENDING" },    \
1644         { SVC_COMPLETE, "SVC_COMPLETE" })
1645 
1646 #define SVC_RQST_ENDPOINT_FIELDS(r) \
1647         __sockaddr(server, (r)->rq_xprt->xpt_locallen) \
1648         __sockaddr(client, (r)->rq_xprt->xpt_remotelen) \
1649         __field(unsigned int, netns_ino) \
1650         __field(u32, xid)
1651 
1652 #define SVC_RQST_ENDPOINT_ASSIGNMENTS(r) \
1653         do { \
1654             struct svc_xprt *xprt = (r)->rq_xprt; \
1655             __assign_sockaddr(server, &xprt->xpt_local, \
1656                       xprt->xpt_locallen); \
1657             __assign_sockaddr(client, &xprt->xpt_remote, \
1658                       xprt->xpt_remotelen); \
1659             __entry->netns_ino = xprt->xpt_net->ns.inum; \
1660             __entry->xid = be32_to_cpu((r)->rq_xid); \
1661         } while (0)
1662 
1663 #define SVC_RQST_ENDPOINT_FORMAT \
1664         "xid=0x%08x server=%pISpc client=%pISpc"
1665 
1666 #define SVC_RQST_ENDPOINT_VARARGS \
1667         __entry->xid, __get_sockaddr(server), __get_sockaddr(client)
1668 
1669 TRACE_EVENT(svc_authenticate,
1670     TP_PROTO(const struct svc_rqst *rqst, int auth_res),
1671 
1672     TP_ARGS(rqst, auth_res),
1673 
1674     TP_STRUCT__entry(
1675         SVC_RQST_ENDPOINT_FIELDS(rqst)
1676 
1677         __field(unsigned long, svc_status)
1678         __field(unsigned long, auth_stat)
1679     ),
1680 
1681     TP_fast_assign(
1682         SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1683 
1684         __entry->svc_status = auth_res;
1685         __entry->auth_stat = be32_to_cpu(rqst->rq_auth_stat);
1686     ),
1687 
1688     TP_printk(SVC_RQST_ENDPOINT_FORMAT
1689         " auth_res=%s auth_stat=%s",
1690         SVC_RQST_ENDPOINT_VARARGS,
1691         svc_show_status(__entry->svc_status),
1692         rpc_show_auth_stat(__entry->auth_stat))
1693 );
1694 
1695 TRACE_EVENT(svc_process,
1696     TP_PROTO(const struct svc_rqst *rqst, const char *name),
1697 
1698     TP_ARGS(rqst, name),
1699 
1700     TP_STRUCT__entry(
1701         __field(u32, xid)
1702         __field(u32, vers)
1703         __field(u32, proc)
1704         __string(service, name)
1705         __string(procedure, svc_proc_name(rqst))
1706         __string(addr, rqst->rq_xprt ?
1707              rqst->rq_xprt->xpt_remotebuf : "(null)")
1708     ),
1709 
1710     TP_fast_assign(
1711         __entry->xid = be32_to_cpu(rqst->rq_xid);
1712         __entry->vers = rqst->rq_vers;
1713         __entry->proc = rqst->rq_proc;
1714         __assign_str(service, name);
1715         __assign_str(procedure, svc_proc_name(rqst));
1716         __assign_str(addr, rqst->rq_xprt ?
1717                  rqst->rq_xprt->xpt_remotebuf : "(null)");
1718     ),
1719 
1720     TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%s",
1721             __get_str(addr), __entry->xid,
1722             __get_str(service), __entry->vers,
1723             __get_str(procedure)
1724     )
1725 );
1726 
1727 DECLARE_EVENT_CLASS(svc_rqst_event,
1728     TP_PROTO(
1729         const struct svc_rqst *rqst
1730     ),
1731 
1732     TP_ARGS(rqst),
1733 
1734     TP_STRUCT__entry(
1735         SVC_RQST_ENDPOINT_FIELDS(rqst)
1736 
1737         __field(unsigned long, flags)
1738     ),
1739 
1740     TP_fast_assign(
1741         SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1742 
1743         __entry->flags = rqst->rq_flags;
1744     ),
1745 
1746     TP_printk(SVC_RQST_ENDPOINT_FORMAT " flags=%s",
1747         SVC_RQST_ENDPOINT_VARARGS,
1748         show_rqstp_flags(__entry->flags))
1749 );
1750 #define DEFINE_SVC_RQST_EVENT(name) \
1751     DEFINE_EVENT(svc_rqst_event, svc_##name, \
1752             TP_PROTO( \
1753                 const struct svc_rqst *rqst \
1754             ), \
1755             TP_ARGS(rqst))
1756 
1757 DEFINE_SVC_RQST_EVENT(defer);
1758 DEFINE_SVC_RQST_EVENT(drop);
1759 
1760 DECLARE_EVENT_CLASS(svc_rqst_status,
1761     TP_PROTO(
1762         const struct svc_rqst *rqst,
1763         int status
1764     ),
1765 
1766     TP_ARGS(rqst, status),
1767 
1768     TP_STRUCT__entry(
1769         SVC_RQST_ENDPOINT_FIELDS(rqst)
1770 
1771         __field(int, status)
1772         __field(unsigned long, flags)
1773     ),
1774 
1775     TP_fast_assign(
1776         SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1777 
1778         __entry->status = status;
1779         __entry->flags = rqst->rq_flags;
1780     ),
1781 
1782     TP_printk(SVC_RQST_ENDPOINT_FORMAT " status=%d flags=%s",
1783         SVC_RQST_ENDPOINT_VARARGS,
1784         __entry->status, show_rqstp_flags(__entry->flags))
1785 );
1786 
1787 DEFINE_EVENT(svc_rqst_status, svc_send,
1788     TP_PROTO(const struct svc_rqst *rqst, int status),
1789     TP_ARGS(rqst, status));
1790 
1791 TRACE_EVENT(svc_stats_latency,
1792     TP_PROTO(
1793         const struct svc_rqst *rqst
1794     ),
1795 
1796     TP_ARGS(rqst),
1797 
1798     TP_STRUCT__entry(
1799         SVC_RQST_ENDPOINT_FIELDS(rqst)
1800 
1801         __field(unsigned long, execute)
1802         __string(procedure, svc_proc_name(rqst))
1803     ),
1804 
1805     TP_fast_assign(
1806         SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1807 
1808         __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
1809                              rqst->rq_stime));
1810         __assign_str(procedure, svc_proc_name(rqst));
1811     ),
1812 
1813     TP_printk(SVC_RQST_ENDPOINT_FORMAT " proc=%s execute-us=%lu",
1814         SVC_RQST_ENDPOINT_VARARGS,
1815         __get_str(procedure), __entry->execute)
1816 );
1817 
1818 #define show_svc_xprt_flags(flags)                  \
1819     __print_flags(flags, "|",                   \
1820         { (1UL << XPT_BUSY),        "XPT_BUSY"},        \
1821         { (1UL << XPT_CONN),        "XPT_CONN"},        \
1822         { (1UL << XPT_CLOSE),       "XPT_CLOSE"},       \
1823         { (1UL << XPT_DATA),        "XPT_DATA"},        \
1824         { (1UL << XPT_TEMP),        "XPT_TEMP"},        \
1825         { (1UL << XPT_DEAD),        "XPT_DEAD"},        \
1826         { (1UL << XPT_CHNGBUF),     "XPT_CHNGBUF"},     \
1827         { (1UL << XPT_DEFERRED),    "XPT_DEFERRED"},    \
1828         { (1UL << XPT_OLD),     "XPT_OLD"},     \
1829         { (1UL << XPT_LISTENER),    "XPT_LISTENER"},    \
1830         { (1UL << XPT_CACHE_AUTH),  "XPT_CACHE_AUTH"},  \
1831         { (1UL << XPT_LOCAL),       "XPT_LOCAL"},       \
1832         { (1UL << XPT_KILL_TEMP),   "XPT_KILL_TEMP"},   \
1833         { (1UL << XPT_CONG_CTRL),   "XPT_CONG_CTRL"})
1834 
1835 TRACE_EVENT(svc_xprt_create_err,
1836     TP_PROTO(
1837         const char *program,
1838         const char *protocol,
1839         struct sockaddr *sap,
1840         size_t salen,
1841         const struct svc_xprt *xprt
1842     ),
1843 
1844     TP_ARGS(program, protocol, sap, salen, xprt),
1845 
1846     TP_STRUCT__entry(
1847         __field(long, error)
1848         __string(program, program)
1849         __string(protocol, protocol)
1850         __sockaddr(addr, salen)
1851     ),
1852 
1853     TP_fast_assign(
1854         __entry->error = PTR_ERR(xprt);
1855         __assign_str(program, program);
1856         __assign_str(protocol, protocol);
1857         __assign_sockaddr(addr, sap, salen);
1858     ),
1859 
1860     TP_printk("addr=%pISpc program=%s protocol=%s error=%ld",
1861         __get_sockaddr(addr), __get_str(program), __get_str(protocol),
1862         __entry->error)
1863 );
1864 
1865 #define SVC_XPRT_ENDPOINT_FIELDS(x) \
1866         __sockaddr(server, (x)->xpt_locallen) \
1867         __sockaddr(client, (x)->xpt_remotelen) \
1868         __field(unsigned long, flags) \
1869         __field(unsigned int, netns_ino)
1870 
1871 #define SVC_XPRT_ENDPOINT_ASSIGNMENTS(x) \
1872         do { \
1873             __assign_sockaddr(server, &(x)->xpt_local, \
1874                       (x)->xpt_locallen); \
1875             __assign_sockaddr(client, &(x)->xpt_remote, \
1876                       (x)->xpt_remotelen); \
1877             __entry->flags = (x)->xpt_flags; \
1878             __entry->netns_ino = (x)->xpt_net->ns.inum; \
1879         } while (0)
1880 
1881 #define SVC_XPRT_ENDPOINT_FORMAT \
1882         "server=%pISpc client=%pISpc flags=%s"
1883 
1884 #define SVC_XPRT_ENDPOINT_VARARGS \
1885         __get_sockaddr(server), __get_sockaddr(client), \
1886         show_svc_xprt_flags(__entry->flags)
1887 
1888 TRACE_EVENT(svc_xprt_enqueue,
1889     TP_PROTO(
1890         const struct svc_xprt *xprt,
1891         const struct svc_rqst *rqst
1892     ),
1893 
1894     TP_ARGS(xprt, rqst),
1895 
1896     TP_STRUCT__entry(
1897         SVC_XPRT_ENDPOINT_FIELDS(xprt)
1898 
1899         __field(int, pid)
1900     ),
1901 
1902     TP_fast_assign(
1903         SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
1904 
1905         __entry->pid = rqst? rqst->rq_task->pid : 0;
1906     ),
1907 
1908     TP_printk(SVC_XPRT_ENDPOINT_FORMAT " pid=%d",
1909         SVC_XPRT_ENDPOINT_VARARGS, __entry->pid)
1910 );
1911 
1912 TRACE_EVENT(svc_xprt_dequeue,
1913     TP_PROTO(
1914         const struct svc_rqst *rqst
1915     ),
1916 
1917     TP_ARGS(rqst),
1918 
1919     TP_STRUCT__entry(
1920         SVC_XPRT_ENDPOINT_FIELDS(rqst->rq_xprt)
1921 
1922         __field(unsigned long, wakeup)
1923     ),
1924 
1925     TP_fast_assign(
1926         SVC_XPRT_ENDPOINT_ASSIGNMENTS(rqst->rq_xprt);
1927 
1928         __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
1929                             rqst->rq_qtime));
1930     ),
1931 
1932     TP_printk(SVC_XPRT_ENDPOINT_FORMAT " wakeup-us=%lu",
1933         SVC_XPRT_ENDPOINT_VARARGS, __entry->wakeup)
1934 );
1935 
1936 DECLARE_EVENT_CLASS(svc_xprt_event,
1937     TP_PROTO(
1938         const struct svc_xprt *xprt
1939     ),
1940 
1941     TP_ARGS(xprt),
1942 
1943     TP_STRUCT__entry(
1944         SVC_XPRT_ENDPOINT_FIELDS(xprt)
1945     ),
1946 
1947     TP_fast_assign(
1948         SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
1949     ),
1950 
1951     TP_printk(SVC_XPRT_ENDPOINT_FORMAT, SVC_XPRT_ENDPOINT_VARARGS)
1952 );
1953 
1954 #define DEFINE_SVC_XPRT_EVENT(name) \
1955     DEFINE_EVENT(svc_xprt_event, svc_xprt_##name, \
1956             TP_PROTO( \
1957                 const struct svc_xprt *xprt \
1958             ), \
1959             TP_ARGS(xprt))
1960 
1961 DEFINE_SVC_XPRT_EVENT(no_write_space);
1962 DEFINE_SVC_XPRT_EVENT(close);
1963 DEFINE_SVC_XPRT_EVENT(detach);
1964 DEFINE_SVC_XPRT_EVENT(free);
1965 
1966 TRACE_EVENT(svc_xprt_accept,
1967     TP_PROTO(
1968         const struct svc_xprt *xprt,
1969         const char *service
1970     ),
1971 
1972     TP_ARGS(xprt, service),
1973 
1974     TP_STRUCT__entry(
1975         SVC_XPRT_ENDPOINT_FIELDS(xprt)
1976 
1977         __string(protocol, xprt->xpt_class->xcl_name)
1978         __string(service, service)
1979     ),
1980 
1981     TP_fast_assign(
1982         SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
1983 
1984         __assign_str(protocol, xprt->xpt_class->xcl_name);
1985         __assign_str(service, service);
1986     ),
1987 
1988     TP_printk(SVC_XPRT_ENDPOINT_FORMAT " protocol=%s service=%s",
1989         SVC_XPRT_ENDPOINT_VARARGS,
1990         __get_str(protocol), __get_str(service)
1991     )
1992 );
1993 
1994 TRACE_EVENT(svc_wake_up,
1995     TP_PROTO(int pid),
1996 
1997     TP_ARGS(pid),
1998 
1999     TP_STRUCT__entry(
2000         __field(int, pid)
2001     ),
2002 
2003     TP_fast_assign(
2004         __entry->pid = pid;
2005     ),
2006 
2007     TP_printk("pid=%d", __entry->pid)
2008 );
2009 
2010 TRACE_EVENT(svc_alloc_arg_err,
2011     TP_PROTO(
2012         unsigned int requested,
2013         unsigned int allocated
2014     ),
2015 
2016     TP_ARGS(requested, allocated),
2017 
2018     TP_STRUCT__entry(
2019         __field(unsigned int, requested)
2020         __field(unsigned int, allocated)
2021     ),
2022 
2023     TP_fast_assign(
2024         __entry->requested = requested;
2025         __entry->allocated = allocated;
2026     ),
2027 
2028     TP_printk("requested=%u allocated=%u",
2029         __entry->requested, __entry->allocated)
2030 );
2031 
2032 DECLARE_EVENT_CLASS(svc_deferred_event,
2033     TP_PROTO(
2034         const struct svc_deferred_req *dr
2035     ),
2036 
2037     TP_ARGS(dr),
2038 
2039     TP_STRUCT__entry(
2040         __field(const void *, dr)
2041         __field(u32, xid)
2042         __sockaddr(addr, dr->addrlen)
2043     ),
2044 
2045     TP_fast_assign(
2046         __entry->dr = dr;
2047         __entry->xid = be32_to_cpu(*(__be32 *)dr->args);
2048         __assign_sockaddr(addr, &dr->addr, dr->addrlen);
2049     ),
2050 
2051     TP_printk("addr=%pISpc dr=%p xid=0x%08x", __get_sockaddr(addr),
2052         __entry->dr, __entry->xid)
2053 );
2054 
2055 #define DEFINE_SVC_DEFERRED_EVENT(name) \
2056     DEFINE_EVENT(svc_deferred_event, svc_defer_##name, \
2057             TP_PROTO( \
2058                 const struct svc_deferred_req *dr \
2059             ), \
2060             TP_ARGS(dr))
2061 
2062 DEFINE_SVC_DEFERRED_EVENT(drop);
2063 DEFINE_SVC_DEFERRED_EVENT(queue);
2064 DEFINE_SVC_DEFERRED_EVENT(recv);
2065 
2066 TRACE_EVENT(svcsock_new_socket,
2067     TP_PROTO(
2068         const struct socket *socket
2069     ),
2070 
2071     TP_ARGS(socket),
2072 
2073     TP_STRUCT__entry(
2074         __field(unsigned long, type)
2075         __field(unsigned long, family)
2076         __field(bool, listener)
2077     ),
2078 
2079     TP_fast_assign(
2080         __entry->type = socket->type;
2081         __entry->family = socket->sk->sk_family;
2082         __entry->listener = (socket->sk->sk_state == TCP_LISTEN);
2083     ),
2084 
2085     TP_printk("type=%s family=%s%s",
2086         show_socket_type(__entry->type),
2087         rpc_show_address_family(__entry->family),
2088         __entry->listener ? " (listener)" : ""
2089     )
2090 );
2091 
2092 TRACE_EVENT(svcsock_marker,
2093     TP_PROTO(
2094         const struct svc_xprt *xprt,
2095         __be32 marker
2096     ),
2097 
2098     TP_ARGS(xprt, marker),
2099 
2100     TP_STRUCT__entry(
2101         __field(unsigned int, length)
2102         __field(bool, last)
2103         __string(addr, xprt->xpt_remotebuf)
2104     ),
2105 
2106     TP_fast_assign(
2107         __entry->length = be32_to_cpu(marker) & RPC_FRAGMENT_SIZE_MASK;
2108         __entry->last = be32_to_cpu(marker) & RPC_LAST_STREAM_FRAGMENT;
2109         __assign_str(addr, xprt->xpt_remotebuf);
2110     ),
2111 
2112     TP_printk("addr=%s length=%u%s", __get_str(addr),
2113         __entry->length, __entry->last ? " (last)" : "")
2114 );
2115 
2116 DECLARE_EVENT_CLASS(svcsock_class,
2117     TP_PROTO(
2118         const struct svc_xprt *xprt,
2119         ssize_t result
2120     ),
2121 
2122     TP_ARGS(xprt, result),
2123 
2124     TP_STRUCT__entry(
2125         __field(ssize_t, result)
2126         __field(unsigned long, flags)
2127         __string(addr, xprt->xpt_remotebuf)
2128     ),
2129 
2130     TP_fast_assign(
2131         __entry->result = result;
2132         __entry->flags = xprt->xpt_flags;
2133         __assign_str(addr, xprt->xpt_remotebuf);
2134     ),
2135 
2136     TP_printk("addr=%s result=%zd flags=%s", __get_str(addr),
2137         __entry->result, show_svc_xprt_flags(__entry->flags)
2138     )
2139 );
2140 
2141 #define DEFINE_SVCSOCK_EVENT(name) \
2142     DEFINE_EVENT(svcsock_class, svcsock_##name, \
2143             TP_PROTO( \
2144                 const struct svc_xprt *xprt, \
2145                 ssize_t result \
2146             ), \
2147             TP_ARGS(xprt, result))
2148 
2149 DEFINE_SVCSOCK_EVENT(udp_send);
2150 DEFINE_SVCSOCK_EVENT(udp_recv);
2151 DEFINE_SVCSOCK_EVENT(udp_recv_err);
2152 DEFINE_SVCSOCK_EVENT(tcp_send);
2153 DEFINE_SVCSOCK_EVENT(tcp_recv);
2154 DEFINE_SVCSOCK_EVENT(tcp_recv_eagain);
2155 DEFINE_SVCSOCK_EVENT(tcp_recv_err);
2156 DEFINE_SVCSOCK_EVENT(data_ready);
2157 DEFINE_SVCSOCK_EVENT(write_space);
2158 
2159 TRACE_EVENT(svcsock_tcp_recv_short,
2160     TP_PROTO(
2161         const struct svc_xprt *xprt,
2162         u32 expected,
2163         u32 received
2164     ),
2165 
2166     TP_ARGS(xprt, expected, received),
2167 
2168     TP_STRUCT__entry(
2169         __field(u32, expected)
2170         __field(u32, received)
2171         __field(unsigned long, flags)
2172         __string(addr, xprt->xpt_remotebuf)
2173     ),
2174 
2175     TP_fast_assign(
2176         __entry->expected = expected;
2177         __entry->received = received;
2178         __entry->flags = xprt->xpt_flags;
2179         __assign_str(addr, xprt->xpt_remotebuf);
2180     ),
2181 
2182     TP_printk("addr=%s flags=%s expected=%u received=%u",
2183         __get_str(addr), show_svc_xprt_flags(__entry->flags),
2184         __entry->expected, __entry->received
2185     )
2186 );
2187 
2188 TRACE_EVENT(svcsock_tcp_state,
2189     TP_PROTO(
2190         const struct svc_xprt *xprt,
2191         const struct socket *socket
2192     ),
2193 
2194     TP_ARGS(xprt, socket),
2195 
2196     TP_STRUCT__entry(
2197         __field(unsigned long, socket_state)
2198         __field(unsigned long, sock_state)
2199         __field(unsigned long, flags)
2200         __string(addr, xprt->xpt_remotebuf)
2201     ),
2202 
2203     TP_fast_assign(
2204         __entry->socket_state = socket->state;
2205         __entry->sock_state = socket->sk->sk_state;
2206         __entry->flags = xprt->xpt_flags;
2207         __assign_str(addr, xprt->xpt_remotebuf);
2208     ),
2209 
2210     TP_printk("addr=%s state=%s sk_state=%s flags=%s", __get_str(addr),
2211         rpc_show_socket_state(__entry->socket_state),
2212         rpc_show_sock_state(__entry->sock_state),
2213         show_svc_xprt_flags(__entry->flags)
2214     )
2215 );
2216 
2217 DECLARE_EVENT_CLASS(svcsock_accept_class,
2218     TP_PROTO(
2219         const struct svc_xprt *xprt,
2220         const char *service,
2221         long status
2222     ),
2223 
2224     TP_ARGS(xprt, service, status),
2225 
2226     TP_STRUCT__entry(
2227         __field(long, status)
2228         __string(service, service)
2229         __field(unsigned int, netns_ino)
2230     ),
2231 
2232     TP_fast_assign(
2233         __entry->status = status;
2234         __assign_str(service, service);
2235         __entry->netns_ino = xprt->xpt_net->ns.inum;
2236     ),
2237 
2238     TP_printk("addr=listener service=%s status=%ld",
2239         __get_str(service), __entry->status
2240     )
2241 );
2242 
2243 #define DEFINE_ACCEPT_EVENT(name) \
2244     DEFINE_EVENT(svcsock_accept_class, svcsock_##name##_err, \
2245             TP_PROTO( \
2246                 const struct svc_xprt *xprt, \
2247                 const char *service, \
2248                 long status \
2249             ), \
2250             TP_ARGS(xprt, service, status))
2251 
2252 DEFINE_ACCEPT_EVENT(accept);
2253 DEFINE_ACCEPT_EVENT(getpeername);
2254 
2255 DECLARE_EVENT_CLASS(cache_event,
2256     TP_PROTO(
2257         const struct cache_detail *cd,
2258         const struct cache_head *h
2259     ),
2260 
2261     TP_ARGS(cd, h),
2262 
2263     TP_STRUCT__entry(
2264         __field(const struct cache_head *, h)
2265         __string(name, cd->name)
2266     ),
2267 
2268     TP_fast_assign(
2269         __entry->h = h;
2270         __assign_str(name, cd->name);
2271     ),
2272 
2273     TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)
2274 );
2275 #define DEFINE_CACHE_EVENT(name) \
2276     DEFINE_EVENT(cache_event, name, \
2277             TP_PROTO( \
2278                 const struct cache_detail *cd, \
2279                 const struct cache_head *h \
2280             ), \
2281             TP_ARGS(cd, h))
2282 DEFINE_CACHE_EVENT(cache_entry_expired);
2283 DEFINE_CACHE_EVENT(cache_entry_upcall);
2284 DEFINE_CACHE_EVENT(cache_entry_update);
2285 DEFINE_CACHE_EVENT(cache_entry_make_negative);
2286 DEFINE_CACHE_EVENT(cache_entry_no_listener);
2287 
2288 DECLARE_EVENT_CLASS(register_class,
2289     TP_PROTO(
2290         const char *program,
2291         const u32 version,
2292         const int family,
2293         const unsigned short protocol,
2294         const unsigned short port,
2295         int error
2296     ),
2297 
2298     TP_ARGS(program, version, family, protocol, port, error),
2299 
2300     TP_STRUCT__entry(
2301         __field(u32, version)
2302         __field(unsigned long, family)
2303         __field(unsigned short, protocol)
2304         __field(unsigned short, port)
2305         __field(int, error)
2306         __string(program, program)
2307     ),
2308 
2309     TP_fast_assign(
2310         __entry->version = version;
2311         __entry->family = family;
2312         __entry->protocol = protocol;
2313         __entry->port = port;
2314         __entry->error = error;
2315         __assign_str(program, program);
2316     ),
2317 
2318     TP_printk("program=%sv%u proto=%s port=%u family=%s error=%d",
2319         __get_str(program), __entry->version,
2320         __entry->protocol == IPPROTO_UDP ? "udp" : "tcp",
2321         __entry->port, rpc_show_address_family(__entry->family),
2322         __entry->error
2323     )
2324 );
2325 
2326 #define DEFINE_REGISTER_EVENT(name) \
2327     DEFINE_EVENT(register_class, svc_##name, \
2328             TP_PROTO( \
2329                 const char *program, \
2330                 const u32 version, \
2331                 const int family, \
2332                 const unsigned short protocol, \
2333                 const unsigned short port, \
2334                 int error \
2335             ), \
2336             TP_ARGS(program, version, family, protocol, \
2337                 port, error))
2338 
2339 DEFINE_REGISTER_EVENT(register);
2340 DEFINE_REGISTER_EVENT(noregister);
2341 
2342 TRACE_EVENT(svc_unregister,
2343     TP_PROTO(
2344         const char *program,
2345         const u32 version,
2346         int error
2347     ),
2348 
2349     TP_ARGS(program, version, error),
2350 
2351     TP_STRUCT__entry(
2352         __field(u32, version)
2353         __field(int, error)
2354         __string(program, program)
2355     ),
2356 
2357     TP_fast_assign(
2358         __entry->version = version;
2359         __entry->error = error;
2360         __assign_str(program, program);
2361     ),
2362 
2363     TP_printk("program=%sv%u error=%d",
2364         __get_str(program), __entry->version, __entry->error
2365     )
2366 );
2367 
2368 #endif /* _TRACE_SUNRPC_H */
2369 
2370 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!