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