include/trace/events/sunrpc.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #undef TRACE_SYSTEM
   3 #define TRACE_SYSTEM sunrpc
   4
   5 #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
   6 #define _TRACE_SUNRPC_H
   7
   8 #include <linux/sunrpc/sched.h>
   9 #include <linux/sunrpc/clnt.h>
  10 #include <linux/sunrpc/svc.h>
  11 #include <linux/sunrpc/xprtsock.h>
  12 #include <linux/sunrpc/svc_xprt.h>
  13 #include <net/tcp_states.h>
  14 #include <linux/net.h>
  15 #include <linux/tracepoint.h>
  16
  17 DECLARE_EVENT_CLASS(rpc_task_status,
  18
  19         TP_PROTO(const struct rpc_task *task),
  20
  21         TP_ARGS(task),
  22
  23         TP_STRUCT__entry(
  24                 __field(unsigned int, task_id)
  25                 __field(unsigned int, client_id)
  26                 __field(int, status)
  27         ),
  28
  29         TP_fast_assign(
  30                 __entry->task_id = task->tk_pid;
  31                 __entry->client_id = task->tk_client->cl_clid;
  32                 __entry->status = task->tk_status;
  33         ),
  34
  35         TP_printk("task:%u@%u status=%d",
  36                 __entry->task_id, __entry->client_id,
  37                 __entry->status)
  38 );
  39 #define DEFINE_RPC_STATUS_EVENT(name) \
  40         DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
  41                         TP_PROTO( \
  42                                 const struct rpc_task *task \
  43                         ), \
  44                         TP_ARGS(task))
  45
  46 DEFINE_RPC_STATUS_EVENT(call);
  47 DEFINE_RPC_STATUS_EVENT(bind);
  48 DEFINE_RPC_STATUS_EVENT(connect);
  49
  50 TRACE_EVENT(rpc_request,
  51         TP_PROTO(const struct rpc_task *task),
  52
  53         TP_ARGS(task),
  54
  55         TP_STRUCT__entry(
  56                 __field(unsigned int, task_id)
  57                 __field(unsigned int, client_id)
  58                 __field(int, version)
  59                 __field(bool, async)
  60                 __string(progname, task->tk_client->cl_program->name)
  61                 __string(procname, rpc_proc_name(task))
  62         ),
  63
  64         TP_fast_assign(
  65                 __entry->task_id = task->tk_pid;
  66                 __entry->client_id = task->tk_client->cl_clid;
  67                 __entry->version = task->tk_client->cl_vers;
  68                 __entry->async = RPC_IS_ASYNC(task);
  69                 __assign_str(progname, task->tk_client->cl_program->name)
  70                 __assign_str(procname, rpc_proc_name(task))
  71         ),
  72
  73         TP_printk("task:%u@%u %sv%d %s (%ssync)",
  74                 __entry->task_id, __entry->client_id,
  75                 __get_str(progname), __entry->version,
  76                 __get_str(procname), __entry->async ? "a": ""
  77                 )
  78 );
  79
  80 TRACE_DEFINE_ENUM(RPC_TASK_ASYNC);
  81 TRACE_DEFINE_ENUM(RPC_TASK_SWAPPER);
  82 TRACE_DEFINE_ENUM(RPC_CALL_MAJORSEEN);
  83 TRACE_DEFINE_ENUM(RPC_TASK_ROOTCREDS);
  84 TRACE_DEFINE_ENUM(RPC_TASK_DYNAMIC);
  85 TRACE_DEFINE_ENUM(RPC_TASK_KILLED);
  86 TRACE_DEFINE_ENUM(RPC_TASK_SOFT);
  87 TRACE_DEFINE_ENUM(RPC_TASK_SOFTCONN);
  88 TRACE_DEFINE_ENUM(RPC_TASK_SENT);
  89 TRACE_DEFINE_ENUM(RPC_TASK_TIMEOUT);
  90 TRACE_DEFINE_ENUM(RPC_TASK_NOCONNECT);
  91 TRACE_DEFINE_ENUM(RPC_TASK_NO_RETRANS_TIMEOUT);
  92
  93 #define rpc_show_task_flags(flags)                                      \
  94         __print_flags(flags, "|",                                       \
  95                 { RPC_TASK_ASYNC, "ASYNC" },                            \
  96                 { RPC_TASK_SWAPPER, "SWAPPER" },                        \
  97                 { RPC_CALL_MAJORSEEN, "MAJORSEEN" },                    \
  98                 { RPC_TASK_ROOTCREDS, "ROOTCREDS" },                    \
  99                 { RPC_TASK_DYNAMIC, "DYNAMIC" },                        \
 100                 { RPC_TASK_KILLED, "KILLED" },                          \
 101                 { RPC_TASK_SOFT, "SOFT" },                              \
 102                 { RPC_TASK_SOFTCONN, "SOFTCONN" },                      \
 103                 { RPC_TASK_SENT, "SENT" },                              \
 104                 { RPC_TASK_TIMEOUT, "TIMEOUT" },                        \
 105                 { RPC_TASK_NOCONNECT, "NOCONNECT" },                    \
 106                 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" })
 107
 108 TRACE_DEFINE_ENUM(RPC_TASK_RUNNING);
 109 TRACE_DEFINE_ENUM(RPC_TASK_QUEUED);
 110 TRACE_DEFINE_ENUM(RPC_TASK_ACTIVE);
 111 TRACE_DEFINE_ENUM(RPC_TASK_NEED_XMIT);
 112 TRACE_DEFINE_ENUM(RPC_TASK_NEED_RECV);
 113 TRACE_DEFINE_ENUM(RPC_TASK_MSG_PIN_WAIT);
 114
 115 #define rpc_show_runstate(flags)                                        \
 116         __print_flags(flags, "|",                                       \
 117                 { (1UL << RPC_TASK_RUNNING), "RUNNING" },               \
 118                 { (1UL << RPC_TASK_QUEUED), "QUEUED" },                 \
 119                 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" },                 \
 120                 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" },           \
 121                 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" },           \
 122                 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" })
 123
 124 DECLARE_EVENT_CLASS(rpc_task_running,
 125
 126         TP_PROTO(const struct rpc_task *task, const void *action),
 127
 128         TP_ARGS(task, action),
 129
 130         TP_STRUCT__entry(
 131                 __field(unsigned int, task_id)
 132                 __field(unsigned int, client_id)
 133                 __field(const void *, action)
 134                 __field(unsigned long, runstate)
 135                 __field(int, status)
 136                 __field(unsigned short, flags)
 137                 ),
 138
 139         TP_fast_assign(
 140                 __entry->client_id = task->tk_client ?
 141                                      task->tk_client->cl_clid : -1;
 142                 __entry->task_id = task->tk_pid;
 143                 __entry->action = action;
 144                 __entry->runstate = task->tk_runstate;
 145                 __entry->status = task->tk_status;
 146                 __entry->flags = task->tk_flags;
 147                 ),
 148
 149         TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%pf",
 150                 __entry->task_id, __entry->client_id,
 151                 rpc_show_task_flags(__entry->flags),
 152                 rpc_show_runstate(__entry->runstate),
 153                 __entry->status,
 154                 __entry->action
 155                 )
 156 );
 157 #define DEFINE_RPC_RUNNING_EVENT(name) \
 158         DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
 159                         TP_PROTO( \
 160                                 const struct rpc_task *task, \
 161                                 const void *action \
 162                         ), \
 163                         TP_ARGS(task, action))
 164
 165 DEFINE_RPC_RUNNING_EVENT(begin);
 166 DEFINE_RPC_RUNNING_EVENT(run_action);
 167 DEFINE_RPC_RUNNING_EVENT(complete);
 168
 169 DECLARE_EVENT_CLASS(rpc_task_queued,
 170
 171         TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
 172
 173         TP_ARGS(task, q),
 174
 175         TP_STRUCT__entry(
 176                 __field(unsigned int, task_id)
 177                 __field(unsigned int, client_id)
 178                 __field(unsigned long, timeout)
 179                 __field(unsigned long, runstate)
 180                 __field(int, status)
 181                 __field(unsigned short, flags)
 182                 __string(q_name, rpc_qname(q))
 183                 ),
 184
 185         TP_fast_assign(
 186                 __entry->client_id = task->tk_client ?
 187                                      task->tk_client->cl_clid : -1;
 188                 __entry->task_id = task->tk_pid;
 189                 __entry->timeout = task->tk_timeout;
 190                 __entry->runstate = task->tk_runstate;
 191                 __entry->status = task->tk_status;
 192                 __entry->flags = task->tk_flags;
 193                 __assign_str(q_name, rpc_qname(q));
 194                 ),
 195
 196         TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s",
 197                 __entry->task_id, __entry->client_id,
 198                 rpc_show_task_flags(__entry->flags),
 199                 rpc_show_runstate(__entry->runstate),
 200                 __entry->status,
 201                 __entry->timeout,
 202                 __get_str(q_name)
 203                 )
 204 );
 205 #define DEFINE_RPC_QUEUED_EVENT(name) \
 206         DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
 207                         TP_PROTO( \
 208                                 const struct rpc_task *task, \
 209                                 const struct rpc_wait_queue *q \
 210                         ), \
 211                         TP_ARGS(task, q))
 212
 213 DEFINE_RPC_QUEUED_EVENT(sleep);
 214 DEFINE_RPC_QUEUED_EVENT(wakeup);
 215
 216 TRACE_EVENT(rpc_stats_latency,
 217
 218         TP_PROTO(
 219                 const struct rpc_task *task,
 220                 ktime_t backlog,
 221                 ktime_t rtt,
 222                 ktime_t execute
 223         ),
 224
 225         TP_ARGS(task, backlog, rtt, execute),
 226
 227         TP_STRUCT__entry(
 228                 __field(unsigned int, task_id)
 229                 __field(unsigned int, client_id)
 230                 __field(u32, xid)
 231                 __field(int, version)
 232                 __string(progname, task->tk_client->cl_program->name)
 233                 __string(procname, rpc_proc_name(task))
 234                 __field(unsigned long, backlog)
 235                 __field(unsigned long, rtt)
 236                 __field(unsigned long, execute)
 237         ),
 238
 239         TP_fast_assign(
 240                 __entry->client_id = task->tk_client->cl_clid;
 241                 __entry->task_id = task->tk_pid;
 242                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 243                 __entry->version = task->tk_client->cl_vers;
 244                 __assign_str(progname, task->tk_client->cl_program->name)
 245                 __assign_str(procname, rpc_proc_name(task))
 246                 __entry->backlog = ktime_to_us(backlog);
 247                 __entry->rtt = ktime_to_us(rtt);
 248                 __entry->execute = ktime_to_us(execute);
 249         ),
 250
 251         TP_printk("task:%u@%d xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
 252                 __entry->task_id, __entry->client_id, __entry->xid,
 253                 __get_str(progname), __entry->version, __get_str(procname),
 254                 __entry->backlog, __entry->rtt, __entry->execute)
 255 );
 256
 257 /*
 258  * First define the enums in the below macros to be exported to userspace
 259  * via TRACE_DEFINE_ENUM().
 260  */
 261 #undef EM
 262 #undef EMe
 263 #define EM(a, b)        TRACE_DEFINE_ENUM(a);
 264 #define EMe(a, b)       TRACE_DEFINE_ENUM(a);
 265
 266 #define RPC_SHOW_SOCKET                         \
 267         EM( SS_FREE, "FREE" )                   \
 268         EM( SS_UNCONNECTED, "UNCONNECTED" )     \
 269         EM( SS_CONNECTING, "CONNECTING," )      \
 270         EM( SS_CONNECTED, "CONNECTED," )        \
 271         EMe(SS_DISCONNECTING, "DISCONNECTING" )
 272
 273 #define rpc_show_socket_state(state) \
 274         __print_symbolic(state, RPC_SHOW_SOCKET)
 275
 276 RPC_SHOW_SOCKET
 277
 278 #define RPC_SHOW_SOCK                           \
 279         EM( TCP_ESTABLISHED, "ESTABLISHED" )    \
 280         EM( TCP_SYN_SENT, "SYN_SENT" )          \
 281         EM( TCP_SYN_RECV, "SYN_RECV" )          \
 282         EM( TCP_FIN_WAIT1, "FIN_WAIT1" )        \
 283         EM( TCP_FIN_WAIT2, "FIN_WAIT2" )        \
 284         EM( TCP_TIME_WAIT, "TIME_WAIT" )        \
 285         EM( TCP_CLOSE, "CLOSE" )                \
 286         EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" )      \
 287         EM( TCP_LAST_ACK, "LAST_ACK" )          \
 288         EM( TCP_LISTEN, "LISTEN" )              \
 289         EMe( TCP_CLOSING, "CLOSING" )
 290
 291 #define rpc_show_sock_state(state) \
 292         __print_symbolic(state, RPC_SHOW_SOCK)
 293
 294 RPC_SHOW_SOCK
 295
 296 /*
 297  * Now redefine the EM() and EMe() macros to map the enums to the strings
 298  * that will be printed in the output.
 299  */
 300 #undef EM
 301 #undef EMe
 302 #define EM(a, b)        {a, b},
 303 #define EMe(a, b)       {a, b}
 304
 305 DECLARE_EVENT_CLASS(xs_socket_event,
 306
 307                 TP_PROTO(
 308                         struct rpc_xprt *xprt,
 309                         struct socket *socket
 310                 ),
 311
 312                 TP_ARGS(xprt, socket),
 313
 314                 TP_STRUCT__entry(
 315                         __field(unsigned int, socket_state)
 316                         __field(unsigned int, sock_state)
 317                         __field(unsigned long long, ino)
 318                         __string(dstaddr,
 319                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 320                         __string(dstport,
 321                                 xprt->address_strings[RPC_DISPLAY_PORT])
 322                 ),
 323
 324                 TP_fast_assign(
 325                         struct inode *inode = SOCK_INODE(socket);
 326                         __entry->socket_state = socket->state;
 327                         __entry->sock_state = socket->sk->sk_state;
 328                         __entry->ino = (unsigned long long)inode->i_ino;
 329                         __assign_str(dstaddr,
 330                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 331                         __assign_str(dstport,
 332                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 333                 ),
 334
 335                 TP_printk(
 336                         "socket:[%llu] dstaddr=%s/%s "
 337                         "state=%u (%s) sk_state=%u (%s)",
 338                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 339                         __entry->socket_state,
 340                         rpc_show_socket_state(__entry->socket_state),
 341                         __entry->sock_state,
 342                         rpc_show_sock_state(__entry->sock_state)
 343                 )
 344 );
 345 #define DEFINE_RPC_SOCKET_EVENT(name) \
 346         DEFINE_EVENT(xs_socket_event, name, \
 347                         TP_PROTO( \
 348                                 struct rpc_xprt *xprt, \
 349                                 struct socket *socket \
 350                         ), \
 351                         TP_ARGS(xprt, socket))
 352
 353 DECLARE_EVENT_CLASS(xs_socket_event_done,
 354
 355                 TP_PROTO(
 356                         struct rpc_xprt *xprt,
 357                         struct socket *socket,
 358                         int error
 359                 ),
 360
 361                 TP_ARGS(xprt, socket, error),
 362
 363                 TP_STRUCT__entry(
 364                         __field(int, error)
 365                         __field(unsigned int, socket_state)
 366                         __field(unsigned int, sock_state)
 367                         __field(unsigned long long, ino)
 368                         __string(dstaddr,
 369                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 370                         __string(dstport,
 371                                 xprt->address_strings[RPC_DISPLAY_PORT])
 372                 ),
 373
 374                 TP_fast_assign(
 375                         struct inode *inode = SOCK_INODE(socket);
 376                         __entry->socket_state = socket->state;
 377                         __entry->sock_state = socket->sk->sk_state;
 378                         __entry->ino = (unsigned long long)inode->i_ino;
 379                         __entry->error = error;
 380                         __assign_str(dstaddr,
 381                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 382                         __assign_str(dstport,
 383                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 384                 ),
 385
 386                 TP_printk(
 387                         "error=%d socket:[%llu] dstaddr=%s/%s "
 388                         "state=%u (%s) sk_state=%u (%s)",
 389                         __entry->error,
 390                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 391                         __entry->socket_state,
 392                         rpc_show_socket_state(__entry->socket_state),
 393                         __entry->sock_state,
 394                         rpc_show_sock_state(__entry->sock_state)
 395                 )
 396 );
 397 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
 398         DEFINE_EVENT(xs_socket_event_done, name, \
 399                         TP_PROTO( \
 400                                 struct rpc_xprt *xprt, \
 401                                 struct socket *socket, \
 402                                 int error \
 403                         ), \
 404                         TP_ARGS(xprt, socket, error))
 405
 406 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
 407 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
 408 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
 409 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
 410 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
 411 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
 412
 413 DECLARE_EVENT_CLASS(rpc_xprt_event,
 414         TP_PROTO(
 415                 const struct rpc_xprt *xprt,
 416                 __be32 xid,
 417                 int status
 418         ),
 419
 420         TP_ARGS(xprt, xid, status),
 421
 422         TP_STRUCT__entry(
 423                 __field(u32, xid)
 424                 __field(int, status)
 425                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 426                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 427         ),
 428
 429         TP_fast_assign(
 430                 __entry->xid = be32_to_cpu(xid);
 431                 __entry->status = status;
 432                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 433                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 434         ),
 435
 436         TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
 437                         __get_str(port), __entry->xid,
 438                         __entry->status)
 439 );
 440 #define DEFINE_RPC_XPRT_EVENT(name) \
 441         DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
 442                         TP_PROTO( \
 443                                 const struct rpc_xprt *xprt, \
 444                                 __be32 xid, \
 445                                 int status \
 446                         ), \
 447                         TP_ARGS(xprt, xid, status))
 448
 449 DEFINE_RPC_XPRT_EVENT(timer);
 450 DEFINE_RPC_XPRT_EVENT(lookup_rqst);
 451 DEFINE_RPC_XPRT_EVENT(transmit);
 452 DEFINE_RPC_XPRT_EVENT(complete_rqst);
 453
 454 TRACE_EVENT(xprt_ping,
 455         TP_PROTO(const struct rpc_xprt *xprt, int status),
 456
 457         TP_ARGS(xprt, status),
 458
 459         TP_STRUCT__entry(
 460                 __field(int, status)
 461                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 462                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 463         ),
 464
 465         TP_fast_assign(
 466                 __entry->status = status;
 467                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 468                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 469         ),
 470
 471         TP_printk("peer=[%s]:%s status=%d",
 472                         __get_str(addr), __get_str(port), __entry->status)
 473 );
 474
 475 TRACE_EVENT(xs_stream_read_data,
 476         TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
 477
 478         TP_ARGS(xprt, err, total),
 479
 480         TP_STRUCT__entry(
 481                 __field(ssize_t, err)
 482                 __field(size_t, total)
 483                 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
 484                                 "(null)")
 485                 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
 486                                 "(null)")
 487         ),
 488
 489         TP_fast_assign(
 490                 __entry->err = err;
 491                 __entry->total = total;
 492                 __assign_str(addr, xprt ?
 493                         xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
 494                 __assign_str(port, xprt ?
 495                         xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
 496         ),
 497
 498         TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
 499                         __get_str(port), __entry->err, __entry->total)
 500 );
 501
 502 TRACE_EVENT(xs_stream_read_request,
 503         TP_PROTO(struct sock_xprt *xs),
 504
 505         TP_ARGS(xs),
 506
 507         TP_STRUCT__entry(
 508                 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
 509                 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
 510                 __field(u32, xid)
 511                 __field(unsigned long, copied)
 512                 __field(unsigned int, reclen)
 513                 __field(unsigned int, offset)
 514         ),
 515
 516         TP_fast_assign(
 517                 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
 518                 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
 519                 __entry->xid = be32_to_cpu(xs->recv.xid);
 520                 __entry->copied = xs->recv.copied;
 521                 __entry->reclen = xs->recv.len;
 522                 __entry->offset = xs->recv.offset;
 523         ),
 524
 525         TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
 526                         __get_str(addr), __get_str(port), __entry->xid,
 527                         __entry->copied, __entry->reclen, __entry->offset)
 528 );
 529
 530 #define show_rqstp_flags(flags)                                         \
 531         __print_flags(flags, "|",                                       \
 532                 { (1UL << RQ_SECURE),           "RQ_SECURE"},           \
 533                 { (1UL << RQ_LOCAL),            "RQ_LOCAL"},            \
 534                 { (1UL << RQ_USEDEFERRAL),      "RQ_USEDEFERRAL"},      \
 535                 { (1UL << RQ_DROPME),           "RQ_DROPME"},           \
 536                 { (1UL << RQ_SPLICE_OK),        "RQ_SPLICE_OK"},        \
 537                 { (1UL << RQ_VICTIM),           "RQ_VICTIM"},           \
 538                 { (1UL << RQ_BUSY),             "RQ_BUSY"})
 539
 540 TRACE_EVENT(svc_recv,
 541         TP_PROTO(struct svc_rqst *rqst, int len),
 542
 543         TP_ARGS(rqst, len),
 544
 545         TP_STRUCT__entry(
 546                 __field(u32, xid)
 547                 __field(int, len)
 548                 __field(unsigned long, flags)
 549                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
 550         ),
 551
 552         TP_fast_assign(
 553                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 554                 __entry->len = len;
 555                 __entry->flags = rqst->rq_flags;
 556                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
 557         ),
 558
 559         TP_printk("addr=%s xid=0x%08x len=%d flags=%s",
 560                         __get_str(addr), __entry->xid, __entry->len,
 561                         show_rqstp_flags(__entry->flags))
 562 );
 563
 564 TRACE_EVENT(svc_process,
 565         TP_PROTO(const struct svc_rqst *rqst, const char *name),
 566
 567         TP_ARGS(rqst, name),
 568
 569         TP_STRUCT__entry(
 570                 __field(u32, xid)
 571                 __field(u32, vers)
 572                 __field(u32, proc)
 573                 __string(service, name)
 574                 __string(addr, rqst->rq_xprt ?
 575                          rqst->rq_xprt->xpt_remotebuf : "(null)")
 576         ),
 577
 578         TP_fast_assign(
 579                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 580                 __entry->vers = rqst->rq_vers;
 581                 __entry->proc = rqst->rq_proc;
 582                 __assign_str(service, name);
 583                 __assign_str(addr, rqst->rq_xprt ?
 584                              rqst->rq_xprt->xpt_remotebuf : "(null)");
 585         ),
 586
 587         TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%u",
 588                         __get_str(addr), __entry->xid,
 589                         __get_str(service), __entry->vers, __entry->proc)
 590 );
 591
 592 DECLARE_EVENT_CLASS(svc_rqst_event,
 593
 594         TP_PROTO(
 595                 const struct svc_rqst *rqst
 596         ),
 597
 598         TP_ARGS(rqst),
 599
 600         TP_STRUCT__entry(
 601                 __field(u32, xid)
 602                 __field(unsigned long, flags)
 603                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
 604         ),
 605
 606         TP_fast_assign(
 607                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 608                 __entry->flags = rqst->rq_flags;
 609                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
 610         ),
 611
 612         TP_printk("addr=%s xid=0x%08x flags=%s",
 613                         __get_str(addr), __entry->xid,
 614                         show_rqstp_flags(__entry->flags))
 615 );
 616 #define DEFINE_SVC_RQST_EVENT(name) \
 617         DEFINE_EVENT(svc_rqst_event, svc_##name, \
 618                         TP_PROTO( \
 619                                 const struct svc_rqst *rqst \
 620                         ), \
 621                         TP_ARGS(rqst))
 622
 623 DEFINE_SVC_RQST_EVENT(defer);
 624 DEFINE_SVC_RQST_EVENT(drop);
 625
 626 DECLARE_EVENT_CLASS(svc_rqst_status,
 627
 628         TP_PROTO(struct svc_rqst *rqst, int status),
 629
 630         TP_ARGS(rqst, status),
 631
 632         TP_STRUCT__entry(
 633                 __field(u32, xid)
 634                 __field(int, status)
 635                 __field(unsigned long, flags)
 636                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
 637         ),
 638
 639         TP_fast_assign(
 640                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 641                 __entry->status = status;
 642                 __entry->flags = rqst->rq_flags;
 643                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
 644         ),
 645
 646         TP_printk("addr=%s xid=0x%08x status=%d flags=%s",
 647                   __get_str(addr), __entry->xid,
 648                   __entry->status, show_rqstp_flags(__entry->flags))
 649 );
 650
 651 DEFINE_EVENT(svc_rqst_status, svc_send,
 652         TP_PROTO(struct svc_rqst *rqst, int status),
 653         TP_ARGS(rqst, status));
 654
 655 #define show_svc_xprt_flags(flags)                                      \
 656         __print_flags(flags, "|",                                       \
 657                 { (1UL << XPT_BUSY),            "XPT_BUSY"},            \
 658                 { (1UL << XPT_CONN),            "XPT_CONN"},            \
 659                 { (1UL << XPT_CLOSE),           "XPT_CLOSE"},           \
 660                 { (1UL << XPT_DATA),            "XPT_DATA"},            \
 661                 { (1UL << XPT_TEMP),            "XPT_TEMP"},            \
 662                 { (1UL << XPT_DEAD),            "XPT_DEAD"},            \
 663                 { (1UL << XPT_CHNGBUF),         "XPT_CHNGBUF"},         \
 664                 { (1UL << XPT_DEFERRED),        "XPT_DEFERRED"},        \
 665                 { (1UL << XPT_OLD),             "XPT_OLD"},             \
 666                 { (1UL << XPT_LISTENER),        "XPT_LISTENER"},        \
 667                 { (1UL << XPT_CACHE_AUTH),      "XPT_CACHE_AUTH"},      \
 668                 { (1UL << XPT_LOCAL),           "XPT_LOCAL"},           \
 669                 { (1UL << XPT_KILL_TEMP),       "XPT_KILL_TEMP"},       \
 670                 { (1UL << XPT_CONG_CTRL),       "XPT_CONG_CTRL"})
 671
 672 TRACE_EVENT(svc_xprt_do_enqueue,
 673         TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
 674
 675         TP_ARGS(xprt, rqst),
 676
 677         TP_STRUCT__entry(
 678                 __field(struct svc_xprt *, xprt)
 679                 __field(int, pid)
 680                 __field(unsigned long, flags)
 681                 __string(addr, xprt->xpt_remotebuf)
 682         ),
 683
 684         TP_fast_assign(
 685                 __entry->xprt = xprt;
 686                 __entry->pid = rqst? rqst->rq_task->pid : 0;
 687                 __entry->flags = xprt->xpt_flags;
 688                 __assign_str(addr, xprt->xpt_remotebuf);
 689         ),
 690
 691         TP_printk("xprt=%p addr=%s pid=%d flags=%s",
 692                         __entry->xprt, __get_str(addr),
 693                         __entry->pid, show_svc_xprt_flags(__entry->flags))
 694 );
 695
 696 DECLARE_EVENT_CLASS(svc_xprt_event,
 697         TP_PROTO(struct svc_xprt *xprt),
 698
 699         TP_ARGS(xprt),
 700
 701         TP_STRUCT__entry(
 702                 __field(struct svc_xprt *, xprt)
 703                 __field(unsigned long, flags)
 704                 __string(addr, xprt->xpt_remotebuf)
 705         ),
 706
 707         TP_fast_assign(
 708                 __entry->xprt = xprt;
 709                 __entry->flags = xprt->xpt_flags;
 710                 __assign_str(addr, xprt->xpt_remotebuf);
 711         ),
 712
 713         TP_printk("xprt=%p addr=%s flags=%s",
 714                         __entry->xprt, __get_str(addr),
 715                         show_svc_xprt_flags(__entry->flags))
 716 );
 717
 718 DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
 719         TP_PROTO(struct svc_xprt *xprt),
 720         TP_ARGS(xprt));
 721
 722 TRACE_EVENT(svc_xprt_dequeue,
 723         TP_PROTO(struct svc_rqst *rqst),
 724
 725         TP_ARGS(rqst),
 726
 727         TP_STRUCT__entry(
 728                 __field(struct svc_xprt *, xprt)
 729                 __field(unsigned long, flags)
 730                 __field(unsigned long, wakeup)
 731                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
 732         ),
 733
 734         TP_fast_assign(
 735                 __entry->xprt = rqst->rq_xprt;
 736                 __entry->flags = rqst->rq_xprt->xpt_flags;
 737                 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
 738                                                         rqst->rq_qtime));
 739                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
 740         ),
 741
 742         TP_printk("xprt=%p addr=%s flags=%s wakeup-us=%lu",
 743                         __entry->xprt, __get_str(addr),
 744                         show_svc_xprt_flags(__entry->flags),
 745                         __entry->wakeup)
 746 );
 747
 748 TRACE_EVENT(svc_wake_up,
 749         TP_PROTO(int pid),
 750
 751         TP_ARGS(pid),
 752
 753         TP_STRUCT__entry(
 754                 __field(int, pid)
 755         ),
 756
 757         TP_fast_assign(
 758                 __entry->pid = pid;
 759         ),
 760
 761         TP_printk("pid=%d", __entry->pid)
 762 );
 763
 764 TRACE_EVENT(svc_handle_xprt,
 765         TP_PROTO(struct svc_xprt *xprt, int len),
 766
 767         TP_ARGS(xprt, len),
 768
 769         TP_STRUCT__entry(
 770                 __field(struct svc_xprt *, xprt)
 771                 __field(int, len)
 772                 __field(unsigned long, flags)
 773                 __string(addr, xprt->xpt_remotebuf)
 774         ),
 775
 776         TP_fast_assign(
 777                 __entry->xprt = xprt;
 778                 __entry->len = len;
 779                 __entry->flags = xprt->xpt_flags;
 780                 __assign_str(addr, xprt->xpt_remotebuf);
 781         ),
 782
 783         TP_printk("xprt=%p addr=%s len=%d flags=%s",
 784                 __entry->xprt, __get_str(addr),
 785                 __entry->len, show_svc_xprt_flags(__entry->flags))
 786 );
 787
 788 TRACE_EVENT(svc_stats_latency,
 789         TP_PROTO(const struct svc_rqst *rqst),
 790
 791         TP_ARGS(rqst),
 792
 793         TP_STRUCT__entry(
 794                 __field(u32, xid)
 795                 __field(unsigned long, execute)
 796                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
 797         ),
 798
 799         TP_fast_assign(
 800                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 801                 __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
 802                                                          rqst->rq_stime));
 803                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
 804         ),
 805
 806         TP_printk("addr=%s xid=0x%08x execute-us=%lu",
 807                 __get_str(addr), __entry->xid, __entry->execute)
 808 );
 809
 810 DECLARE_EVENT_CLASS(svc_deferred_event,
 811         TP_PROTO(
 812                 const struct svc_deferred_req *dr
 813         ),
 814
 815         TP_ARGS(dr),
 816
 817         TP_STRUCT__entry(
 818                 __field(u32, xid)
 819                 __string(addr, dr->xprt->xpt_remotebuf)
 820         ),
 821
 822         TP_fast_assign(
 823                 __entry->xid = be32_to_cpu(*(__be32 *)(dr->args +
 824                                                        (dr->xprt_hlen>>2)));
 825                 __assign_str(addr, dr->xprt->xpt_remotebuf);
 826         ),
 827
 828         TP_printk("addr=%s xid=0x%08x", __get_str(addr), __entry->xid)
 829 );
 830 #define DEFINE_SVC_DEFERRED_EVENT(name) \
 831         DEFINE_EVENT(svc_deferred_event, svc_##name##_deferred, \
 832                         TP_PROTO( \
 833                                 const struct svc_deferred_req *dr \
 834                         ), \
 835                         TP_ARGS(dr))
 836
 837 DEFINE_SVC_DEFERRED_EVENT(drop);
 838 DEFINE_SVC_DEFERRED_EVENT(revisit);
 839
 840 #endif /* _TRACE_SUNRPC_H */
 841
 842 #include <trace/define_trace.h>