include/trace/events/sunrpc.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM sunrpc
   4
   5 #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define _TRACE_SUNRPC_H
   7
   8 #include <linux/sunrpc/sched.h>
   9 #include <linux/sunrpc/clnt.h>
  10 #include <linux/sunrpc/svc.h>
  11 #include <linux/sunrpc/xprtsock.h>
  12 #include <linux/sunrpc/svc_xprt.h>
  13 #include <net/tcp_states.h>
  14 #include <linux/net.h>
  15 #include <linux/tracepoint.h>
  16
  17 DECLARE_EVENT_CLASS(rpc_xdr_buf_class,
  18         TP_PROTO(
  19                 const struct rpc_task *task,
  20                 const struct xdr_buf *xdr
  21         ),
  22
  23         TP_ARGS(task, xdr),
  24
  25         TP_STRUCT__entry(
  26                 __field(unsigned int, task_id)
  27                 __field(unsigned int, client_id)
  28                 __field(const void *, head_base)
  29                 __field(size_t, head_len)
  30                 __field(const void *, tail_base)
  31                 __field(size_t, tail_len)
  32                 __field(unsigned int, page_len)
  33                 __field(unsigned int, msg_len)
  34         ),
  35
  36         TP_fast_assign(
  37                 __entry->task_id = task->tk_pid;
  38                 __entry->client_id = task->tk_client->cl_clid;
  39                 __entry->head_base = xdr->head[0].iov_base;
  40                 __entry->head_len = xdr->head[0].iov_len;
  41                 __entry->tail_base = xdr->tail[0].iov_base;
  42                 __entry->tail_len = xdr->tail[0].iov_len;
  43                 __entry->page_len = xdr->page_len;
  44                 __entry->msg_len = xdr->len;
  45         ),
  46
  47         TP_printk("task:%u@%u head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
  48                 __entry->task_id, __entry->client_id,
  49                 __entry->head_base, __entry->head_len, __entry->page_len,
  50                 __entry->tail_base, __entry->tail_len, __entry->msg_len
  51         )
  52 );
  53
  54 #define DEFINE_RPCXDRBUF_EVENT(name)                                    \
  55                 DEFINE_EVENT(rpc_xdr_buf_class,                         \
  56                                 rpc_xdr_##name,                         \
  57                                 TP_PROTO(                               \
  58                                         const struct rpc_task *task,    \
  59                                         const struct xdr_buf *xdr       \
  60                                 ),                                      \
  61                                 TP_ARGS(task, xdr))
  62
  63 DEFINE_RPCXDRBUF_EVENT(sendto);
  64 DEFINE_RPCXDRBUF_EVENT(recvfrom);
  65 DEFINE_RPCXDRBUF_EVENT(reply_pages);
  66
  67
  68 DECLARE_EVENT_CLASS(rpc_clnt_class,
  69         TP_PROTO(
  70                 const struct rpc_clnt *clnt
  71         ),
  72
  73         TP_ARGS(clnt),
  74
  75         TP_STRUCT__entry(
  76                 __field(unsigned int, client_id)
  77         ),
  78
  79         TP_fast_assign(
  80                 __entry->client_id = clnt->cl_clid;
  81         ),
  82
  83         TP_printk("clid=%u", __entry->client_id)
  84 );
  85
  86 #define DEFINE_RPC_CLNT_EVENT(name)                                     \
  87                 DEFINE_EVENT(rpc_clnt_class,                            \
  88                                 rpc_clnt_##name,                        \
  89                                 TP_PROTO(                               \
  90                                         const struct rpc_clnt *clnt     \
  91                                 ),                                      \
  92                                 TP_ARGS(clnt))
  93
  94 DEFINE_RPC_CLNT_EVENT(free);
  95 DEFINE_RPC_CLNT_EVENT(killall);
  96 DEFINE_RPC_CLNT_EVENT(shutdown);
  97 DEFINE_RPC_CLNT_EVENT(release);
  98 DEFINE_RPC_CLNT_EVENT(replace_xprt);
  99 DEFINE_RPC_CLNT_EVENT(replace_xprt_err);
 100
 101 TRACE_EVENT(rpc_clnt_new,
 102         TP_PROTO(
 103                 const struct rpc_clnt *clnt,
 104                 const struct rpc_xprt *xprt,
 105                 const char *program,
 106                 const char *server
 107         ),
 108
 109         TP_ARGS(clnt, xprt, program, server),
 110
 111         TP_STRUCT__entry(
 112                 __field(unsigned int, client_id)
 113                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 114                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 115                 __string(program, program)
 116                 __string(server, server)
 117         ),
 118
 119         TP_fast_assign(
 120                 __entry->client_id = clnt->cl_clid;
 121                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 122                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 123                 __assign_str(program, program)
 124                 __assign_str(server, server)
 125         ),
 126
 127         TP_printk("client=%u peer=[%s]:%s program=%s server=%s",
 128                 __entry->client_id, __get_str(addr), __get_str(port),
 129                 __get_str(program), __get_str(server))
 130 );
 131
 132 TRACE_EVENT(rpc_clnt_new_err,
 133         TP_PROTO(
 134                 const char *program,
 135                 const char *server,
 136                 int error
 137         ),
 138
 139         TP_ARGS(program, server, error),
 140
 141         TP_STRUCT__entry(
 142                 __field(int, error)
 143                 __string(program, program)
 144                 __string(server, server)
 145         ),
 146
 147         TP_fast_assign(
 148                 __entry->error = error;
 149                 __assign_str(program, program)
 150                 __assign_str(server, server)
 151         ),
 152
 153         TP_printk("program=%s server=%s error=%d",
 154                 __get_str(program), __get_str(server), __entry->error)
 155 );
 156
 157 TRACE_EVENT(rpc_clnt_clone_err,
 158         TP_PROTO(
 159                 const struct rpc_clnt *clnt,
 160                 int error
 161         ),
 162
 163         TP_ARGS(clnt, error),
 164
 165         TP_STRUCT__entry(
 166                 __field(unsigned int, client_id)
 167                 __field(int, error)
 168         ),
 169
 170         TP_fast_assign(
 171                 __entry->client_id = clnt->cl_clid;
 172                 __entry->error = error;
 173         ),
 174
 175         TP_printk("client=%u error=%d", __entry->client_id, __entry->error)
 176 );
 177
 178
 179 TRACE_DEFINE_ENUM(RPC_AUTH_OK);
 180 TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
 181 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
 182 TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
 183 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
 184 TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
 185 TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
 186 TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);
 187
 188 #define rpc_show_auth_stat(status)                                      \
 189         __print_symbolic(status,                                        \
 190                 { RPC_AUTH_OK,                  "AUTH_OK" },            \
 191                 { RPC_AUTH_BADCRED,             "BADCRED" },            \
 192                 { RPC_AUTH_REJECTEDCRED,        "REJECTEDCRED" },       \
 193                 { RPC_AUTH_BADVERF,             "BADVERF" },            \
 194                 { RPC_AUTH_REJECTEDVERF,        "REJECTEDVERF" },       \
 195                 { RPC_AUTH_TOOWEAK,             "TOOWEAK" },            \
 196                 { RPCSEC_GSS_CREDPROBLEM,       "GSS_CREDPROBLEM" },    \
 197                 { RPCSEC_GSS_CTXPROBLEM,        "GSS_CTXPROBLEM" })     \
 198
 199 DECLARE_EVENT_CLASS(rpc_task_status,
 200
 201         TP_PROTO(const struct rpc_task *task),
 202
 203         TP_ARGS(task),
 204
 205         TP_STRUCT__entry(
 206                 __field(unsigned int, task_id)
 207                 __field(unsigned int, client_id)
 208                 __field(int, status)
 209         ),
 210
 211         TP_fast_assign(
 212                 __entry->task_id = task->tk_pid;
 213                 __entry->client_id = task->tk_client->cl_clid;
 214                 __entry->status = task->tk_status;
 215         ),
 216
 217         TP_printk("task:%u@%u status=%d",
 218                 __entry->task_id, __entry->client_id,
 219                 __entry->status)
 220 );
 221 #define DEFINE_RPC_STATUS_EVENT(name) \
 222         DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
 223                         TP_PROTO( \
 224                                 const struct rpc_task *task \
 225                         ), \
 226                         TP_ARGS(task))
 227
 228 DEFINE_RPC_STATUS_EVENT(call);
 229 DEFINE_RPC_STATUS_EVENT(bind);
 230 DEFINE_RPC_STATUS_EVENT(connect);
 231
 232 TRACE_EVENT(rpc_request,
 233         TP_PROTO(const struct rpc_task *task),
 234
 235         TP_ARGS(task),
 236
 237         TP_STRUCT__entry(
 238                 __field(unsigned int, task_id)
 239                 __field(unsigned int, client_id)
 240                 __field(int, version)
 241                 __field(bool, async)
 242                 __string(progname, task->tk_client->cl_program->name)
 243                 __string(procname, rpc_proc_name(task))
 244         ),
 245
 246         TP_fast_assign(
 247                 __entry->task_id = task->tk_pid;
 248                 __entry->client_id = task->tk_client->cl_clid;
 249                 __entry->version = task->tk_client->cl_vers;
 250                 __entry->async = RPC_IS_ASYNC(task);
 251                 __assign_str(progname, task->tk_client->cl_program->name)
 252                 __assign_str(procname, rpc_proc_name(task))
 253         ),
 254
 255         TP_printk("task:%u@%u %sv%d %s (%ssync)",
 256                 __entry->task_id, __entry->client_id,
 257                 __get_str(progname), __entry->version,
 258                 __get_str(procname), __entry->async ? "a": ""
 259                 )
 260 );
 261
 262 TRACE_DEFINE_ENUM(RPC_TASK_ASYNC);
 263 TRACE_DEFINE_ENUM(RPC_TASK_SWAPPER);
 264 TRACE_DEFINE_ENUM(RPC_TASK_NULLCREDS);
 265 TRACE_DEFINE_ENUM(RPC_CALL_MAJORSEEN);
 266 TRACE_DEFINE_ENUM(RPC_TASK_ROOTCREDS);
 267 TRACE_DEFINE_ENUM(RPC_TASK_DYNAMIC);
 268 TRACE_DEFINE_ENUM(RPC_TASK_NO_ROUND_ROBIN);
 269 TRACE_DEFINE_ENUM(RPC_TASK_SOFT);
 270 TRACE_DEFINE_ENUM(RPC_TASK_SOFTCONN);
 271 TRACE_DEFINE_ENUM(RPC_TASK_SENT);
 272 TRACE_DEFINE_ENUM(RPC_TASK_TIMEOUT);
 273 TRACE_DEFINE_ENUM(RPC_TASK_NOCONNECT);
 274 TRACE_DEFINE_ENUM(RPC_TASK_NO_RETRANS_TIMEOUT);
 275 TRACE_DEFINE_ENUM(RPC_TASK_CRED_NOREF);
 276
 277 #define rpc_show_task_flags(flags)                                      \
 278         __print_flags(flags, "|",                                       \
 279                 { RPC_TASK_ASYNC, "ASYNC" },                            \
 280                 { RPC_TASK_SWAPPER, "SWAPPER" },                        \
 281                 { RPC_TASK_NULLCREDS, "NULLCREDS" },                    \
 282                 { RPC_CALL_MAJORSEEN, "MAJORSEEN" },                    \
 283                 { RPC_TASK_ROOTCREDS, "ROOTCREDS" },                    \
 284                 { RPC_TASK_DYNAMIC, "DYNAMIC" },                        \
 285                 { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" },          \
 286                 { RPC_TASK_SOFT, "SOFT" },                              \
 287                 { RPC_TASK_SOFTCONN, "SOFTCONN" },                      \
 288                 { RPC_TASK_SENT, "SENT" },                              \
 289                 { RPC_TASK_TIMEOUT, "TIMEOUT" },                        \
 290                 { RPC_TASK_NOCONNECT, "NOCONNECT" },                    \
 291                 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" },               \
 292                 { RPC_TASK_CRED_NOREF, "CRED_NOREF" })
 293
 294 TRACE_DEFINE_ENUM(RPC_TASK_RUNNING);
 295 TRACE_DEFINE_ENUM(RPC_TASK_QUEUED);
 296 TRACE_DEFINE_ENUM(RPC_TASK_ACTIVE);
 297 TRACE_DEFINE_ENUM(RPC_TASK_NEED_XMIT);
 298 TRACE_DEFINE_ENUM(RPC_TASK_NEED_RECV);
 299 TRACE_DEFINE_ENUM(RPC_TASK_MSG_PIN_WAIT);
 300 TRACE_DEFINE_ENUM(RPC_TASK_SIGNALLED);
 301
 302 #define rpc_show_runstate(flags)                                        \
 303         __print_flags(flags, "|",                                       \
 304                 { (1UL << RPC_TASK_RUNNING), "RUNNING" },               \
 305                 { (1UL << RPC_TASK_QUEUED), "QUEUED" },                 \
 306                 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" },                 \
 307                 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" },           \
 308                 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" },           \
 309                 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" },     \
 310                 { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
 311
 312 DECLARE_EVENT_CLASS(rpc_task_running,
 313
 314         TP_PROTO(const struct rpc_task *task, const void *action),
 315
 316         TP_ARGS(task, action),
 317
 318         TP_STRUCT__entry(
 319                 __field(unsigned int, task_id)
 320                 __field(unsigned int, client_id)
 321                 __field(const void *, action)
 322                 __field(unsigned long, runstate)
 323                 __field(int, status)
 324                 __field(unsigned short, flags)
 325                 ),
 326
 327         TP_fast_assign(
 328                 __entry->client_id = task->tk_client ?
 329                                      task->tk_client->cl_clid : -1;
 330                 __entry->task_id = task->tk_pid;
 331                 __entry->action = action;
 332                 __entry->runstate = task->tk_runstate;
 333                 __entry->status = task->tk_status;
 334                 __entry->flags = task->tk_flags;
 335                 ),
 336
 337         TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%ps",
 338                 __entry->task_id, __entry->client_id,
 339                 rpc_show_task_flags(__entry->flags),
 340                 rpc_show_runstate(__entry->runstate),
 341                 __entry->status,
 342                 __entry->action
 343                 )
 344 );
 345 #define DEFINE_RPC_RUNNING_EVENT(name) \
 346         DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
 347                         TP_PROTO( \
 348                                 const struct rpc_task *task, \
 349                                 const void *action \
 350                         ), \
 351                         TP_ARGS(task, action))
 352
 353 DEFINE_RPC_RUNNING_EVENT(begin);
 354 DEFINE_RPC_RUNNING_EVENT(run_action);
 355 DEFINE_RPC_RUNNING_EVENT(complete);
 356 DEFINE_RPC_RUNNING_EVENT(signalled);
 357 DEFINE_RPC_RUNNING_EVENT(end);
 358
 359 DECLARE_EVENT_CLASS(rpc_task_queued,
 360
 361         TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
 362
 363         TP_ARGS(task, q),
 364
 365         TP_STRUCT__entry(
 366                 __field(unsigned int, task_id)
 367                 __field(unsigned int, client_id)
 368                 __field(unsigned long, timeout)
 369                 __field(unsigned long, runstate)
 370                 __field(int, status)
 371                 __field(unsigned short, flags)
 372                 __string(q_name, rpc_qname(q))
 373                 ),
 374
 375         TP_fast_assign(
 376                 __entry->client_id = task->tk_client ?
 377                                      task->tk_client->cl_clid : -1;
 378                 __entry->task_id = task->tk_pid;
 379                 __entry->timeout = rpc_task_timeout(task);
 380                 __entry->runstate = task->tk_runstate;
 381                 __entry->status = task->tk_status;
 382                 __entry->flags = task->tk_flags;
 383                 __assign_str(q_name, rpc_qname(q));
 384                 ),
 385
 386         TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s",
 387                 __entry->task_id, __entry->client_id,
 388                 rpc_show_task_flags(__entry->flags),
 389                 rpc_show_runstate(__entry->runstate),
 390                 __entry->status,
 391                 __entry->timeout,
 392                 __get_str(q_name)
 393                 )
 394 );
 395 #define DEFINE_RPC_QUEUED_EVENT(name) \
 396         DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
 397                         TP_PROTO( \
 398                                 const struct rpc_task *task, \
 399                                 const struct rpc_wait_queue *q \
 400                         ), \
 401                         TP_ARGS(task, q))
 402
 403 DEFINE_RPC_QUEUED_EVENT(sleep);
 404 DEFINE_RPC_QUEUED_EVENT(wakeup);
 405
 406 DECLARE_EVENT_CLASS(rpc_failure,
 407
 408         TP_PROTO(const struct rpc_task *task),
 409
 410         TP_ARGS(task),
 411
 412         TP_STRUCT__entry(
 413                 __field(unsigned int, task_id)
 414                 __field(unsigned int, client_id)
 415         ),
 416
 417         TP_fast_assign(
 418                 __entry->task_id = task->tk_pid;
 419                 __entry->client_id = task->tk_client->cl_clid;
 420         ),
 421
 422         TP_printk("task:%u@%u",
 423                 __entry->task_id, __entry->client_id)
 424 );
 425
 426 #define DEFINE_RPC_FAILURE(name)                                        \
 427         DEFINE_EVENT(rpc_failure, rpc_bad_##name,                       \
 428                         TP_PROTO(                                       \
 429                                 const struct rpc_task *task             \
 430                         ),                                              \
 431                         TP_ARGS(task))
 432
 433 DEFINE_RPC_FAILURE(callhdr);
 434 DEFINE_RPC_FAILURE(verifier);
 435
 436 DECLARE_EVENT_CLASS(rpc_reply_event,
 437
 438         TP_PROTO(
 439                 const struct rpc_task *task
 440         ),
 441
 442         TP_ARGS(task),
 443
 444         TP_STRUCT__entry(
 445                 __field(unsigned int, task_id)
 446                 __field(unsigned int, client_id)
 447                 __field(u32, xid)
 448                 __string(progname, task->tk_client->cl_program->name)
 449                 __field(u32, version)
 450                 __string(procname, rpc_proc_name(task))
 451                 __string(servername, task->tk_xprt->servername)
 452         ),
 453
 454         TP_fast_assign(
 455                 __entry->task_id = task->tk_pid;
 456                 __entry->client_id = task->tk_client->cl_clid;
 457                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 458                 __assign_str(progname, task->tk_client->cl_program->name)
 459                 __entry->version = task->tk_client->cl_vers;
 460                 __assign_str(procname, rpc_proc_name(task))
 461                 __assign_str(servername, task->tk_xprt->servername)
 462         ),
 463
 464         TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
 465                 __entry->task_id, __entry->client_id, __get_str(servername),
 466                 __entry->xid, __get_str(progname), __entry->version,
 467                 __get_str(procname))
 468 )
 469
 470 #define DEFINE_RPC_REPLY_EVENT(name)                                    \
 471         DEFINE_EVENT(rpc_reply_event, rpc__##name,                      \
 472                         TP_PROTO(                                       \
 473                                 const struct rpc_task *task             \
 474                         ),                                              \
 475                         TP_ARGS(task))
 476
 477 DEFINE_RPC_REPLY_EVENT(prog_unavail);
 478 DEFINE_RPC_REPLY_EVENT(prog_mismatch);
 479 DEFINE_RPC_REPLY_EVENT(proc_unavail);
 480 DEFINE_RPC_REPLY_EVENT(garbage_args);
 481 DEFINE_RPC_REPLY_EVENT(unparsable);
 482 DEFINE_RPC_REPLY_EVENT(mismatch);
 483 DEFINE_RPC_REPLY_EVENT(stale_creds);
 484 DEFINE_RPC_REPLY_EVENT(bad_creds);
 485 DEFINE_RPC_REPLY_EVENT(auth_tooweak);
 486
 487 TRACE_EVENT(rpc_call_rpcerror,
 488         TP_PROTO(
 489                 const struct rpc_task *task,
 490                 int tk_status,
 491                 int rpc_status
 492         ),
 493
 494         TP_ARGS(task, tk_status, rpc_status),
 495
 496         TP_STRUCT__entry(
 497                 __field(unsigned int, task_id)
 498                 __field(unsigned int, client_id)
 499                 __field(int, tk_status)
 500                 __field(int, rpc_status)
 501         ),
 502
 503         TP_fast_assign(
 504                 __entry->client_id = task->tk_client->cl_clid;
 505                 __entry->task_id = task->tk_pid;
 506                 __entry->tk_status = tk_status;
 507                 __entry->rpc_status = rpc_status;
 508         ),
 509
 510         TP_printk("task:%u@%u tk_status=%d rpc_status=%d",
 511                 __entry->task_id, __entry->client_id,
 512                 __entry->tk_status, __entry->rpc_status)
 513 );
 514
 515 TRACE_EVENT(rpc_stats_latency,
 516
 517         TP_PROTO(
 518                 const struct rpc_task *task,
 519                 ktime_t backlog,
 520                 ktime_t rtt,
 521                 ktime_t execute
 522         ),
 523
 524         TP_ARGS(task, backlog, rtt, execute),
 525
 526         TP_STRUCT__entry(
 527                 __field(unsigned int, task_id)
 528                 __field(unsigned int, client_id)
 529                 __field(u32, xid)
 530                 __field(int, version)
 531                 __string(progname, task->tk_client->cl_program->name)
 532                 __string(procname, rpc_proc_name(task))
 533                 __field(unsigned long, backlog)
 534                 __field(unsigned long, rtt)
 535                 __field(unsigned long, execute)
 536         ),
 537
 538         TP_fast_assign(
 539                 __entry->client_id = task->tk_client->cl_clid;
 540                 __entry->task_id = task->tk_pid;
 541                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 542                 __entry->version = task->tk_client->cl_vers;
 543                 __assign_str(progname, task->tk_client->cl_program->name)
 544                 __assign_str(procname, rpc_proc_name(task))
 545                 __entry->backlog = ktime_to_us(backlog);
 546                 __entry->rtt = ktime_to_us(rtt);
 547                 __entry->execute = ktime_to_us(execute);
 548         ),
 549
 550         TP_printk("task:%u@%d xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
 551                 __entry->task_id, __entry->client_id, __entry->xid,
 552                 __get_str(progname), __entry->version, __get_str(procname),
 553                 __entry->backlog, __entry->rtt, __entry->execute)
 554 );
 555
 556 TRACE_EVENT(rpc_xdr_overflow,
 557         TP_PROTO(
 558                 const struct xdr_stream *xdr,
 559                 size_t requested
 560         ),
 561
 562         TP_ARGS(xdr, requested),
 563
 564         TP_STRUCT__entry(
 565                 __field(unsigned int, task_id)
 566                 __field(unsigned int, client_id)
 567                 __field(int, version)
 568                 __field(size_t, requested)
 569                 __field(const void *, end)
 570                 __field(const void *, p)
 571                 __field(const void *, head_base)
 572                 __field(size_t, head_len)
 573                 __field(const void *, tail_base)
 574                 __field(size_t, tail_len)
 575                 __field(unsigned int, page_len)
 576                 __field(unsigned int, len)
 577                 __string(progname,
 578                          xdr->rqst->rq_task->tk_client->cl_program->name)
 579                 __string(procedure,
 580                          xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
 581         ),
 582
 583         TP_fast_assign(
 584                 if (xdr->rqst) {
 585                         const struct rpc_task *task = xdr->rqst->rq_task;
 586
 587                         __entry->task_id = task->tk_pid;
 588                         __entry->client_id = task->tk_client->cl_clid;
 589                         __assign_str(progname,
 590                                      task->tk_client->cl_program->name)
 591                         __entry->version = task->tk_client->cl_vers;
 592                         __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
 593                 } else {
 594                         __entry->task_id = 0;
 595                         __entry->client_id = 0;
 596                         __assign_str(progname, "unknown")
 597                         __entry->version = 0;
 598                         __assign_str(procedure, "unknown")
 599                 }
 600                 __entry->requested = requested;
 601                 __entry->end = xdr->end;
 602                 __entry->p = xdr->p;
 603                 __entry->head_base = xdr->buf->head[0].iov_base,
 604                 __entry->head_len = xdr->buf->head[0].iov_len,
 605                 __entry->page_len = xdr->buf->page_len,
 606                 __entry->tail_base = xdr->buf->tail[0].iov_base,
 607                 __entry->tail_len = xdr->buf->tail[0].iov_len,
 608                 __entry->len = xdr->buf->len;
 609         ),
 610
 611         TP_printk(
 612                 "task:%u@%u %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
 613                 __entry->task_id, __entry->client_id,
 614                 __get_str(progname), __entry->version, __get_str(procedure),
 615                 __entry->requested, __entry->p, __entry->end,
 616                 __entry->head_base, __entry->head_len,
 617                 __entry->page_len,
 618                 __entry->tail_base, __entry->tail_len,
 619                 __entry->len
 620         )
 621 );
 622
 623 TRACE_EVENT(rpc_xdr_alignment,
 624         TP_PROTO(
 625                 const struct xdr_stream *xdr,
 626                 size_t offset,
 627                 unsigned int copied
 628         ),
 629
 630         TP_ARGS(xdr, offset, copied),
 631
 632         TP_STRUCT__entry(
 633                 __field(unsigned int, task_id)
 634                 __field(unsigned int, client_id)
 635                 __field(int, version)
 636                 __field(size_t, offset)
 637                 __field(unsigned int, copied)
 638                 __field(const void *, head_base)
 639                 __field(size_t, head_len)
 640                 __field(const void *, tail_base)
 641                 __field(size_t, tail_len)
 642                 __field(unsigned int, page_len)
 643                 __field(unsigned int, len)
 644                 __string(progname,
 645                          xdr->rqst->rq_task->tk_client->cl_program->name)
 646                 __string(procedure,
 647                          xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
 648         ),
 649
 650         TP_fast_assign(
 651                 const struct rpc_task *task = xdr->rqst->rq_task;
 652
 653                 __entry->task_id = task->tk_pid;
 654                 __entry->client_id = task->tk_client->cl_clid;
 655                 __assign_str(progname,
 656                              task->tk_client->cl_program->name)
 657                 __entry->version = task->tk_client->cl_vers;
 658                 __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
 659
 660                 __entry->offset = offset;
 661                 __entry->copied = copied;
 662                 __entry->head_base = xdr->buf->head[0].iov_base,
 663                 __entry->head_len = xdr->buf->head[0].iov_len,
 664                 __entry->page_len = xdr->buf->page_len,
 665                 __entry->tail_base = xdr->buf->tail[0].iov_base,
 666                 __entry->tail_len = xdr->buf->tail[0].iov_len,
 667                 __entry->len = xdr->buf->len;
 668         ),
 669
 670         TP_printk(
 671                 "task:%u@%u %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
 672                 __entry->task_id, __entry->client_id,
 673                 __get_str(progname), __entry->version, __get_str(procedure),
 674                 __entry->offset, __entry->copied,
 675                 __entry->head_base, __entry->head_len,
 676                 __entry->page_len,
 677                 __entry->tail_base, __entry->tail_len,
 678                 __entry->len
 679         )
 680 );
 681
 682 /*
 683  * First define the enums in the below macros to be exported to userspace
 684  * via TRACE_DEFINE_ENUM().
 685  */
 686 #undef EM
 687 #undef EMe
 688 #define EM(a, b)        TRACE_DEFINE_ENUM(a);
 689 #define EMe(a, b)       TRACE_DEFINE_ENUM(a);
 690
 691 #define RPC_SHOW_SOCKET                         \
 692         EM( SS_FREE, "FREE" )                   \
 693         EM( SS_UNCONNECTED, "UNCONNECTED" )     \
 694         EM( SS_CONNECTING, "CONNECTING" )       \
 695         EM( SS_CONNECTED, "CONNECTED" )         \
 696         EMe( SS_DISCONNECTING, "DISCONNECTING" )
 697
 698 #define rpc_show_socket_state(state) \
 699         __print_symbolic(state, RPC_SHOW_SOCKET)
 700
 701 RPC_SHOW_SOCKET
 702
 703 #define RPC_SHOW_SOCK                           \
 704         EM( TCP_ESTABLISHED, "ESTABLISHED" )    \
 705         EM( TCP_SYN_SENT, "SYN_SENT" )          \
 706         EM( TCP_SYN_RECV, "SYN_RECV" )          \
 707         EM( TCP_FIN_WAIT1, "FIN_WAIT1" )        \
 708         EM( TCP_FIN_WAIT2, "FIN_WAIT2" )        \
 709         EM( TCP_TIME_WAIT, "TIME_WAIT" )        \
 710         EM( TCP_CLOSE, "CLOSE" )                \
 711         EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" )      \
 712         EM( TCP_LAST_ACK, "LAST_ACK" )          \
 713         EM( TCP_LISTEN, "LISTEN" )              \
 714         EMe( TCP_CLOSING, "CLOSING" )
 715
 716 #define rpc_show_sock_state(state) \
 717         __print_symbolic(state, RPC_SHOW_SOCK)
 718
 719 RPC_SHOW_SOCK
 720
 721 /*
 722  * Now redefine the EM() and EMe() macros to map the enums to the strings
 723  * that will be printed in the output.
 724  */
 725 #undef EM
 726 #undef EMe
 727 #define EM(a, b)        {a, b},
 728 #define EMe(a, b)       {a, b}
 729
 730 DECLARE_EVENT_CLASS(xs_socket_event,
 731
 732                 TP_PROTO(
 733                         struct rpc_xprt *xprt,
 734                         struct socket *socket
 735                 ),
 736
 737                 TP_ARGS(xprt, socket),
 738
 739                 TP_STRUCT__entry(
 740                         __field(unsigned int, socket_state)
 741                         __field(unsigned int, sock_state)
 742                         __field(unsigned long long, ino)
 743                         __string(dstaddr,
 744                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 745                         __string(dstport,
 746                                 xprt->address_strings[RPC_DISPLAY_PORT])
 747                 ),
 748
 749                 TP_fast_assign(
 750                         struct inode *inode = SOCK_INODE(socket);
 751                         __entry->socket_state = socket->state;
 752                         __entry->sock_state = socket->sk->sk_state;
 753                         __entry->ino = (unsigned long long)inode->i_ino;
 754                         __assign_str(dstaddr,
 755                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 756                         __assign_str(dstport,
 757                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 758                 ),
 759
 760                 TP_printk(
 761                         "socket:[%llu] dstaddr=%s/%s "
 762                         "state=%u (%s) sk_state=%u (%s)",
 763                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 764                         __entry->socket_state,
 765                         rpc_show_socket_state(__entry->socket_state),
 766                         __entry->sock_state,
 767                         rpc_show_sock_state(__entry->sock_state)
 768                 )
 769 );
 770 #define DEFINE_RPC_SOCKET_EVENT(name) \
 771         DEFINE_EVENT(xs_socket_event, name, \
 772                         TP_PROTO( \
 773                                 struct rpc_xprt *xprt, \
 774                                 struct socket *socket \
 775                         ), \
 776                         TP_ARGS(xprt, socket))
 777
 778 DECLARE_EVENT_CLASS(xs_socket_event_done,
 779
 780                 TP_PROTO(
 781                         struct rpc_xprt *xprt,
 782                         struct socket *socket,
 783                         int error
 784                 ),
 785
 786                 TP_ARGS(xprt, socket, error),
 787
 788                 TP_STRUCT__entry(
 789                         __field(int, error)
 790                         __field(unsigned int, socket_state)
 791                         __field(unsigned int, sock_state)
 792                         __field(unsigned long long, ino)
 793                         __string(dstaddr,
 794                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 795                         __string(dstport,
 796                                 xprt->address_strings[RPC_DISPLAY_PORT])
 797                 ),
 798
 799                 TP_fast_assign(
 800                         struct inode *inode = SOCK_INODE(socket);
 801                         __entry->socket_state = socket->state;
 802                         __entry->sock_state = socket->sk->sk_state;
 803                         __entry->ino = (unsigned long long)inode->i_ino;
 804                         __entry->error = error;
 805                         __assign_str(dstaddr,
 806                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 807                         __assign_str(dstport,
 808                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 809                 ),
 810
 811                 TP_printk(
 812                         "error=%d socket:[%llu] dstaddr=%s/%s "
 813                         "state=%u (%s) sk_state=%u (%s)",
 814                         __entry->error,
 815                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 816                         __entry->socket_state,
 817                         rpc_show_socket_state(__entry->socket_state),
 818                         __entry->sock_state,
 819                         rpc_show_sock_state(__entry->sock_state)
 820                 )
 821 );
 822 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
 823         DEFINE_EVENT(xs_socket_event_done, name, \
 824                         TP_PROTO( \
 825                                 struct rpc_xprt *xprt, \
 826                                 struct socket *socket, \
 827                                 int error \
 828                         ), \
 829                         TP_ARGS(xprt, socket, error))
 830
 831 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
 832 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
 833 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
 834 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
 835 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
 836 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
 837
 838 DECLARE_EVENT_CLASS(rpc_xprt_lifetime_class,
 839         TP_PROTO(
 840                 const struct rpc_xprt *xprt
 841         ),
 842
 843         TP_ARGS(xprt),
 844
 845         TP_STRUCT__entry(
 846                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 847                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 848         ),
 849
 850         TP_fast_assign(
 851                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 852                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 853         ),
 854
 855         TP_printk("peer=[%s]:%s", __get_str(addr), __get_str(port))
 856 );
 857
 858 #define DEFINE_RPC_XPRT_LIFETIME_EVENT(name) \
 859         DEFINE_EVENT(rpc_xprt_lifetime_class, \
 860                         xprt_##name, \
 861                         TP_PROTO( \
 862                                 const struct rpc_xprt *xprt \
 863                         ), \
 864                         TP_ARGS(xprt))
 865
 866 DEFINE_RPC_XPRT_LIFETIME_EVENT(create);
 867 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto);
 868 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done);
 869 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force);
 870 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_cleanup);
 871 DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy);
 872
 873 DECLARE_EVENT_CLASS(rpc_xprt_event,
 874         TP_PROTO(
 875                 const struct rpc_xprt *xprt,
 876                 __be32 xid,
 877                 int status
 878         ),
 879
 880         TP_ARGS(xprt, xid, status),
 881
 882         TP_STRUCT__entry(
 883                 __field(u32, xid)
 884                 __field(int, status)
 885                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 886                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 887         ),
 888
 889         TP_fast_assign(
 890                 __entry->xid = be32_to_cpu(xid);
 891                 __entry->status = status;
 892                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 893                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 894         ),
 895
 896         TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
 897                         __get_str(port), __entry->xid,
 898                         __entry->status)
 899 );
 900 #define DEFINE_RPC_XPRT_EVENT(name) \
 901         DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
 902                         TP_PROTO( \
 903                                 const struct rpc_xprt *xprt, \
 904                                 __be32 xid, \
 905                                 int status \
 906                         ), \
 907                         TP_ARGS(xprt, xid, status))
 908
 909 DEFINE_RPC_XPRT_EVENT(timer);
 910 DEFINE_RPC_XPRT_EVENT(lookup_rqst);
 911 DEFINE_RPC_XPRT_EVENT(complete_rqst);
 912
 913 TRACE_EVENT(xprt_transmit,
 914         TP_PROTO(
 915                 const struct rpc_rqst *rqst,
 916                 int status
 917         ),
 918
 919         TP_ARGS(rqst, status),
 920
 921         TP_STRUCT__entry(
 922                 __field(unsigned int, task_id)
 923                 __field(unsigned int, client_id)
 924                 __field(u32, xid)
 925                 __field(u32, seqno)
 926                 __field(int, status)
 927         ),
 928
 929         TP_fast_assign(
 930                 __entry->task_id = rqst->rq_task->tk_pid;
 931                 __entry->client_id = rqst->rq_task->tk_client ?
 932                         rqst->rq_task->tk_client->cl_clid : -1;
 933                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 934                 __entry->seqno = rqst->rq_seqno;
 935                 __entry->status = status;
 936         ),
 937
 938         TP_printk(
 939                 "task:%u@%u xid=0x%08x seqno=%u status=%d",
 940                 __entry->task_id, __entry->client_id, __entry->xid,
 941                 __entry->seqno, __entry->status)
 942 );
 943
 944 TRACE_EVENT(xprt_enq_xmit,
 945         TP_PROTO(
 946                 const struct rpc_task *task,
 947                 int stage
 948         ),
 949
 950         TP_ARGS(task, stage),
 951
 952         TP_STRUCT__entry(
 953                 __field(unsigned int, task_id)
 954                 __field(unsigned int, client_id)
 955                 __field(u32, xid)
 956                 __field(u32, seqno)
 957                 __field(int, stage)
 958         ),
 959
 960         TP_fast_assign(
 961                 __entry->task_id = task->tk_pid;
 962                 __entry->client_id = task->tk_client ?
 963                         task->tk_client->cl_clid : -1;
 964                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 965                 __entry->seqno = task->tk_rqstp->rq_seqno;
 966                 __entry->stage = stage;
 967         ),
 968
 969         TP_printk(
 970                 "task:%u@%u xid=0x%08x seqno=%u stage=%d",
 971                 __entry->task_id, __entry->client_id, __entry->xid,
 972                 __entry->seqno, __entry->stage)
 973 );
 974
 975 TRACE_EVENT(xprt_ping,
 976         TP_PROTO(const struct rpc_xprt *xprt, int status),
 977
 978         TP_ARGS(xprt, status),
 979
 980         TP_STRUCT__entry(
 981                 __field(int, status)
 982                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 983                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 984         ),
 985
 986         TP_fast_assign(
 987                 __entry->status = status;
 988                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 989                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 990         ),
 991
 992         TP_printk("peer=[%s]:%s status=%d",
 993                         __get_str(addr), __get_str(port), __entry->status)
 994 );
 995
 996 DECLARE_EVENT_CLASS(xprt_writelock_event,
 997         TP_PROTO(
 998                 const struct rpc_xprt *xprt, const struct rpc_task *task
 999         ),
1000
1001         TP_ARGS(xprt, task),
1002
1003         TP_STRUCT__entry(
1004                 __field(unsigned int, task_id)
1005                 __field(unsigned int, client_id)
1006                 __field(unsigned int, snd_task_id)
1007         ),
1008
1009         TP_fast_assign(
1010                 if (task) {
1011                         __entry->task_id = task->tk_pid;
1012                         __entry->client_id = task->tk_client ?
1013                                              task->tk_client->cl_clid : -1;
1014                 } else {
1015                         __entry->task_id = -1;
1016                         __entry->client_id = -1;
1017                 }
1018                 __entry->snd_task_id = xprt->snd_task ?
1019                                         xprt->snd_task->tk_pid : -1;
1020         ),
1021
1022         TP_printk("task:%u@%u snd_task:%u",
1023                         __entry->task_id, __entry->client_id,
1024                         __entry->snd_task_id)
1025 );
1026
1027 #define DEFINE_WRITELOCK_EVENT(name) \
1028         DEFINE_EVENT(xprt_writelock_event, xprt_##name, \
1029                         TP_PROTO( \
1030                                 const struct rpc_xprt *xprt, \
1031                                 const struct rpc_task *task \
1032                         ), \
1033                         TP_ARGS(xprt, task))
1034
1035 DEFINE_WRITELOCK_EVENT(reserve_xprt);
1036 DEFINE_WRITELOCK_EVENT(release_xprt);
1037
1038 DECLARE_EVENT_CLASS(xprt_cong_event,
1039         TP_PROTO(
1040                 const struct rpc_xprt *xprt, const struct rpc_task *task
1041         ),
1042
1043         TP_ARGS(xprt, task),
1044
1045         TP_STRUCT__entry(
1046                 __field(unsigned int, task_id)
1047                 __field(unsigned int, client_id)
1048                 __field(unsigned int, snd_task_id)
1049                 __field(unsigned long, cong)
1050                 __field(unsigned long, cwnd)
1051                 __field(bool, wait)
1052         ),
1053
1054         TP_fast_assign(
1055                 if (task) {
1056                         __entry->task_id = task->tk_pid;
1057                         __entry->client_id = task->tk_client ?
1058                                              task->tk_client->cl_clid : -1;
1059                 } else {
1060                         __entry->task_id = -1;
1061                         __entry->client_id = -1;
1062                 }
1063                 __entry->snd_task_id = xprt->snd_task ?
1064                                         xprt->snd_task->tk_pid : -1;
1065                 __entry->cong = xprt->cong;
1066                 __entry->cwnd = xprt->cwnd;
1067                 __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
1068         ),
1069
1070         TP_printk("task:%u@%u snd_task:%u cong=%lu cwnd=%lu%s",
1071                         __entry->task_id, __entry->client_id,
1072                         __entry->snd_task_id, __entry->cong, __entry->cwnd,
1073                         __entry->wait ? " (wait)" : "")
1074 );
1075
1076 #define DEFINE_CONG_EVENT(name) \
1077         DEFINE_EVENT(xprt_cong_event, xprt_##name, \
1078                         TP_PROTO( \
1079                                 const struct rpc_xprt *xprt, \
1080                                 const struct rpc_task *task \
1081                         ), \
1082                         TP_ARGS(xprt, task))
1083
1084 DEFINE_CONG_EVENT(reserve_cong);
1085 DEFINE_CONG_EVENT(release_cong);
1086 DEFINE_CONG_EVENT(get_cong);
1087 DEFINE_CONG_EVENT(put_cong);
1088
1089 TRACE_EVENT(xs_stream_read_data,
1090         TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
1091
1092         TP_ARGS(xprt, err, total),
1093
1094         TP_STRUCT__entry(
1095                 __field(ssize_t, err)
1096                 __field(size_t, total)
1097                 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
1098                                 "(null)")
1099                 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
1100                                 "(null)")
1101         ),
1102
1103         TP_fast_assign(
1104                 __entry->err = err;
1105                 __entry->total = total;
1106                 __assign_str(addr, xprt ?
1107                         xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
1108                 __assign_str(port, xprt ?
1109                         xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
1110         ),
1111
1112         TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
1113                         __get_str(port), __entry->err, __entry->total)
1114 );
1115
1116 TRACE_EVENT(xs_stream_read_request,
1117         TP_PROTO(struct sock_xprt *xs),
1118
1119         TP_ARGS(xs),
1120
1121         TP_STRUCT__entry(
1122                 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
1123                 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
1124                 __field(u32, xid)
1125                 __field(unsigned long, copied)
1126                 __field(unsigned int, reclen)
1127                 __field(unsigned int, offset)
1128         ),
1129
1130         TP_fast_assign(
1131                 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
1132                 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
1133                 __entry->xid = be32_to_cpu(xs->recv.xid);
1134                 __entry->copied = xs->recv.copied;
1135                 __entry->reclen = xs->recv.len;
1136                 __entry->offset = xs->recv.offset;
1137         ),
1138
1139         TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
1140                         __get_str(addr), __get_str(port), __entry->xid,
1141                         __entry->copied, __entry->reclen, __entry->offset)
1142 );
1143
1144
1145 DECLARE_EVENT_CLASS(svc_xdr_buf_class,
1146         TP_PROTO(
1147                 const struct svc_rqst *rqst,
1148                 const struct xdr_buf *xdr
1149         ),
1150
1151         TP_ARGS(rqst, xdr),
1152
1153         TP_STRUCT__entry(
1154                 __field(u32, xid)
1155                 __field(const void *, head_base)
1156                 __field(size_t, head_len)
1157                 __field(const void *, tail_base)
1158                 __field(size_t, tail_len)
1159                 __field(unsigned int, page_len)
1160                 __field(unsigned int, msg_len)
1161         ),
1162
1163         TP_fast_assign(
1164                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1165                 __entry->head_base = xdr->head[0].iov_base;
1166                 __entry->head_len = xdr->head[0].iov_len;
1167                 __entry->tail_base = xdr->tail[0].iov_base;
1168                 __entry->tail_len = xdr->tail[0].iov_len;
1169                 __entry->page_len = xdr->page_len;
1170                 __entry->msg_len = xdr->len;
1171         ),
1172
1173         TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
1174                 __entry->xid,
1175                 __entry->head_base, __entry->head_len, __entry->page_len,
1176                 __entry->tail_base, __entry->tail_len, __entry->msg_len
1177         )
1178 );
1179
1180 #define DEFINE_SVCXDRBUF_EVENT(name)                                    \
1181                 DEFINE_EVENT(svc_xdr_buf_class,                         \
1182                                 svc_xdr_##name,                         \
1183                                 TP_PROTO(                               \
1184                                         const struct svc_rqst *rqst,    \
1185                                         const struct xdr_buf *xdr       \
1186                                 ),                                      \
1187                                 TP_ARGS(rqst, xdr))
1188
1189 DEFINE_SVCXDRBUF_EVENT(recvfrom);
1190 DEFINE_SVCXDRBUF_EVENT(sendto);
1191
1192 #define show_rqstp_flags(flags)                                         \
1193         __print_flags(flags, "|",                                       \
1194                 { (1UL << RQ_SECURE),           "RQ_SECURE"},           \
1195                 { (1UL << RQ_LOCAL),            "RQ_LOCAL"},            \
1196                 { (1UL << RQ_USEDEFERRAL),      "RQ_USEDEFERRAL"},      \
1197                 { (1UL << RQ_DROPME),           "RQ_DROPME"},           \
1198                 { (1UL << RQ_SPLICE_OK),        "RQ_SPLICE_OK"},        \
1199                 { (1UL << RQ_VICTIM),           "RQ_VICTIM"},           \
1200                 { (1UL << RQ_BUSY),             "RQ_BUSY"})
1201
1202 TRACE_EVENT(svc_recv,
1203         TP_PROTO(struct svc_rqst *rqst, int len),
1204
1205         TP_ARGS(rqst, len),
1206
1207         TP_STRUCT__entry(
1208                 __field(u32, xid)
1209                 __field(int, len)
1210                 __field(unsigned long, flags)
1211                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1212         ),
1213
1214         TP_fast_assign(
1215                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1216                 __entry->len = len;
1217                 __entry->flags = rqst->rq_flags;
1218                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1219         ),
1220
1221         TP_printk("addr=%s xid=0x%08x len=%d flags=%s",
1222                         __get_str(addr), __entry->xid, __entry->len,
1223                         show_rqstp_flags(__entry->flags))
1224 );
1225
1226 #define svc_show_status(status)                         \
1227         __print_symbolic(status,                        \
1228                 { SVC_GARBAGE,  "SVC_GARBAGE" },        \
1229                 { SVC_SYSERR,   "SVC_SYSERR" },         \
1230                 { SVC_VALID,    "SVC_VALID" },          \
1231                 { SVC_NEGATIVE, "SVC_NEGATIVE" },       \
1232                 { SVC_OK,       "SVC_OK" },             \
1233                 { SVC_DROP,     "SVC_DROP" },           \
1234                 { SVC_CLOSE,    "SVC_CLOSE" },          \
1235                 { SVC_DENIED,   "SVC_DENIED" },         \
1236                 { SVC_PENDING,  "SVC_PENDING" },        \
1237                 { SVC_COMPLETE, "SVC_COMPLETE" })
1238
1239 TRACE_EVENT(svc_authenticate,
1240         TP_PROTO(const struct svc_rqst *rqst, int auth_res, __be32 auth_stat),
1241
1242         TP_ARGS(rqst, auth_res, auth_stat),
1243
1244         TP_STRUCT__entry(
1245                 __field(u32, xid)
1246                 __field(unsigned long, svc_status)
1247                 __field(unsigned long, auth_stat)
1248         ),
1249
1250         TP_fast_assign(
1251                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1252                 __entry->svc_status = auth_res;
1253                 __entry->auth_stat = be32_to_cpu(auth_stat);
1254         ),
1255
1256         TP_printk("xid=0x%08x auth_res=%s auth_stat=%s",
1257                         __entry->xid, svc_show_status(__entry->svc_status),
1258                         rpc_show_auth_stat(__entry->auth_stat))
1259 );
1260
1261 TRACE_EVENT(svc_process,
1262         TP_PROTO(const struct svc_rqst *rqst, const char *name),
1263
1264         TP_ARGS(rqst, name),
1265
1266         TP_STRUCT__entry(
1267                 __field(u32, xid)
1268                 __field(u32, vers)
1269                 __field(u32, proc)
1270                 __string(service, name)
1271                 __string(addr, rqst->rq_xprt ?
1272                          rqst->rq_xprt->xpt_remotebuf : "(null)")
1273         ),
1274
1275         TP_fast_assign(
1276                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1277                 __entry->vers = rqst->rq_vers;
1278                 __entry->proc = rqst->rq_proc;
1279                 __assign_str(service, name);
1280                 __assign_str(addr, rqst->rq_xprt ?
1281                              rqst->rq_xprt->xpt_remotebuf : "(null)");
1282         ),
1283
1284         TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%u",
1285                         __get_str(addr), __entry->xid,
1286                         __get_str(service), __entry->vers, __entry->proc)
1287 );
1288
1289 DECLARE_EVENT_CLASS(svc_rqst_event,
1290
1291         TP_PROTO(
1292                 const struct svc_rqst *rqst
1293         ),
1294
1295         TP_ARGS(rqst),
1296
1297         TP_STRUCT__entry(
1298                 __field(u32, xid)
1299                 __field(unsigned long, flags)
1300                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1301         ),
1302
1303         TP_fast_assign(
1304                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1305                 __entry->flags = rqst->rq_flags;
1306                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1307         ),
1308
1309         TP_printk("addr=%s xid=0x%08x flags=%s",
1310                         __get_str(addr), __entry->xid,
1311                         show_rqstp_flags(__entry->flags))
1312 );
1313 #define DEFINE_SVC_RQST_EVENT(name) \
1314         DEFINE_EVENT(svc_rqst_event, svc_##name, \
1315                         TP_PROTO( \
1316                                 const struct svc_rqst *rqst \
1317                         ), \
1318                         TP_ARGS(rqst))
1319
1320 DEFINE_SVC_RQST_EVENT(defer);
1321 DEFINE_SVC_RQST_EVENT(drop);
1322
1323 DECLARE_EVENT_CLASS(svc_rqst_status,
1324
1325         TP_PROTO(struct svc_rqst *rqst, int status),
1326
1327         TP_ARGS(rqst, status),
1328
1329         TP_STRUCT__entry(
1330                 __field(u32, xid)
1331                 __field(int, status)
1332                 __field(unsigned long, flags)
1333                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1334         ),
1335
1336         TP_fast_assign(
1337                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1338                 __entry->status = status;
1339                 __entry->flags = rqst->rq_flags;
1340                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1341         ),
1342
1343         TP_printk("addr=%s xid=0x%08x status=%d flags=%s",
1344                   __get_str(addr), __entry->xid,
1345                   __entry->status, show_rqstp_flags(__entry->flags))
1346 );
1347
1348 DEFINE_EVENT(svc_rqst_status, svc_send,
1349         TP_PROTO(struct svc_rqst *rqst, int status),
1350         TP_ARGS(rqst, status));
1351
1352 #define show_svc_xprt_flags(flags)                                      \
1353         __print_flags(flags, "|",                                       \
1354                 { (1UL << XPT_BUSY),            "XPT_BUSY"},            \
1355                 { (1UL << XPT_CONN),            "XPT_CONN"},            \
1356                 { (1UL << XPT_CLOSE),           "XPT_CLOSE"},           \
1357                 { (1UL << XPT_DATA),            "XPT_DATA"},            \
1358                 { (1UL << XPT_TEMP),            "XPT_TEMP"},            \
1359                 { (1UL << XPT_DEAD),            "XPT_DEAD"},            \
1360                 { (1UL << XPT_CHNGBUF),         "XPT_CHNGBUF"},         \
1361                 { (1UL << XPT_DEFERRED),        "XPT_DEFERRED"},        \
1362                 { (1UL << XPT_OLD),             "XPT_OLD"},             \
1363                 { (1UL << XPT_LISTENER),        "XPT_LISTENER"},        \
1364                 { (1UL << XPT_CACHE_AUTH),      "XPT_CACHE_AUTH"},      \
1365                 { (1UL << XPT_LOCAL),           "XPT_LOCAL"},           \
1366                 { (1UL << XPT_KILL_TEMP),       "XPT_KILL_TEMP"},       \
1367                 { (1UL << XPT_CONG_CTRL),       "XPT_CONG_CTRL"})
1368
1369 TRACE_EVENT(svc_xprt_do_enqueue,
1370         TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
1371
1372         TP_ARGS(xprt, rqst),
1373
1374         TP_STRUCT__entry(
1375                 __field(struct svc_xprt *, xprt)
1376                 __field(int, pid)
1377                 __field(unsigned long, flags)
1378                 __string(addr, xprt->xpt_remotebuf)
1379         ),
1380
1381         TP_fast_assign(
1382                 __entry->xprt = xprt;
1383                 __entry->pid = rqst? rqst->rq_task->pid : 0;
1384                 __entry->flags = xprt->xpt_flags;
1385                 __assign_str(addr, xprt->xpt_remotebuf);
1386         ),
1387
1388         TP_printk("xprt=%p addr=%s pid=%d flags=%s",
1389                         __entry->xprt, __get_str(addr),
1390                         __entry->pid, show_svc_xprt_flags(__entry->flags))
1391 );
1392
1393 DECLARE_EVENT_CLASS(svc_xprt_event,
1394         TP_PROTO(struct svc_xprt *xprt),
1395
1396         TP_ARGS(xprt),
1397
1398         TP_STRUCT__entry(
1399                 __field(struct svc_xprt *, xprt)
1400                 __field(unsigned long, flags)
1401                 __string(addr, xprt->xpt_remotebuf)
1402         ),
1403
1404         TP_fast_assign(
1405                 __entry->xprt = xprt;
1406                 __entry->flags = xprt->xpt_flags;
1407                 __assign_str(addr, xprt->xpt_remotebuf);
1408         ),
1409
1410         TP_printk("xprt=%p addr=%s flags=%s",
1411                         __entry->xprt, __get_str(addr),
1412                         show_svc_xprt_flags(__entry->flags))
1413 );
1414
1415 DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
1416         TP_PROTO(struct svc_xprt *xprt),
1417         TP_ARGS(xprt));
1418
1419 TRACE_EVENT(svc_xprt_dequeue,
1420         TP_PROTO(struct svc_rqst *rqst),
1421
1422         TP_ARGS(rqst),
1423
1424         TP_STRUCT__entry(
1425                 __field(struct svc_xprt *, xprt)
1426                 __field(unsigned long, flags)
1427                 __field(unsigned long, wakeup)
1428                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1429         ),
1430
1431         TP_fast_assign(
1432                 __entry->xprt = rqst->rq_xprt;
1433                 __entry->flags = rqst->rq_xprt->xpt_flags;
1434                 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
1435                                                         rqst->rq_qtime));
1436                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1437         ),
1438
1439         TP_printk("xprt=%p addr=%s flags=%s wakeup-us=%lu",
1440                         __entry->xprt, __get_str(addr),
1441                         show_svc_xprt_flags(__entry->flags),
1442                         __entry->wakeup)
1443 );
1444
1445 TRACE_EVENT(svc_wake_up,
1446         TP_PROTO(int pid),
1447
1448         TP_ARGS(pid),
1449
1450         TP_STRUCT__entry(
1451                 __field(int, pid)
1452         ),
1453
1454         TP_fast_assign(
1455                 __entry->pid = pid;
1456         ),
1457
1458         TP_printk("pid=%d", __entry->pid)
1459 );
1460
1461 TRACE_EVENT(svc_handle_xprt,
1462         TP_PROTO(struct svc_xprt *xprt, int len),
1463
1464         TP_ARGS(xprt, len),
1465
1466         TP_STRUCT__entry(
1467                 __field(struct svc_xprt *, xprt)
1468                 __field(int, len)
1469                 __field(unsigned long, flags)
1470                 __string(addr, xprt->xpt_remotebuf)
1471         ),
1472
1473         TP_fast_assign(
1474                 __entry->xprt = xprt;
1475                 __entry->len = len;
1476                 __entry->flags = xprt->xpt_flags;
1477                 __assign_str(addr, xprt->xpt_remotebuf);
1478         ),
1479
1480         TP_printk("xprt=%p addr=%s len=%d flags=%s",
1481                 __entry->xprt, __get_str(addr),
1482                 __entry->len, show_svc_xprt_flags(__entry->flags))
1483 );
1484
1485 TRACE_EVENT(svc_stats_latency,
1486         TP_PROTO(const struct svc_rqst *rqst),
1487
1488         TP_ARGS(rqst),
1489
1490         TP_STRUCT__entry(
1491                 __field(u32, xid)
1492                 __field(unsigned long, execute)
1493                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1494         ),
1495
1496         TP_fast_assign(
1497                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1498                 __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
1499                                                          rqst->rq_stime));
1500                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1501         ),
1502
1503         TP_printk("addr=%s xid=0x%08x execute-us=%lu",
1504                 __get_str(addr), __entry->xid, __entry->execute)
1505 );
1506
1507 DECLARE_EVENT_CLASS(svc_deferred_event,
1508         TP_PROTO(
1509                 const struct svc_deferred_req *dr
1510         ),
1511
1512         TP_ARGS(dr),
1513
1514         TP_STRUCT__entry(
1515                 __field(u32, xid)
1516                 __string(addr, dr->xprt->xpt_remotebuf)
1517         ),
1518
1519         TP_fast_assign(
1520                 __entry->xid = be32_to_cpu(*(__be32 *)(dr->args +
1521                                                        (dr->xprt_hlen>>2)));
1522                 __assign_str(addr, dr->xprt->xpt_remotebuf);
1523         ),
1524
1525         TP_printk("addr=%s xid=0x%08x", __get_str(addr), __entry->xid)
1526 );
1527 #define DEFINE_SVC_DEFERRED_EVENT(name) \
1528         DEFINE_EVENT(svc_deferred_event, svc_##name##_deferred, \
1529                         TP_PROTO( \
1530                                 const struct svc_deferred_req *dr \
1531                         ), \
1532                         TP_ARGS(dr))
1533
1534 DEFINE_SVC_DEFERRED_EVENT(drop);
1535 DEFINE_SVC_DEFERRED_EVENT(revisit);
1536
1537 DECLARE_EVENT_CLASS(cache_event,
1538         TP_PROTO(
1539                 const struct cache_detail *cd,
1540                 const struct cache_head *h
1541         ),
1542
1543         TP_ARGS(cd, h),
1544
1545         TP_STRUCT__entry(
1546                 __field(const struct cache_head *, h)
1547                 __string(name, cd->name)
1548         ),
1549
1550         TP_fast_assign(
1551                 __entry->h = h;
1552                 __assign_str(name, cd->name);
1553         ),
1554
1555         TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)
1556 );
1557 #define DEFINE_CACHE_EVENT(name) \
1558         DEFINE_EVENT(cache_event, name, \
1559                         TP_PROTO( \
1560                                 const struct cache_detail *cd, \
1561                                 const struct cache_head *h \
1562                         ), \
1563                         TP_ARGS(cd, h))
1564 DEFINE_CACHE_EVENT(cache_entry_expired);
1565 DEFINE_CACHE_EVENT(cache_entry_upcall);
1566 DEFINE_CACHE_EVENT(cache_entry_update);
1567 DEFINE_CACHE_EVENT(cache_entry_make_negative);
1568 DEFINE_CACHE_EVENT(cache_entry_no_listener);
1569
1570 #endif /* _TRACE_SUNRPC_H */
1571
1572 #include <trace/define_trace.h>