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 TRACE_DEFINE_ENUM(SOCK_STREAM);
  18 TRACE_DEFINE_ENUM(SOCK_DGRAM);
  19 TRACE_DEFINE_ENUM(SOCK_RAW);
  20 TRACE_DEFINE_ENUM(SOCK_RDM);
  21 TRACE_DEFINE_ENUM(SOCK_SEQPACKET);
  22 TRACE_DEFINE_ENUM(SOCK_DCCP);
  23 TRACE_DEFINE_ENUM(SOCK_PACKET);
  24
  25 #define show_socket_type(type)                                  \
  26         __print_symbolic(type,                                  \
  27                 { SOCK_STREAM,          "STREAM" },             \
  28                 { SOCK_DGRAM,           "DGRAM" },              \
  29                 { SOCK_RAW,             "RAW" },                \
  30                 { SOCK_RDM,             "RDM" },                \
  31                 { SOCK_SEQPACKET,       "SEQPACKET" },          \
  32                 { SOCK_DCCP,            "DCCP" },               \
  33                 { SOCK_PACKET,          "PACKET" })
  34
  35 /* This list is known to be incomplete, add new enums as needed. */
  36 TRACE_DEFINE_ENUM(AF_UNSPEC);
  37 TRACE_DEFINE_ENUM(AF_UNIX);
  38 TRACE_DEFINE_ENUM(AF_LOCAL);
  39 TRACE_DEFINE_ENUM(AF_INET);
  40 TRACE_DEFINE_ENUM(AF_INET6);
  41
  42 #define rpc_show_address_family(family)                         \
  43         __print_symbolic(family,                                \
  44                 { AF_UNSPEC,            "AF_UNSPEC" },          \
  45                 { AF_UNIX,              "AF_UNIX" },            \
  46                 { AF_LOCAL,             "AF_LOCAL" },           \
  47                 { AF_INET,              "AF_INET" },            \
  48                 { AF_INET6,             "AF_INET6" })
  49
  50 DECLARE_EVENT_CLASS(rpc_xdr_buf_class,
  51         TP_PROTO(
  52                 const struct rpc_task *task,
  53                 const struct xdr_buf *xdr
  54         ),
  55
  56         TP_ARGS(task, xdr),
  57
  58         TP_STRUCT__entry(
  59                 __field(unsigned int, task_id)
  60                 __field(unsigned int, client_id)
  61                 __field(const void *, head_base)
  62                 __field(size_t, head_len)
  63                 __field(const void *, tail_base)
  64                 __field(size_t, tail_len)
  65                 __field(unsigned int, page_len)
  66                 __field(unsigned int, msg_len)
  67         ),
  68
  69         TP_fast_assign(
  70                 __entry->task_id = task->tk_pid;
  71                 __entry->client_id = task->tk_client ?
  72                                      task->tk_client->cl_clid : -1;
  73                 __entry->head_base = xdr->head[0].iov_base;
  74                 __entry->head_len = xdr->head[0].iov_len;
  75                 __entry->tail_base = xdr->tail[0].iov_base;
  76                 __entry->tail_len = xdr->tail[0].iov_len;
  77                 __entry->page_len = xdr->page_len;
  78                 __entry->msg_len = xdr->len;
  79         ),
  80
  81         TP_printk("task:%u@%u head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
  82                 __entry->task_id, __entry->client_id,
  83                 __entry->head_base, __entry->head_len, __entry->page_len,
  84                 __entry->tail_base, __entry->tail_len, __entry->msg_len
  85         )
  86 );
  87
  88 #define DEFINE_RPCXDRBUF_EVENT(name)                                    \
  89                 DEFINE_EVENT(rpc_xdr_buf_class,                         \
  90                                 rpc_xdr_##name,                         \
  91                                 TP_PROTO(                               \
  92                                         const struct rpc_task *task,    \
  93                                         const struct xdr_buf *xdr       \
  94                                 ),                                      \
  95                                 TP_ARGS(task, xdr))
  96
  97 DEFINE_RPCXDRBUF_EVENT(sendto);
  98 DEFINE_RPCXDRBUF_EVENT(recvfrom);
  99 DEFINE_RPCXDRBUF_EVENT(reply_pages);
 100
 101
 102 DECLARE_EVENT_CLASS(rpc_clnt_class,
 103         TP_PROTO(
 104                 const struct rpc_clnt *clnt
 105         ),
 106
 107         TP_ARGS(clnt),
 108
 109         TP_STRUCT__entry(
 110                 __field(unsigned int, client_id)
 111         ),
 112
 113         TP_fast_assign(
 114                 __entry->client_id = clnt->cl_clid;
 115         ),
 116
 117         TP_printk("clid=%u", __entry->client_id)
 118 );
 119
 120 #define DEFINE_RPC_CLNT_EVENT(name)                                     \
 121                 DEFINE_EVENT(rpc_clnt_class,                            \
 122                                 rpc_clnt_##name,                        \
 123                                 TP_PROTO(                               \
 124                                         const struct rpc_clnt *clnt     \
 125                                 ),                                      \
 126                                 TP_ARGS(clnt))
 127
 128 DEFINE_RPC_CLNT_EVENT(free);
 129 DEFINE_RPC_CLNT_EVENT(killall);
 130 DEFINE_RPC_CLNT_EVENT(shutdown);
 131 DEFINE_RPC_CLNT_EVENT(release);
 132 DEFINE_RPC_CLNT_EVENT(replace_xprt);
 133 DEFINE_RPC_CLNT_EVENT(replace_xprt_err);
 134
 135 TRACE_EVENT(rpc_clnt_new,
 136         TP_PROTO(
 137                 const struct rpc_clnt *clnt,
 138                 const struct rpc_xprt *xprt,
 139                 const char *program,
 140                 const char *server
 141         ),
 142
 143         TP_ARGS(clnt, xprt, program, server),
 144
 145         TP_STRUCT__entry(
 146                 __field(unsigned int, client_id)
 147                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 148                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 149                 __string(program, program)
 150                 __string(server, server)
 151         ),
 152
 153         TP_fast_assign(
 154                 __entry->client_id = clnt->cl_clid;
 155                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 156                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 157                 __assign_str(program, program)
 158                 __assign_str(server, server)
 159         ),
 160
 161         TP_printk("client=%u peer=[%s]:%s program=%s server=%s",
 162                 __entry->client_id, __get_str(addr), __get_str(port),
 163                 __get_str(program), __get_str(server))
 164 );
 165
 166 TRACE_EVENT(rpc_clnt_new_err,
 167         TP_PROTO(
 168                 const char *program,
 169                 const char *server,
 170                 int error
 171         ),
 172
 173         TP_ARGS(program, server, error),
 174
 175         TP_STRUCT__entry(
 176                 __field(int, error)
 177                 __string(program, program)
 178                 __string(server, server)
 179         ),
 180
 181         TP_fast_assign(
 182                 __entry->error = error;
 183                 __assign_str(program, program)
 184                 __assign_str(server, server)
 185         ),
 186
 187         TP_printk("program=%s server=%s error=%d",
 188                 __get_str(program), __get_str(server), __entry->error)
 189 );
 190
 191 TRACE_EVENT(rpc_clnt_clone_err,
 192         TP_PROTO(
 193                 const struct rpc_clnt *clnt,
 194                 int error
 195         ),
 196
 197         TP_ARGS(clnt, error),
 198
 199         TP_STRUCT__entry(
 200                 __field(unsigned int, client_id)
 201                 __field(int, error)
 202         ),
 203
 204         TP_fast_assign(
 205                 __entry->client_id = clnt->cl_clid;
 206                 __entry->error = error;
 207         ),
 208
 209         TP_printk("client=%u error=%d", __entry->client_id, __entry->error)
 210 );
 211
 212
 213 TRACE_DEFINE_ENUM(RPC_AUTH_OK);
 214 TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
 215 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
 216 TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
 217 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
 218 TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
 219 TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
 220 TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);
 221
 222 #define rpc_show_auth_stat(status)                                      \
 223         __print_symbolic(status,                                        \
 224                 { RPC_AUTH_OK,                  "AUTH_OK" },            \
 225                 { RPC_AUTH_BADCRED,             "BADCRED" },            \
 226                 { RPC_AUTH_REJECTEDCRED,        "REJECTEDCRED" },       \
 227                 { RPC_AUTH_BADVERF,             "BADVERF" },            \
 228                 { RPC_AUTH_REJECTEDVERF,        "REJECTEDVERF" },       \
 229                 { RPC_AUTH_TOOWEAK,             "TOOWEAK" },            \
 230                 { RPCSEC_GSS_CREDPROBLEM,       "GSS_CREDPROBLEM" },    \
 231                 { RPCSEC_GSS_CTXPROBLEM,        "GSS_CTXPROBLEM" })     \
 232
 233 DECLARE_EVENT_CLASS(rpc_task_status,
 234
 235         TP_PROTO(const struct rpc_task *task),
 236
 237         TP_ARGS(task),
 238
 239         TP_STRUCT__entry(
 240                 __field(unsigned int, task_id)
 241                 __field(unsigned int, client_id)
 242                 __field(int, status)
 243         ),
 244
 245         TP_fast_assign(
 246                 __entry->task_id = task->tk_pid;
 247                 __entry->client_id = task->tk_client->cl_clid;
 248                 __entry->status = task->tk_status;
 249         ),
 250
 251         TP_printk("task:%u@%u status=%d",
 252                 __entry->task_id, __entry->client_id,
 253                 __entry->status)
 254 );
 255 #define DEFINE_RPC_STATUS_EVENT(name) \
 256         DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
 257                         TP_PROTO( \
 258                                 const struct rpc_task *task \
 259                         ), \
 260                         TP_ARGS(task))
 261
 262 DEFINE_RPC_STATUS_EVENT(call);
 263 DEFINE_RPC_STATUS_EVENT(connect);
 264 DEFINE_RPC_STATUS_EVENT(timeout);
 265 DEFINE_RPC_STATUS_EVENT(retry_refresh);
 266 DEFINE_RPC_STATUS_EVENT(refresh);
 267
 268 TRACE_EVENT(rpc_request,
 269         TP_PROTO(const struct rpc_task *task),
 270
 271         TP_ARGS(task),
 272
 273         TP_STRUCT__entry(
 274                 __field(unsigned int, task_id)
 275                 __field(unsigned int, client_id)
 276                 __field(int, version)
 277                 __field(bool, async)
 278                 __string(progname, task->tk_client->cl_program->name)
 279                 __string(procname, rpc_proc_name(task))
 280         ),
 281
 282         TP_fast_assign(
 283                 __entry->task_id = task->tk_pid;
 284                 __entry->client_id = task->tk_client->cl_clid;
 285                 __entry->version = task->tk_client->cl_vers;
 286                 __entry->async = RPC_IS_ASYNC(task);
 287                 __assign_str(progname, task->tk_client->cl_program->name)
 288                 __assign_str(procname, rpc_proc_name(task))
 289         ),
 290
 291         TP_printk("task:%u@%u %sv%d %s (%ssync)",
 292                 __entry->task_id, __entry->client_id,
 293                 __get_str(progname), __entry->version,
 294                 __get_str(procname), __entry->async ? "a": ""
 295                 )
 296 );
 297
 298 TRACE_DEFINE_ENUM(RPC_TASK_ASYNC);
 299 TRACE_DEFINE_ENUM(RPC_TASK_SWAPPER);
 300 TRACE_DEFINE_ENUM(RPC_TASK_NULLCREDS);
 301 TRACE_DEFINE_ENUM(RPC_CALL_MAJORSEEN);
 302 TRACE_DEFINE_ENUM(RPC_TASK_ROOTCREDS);
 303 TRACE_DEFINE_ENUM(RPC_TASK_DYNAMIC);
 304 TRACE_DEFINE_ENUM(RPC_TASK_NO_ROUND_ROBIN);
 305 TRACE_DEFINE_ENUM(RPC_TASK_SOFT);
 306 TRACE_DEFINE_ENUM(RPC_TASK_SOFTCONN);
 307 TRACE_DEFINE_ENUM(RPC_TASK_SENT);
 308 TRACE_DEFINE_ENUM(RPC_TASK_TIMEOUT);
 309 TRACE_DEFINE_ENUM(RPC_TASK_NOCONNECT);
 310 TRACE_DEFINE_ENUM(RPC_TASK_NO_RETRANS_TIMEOUT);
 311 TRACE_DEFINE_ENUM(RPC_TASK_CRED_NOREF);
 312
 313 #define rpc_show_task_flags(flags)                                      \
 314         __print_flags(flags, "|",                                       \
 315                 { RPC_TASK_ASYNC, "ASYNC" },                            \
 316                 { RPC_TASK_SWAPPER, "SWAPPER" },                        \
 317                 { RPC_TASK_NULLCREDS, "NULLCREDS" },                    \
 318                 { RPC_CALL_MAJORSEEN, "MAJORSEEN" },                    \
 319                 { RPC_TASK_ROOTCREDS, "ROOTCREDS" },                    \
 320                 { RPC_TASK_DYNAMIC, "DYNAMIC" },                        \
 321                 { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" },          \
 322                 { RPC_TASK_SOFT, "SOFT" },                              \
 323                 { RPC_TASK_SOFTCONN, "SOFTCONN" },                      \
 324                 { RPC_TASK_SENT, "SENT" },                              \
 325                 { RPC_TASK_TIMEOUT, "TIMEOUT" },                        \
 326                 { RPC_TASK_NOCONNECT, "NOCONNECT" },                    \
 327                 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" },               \
 328                 { RPC_TASK_CRED_NOREF, "CRED_NOREF" })
 329
 330 TRACE_DEFINE_ENUM(RPC_TASK_RUNNING);
 331 TRACE_DEFINE_ENUM(RPC_TASK_QUEUED);
 332 TRACE_DEFINE_ENUM(RPC_TASK_ACTIVE);
 333 TRACE_DEFINE_ENUM(RPC_TASK_NEED_XMIT);
 334 TRACE_DEFINE_ENUM(RPC_TASK_NEED_RECV);
 335 TRACE_DEFINE_ENUM(RPC_TASK_MSG_PIN_WAIT);
 336 TRACE_DEFINE_ENUM(RPC_TASK_SIGNALLED);
 337
 338 #define rpc_show_runstate(flags)                                        \
 339         __print_flags(flags, "|",                                       \
 340                 { (1UL << RPC_TASK_RUNNING), "RUNNING" },               \
 341                 { (1UL << RPC_TASK_QUEUED), "QUEUED" },                 \
 342                 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" },                 \
 343                 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" },           \
 344                 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" },           \
 345                 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" },     \
 346                 { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
 347
 348 DECLARE_EVENT_CLASS(rpc_task_running,
 349
 350         TP_PROTO(const struct rpc_task *task, const void *action),
 351
 352         TP_ARGS(task, action),
 353
 354         TP_STRUCT__entry(
 355                 __field(unsigned int, task_id)
 356                 __field(unsigned int, client_id)
 357                 __field(const void *, action)
 358                 __field(unsigned long, runstate)
 359                 __field(int, status)
 360                 __field(unsigned short, flags)
 361                 ),
 362
 363         TP_fast_assign(
 364                 __entry->client_id = task->tk_client ?
 365                                      task->tk_client->cl_clid : -1;
 366                 __entry->task_id = task->tk_pid;
 367                 __entry->action = action;
 368                 __entry->runstate = task->tk_runstate;
 369                 __entry->status = task->tk_status;
 370                 __entry->flags = task->tk_flags;
 371                 ),
 372
 373         TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%ps",
 374                 __entry->task_id, __entry->client_id,
 375                 rpc_show_task_flags(__entry->flags),
 376                 rpc_show_runstate(__entry->runstate),
 377                 __entry->status,
 378                 __entry->action
 379                 )
 380 );
 381 #define DEFINE_RPC_RUNNING_EVENT(name) \
 382         DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
 383                         TP_PROTO( \
 384                                 const struct rpc_task *task, \
 385                                 const void *action \
 386                         ), \
 387                         TP_ARGS(task, action))
 388
 389 DEFINE_RPC_RUNNING_EVENT(begin);
 390 DEFINE_RPC_RUNNING_EVENT(run_action);
 391 DEFINE_RPC_RUNNING_EVENT(sync_sleep);
 392 DEFINE_RPC_RUNNING_EVENT(sync_wake);
 393 DEFINE_RPC_RUNNING_EVENT(complete);
 394 DEFINE_RPC_RUNNING_EVENT(timeout);
 395 DEFINE_RPC_RUNNING_EVENT(signalled);
 396 DEFINE_RPC_RUNNING_EVENT(end);
 397
 398 DECLARE_EVENT_CLASS(rpc_task_queued,
 399
 400         TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
 401
 402         TP_ARGS(task, q),
 403
 404         TP_STRUCT__entry(
 405                 __field(unsigned int, task_id)
 406                 __field(unsigned int, client_id)
 407                 __field(unsigned long, timeout)
 408                 __field(unsigned long, runstate)
 409                 __field(int, status)
 410                 __field(unsigned short, flags)
 411                 __string(q_name, rpc_qname(q))
 412                 ),
 413
 414         TP_fast_assign(
 415                 __entry->client_id = task->tk_client ?
 416                                      task->tk_client->cl_clid : -1;
 417                 __entry->task_id = task->tk_pid;
 418                 __entry->timeout = rpc_task_timeout(task);
 419                 __entry->runstate = task->tk_runstate;
 420                 __entry->status = task->tk_status;
 421                 __entry->flags = task->tk_flags;
 422                 __assign_str(q_name, rpc_qname(q));
 423                 ),
 424
 425         TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s",
 426                 __entry->task_id, __entry->client_id,
 427                 rpc_show_task_flags(__entry->flags),
 428                 rpc_show_runstate(__entry->runstate),
 429                 __entry->status,
 430                 __entry->timeout,
 431                 __get_str(q_name)
 432                 )
 433 );
 434 #define DEFINE_RPC_QUEUED_EVENT(name) \
 435         DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
 436                         TP_PROTO( \
 437                                 const struct rpc_task *task, \
 438                                 const struct rpc_wait_queue *q \
 439                         ), \
 440                         TP_ARGS(task, q))
 441
 442 DEFINE_RPC_QUEUED_EVENT(sleep);
 443 DEFINE_RPC_QUEUED_EVENT(wakeup);
 444
 445 DECLARE_EVENT_CLASS(rpc_failure,
 446
 447         TP_PROTO(const struct rpc_task *task),
 448
 449         TP_ARGS(task),
 450
 451         TP_STRUCT__entry(
 452                 __field(unsigned int, task_id)
 453                 __field(unsigned int, client_id)
 454         ),
 455
 456         TP_fast_assign(
 457                 __entry->task_id = task->tk_pid;
 458                 __entry->client_id = task->tk_client->cl_clid;
 459         ),
 460
 461         TP_printk("task:%u@%u",
 462                 __entry->task_id, __entry->client_id)
 463 );
 464
 465 #define DEFINE_RPC_FAILURE(name)                                        \
 466         DEFINE_EVENT(rpc_failure, rpc_bad_##name,                       \
 467                         TP_PROTO(                                       \
 468                                 const struct rpc_task *task             \
 469                         ),                                              \
 470                         TP_ARGS(task))
 471
 472 DEFINE_RPC_FAILURE(callhdr);
 473 DEFINE_RPC_FAILURE(verifier);
 474
 475 DECLARE_EVENT_CLASS(rpc_reply_event,
 476
 477         TP_PROTO(
 478                 const struct rpc_task *task
 479         ),
 480
 481         TP_ARGS(task),
 482
 483         TP_STRUCT__entry(
 484                 __field(unsigned int, task_id)
 485                 __field(unsigned int, client_id)
 486                 __field(u32, xid)
 487                 __string(progname, task->tk_client->cl_program->name)
 488                 __field(u32, version)
 489                 __string(procname, rpc_proc_name(task))
 490                 __string(servername, task->tk_xprt->servername)
 491         ),
 492
 493         TP_fast_assign(
 494                 __entry->task_id = task->tk_pid;
 495                 __entry->client_id = task->tk_client->cl_clid;
 496                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 497                 __assign_str(progname, task->tk_client->cl_program->name)
 498                 __entry->version = task->tk_client->cl_vers;
 499                 __assign_str(procname, rpc_proc_name(task))
 500                 __assign_str(servername, task->tk_xprt->servername)
 501         ),
 502
 503         TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
 504                 __entry->task_id, __entry->client_id, __get_str(servername),
 505                 __entry->xid, __get_str(progname), __entry->version,
 506                 __get_str(procname))
 507 )
 508
 509 #define DEFINE_RPC_REPLY_EVENT(name)                                    \
 510         DEFINE_EVENT(rpc_reply_event, rpc__##name,                      \
 511                         TP_PROTO(                                       \
 512                                 const struct rpc_task *task             \
 513                         ),                                              \
 514                         TP_ARGS(task))
 515
 516 DEFINE_RPC_REPLY_EVENT(prog_unavail);
 517 DEFINE_RPC_REPLY_EVENT(prog_mismatch);
 518 DEFINE_RPC_REPLY_EVENT(proc_unavail);
 519 DEFINE_RPC_REPLY_EVENT(garbage_args);
 520 DEFINE_RPC_REPLY_EVENT(unparsable);
 521 DEFINE_RPC_REPLY_EVENT(mismatch);
 522 DEFINE_RPC_REPLY_EVENT(stale_creds);
 523 DEFINE_RPC_REPLY_EVENT(bad_creds);
 524 DEFINE_RPC_REPLY_EVENT(auth_tooweak);
 525
 526 #define DEFINE_RPCB_ERROR_EVENT(name)                                   \
 527         DEFINE_EVENT(rpc_reply_event, rpcb_##name##_err,                \
 528                         TP_PROTO(                                       \
 529                                 const struct rpc_task *task             \
 530                         ),                                              \
 531                         TP_ARGS(task))
 532
 533 DEFINE_RPCB_ERROR_EVENT(prog_unavail);
 534 DEFINE_RPCB_ERROR_EVENT(timeout);
 535 DEFINE_RPCB_ERROR_EVENT(bind_version);
 536 DEFINE_RPCB_ERROR_EVENT(unreachable);
 537 DEFINE_RPCB_ERROR_EVENT(unrecognized);
 538
 539 TRACE_EVENT(rpc_buf_alloc,
 540         TP_PROTO(
 541                 const struct rpc_task *task,
 542                 int status
 543         ),
 544
 545         TP_ARGS(task, status),
 546
 547         TP_STRUCT__entry(
 548                 __field(unsigned int, task_id)
 549                 __field(unsigned int, client_id)
 550                 __field(size_t, callsize)
 551                 __field(size_t, recvsize)
 552                 __field(int, status)
 553         ),
 554
 555         TP_fast_assign(
 556                 __entry->task_id = task->tk_pid;
 557                 __entry->client_id = task->tk_client->cl_clid;
 558                 __entry->callsize = task->tk_rqstp->rq_callsize;
 559                 __entry->recvsize = task->tk_rqstp->rq_rcvsize;
 560                 __entry->status = status;
 561         ),
 562
 563         TP_printk("task:%u@%u callsize=%zu recvsize=%zu status=%d",
 564                 __entry->task_id, __entry->client_id,
 565                 __entry->callsize, __entry->recvsize, __entry->status
 566         )
 567 );
 568
 569 TRACE_EVENT(rpc_call_rpcerror,
 570         TP_PROTO(
 571                 const struct rpc_task *task,
 572                 int tk_status,
 573                 int rpc_status
 574         ),
 575
 576         TP_ARGS(task, tk_status, rpc_status),
 577
 578         TP_STRUCT__entry(
 579                 __field(unsigned int, task_id)
 580                 __field(unsigned int, client_id)
 581                 __field(int, tk_status)
 582                 __field(int, rpc_status)
 583         ),
 584
 585         TP_fast_assign(
 586                 __entry->client_id = task->tk_client->cl_clid;
 587                 __entry->task_id = task->tk_pid;
 588                 __entry->tk_status = tk_status;
 589                 __entry->rpc_status = rpc_status;
 590         ),
 591
 592         TP_printk("task:%u@%u tk_status=%d rpc_status=%d",
 593                 __entry->task_id, __entry->client_id,
 594                 __entry->tk_status, __entry->rpc_status)
 595 );
 596
 597 TRACE_EVENT(rpc_stats_latency,
 598
 599         TP_PROTO(
 600                 const struct rpc_task *task,
 601                 ktime_t backlog,
 602                 ktime_t rtt,
 603                 ktime_t execute
 604         ),
 605
 606         TP_ARGS(task, backlog, rtt, execute),
 607
 608         TP_STRUCT__entry(
 609                 __field(unsigned int, task_id)
 610                 __field(unsigned int, client_id)
 611                 __field(u32, xid)
 612                 __field(int, version)
 613                 __string(progname, task->tk_client->cl_program->name)
 614                 __string(procname, rpc_proc_name(task))
 615                 __field(unsigned long, backlog)
 616                 __field(unsigned long, rtt)
 617                 __field(unsigned long, execute)
 618         ),
 619
 620         TP_fast_assign(
 621                 __entry->client_id = task->tk_client->cl_clid;
 622                 __entry->task_id = task->tk_pid;
 623                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 624                 __entry->version = task->tk_client->cl_vers;
 625                 __assign_str(progname, task->tk_client->cl_program->name)
 626                 __assign_str(procname, rpc_proc_name(task))
 627                 __entry->backlog = ktime_to_us(backlog);
 628                 __entry->rtt = ktime_to_us(rtt);
 629                 __entry->execute = ktime_to_us(execute);
 630         ),
 631
 632         TP_printk("task:%u@%d xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
 633                 __entry->task_id, __entry->client_id, __entry->xid,
 634                 __get_str(progname), __entry->version, __get_str(procname),
 635                 __entry->backlog, __entry->rtt, __entry->execute)
 636 );
 637
 638 TRACE_EVENT(rpc_xdr_overflow,
 639         TP_PROTO(
 640                 const struct xdr_stream *xdr,
 641                 size_t requested
 642         ),
 643
 644         TP_ARGS(xdr, requested),
 645
 646         TP_STRUCT__entry(
 647                 __field(unsigned int, task_id)
 648                 __field(unsigned int, client_id)
 649                 __field(int, version)
 650                 __field(size_t, requested)
 651                 __field(const void *, end)
 652                 __field(const void *, p)
 653                 __field(const void *, head_base)
 654                 __field(size_t, head_len)
 655                 __field(const void *, tail_base)
 656                 __field(size_t, tail_len)
 657                 __field(unsigned int, page_len)
 658                 __field(unsigned int, len)
 659                 __string(progname, xdr->rqst ?
 660                          xdr->rqst->rq_task->tk_client->cl_program->name : "unknown")
 661                 __string(procedure, xdr->rqst ?
 662                          xdr->rqst->rq_task->tk_msg.rpc_proc->p_name : "unknown")
 663         ),
 664
 665         TP_fast_assign(
 666                 if (xdr->rqst) {
 667                         const struct rpc_task *task = xdr->rqst->rq_task;
 668
 669                         __entry->task_id = task->tk_pid;
 670                         __entry->client_id = task->tk_client->cl_clid;
 671                         __assign_str(progname,
 672                                      task->tk_client->cl_program->name)
 673                         __entry->version = task->tk_client->cl_vers;
 674                         __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
 675                 } else {
 676                         __entry->task_id = 0;
 677                         __entry->client_id = 0;
 678                         __assign_str(progname, "unknown")
 679                         __entry->version = 0;
 680                         __assign_str(procedure, "unknown")
 681                 }
 682                 __entry->requested = requested;
 683                 __entry->end = xdr->end;
 684                 __entry->p = xdr->p;
 685                 __entry->head_base = xdr->buf->head[0].iov_base,
 686                 __entry->head_len = xdr->buf->head[0].iov_len,
 687                 __entry->page_len = xdr->buf->page_len,
 688                 __entry->tail_base = xdr->buf->tail[0].iov_base,
 689                 __entry->tail_len = xdr->buf->tail[0].iov_len,
 690                 __entry->len = xdr->buf->len;
 691         ),
 692
 693         TP_printk(
 694                 "task:%u@%u %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
 695                 __entry->task_id, __entry->client_id,
 696                 __get_str(progname), __entry->version, __get_str(procedure),
 697                 __entry->requested, __entry->p, __entry->end,
 698                 __entry->head_base, __entry->head_len,
 699                 __entry->page_len,
 700                 __entry->tail_base, __entry->tail_len,
 701                 __entry->len
 702         )
 703 );
 704
 705 TRACE_EVENT(rpc_xdr_alignment,
 706         TP_PROTO(
 707                 const struct xdr_stream *xdr,
 708                 size_t offset,
 709                 unsigned int copied
 710         ),
 711
 712         TP_ARGS(xdr, offset, copied),
 713
 714         TP_STRUCT__entry(
 715                 __field(unsigned int, task_id)
 716                 __field(unsigned int, client_id)
 717                 __field(int, version)
 718                 __field(size_t, offset)
 719                 __field(unsigned int, copied)
 720                 __field(const void *, head_base)
 721                 __field(size_t, head_len)
 722                 __field(const void *, tail_base)
 723                 __field(size_t, tail_len)
 724                 __field(unsigned int, page_len)
 725                 __field(unsigned int, len)
 726                 __string(progname,
 727                          xdr->rqst->rq_task->tk_client->cl_program->name)
 728                 __string(procedure,
 729                          xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
 730         ),
 731
 732         TP_fast_assign(
 733                 const struct rpc_task *task = xdr->rqst->rq_task;
 734
 735                 __entry->task_id = task->tk_pid;
 736                 __entry->client_id = task->tk_client->cl_clid;
 737                 __assign_str(progname,
 738                              task->tk_client->cl_program->name)
 739                 __entry->version = task->tk_client->cl_vers;
 740                 __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
 741
 742                 __entry->offset = offset;
 743                 __entry->copied = copied;
 744                 __entry->head_base = xdr->buf->head[0].iov_base,
 745                 __entry->head_len = xdr->buf->head[0].iov_len,
 746                 __entry->page_len = xdr->buf->page_len,
 747                 __entry->tail_base = xdr->buf->tail[0].iov_base,
 748                 __entry->tail_len = xdr->buf->tail[0].iov_len,
 749                 __entry->len = xdr->buf->len;
 750         ),
 751
 752         TP_printk(
 753                 "task:%u@%u %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
 754                 __entry->task_id, __entry->client_id,
 755                 __get_str(progname), __entry->version, __get_str(procedure),
 756                 __entry->offset, __entry->copied,
 757                 __entry->head_base, __entry->head_len,
 758                 __entry->page_len,
 759                 __entry->tail_base, __entry->tail_len,
 760                 __entry->len
 761         )
 762 );
 763
 764 /*
 765  * First define the enums in the below macros to be exported to userspace
 766  * via TRACE_DEFINE_ENUM().
 767  */
 768 #undef EM
 769 #undef EMe
 770 #define EM(a, b)        TRACE_DEFINE_ENUM(a);
 771 #define EMe(a, b)       TRACE_DEFINE_ENUM(a);
 772
 773 #define RPC_SHOW_SOCKET                         \
 774         EM( SS_FREE, "FREE" )                   \
 775         EM( SS_UNCONNECTED, "UNCONNECTED" )     \
 776         EM( SS_CONNECTING, "CONNECTING" )       \
 777         EM( SS_CONNECTED, "CONNECTED" )         \
 778         EMe( SS_DISCONNECTING, "DISCONNECTING" )
 779
 780 #define rpc_show_socket_state(state) \
 781         __print_symbolic(state, RPC_SHOW_SOCKET)
 782
 783 RPC_SHOW_SOCKET
 784
 785 #define RPC_SHOW_SOCK                           \
 786         EM( TCP_ESTABLISHED, "ESTABLISHED" )    \
 787         EM( TCP_SYN_SENT, "SYN_SENT" )          \
 788         EM( TCP_SYN_RECV, "SYN_RECV" )          \
 789         EM( TCP_FIN_WAIT1, "FIN_WAIT1" )        \
 790         EM( TCP_FIN_WAIT2, "FIN_WAIT2" )        \
 791         EM( TCP_TIME_WAIT, "TIME_WAIT" )        \
 792         EM( TCP_CLOSE, "CLOSE" )                \
 793         EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" )      \
 794         EM( TCP_LAST_ACK, "LAST_ACK" )          \
 795         EM( TCP_LISTEN, "LISTEN" )              \
 796         EMe( TCP_CLOSING, "CLOSING" )
 797
 798 #define rpc_show_sock_state(state) \
 799         __print_symbolic(state, RPC_SHOW_SOCK)
 800
 801 RPC_SHOW_SOCK
 802
 803 /*
 804  * Now redefine the EM() and EMe() macros to map the enums to the strings
 805  * that will be printed in the output.
 806  */
 807 #undef EM
 808 #undef EMe
 809 #define EM(a, b)        {a, b},
 810 #define EMe(a, b)       {a, b}
 811
 812 DECLARE_EVENT_CLASS(xs_socket_event,
 813
 814                 TP_PROTO(
 815                         struct rpc_xprt *xprt,
 816                         struct socket *socket
 817                 ),
 818
 819                 TP_ARGS(xprt, socket),
 820
 821                 TP_STRUCT__entry(
 822                         __field(unsigned int, socket_state)
 823                         __field(unsigned int, sock_state)
 824                         __field(unsigned long long, ino)
 825                         __string(dstaddr,
 826                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 827                         __string(dstport,
 828                                 xprt->address_strings[RPC_DISPLAY_PORT])
 829                 ),
 830
 831                 TP_fast_assign(
 832                         struct inode *inode = SOCK_INODE(socket);
 833                         __entry->socket_state = socket->state;
 834                         __entry->sock_state = socket->sk->sk_state;
 835                         __entry->ino = (unsigned long long)inode->i_ino;
 836                         __assign_str(dstaddr,
 837                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 838                         __assign_str(dstport,
 839                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 840                 ),
 841
 842                 TP_printk(
 843                         "socket:[%llu] dstaddr=%s/%s "
 844                         "state=%u (%s) sk_state=%u (%s)",
 845                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 846                         __entry->socket_state,
 847                         rpc_show_socket_state(__entry->socket_state),
 848                         __entry->sock_state,
 849                         rpc_show_sock_state(__entry->sock_state)
 850                 )
 851 );
 852 #define DEFINE_RPC_SOCKET_EVENT(name) \
 853         DEFINE_EVENT(xs_socket_event, name, \
 854                         TP_PROTO( \
 855                                 struct rpc_xprt *xprt, \
 856                                 struct socket *socket \
 857                         ), \
 858                         TP_ARGS(xprt, socket))
 859
 860 DECLARE_EVENT_CLASS(xs_socket_event_done,
 861
 862                 TP_PROTO(
 863                         struct rpc_xprt *xprt,
 864                         struct socket *socket,
 865                         int error
 866                 ),
 867
 868                 TP_ARGS(xprt, socket, error),
 869
 870                 TP_STRUCT__entry(
 871                         __field(int, error)
 872                         __field(unsigned int, socket_state)
 873                         __field(unsigned int, sock_state)
 874                         __field(unsigned long long, ino)
 875                         __string(dstaddr,
 876                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 877                         __string(dstport,
 878                                 xprt->address_strings[RPC_DISPLAY_PORT])
 879                 ),
 880
 881                 TP_fast_assign(
 882                         struct inode *inode = SOCK_INODE(socket);
 883                         __entry->socket_state = socket->state;
 884                         __entry->sock_state = socket->sk->sk_state;
 885                         __entry->ino = (unsigned long long)inode->i_ino;
 886                         __entry->error = error;
 887                         __assign_str(dstaddr,
 888                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 889                         __assign_str(dstport,
 890                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 891                 ),
 892
 893                 TP_printk(
 894                         "error=%d socket:[%llu] dstaddr=%s/%s "
 895                         "state=%u (%s) sk_state=%u (%s)",
 896                         __entry->error,
 897                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 898                         __entry->socket_state,
 899                         rpc_show_socket_state(__entry->socket_state),
 900                         __entry->sock_state,
 901                         rpc_show_sock_state(__entry->sock_state)
 902                 )
 903 );
 904 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
 905         DEFINE_EVENT(xs_socket_event_done, name, \
 906                         TP_PROTO( \
 907                                 struct rpc_xprt *xprt, \
 908                                 struct socket *socket, \
 909                                 int error \
 910                         ), \
 911                         TP_ARGS(xprt, socket, error))
 912
 913 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
 914 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
 915 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
 916 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
 917 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
 918 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
 919
 920 TRACE_EVENT(rpc_socket_nospace,
 921         TP_PROTO(
 922                 const struct rpc_rqst *rqst,
 923                 const struct sock_xprt *transport
 924         ),
 925
 926         TP_ARGS(rqst, transport),
 927
 928         TP_STRUCT__entry(
 929                 __field(unsigned int, task_id)
 930                 __field(unsigned int, client_id)
 931                 __field(unsigned int, total)
 932                 __field(unsigned int, remaining)
 933         ),
 934
 935         TP_fast_assign(
 936                 __entry->task_id = rqst->rq_task->tk_pid;
 937                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
 938                 __entry->total = rqst->rq_slen;
 939                 __entry->remaining = rqst->rq_slen - transport->xmit.offset;
 940         ),
 941
 942         TP_printk("task:%u@%u total=%u remaining=%u",
 943                 __entry->task_id, __entry->client_id,
 944                 __entry->total, __entry->remaining
 945         )
 946 );
 947
 948 TRACE_DEFINE_ENUM(XPRT_LOCKED);
 949 TRACE_DEFINE_ENUM(XPRT_CONNECTED);
 950 TRACE_DEFINE_ENUM(XPRT_CONNECTING);
 951 TRACE_DEFINE_ENUM(XPRT_CLOSE_WAIT);
 952 TRACE_DEFINE_ENUM(XPRT_BOUND);
 953 TRACE_DEFINE_ENUM(XPRT_BINDING);
 954 TRACE_DEFINE_ENUM(XPRT_CLOSING);
 955 TRACE_DEFINE_ENUM(XPRT_CONGESTED);
 956 TRACE_DEFINE_ENUM(XPRT_CWND_WAIT);
 957 TRACE_DEFINE_ENUM(XPRT_WRITE_SPACE);
 958
 959 #define rpc_show_xprt_state(x)                                          \
 960         __print_flags(x, "|",                                           \
 961                 { (1UL << XPRT_LOCKED),         "LOCKED"},              \
 962                 { (1UL << XPRT_CONNECTED),      "CONNECTED"},           \
 963                 { (1UL << XPRT_CONNECTING),     "CONNECTING"},          \
 964                 { (1UL << XPRT_CLOSE_WAIT),     "CLOSE_WAIT"},          \
 965                 { (1UL << XPRT_BOUND),          "BOUND"},               \
 966                 { (1UL << XPRT_BINDING),        "BINDING"},             \
 967                 { (1UL << XPRT_CLOSING),        "CLOSING"},             \
 968                 { (1UL << XPRT_CONGESTED),      "CONGESTED"},           \
 969                 { (1UL << XPRT_CWND_WAIT),      "CWND_WAIT"},           \
 970                 { (1UL << XPRT_WRITE_SPACE),    "WRITE_SPACE"})
 971
 972 DECLARE_EVENT_CLASS(rpc_xprt_lifetime_class,
 973         TP_PROTO(
 974                 const struct rpc_xprt *xprt
 975         ),
 976
 977         TP_ARGS(xprt),
 978
 979         TP_STRUCT__entry(
 980                 __field(unsigned long, state)
 981                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 982                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 983         ),
 984
 985         TP_fast_assign(
 986                 __entry->state = xprt->state;
 987                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 988                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 989         ),
 990
 991         TP_printk("peer=[%s]:%s state=%s",
 992                 __get_str(addr), __get_str(port),
 993                 rpc_show_xprt_state(__entry->state))
 994 );
 995
 996 #define DEFINE_RPC_XPRT_LIFETIME_EVENT(name) \
 997         DEFINE_EVENT(rpc_xprt_lifetime_class, \
 998                         xprt_##name, \
 999                         TP_PROTO( \
1000                                 const struct rpc_xprt *xprt \
1001                         ), \
1002                         TP_ARGS(xprt))
1003
1004 DEFINE_RPC_XPRT_LIFETIME_EVENT(create);
1005 DEFINE_RPC_XPRT_LIFETIME_EVENT(connect);
1006 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto);
1007 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done);
1008 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force);
1009 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_cleanup);
1010 DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy);
1011
1012 DECLARE_EVENT_CLASS(rpc_xprt_event,
1013         TP_PROTO(
1014                 const struct rpc_xprt *xprt,
1015                 __be32 xid,
1016                 int status
1017         ),
1018
1019         TP_ARGS(xprt, xid, status),
1020
1021         TP_STRUCT__entry(
1022                 __field(u32, xid)
1023                 __field(int, status)
1024                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
1025                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
1026         ),
1027
1028         TP_fast_assign(
1029                 __entry->xid = be32_to_cpu(xid);
1030                 __entry->status = status;
1031                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1032                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1033         ),
1034
1035         TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
1036                         __get_str(port), __entry->xid,
1037                         __entry->status)
1038 );
1039 #define DEFINE_RPC_XPRT_EVENT(name) \
1040         DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
1041                         TP_PROTO( \
1042                                 const struct rpc_xprt *xprt, \
1043                                 __be32 xid, \
1044                                 int status \
1045                         ), \
1046                         TP_ARGS(xprt, xid, status))
1047
1048 DEFINE_RPC_XPRT_EVENT(timer);
1049 DEFINE_RPC_XPRT_EVENT(lookup_rqst);
1050
1051 TRACE_EVENT(xprt_transmit,
1052         TP_PROTO(
1053                 const struct rpc_rqst *rqst,
1054                 int status
1055         ),
1056
1057         TP_ARGS(rqst, status),
1058
1059         TP_STRUCT__entry(
1060                 __field(unsigned int, task_id)
1061                 __field(unsigned int, client_id)
1062                 __field(u32, xid)
1063                 __field(u32, seqno)
1064                 __field(int, status)
1065         ),
1066
1067         TP_fast_assign(
1068                 __entry->task_id = rqst->rq_task->tk_pid;
1069                 __entry->client_id = rqst->rq_task->tk_client ?
1070                         rqst->rq_task->tk_client->cl_clid : -1;
1071                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1072                 __entry->seqno = rqst->rq_seqno;
1073                 __entry->status = status;
1074         ),
1075
1076         TP_printk(
1077                 "task:%u@%u xid=0x%08x seqno=%u status=%d",
1078                 __entry->task_id, __entry->client_id, __entry->xid,
1079                 __entry->seqno, __entry->status)
1080 );
1081
1082 TRACE_EVENT(xprt_retransmit,
1083         TP_PROTO(
1084                 const struct rpc_rqst *rqst
1085         ),
1086
1087         TP_ARGS(rqst),
1088
1089         TP_STRUCT__entry(
1090                 __field(unsigned int, task_id)
1091                 __field(unsigned int, client_id)
1092                 __field(u32, xid)
1093                 __field(int, ntrans)
1094                 __field(int, version)
1095                 __string(progname,
1096                          rqst->rq_task->tk_client->cl_program->name)
1097                 __string(procedure,
1098                          rqst->rq_task->tk_msg.rpc_proc->p_name)
1099         ),
1100
1101         TP_fast_assign(
1102                 struct rpc_task *task = rqst->rq_task;
1103
1104                 __entry->task_id = task->tk_pid;
1105                 __entry->client_id = task->tk_client ?
1106                         task->tk_client->cl_clid : -1;
1107                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1108                 __entry->ntrans = rqst->rq_ntrans;
1109                 __assign_str(progname,
1110                              task->tk_client->cl_program->name)
1111                 __entry->version = task->tk_client->cl_vers;
1112                 __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
1113         ),
1114
1115         TP_printk(
1116                 "task:%u@%u xid=0x%08x %sv%d %s ntrans=%d",
1117                 __entry->task_id, __entry->client_id, __entry->xid,
1118                 __get_str(progname), __entry->version, __get_str(procedure),
1119                 __entry->ntrans)
1120 );
1121
1122 TRACE_EVENT(xprt_ping,
1123         TP_PROTO(const struct rpc_xprt *xprt, int status),
1124
1125         TP_ARGS(xprt, status),
1126
1127         TP_STRUCT__entry(
1128                 __field(int, status)
1129                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
1130                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
1131         ),
1132
1133         TP_fast_assign(
1134                 __entry->status = status;
1135                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1136                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1137         ),
1138
1139         TP_printk("peer=[%s]:%s status=%d",
1140                         __get_str(addr), __get_str(port), __entry->status)
1141 );
1142
1143 DECLARE_EVENT_CLASS(xprt_writelock_event,
1144         TP_PROTO(
1145                 const struct rpc_xprt *xprt, const struct rpc_task *task
1146         ),
1147
1148         TP_ARGS(xprt, task),
1149
1150         TP_STRUCT__entry(
1151                 __field(unsigned int, task_id)
1152                 __field(unsigned int, client_id)
1153                 __field(unsigned int, snd_task_id)
1154         ),
1155
1156         TP_fast_assign(
1157                 if (task) {
1158                         __entry->task_id = task->tk_pid;
1159                         __entry->client_id = task->tk_client ?
1160                                              task->tk_client->cl_clid : -1;
1161                 } else {
1162                         __entry->task_id = -1;
1163                         __entry->client_id = -1;
1164                 }
1165                 __entry->snd_task_id = xprt->snd_task ?
1166                                         xprt->snd_task->tk_pid : -1;
1167         ),
1168
1169         TP_printk("task:%u@%u snd_task:%u",
1170                         __entry->task_id, __entry->client_id,
1171                         __entry->snd_task_id)
1172 );
1173
1174 #define DEFINE_WRITELOCK_EVENT(name) \
1175         DEFINE_EVENT(xprt_writelock_event, xprt_##name, \
1176                         TP_PROTO( \
1177                                 const struct rpc_xprt *xprt, \
1178                                 const struct rpc_task *task \
1179                         ), \
1180                         TP_ARGS(xprt, task))
1181
1182 DEFINE_WRITELOCK_EVENT(reserve_xprt);
1183 DEFINE_WRITELOCK_EVENT(release_xprt);
1184
1185 DECLARE_EVENT_CLASS(xprt_cong_event,
1186         TP_PROTO(
1187                 const struct rpc_xprt *xprt, const struct rpc_task *task
1188         ),
1189
1190         TP_ARGS(xprt, task),
1191
1192         TP_STRUCT__entry(
1193                 __field(unsigned int, task_id)
1194                 __field(unsigned int, client_id)
1195                 __field(unsigned int, snd_task_id)
1196                 __field(unsigned long, cong)
1197                 __field(unsigned long, cwnd)
1198                 __field(bool, wait)
1199         ),
1200
1201         TP_fast_assign(
1202                 if (task) {
1203                         __entry->task_id = task->tk_pid;
1204                         __entry->client_id = task->tk_client ?
1205                                              task->tk_client->cl_clid : -1;
1206                 } else {
1207                         __entry->task_id = -1;
1208                         __entry->client_id = -1;
1209                 }
1210                 __entry->snd_task_id = xprt->snd_task ?
1211                                         xprt->snd_task->tk_pid : -1;
1212                 __entry->cong = xprt->cong;
1213                 __entry->cwnd = xprt->cwnd;
1214                 __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
1215         ),
1216
1217         TP_printk("task:%u@%u snd_task:%u cong=%lu cwnd=%lu%s",
1218                         __entry->task_id, __entry->client_id,
1219                         __entry->snd_task_id, __entry->cong, __entry->cwnd,
1220                         __entry->wait ? " (wait)" : "")
1221 );
1222
1223 #define DEFINE_CONG_EVENT(name) \
1224         DEFINE_EVENT(xprt_cong_event, xprt_##name, \
1225                         TP_PROTO( \
1226                                 const struct rpc_xprt *xprt, \
1227                                 const struct rpc_task *task \
1228                         ), \
1229                         TP_ARGS(xprt, task))
1230
1231 DEFINE_CONG_EVENT(reserve_cong);
1232 DEFINE_CONG_EVENT(release_cong);
1233 DEFINE_CONG_EVENT(get_cong);
1234 DEFINE_CONG_EVENT(put_cong);
1235
1236 TRACE_EVENT(xprt_reserve,
1237         TP_PROTO(
1238                 const struct rpc_rqst *rqst
1239         ),
1240
1241         TP_ARGS(rqst),
1242
1243         TP_STRUCT__entry(
1244                 __field(unsigned int, task_id)
1245                 __field(unsigned int, client_id)
1246                 __field(u32, xid)
1247         ),
1248
1249         TP_fast_assign(
1250                 __entry->task_id = rqst->rq_task->tk_pid;
1251                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
1252                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1253         ),
1254
1255         TP_printk("task:%u@%u xid=0x%08x",
1256                 __entry->task_id, __entry->client_id, __entry->xid
1257         )
1258 );
1259
1260 TRACE_EVENT(xs_stream_read_data,
1261         TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
1262
1263         TP_ARGS(xprt, err, total),
1264
1265         TP_STRUCT__entry(
1266                 __field(ssize_t, err)
1267                 __field(size_t, total)
1268                 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
1269                                 "(null)")
1270                 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
1271                                 "(null)")
1272         ),
1273
1274         TP_fast_assign(
1275                 __entry->err = err;
1276                 __entry->total = total;
1277                 __assign_str(addr, xprt ?
1278                         xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
1279                 __assign_str(port, xprt ?
1280                         xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
1281         ),
1282
1283         TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
1284                         __get_str(port), __entry->err, __entry->total)
1285 );
1286
1287 TRACE_EVENT(xs_stream_read_request,
1288         TP_PROTO(struct sock_xprt *xs),
1289
1290         TP_ARGS(xs),
1291
1292         TP_STRUCT__entry(
1293                 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
1294                 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
1295                 __field(u32, xid)
1296                 __field(unsigned long, copied)
1297                 __field(unsigned int, reclen)
1298                 __field(unsigned int, offset)
1299         ),
1300
1301         TP_fast_assign(
1302                 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
1303                 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
1304                 __entry->xid = be32_to_cpu(xs->recv.xid);
1305                 __entry->copied = xs->recv.copied;
1306                 __entry->reclen = xs->recv.len;
1307                 __entry->offset = xs->recv.offset;
1308         ),
1309
1310         TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
1311                         __get_str(addr), __get_str(port), __entry->xid,
1312                         __entry->copied, __entry->reclen, __entry->offset)
1313 );
1314
1315 TRACE_EVENT(rpcb_getport,
1316         TP_PROTO(
1317                 const struct rpc_clnt *clnt,
1318                 const struct rpc_task *task,
1319                 unsigned int bind_version
1320         ),
1321
1322         TP_ARGS(clnt, task, bind_version),
1323
1324         TP_STRUCT__entry(
1325                 __field(unsigned int, task_id)
1326                 __field(unsigned int, client_id)
1327                 __field(unsigned int, program)
1328                 __field(unsigned int, version)
1329                 __field(int, protocol)
1330                 __field(unsigned int, bind_version)
1331                 __string(servername, task->tk_xprt->servername)
1332         ),
1333
1334         TP_fast_assign(
1335                 __entry->task_id = task->tk_pid;
1336                 __entry->client_id = clnt->cl_clid;
1337                 __entry->program = clnt->cl_prog;
1338                 __entry->version = clnt->cl_vers;
1339                 __entry->protocol = task->tk_xprt->prot;
1340                 __entry->bind_version = bind_version;
1341                 __assign_str(servername, task->tk_xprt->servername);
1342         ),
1343
1344         TP_printk("task:%u@%u server=%s program=%u version=%u protocol=%d bind_version=%u",
1345                 __entry->task_id, __entry->client_id, __get_str(servername),
1346                 __entry->program, __entry->version, __entry->protocol,
1347                 __entry->bind_version
1348         )
1349 );
1350
1351 TRACE_EVENT(rpcb_setport,
1352         TP_PROTO(
1353                 const struct rpc_task *task,
1354                 int status,
1355                 unsigned short port
1356         ),
1357
1358         TP_ARGS(task, status, port),
1359
1360         TP_STRUCT__entry(
1361                 __field(unsigned int, task_id)
1362                 __field(unsigned int, client_id)
1363                 __field(int, status)
1364                 __field(unsigned short, port)
1365         ),
1366
1367         TP_fast_assign(
1368                 __entry->task_id = task->tk_pid;
1369                 __entry->client_id = task->tk_client->cl_clid;
1370                 __entry->status = status;
1371                 __entry->port = port;
1372         ),
1373
1374         TP_printk("task:%u@%u status=%d port=%u",
1375                 __entry->task_id, __entry->client_id,
1376                 __entry->status, __entry->port
1377         )
1378 );
1379
1380 TRACE_EVENT(pmap_register,
1381         TP_PROTO(
1382                 u32 program,
1383                 u32 version,
1384                 int protocol,
1385                 unsigned short port
1386         ),
1387
1388         TP_ARGS(program, version, protocol, port),
1389
1390         TP_STRUCT__entry(
1391                 __field(unsigned int, program)
1392                 __field(unsigned int, version)
1393                 __field(int, protocol)
1394                 __field(unsigned int, port)
1395         ),
1396
1397         TP_fast_assign(
1398                 __entry->program = program;
1399                 __entry->version = version;
1400                 __entry->protocol = protocol;
1401                 __entry->port = port;
1402         ),
1403
1404         TP_printk("program=%u version=%u protocol=%d port=%u",
1405                 __entry->program, __entry->version,
1406                 __entry->protocol, __entry->port
1407         )
1408 );
1409
1410 TRACE_EVENT(rpcb_register,
1411         TP_PROTO(
1412                 u32 program,
1413                 u32 version,
1414                 const char *addr,
1415                 const char *netid
1416         ),
1417
1418         TP_ARGS(program, version, addr, netid),
1419
1420         TP_STRUCT__entry(
1421                 __field(unsigned int, program)
1422                 __field(unsigned int, version)
1423                 __string(addr, addr)
1424                 __string(netid, netid)
1425         ),
1426
1427         TP_fast_assign(
1428                 __entry->program = program;
1429                 __entry->version = version;
1430                 __assign_str(addr, addr);
1431                 __assign_str(netid, netid);
1432         ),
1433
1434         TP_printk("program=%u version=%u addr=%s netid=%s",
1435                 __entry->program, __entry->version,
1436                 __get_str(addr), __get_str(netid)
1437         )
1438 );
1439
1440 TRACE_EVENT(rpcb_unregister,
1441         TP_PROTO(
1442                 u32 program,
1443                 u32 version,
1444                 const char *netid
1445         ),
1446
1447         TP_ARGS(program, version, netid),
1448
1449         TP_STRUCT__entry(
1450                 __field(unsigned int, program)
1451                 __field(unsigned int, version)
1452                 __string(netid, netid)
1453         ),
1454
1455         TP_fast_assign(
1456                 __entry->program = program;
1457                 __entry->version = version;
1458                 __assign_str(netid, netid);
1459         ),
1460
1461         TP_printk("program=%u version=%u netid=%s",
1462                 __entry->program, __entry->version, __get_str(netid)
1463         )
1464 );
1465
1466 /* Record an xdr_buf containing a fully-formed RPC message */
1467 DECLARE_EVENT_CLASS(svc_xdr_msg_class,
1468         TP_PROTO(
1469                 const struct xdr_buf *xdr
1470         ),
1471
1472         TP_ARGS(xdr),
1473
1474         TP_STRUCT__entry(
1475                 __field(u32, xid)
1476                 __field(const void *, head_base)
1477                 __field(size_t, head_len)
1478                 __field(const void *, tail_base)
1479                 __field(size_t, tail_len)
1480                 __field(unsigned int, page_len)
1481                 __field(unsigned int, msg_len)
1482         ),
1483
1484         TP_fast_assign(
1485                 __be32 *p = (__be32 *)xdr->head[0].iov_base;
1486
1487                 __entry->xid = be32_to_cpu(*p);
1488                 __entry->head_base = p;
1489                 __entry->head_len = xdr->head[0].iov_len;
1490                 __entry->tail_base = xdr->tail[0].iov_base;
1491                 __entry->tail_len = xdr->tail[0].iov_len;
1492                 __entry->page_len = xdr->page_len;
1493                 __entry->msg_len = xdr->len;
1494         ),
1495
1496         TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
1497                 __entry->xid,
1498                 __entry->head_base, __entry->head_len, __entry->page_len,
1499                 __entry->tail_base, __entry->tail_len, __entry->msg_len
1500         )
1501 );
1502
1503 #define DEFINE_SVCXDRMSG_EVENT(name)                                    \
1504                 DEFINE_EVENT(svc_xdr_msg_class,                         \
1505                                 svc_xdr_##name,                         \
1506                                 TP_PROTO(                               \
1507                                         const struct xdr_buf *xdr       \
1508                                 ),                                      \
1509                                 TP_ARGS(xdr))
1510
1511 DEFINE_SVCXDRMSG_EVENT(recvfrom);
1512
1513 /* Record an xdr_buf containing arbitrary data, tagged with an XID */
1514 DECLARE_EVENT_CLASS(svc_xdr_buf_class,
1515         TP_PROTO(
1516                 __be32 xid,
1517                 const struct xdr_buf *xdr
1518         ),
1519
1520         TP_ARGS(xid, xdr),
1521
1522         TP_STRUCT__entry(
1523                 __field(u32, xid)
1524                 __field(const void *, head_base)
1525                 __field(size_t, head_len)
1526                 __field(const void *, tail_base)
1527                 __field(size_t, tail_len)
1528                 __field(unsigned int, page_len)
1529                 __field(unsigned int, msg_len)
1530         ),
1531
1532         TP_fast_assign(
1533                 __entry->xid = be32_to_cpu(xid);
1534                 __entry->head_base = xdr->head[0].iov_base;
1535                 __entry->head_len = xdr->head[0].iov_len;
1536                 __entry->tail_base = xdr->tail[0].iov_base;
1537                 __entry->tail_len = xdr->tail[0].iov_len;
1538                 __entry->page_len = xdr->page_len;
1539                 __entry->msg_len = xdr->len;
1540         ),
1541
1542         TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
1543                 __entry->xid,
1544                 __entry->head_base, __entry->head_len, __entry->page_len,
1545                 __entry->tail_base, __entry->tail_len, __entry->msg_len
1546         )
1547 );
1548
1549 #define DEFINE_SVCXDRBUF_EVENT(name)                                    \
1550                 DEFINE_EVENT(svc_xdr_buf_class,                         \
1551                                 svc_xdr_##name,                         \
1552                                 TP_PROTO(                               \
1553                                         __be32 xid,                     \
1554                                         const struct xdr_buf *xdr       \
1555                                 ),                                      \
1556                                 TP_ARGS(xid, xdr))
1557
1558 DEFINE_SVCXDRBUF_EVENT(sendto);
1559
1560 /*
1561  * from include/linux/sunrpc/svc.h
1562  */
1563 #define SVC_RQST_FLAG_LIST                                              \
1564         svc_rqst_flag(SECURE)                                           \
1565         svc_rqst_flag(LOCAL)                                            \
1566         svc_rqst_flag(USEDEFERRAL)                                      \
1567         svc_rqst_flag(DROPME)                                           \
1568         svc_rqst_flag(SPLICE_OK)                                        \
1569         svc_rqst_flag(VICTIM)                                           \
1570         svc_rqst_flag(BUSY)                                             \
1571         svc_rqst_flag(DATA)                                             \
1572         svc_rqst_flag_end(AUTHERR)
1573
1574 #undef svc_rqst_flag
1575 #undef svc_rqst_flag_end
1576 #define svc_rqst_flag(x)        TRACE_DEFINE_ENUM(RQ_##x);
1577 #define svc_rqst_flag_end(x)    TRACE_DEFINE_ENUM(RQ_##x);
1578
1579 SVC_RQST_FLAG_LIST
1580
1581 #undef svc_rqst_flag
1582 #undef svc_rqst_flag_end
1583 #define svc_rqst_flag(x)        { BIT(RQ_##x), #x },
1584 #define svc_rqst_flag_end(x)    { BIT(RQ_##x), #x }
1585
1586 #define show_rqstp_flags(flags)                                         \
1587                 __print_flags(flags, "|", SVC_RQST_FLAG_LIST)
1588
1589 TRACE_DEFINE_ENUM(SVC_GARBAGE);
1590 TRACE_DEFINE_ENUM(SVC_SYSERR);
1591 TRACE_DEFINE_ENUM(SVC_VALID);
1592 TRACE_DEFINE_ENUM(SVC_NEGATIVE);
1593 TRACE_DEFINE_ENUM(SVC_OK);
1594 TRACE_DEFINE_ENUM(SVC_DROP);
1595 TRACE_DEFINE_ENUM(SVC_CLOSE);
1596 TRACE_DEFINE_ENUM(SVC_DENIED);
1597 TRACE_DEFINE_ENUM(SVC_PENDING);
1598 TRACE_DEFINE_ENUM(SVC_COMPLETE);
1599
1600 #define svc_show_status(status)                         \
1601         __print_symbolic(status,                        \
1602                 { SVC_GARBAGE,  "SVC_GARBAGE" },        \
1603                 { SVC_SYSERR,   "SVC_SYSERR" },         \
1604                 { SVC_VALID,    "SVC_VALID" },          \
1605                 { SVC_NEGATIVE, "SVC_NEGATIVE" },       \
1606                 { SVC_OK,       "SVC_OK" },             \
1607                 { SVC_DROP,     "SVC_DROP" },           \
1608                 { SVC_CLOSE,    "SVC_CLOSE" },          \
1609                 { SVC_DENIED,   "SVC_DENIED" },         \
1610                 { SVC_PENDING,  "SVC_PENDING" },        \
1611                 { SVC_COMPLETE, "SVC_COMPLETE" })
1612
1613 TRACE_EVENT(svc_authenticate,
1614         TP_PROTO(const struct svc_rqst *rqst, int auth_res, __be32 auth_stat),
1615
1616         TP_ARGS(rqst, auth_res, auth_stat),
1617
1618         TP_STRUCT__entry(
1619                 __field(u32, xid)
1620                 __field(unsigned long, svc_status)
1621                 __field(unsigned long, auth_stat)
1622         ),
1623
1624         TP_fast_assign(
1625                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1626                 __entry->svc_status = auth_res;
1627                 __entry->auth_stat = be32_to_cpu(auth_stat);
1628         ),
1629
1630         TP_printk("xid=0x%08x auth_res=%s auth_stat=%s",
1631                         __entry->xid, svc_show_status(__entry->svc_status),
1632                         rpc_show_auth_stat(__entry->auth_stat))
1633 );
1634
1635 TRACE_EVENT(svc_process,
1636         TP_PROTO(const struct svc_rqst *rqst, const char *name),
1637
1638         TP_ARGS(rqst, name),
1639
1640         TP_STRUCT__entry(
1641                 __field(u32, xid)
1642                 __field(u32, vers)
1643                 __field(u32, proc)
1644                 __string(service, name)
1645                 __string(procedure, rqst->rq_procinfo->pc_name)
1646                 __string(addr, rqst->rq_xprt ?
1647                          rqst->rq_xprt->xpt_remotebuf : "(null)")
1648         ),
1649
1650         TP_fast_assign(
1651                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1652                 __entry->vers = rqst->rq_vers;
1653                 __entry->proc = rqst->rq_proc;
1654                 __assign_str(service, name);
1655                 __assign_str(procedure, rqst->rq_procinfo->pc_name);
1656                 __assign_str(addr, rqst->rq_xprt ?
1657                              rqst->rq_xprt->xpt_remotebuf : "(null)");
1658         ),
1659
1660         TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%s",
1661                         __get_str(addr), __entry->xid,
1662                         __get_str(service), __entry->vers,
1663                         __get_str(procedure)
1664         )
1665 );
1666
1667 DECLARE_EVENT_CLASS(svc_rqst_event,
1668
1669         TP_PROTO(
1670                 const struct svc_rqst *rqst
1671         ),
1672
1673         TP_ARGS(rqst),
1674
1675         TP_STRUCT__entry(
1676                 __field(u32, xid)
1677                 __field(unsigned long, flags)
1678                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1679         ),
1680
1681         TP_fast_assign(
1682                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1683                 __entry->flags = rqst->rq_flags;
1684                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1685         ),
1686
1687         TP_printk("addr=%s xid=0x%08x flags=%s",
1688                         __get_str(addr), __entry->xid,
1689                         show_rqstp_flags(__entry->flags))
1690 );
1691 #define DEFINE_SVC_RQST_EVENT(name) \
1692         DEFINE_EVENT(svc_rqst_event, svc_##name, \
1693                         TP_PROTO( \
1694                                 const struct svc_rqst *rqst \
1695                         ), \
1696                         TP_ARGS(rqst))
1697
1698 DEFINE_SVC_RQST_EVENT(defer);
1699 DEFINE_SVC_RQST_EVENT(drop);
1700
1701 DECLARE_EVENT_CLASS(svc_rqst_status,
1702
1703         TP_PROTO(struct svc_rqst *rqst, int status),
1704
1705         TP_ARGS(rqst, status),
1706
1707         TP_STRUCT__entry(
1708                 __field(u32, xid)
1709                 __field(int, status)
1710                 __field(unsigned long, flags)
1711                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1712         ),
1713
1714         TP_fast_assign(
1715                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1716                 __entry->status = status;
1717                 __entry->flags = rqst->rq_flags;
1718                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1719         ),
1720
1721         TP_printk("addr=%s xid=0x%08x status=%d flags=%s",
1722                   __get_str(addr), __entry->xid,
1723                   __entry->status, show_rqstp_flags(__entry->flags))
1724 );
1725
1726 DEFINE_EVENT(svc_rqst_status, svc_send,
1727         TP_PROTO(struct svc_rqst *rqst, int status),
1728         TP_ARGS(rqst, status));
1729
1730 #define show_svc_xprt_flags(flags)                                      \
1731         __print_flags(flags, "|",                                       \
1732                 { (1UL << XPT_BUSY),            "XPT_BUSY"},            \
1733                 { (1UL << XPT_CONN),            "XPT_CONN"},            \
1734                 { (1UL << XPT_CLOSE),           "XPT_CLOSE"},           \
1735                 { (1UL << XPT_DATA),            "XPT_DATA"},            \
1736                 { (1UL << XPT_TEMP),            "XPT_TEMP"},            \
1737                 { (1UL << XPT_DEAD),            "XPT_DEAD"},            \
1738                 { (1UL << XPT_CHNGBUF),         "XPT_CHNGBUF"},         \
1739                 { (1UL << XPT_DEFERRED),        "XPT_DEFERRED"},        \
1740                 { (1UL << XPT_OLD),             "XPT_OLD"},             \
1741                 { (1UL << XPT_LISTENER),        "XPT_LISTENER"},        \
1742                 { (1UL << XPT_CACHE_AUTH),      "XPT_CACHE_AUTH"},      \
1743                 { (1UL << XPT_LOCAL),           "XPT_LOCAL"},           \
1744                 { (1UL << XPT_KILL_TEMP),       "XPT_KILL_TEMP"},       \
1745                 { (1UL << XPT_CONG_CTRL),       "XPT_CONG_CTRL"})
1746
1747 TRACE_EVENT(svc_xprt_create_err,
1748         TP_PROTO(
1749                 const char *program,
1750                 const char *protocol,
1751                 struct sockaddr *sap,
1752                 const struct svc_xprt *xprt
1753         ),
1754
1755         TP_ARGS(program, protocol, sap, xprt),
1756
1757         TP_STRUCT__entry(
1758                 __field(long, error)
1759                 __string(program, program)
1760                 __string(protocol, protocol)
1761                 __array(unsigned char, addr, sizeof(struct sockaddr_in6))
1762         ),
1763
1764         TP_fast_assign(
1765                 __entry->error = PTR_ERR(xprt);
1766                 __assign_str(program, program);
1767                 __assign_str(protocol, protocol);
1768                 memcpy(__entry->addr, sap, sizeof(__entry->addr));
1769         ),
1770
1771         TP_printk("addr=%pISpc program=%s protocol=%s error=%ld",
1772                 __entry->addr, __get_str(program), __get_str(protocol),
1773                 __entry->error)
1774 );
1775
1776 TRACE_EVENT(svc_xprt_do_enqueue,
1777         TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
1778
1779         TP_ARGS(xprt, rqst),
1780
1781         TP_STRUCT__entry(
1782                 __field(int, pid)
1783                 __field(unsigned long, flags)
1784                 __string(addr, xprt->xpt_remotebuf)
1785         ),
1786
1787         TP_fast_assign(
1788                 __entry->pid = rqst? rqst->rq_task->pid : 0;
1789                 __entry->flags = xprt->xpt_flags;
1790                 __assign_str(addr, xprt->xpt_remotebuf);
1791         ),
1792
1793         TP_printk("addr=%s pid=%d flags=%s", __get_str(addr),
1794                 __entry->pid, show_svc_xprt_flags(__entry->flags))
1795 );
1796
1797 DECLARE_EVENT_CLASS(svc_xprt_event,
1798         TP_PROTO(struct svc_xprt *xprt),
1799
1800         TP_ARGS(xprt),
1801
1802         TP_STRUCT__entry(
1803                 __field(unsigned long, flags)
1804                 __string(addr, xprt->xpt_remotebuf)
1805         ),
1806
1807         TP_fast_assign(
1808                 __entry->flags = xprt->xpt_flags;
1809                 __assign_str(addr, xprt->xpt_remotebuf);
1810         ),
1811
1812         TP_printk("addr=%s flags=%s", __get_str(addr),
1813                 show_svc_xprt_flags(__entry->flags))
1814 );
1815
1816 #define DEFINE_SVC_XPRT_EVENT(name) \
1817         DEFINE_EVENT(svc_xprt_event, svc_xprt_##name, \
1818                         TP_PROTO( \
1819                                 struct svc_xprt *xprt \
1820                         ), \
1821                         TP_ARGS(xprt))
1822
1823 DEFINE_SVC_XPRT_EVENT(received);
1824 DEFINE_SVC_XPRT_EVENT(no_write_space);
1825 DEFINE_SVC_XPRT_EVENT(close);
1826 DEFINE_SVC_XPRT_EVENT(detach);
1827 DEFINE_SVC_XPRT_EVENT(free);
1828
1829 TRACE_EVENT(svc_xprt_accept,
1830         TP_PROTO(
1831                 const struct svc_xprt *xprt,
1832                 const char *service
1833         ),
1834
1835         TP_ARGS(xprt, service),
1836
1837         TP_STRUCT__entry(
1838                 __string(addr, xprt->xpt_remotebuf)
1839                 __string(protocol, xprt->xpt_class->xcl_name)
1840                 __string(service, service)
1841         ),
1842
1843         TP_fast_assign(
1844                 __assign_str(addr, xprt->xpt_remotebuf);
1845                 __assign_str(protocol, xprt->xpt_class->xcl_name)
1846                 __assign_str(service, service);
1847         ),
1848
1849         TP_printk("addr=%s protocol=%s service=%s",
1850                 __get_str(addr), __get_str(protocol), __get_str(service)
1851         )
1852 );
1853
1854 TRACE_EVENT(svc_xprt_dequeue,
1855         TP_PROTO(struct svc_rqst *rqst),
1856
1857         TP_ARGS(rqst),
1858
1859         TP_STRUCT__entry(
1860                 __field(unsigned long, flags)
1861                 __field(unsigned long, wakeup)
1862                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1863         ),
1864
1865         TP_fast_assign(
1866                 __entry->flags = rqst->rq_xprt->xpt_flags;
1867                 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
1868                                                         rqst->rq_qtime));
1869                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1870         ),
1871
1872         TP_printk("addr=%s flags=%s wakeup-us=%lu", __get_str(addr),
1873                 show_svc_xprt_flags(__entry->flags), __entry->wakeup)
1874 );
1875
1876 TRACE_EVENT(svc_wake_up,
1877         TP_PROTO(int pid),
1878
1879         TP_ARGS(pid),
1880
1881         TP_STRUCT__entry(
1882                 __field(int, pid)
1883         ),
1884
1885         TP_fast_assign(
1886                 __entry->pid = pid;
1887         ),
1888
1889         TP_printk("pid=%d", __entry->pid)
1890 );
1891
1892 TRACE_EVENT(svc_handle_xprt,
1893         TP_PROTO(struct svc_xprt *xprt, int len),
1894
1895         TP_ARGS(xprt, len),
1896
1897         TP_STRUCT__entry(
1898                 __field(int, len)
1899                 __field(unsigned long, flags)
1900                 __string(addr, xprt->xpt_remotebuf)
1901         ),
1902
1903         TP_fast_assign(
1904                 __entry->len = len;
1905                 __entry->flags = xprt->xpt_flags;
1906                 __assign_str(addr, xprt->xpt_remotebuf);
1907         ),
1908
1909         TP_printk("addr=%s len=%d flags=%s", __get_str(addr),
1910                 __entry->len, show_svc_xprt_flags(__entry->flags))
1911 );
1912
1913 TRACE_EVENT(svc_stats_latency,
1914         TP_PROTO(const struct svc_rqst *rqst),
1915
1916         TP_ARGS(rqst),
1917
1918         TP_STRUCT__entry(
1919                 __field(u32, xid)
1920                 __field(unsigned long, execute)
1921                 __string(procedure, rqst->rq_procinfo->pc_name)
1922                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1923         ),
1924
1925         TP_fast_assign(
1926                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1927                 __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
1928                                                          rqst->rq_stime));
1929                 __assign_str(procedure, rqst->rq_procinfo->pc_name);
1930                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1931         ),
1932
1933         TP_printk("addr=%s xid=0x%08x proc=%s execute-us=%lu",
1934                 __get_str(addr), __entry->xid, __get_str(procedure),
1935                 __entry->execute)
1936 );
1937
1938 DECLARE_EVENT_CLASS(svc_deferred_event,
1939         TP_PROTO(
1940                 const struct svc_deferred_req *dr
1941         ),
1942
1943         TP_ARGS(dr),
1944
1945         TP_STRUCT__entry(
1946                 __field(const void *, dr)
1947                 __field(u32, xid)
1948                 __string(addr, dr->xprt->xpt_remotebuf)
1949         ),
1950
1951         TP_fast_assign(
1952                 __entry->dr = dr;
1953                 __entry->xid = be32_to_cpu(*(__be32 *)(dr->args +
1954                                                        (dr->xprt_hlen>>2)));
1955                 __assign_str(addr, dr->xprt->xpt_remotebuf);
1956         ),
1957
1958         TP_printk("addr=%s dr=%p xid=0x%08x", __get_str(addr), __entry->dr,
1959                 __entry->xid)
1960 );
1961
1962 #define DEFINE_SVC_DEFERRED_EVENT(name) \
1963         DEFINE_EVENT(svc_deferred_event, svc_defer_##name, \
1964                         TP_PROTO( \
1965                                 const struct svc_deferred_req *dr \
1966                         ), \
1967                         TP_ARGS(dr))
1968
1969 DEFINE_SVC_DEFERRED_EVENT(drop);
1970 DEFINE_SVC_DEFERRED_EVENT(queue);
1971 DEFINE_SVC_DEFERRED_EVENT(recv);
1972
1973 TRACE_EVENT(svcsock_new_socket,
1974         TP_PROTO(
1975                 const struct socket *socket
1976         ),
1977
1978         TP_ARGS(socket),
1979
1980         TP_STRUCT__entry(
1981                 __field(unsigned long, type)
1982                 __field(unsigned long, family)
1983                 __field(bool, listener)
1984         ),
1985
1986         TP_fast_assign(
1987                 __entry->type = socket->type;
1988                 __entry->family = socket->sk->sk_family;
1989                 __entry->listener = (socket->sk->sk_state == TCP_LISTEN);
1990         ),
1991
1992         TP_printk("type=%s family=%s%s",
1993                 show_socket_type(__entry->type),
1994                 rpc_show_address_family(__entry->family),
1995                 __entry->listener ? " (listener)" : ""
1996         )
1997 );
1998
1999 TRACE_EVENT(svcsock_marker,
2000         TP_PROTO(
2001                 const struct svc_xprt *xprt,
2002                 __be32 marker
2003         ),
2004
2005         TP_ARGS(xprt, marker),
2006
2007         TP_STRUCT__entry(
2008                 __field(unsigned int, length)
2009                 __field(bool, last)
2010                 __string(addr, xprt->xpt_remotebuf)
2011         ),
2012
2013         TP_fast_assign(
2014                 __entry->length = be32_to_cpu(marker) & RPC_FRAGMENT_SIZE_MASK;
2015                 __entry->last = be32_to_cpu(marker) & RPC_LAST_STREAM_FRAGMENT;
2016                 __assign_str(addr, xprt->xpt_remotebuf);
2017         ),
2018
2019         TP_printk("addr=%s length=%u%s", __get_str(addr),
2020                 __entry->length, __entry->last ? " (last)" : "")
2021 );
2022
2023 DECLARE_EVENT_CLASS(svcsock_class,
2024         TP_PROTO(
2025                 const struct svc_xprt *xprt,
2026                 ssize_t result
2027         ),
2028
2029         TP_ARGS(xprt, result),
2030
2031         TP_STRUCT__entry(
2032                 __field(ssize_t, result)
2033                 __field(unsigned long, flags)
2034                 __string(addr, xprt->xpt_remotebuf)
2035         ),
2036
2037         TP_fast_assign(
2038                 __entry->result = result;
2039                 __entry->flags = xprt->xpt_flags;
2040                 __assign_str(addr, xprt->xpt_remotebuf);
2041         ),
2042
2043         TP_printk("addr=%s result=%zd flags=%s", __get_str(addr),
2044                 __entry->result, show_svc_xprt_flags(__entry->flags)
2045         )
2046 );
2047
2048 #define DEFINE_SVCSOCK_EVENT(name) \
2049         DEFINE_EVENT(svcsock_class, svcsock_##name, \
2050                         TP_PROTO( \
2051                                 const struct svc_xprt *xprt, \
2052                                 ssize_t result \
2053                         ), \
2054                         TP_ARGS(xprt, result))
2055
2056 DEFINE_SVCSOCK_EVENT(udp_send);
2057 DEFINE_SVCSOCK_EVENT(udp_recv);
2058 DEFINE_SVCSOCK_EVENT(udp_recv_err);
2059 DEFINE_SVCSOCK_EVENT(tcp_send);
2060 DEFINE_SVCSOCK_EVENT(tcp_recv);
2061 DEFINE_SVCSOCK_EVENT(tcp_recv_eagain);
2062 DEFINE_SVCSOCK_EVENT(tcp_recv_err);
2063 DEFINE_SVCSOCK_EVENT(data_ready);
2064 DEFINE_SVCSOCK_EVENT(write_space);
2065
2066 TRACE_EVENT(svcsock_tcp_recv_short,
2067         TP_PROTO(
2068                 const struct svc_xprt *xprt,
2069                 u32 expected,
2070                 u32 received
2071         ),
2072
2073         TP_ARGS(xprt, expected, received),
2074
2075         TP_STRUCT__entry(
2076                 __field(u32, expected)
2077                 __field(u32, received)
2078                 __field(unsigned long, flags)
2079                 __string(addr, xprt->xpt_remotebuf)
2080         ),
2081
2082         TP_fast_assign(
2083                 __entry->expected = expected;
2084                 __entry->received = received;
2085                 __entry->flags = xprt->xpt_flags;
2086                 __assign_str(addr, xprt->xpt_remotebuf);
2087         ),
2088
2089         TP_printk("addr=%s flags=%s expected=%u received=%u",
2090                 __get_str(addr), show_svc_xprt_flags(__entry->flags),
2091                 __entry->expected, __entry->received
2092         )
2093 );
2094
2095 TRACE_EVENT(svcsock_tcp_state,
2096         TP_PROTO(
2097                 const struct svc_xprt *xprt,
2098                 const struct socket *socket
2099         ),
2100
2101         TP_ARGS(xprt, socket),
2102
2103         TP_STRUCT__entry(
2104                 __field(unsigned long, socket_state)
2105                 __field(unsigned long, sock_state)
2106                 __field(unsigned long, flags)
2107                 __string(addr, xprt->xpt_remotebuf)
2108         ),
2109
2110         TP_fast_assign(
2111                 __entry->socket_state = socket->state;
2112                 __entry->sock_state = socket->sk->sk_state;
2113                 __entry->flags = xprt->xpt_flags;
2114                 __assign_str(addr, xprt->xpt_remotebuf);
2115         ),
2116
2117         TP_printk("addr=%s state=%s sk_state=%s flags=%s", __get_str(addr),
2118                 rpc_show_socket_state(__entry->socket_state),
2119                 rpc_show_sock_state(__entry->sock_state),
2120                 show_svc_xprt_flags(__entry->flags)
2121         )
2122 );
2123
2124 DECLARE_EVENT_CLASS(svcsock_accept_class,
2125         TP_PROTO(
2126                 const struct svc_xprt *xprt,
2127                 const char *service,
2128                 long status
2129         ),
2130
2131         TP_ARGS(xprt, service, status),
2132
2133         TP_STRUCT__entry(
2134                 __field(long, status)
2135                 __string(service, service)
2136                 __array(unsigned char, addr, sizeof(struct sockaddr_in6))
2137         ),
2138
2139         TP_fast_assign(
2140                 __entry->status = status;
2141                 __assign_str(service, service);
2142                 memcpy(__entry->addr, &xprt->xpt_local, sizeof(__entry->addr));
2143         ),
2144
2145         TP_printk("listener=%pISpc service=%s status=%ld",
2146                 __entry->addr, __get_str(service), __entry->status
2147         )
2148 );
2149
2150 #define DEFINE_ACCEPT_EVENT(name) \
2151         DEFINE_EVENT(svcsock_accept_class, svcsock_##name##_err, \
2152                         TP_PROTO( \
2153                                 const struct svc_xprt *xprt, \
2154                                 const char *service, \
2155                                 long status \
2156                         ), \
2157                         TP_ARGS(xprt, service, status))
2158
2159 DEFINE_ACCEPT_EVENT(accept);
2160 DEFINE_ACCEPT_EVENT(getpeername);
2161
2162 DECLARE_EVENT_CLASS(cache_event,
2163         TP_PROTO(
2164                 const struct cache_detail *cd,
2165                 const struct cache_head *h
2166         ),
2167
2168         TP_ARGS(cd, h),
2169
2170         TP_STRUCT__entry(
2171                 __field(const struct cache_head *, h)
2172                 __string(name, cd->name)
2173         ),
2174
2175         TP_fast_assign(
2176                 __entry->h = h;
2177                 __assign_str(name, cd->name);
2178         ),
2179
2180         TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)
2181 );
2182 #define DEFINE_CACHE_EVENT(name) \
2183         DEFINE_EVENT(cache_event, name, \
2184                         TP_PROTO( \
2185                                 const struct cache_detail *cd, \
2186                                 const struct cache_head *h \
2187                         ), \
2188                         TP_ARGS(cd, h))
2189 DEFINE_CACHE_EVENT(cache_entry_expired);
2190 DEFINE_CACHE_EVENT(cache_entry_upcall);
2191 DEFINE_CACHE_EVENT(cache_entry_update);
2192 DEFINE_CACHE_EVENT(cache_entry_make_negative);
2193 DEFINE_CACHE_EVENT(cache_entry_no_listener);
2194
2195 DECLARE_EVENT_CLASS(register_class,
2196         TP_PROTO(
2197                 const char *program,
2198                 const u32 version,
2199                 const int family,
2200                 const unsigned short protocol,
2201                 const unsigned short port,
2202                 int error
2203         ),
2204
2205         TP_ARGS(program, version, family, protocol, port, error),
2206
2207         TP_STRUCT__entry(
2208                 __field(u32, version)
2209                 __field(unsigned long, family)
2210                 __field(unsigned short, protocol)
2211                 __field(unsigned short, port)
2212                 __field(int, error)
2213                 __string(program, program)
2214         ),
2215
2216         TP_fast_assign(
2217                 __entry->version = version;
2218                 __entry->family = family;
2219                 __entry->protocol = protocol;
2220                 __entry->port = port;
2221                 __entry->error = error;
2222                 __assign_str(program, program);
2223         ),
2224
2225         TP_printk("program=%sv%u proto=%s port=%u family=%s error=%d",
2226                 __get_str(program), __entry->version,
2227                 __entry->protocol == IPPROTO_UDP ? "udp" : "tcp",
2228                 __entry->port, rpc_show_address_family(__entry->family),
2229                 __entry->error
2230         )
2231 );
2232
2233 #define DEFINE_REGISTER_EVENT(name) \
2234         DEFINE_EVENT(register_class, svc_##name, \
2235                         TP_PROTO( \
2236                                 const char *program, \
2237                                 const u32 version, \
2238                                 const int family, \
2239                                 const unsigned short protocol, \
2240                                 const unsigned short port, \
2241                                 int error \
2242                         ), \
2243                         TP_ARGS(program, version, family, protocol, \
2244                                 port, error))
2245
2246 DEFINE_REGISTER_EVENT(register);
2247 DEFINE_REGISTER_EVENT(noregister);
2248
2249 TRACE_EVENT(svc_unregister,
2250         TP_PROTO(
2251                 const char *program,
2252                 const u32 version,
2253                 int error
2254         ),
2255
2256         TP_ARGS(program, version, error),
2257
2258         TP_STRUCT__entry(
2259                 __field(u32, version)
2260                 __field(int, error)
2261                 __string(program, program)
2262         ),
2263
2264         TP_fast_assign(
2265                 __entry->version = version;
2266                 __entry->error = error;
2267                 __assign_str(program, program);
2268         ),
2269
2270         TP_printk("program=%sv%u error=%d",
2271                 __get_str(program), __entry->version, __entry->error
2272         )
2273 );
2274
2275 #endif /* _TRACE_SUNRPC_H */
2276
2277 #include <trace/define_trace.h>