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