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(struct rpc_task *task, int status),
  54
  55         TP_ARGS(task, status),
  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 = status;
  67         ),
  68
  69         TP_printk("task:%u@%u, status %d",
  70                 __entry->task_id, __entry->client_id,
  71                 __entry->status)
  72 );
  73
  74 DECLARE_EVENT_CLASS(rpc_task_running,
  75
  76         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
  77
  78         TP_ARGS(clnt, task, action),
  79
  80         TP_STRUCT__entry(
  81                 __field(unsigned int, task_id)
  82                 __field(unsigned int, client_id)
  83                 __field(const void *, action)
  84                 __field(unsigned long, runstate)
  85                 __field(int, status)
  86                 __field(unsigned short, flags)
  87                 ),
  88
  89         TP_fast_assign(
  90                 __entry->client_id = clnt ? clnt->cl_clid : -1;
  91                 __entry->task_id = task->tk_pid;
  92                 __entry->action = action;
  93                 __entry->runstate = task->tk_runstate;
  94                 __entry->status = task->tk_status;
  95                 __entry->flags = task->tk_flags;
  96                 ),
  97
  98         TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf",
  99                 __entry->task_id, __entry->client_id,
 100                 __entry->flags,
 101                 __entry->runstate,
 102                 __entry->status,
 103                 __entry->action
 104                 )
 105 );
 106
 107 DEFINE_EVENT(rpc_task_running, rpc_task_begin,
 108
 109         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
 110
 111         TP_ARGS(clnt, task, action)
 112
 113 );
 114
 115 DEFINE_EVENT(rpc_task_running, rpc_task_run_action,
 116
 117         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
 118
 119         TP_ARGS(clnt, task, action)
 120
 121 );
 122
 123 DEFINE_EVENT(rpc_task_running, rpc_task_complete,
 124
 125         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
 126
 127         TP_ARGS(clnt, task, action)
 128
 129 );
 130
 131 DECLARE_EVENT_CLASS(rpc_task_queued,
 132
 133         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
 134
 135         TP_ARGS(clnt, task, q),
 136
 137         TP_STRUCT__entry(
 138                 __field(unsigned int, task_id)
 139                 __field(unsigned int, client_id)
 140                 __field(unsigned long, timeout)
 141                 __field(unsigned long, runstate)
 142                 __field(int, status)
 143                 __field(unsigned short, flags)
 144                 __string(q_name, rpc_qname(q))
 145                 ),
 146
 147         TP_fast_assign(
 148                 __entry->client_id = clnt->cl_clid;
 149                 __entry->task_id = task->tk_pid;
 150                 __entry->timeout = task->tk_timeout;
 151                 __entry->runstate = task->tk_runstate;
 152                 __entry->status = task->tk_status;
 153                 __entry->flags = task->tk_flags;
 154                 __assign_str(q_name, rpc_qname(q));
 155                 ),
 156
 157         TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
 158                 __entry->task_id, __entry->client_id,
 159                 __entry->flags,
 160                 __entry->runstate,
 161                 __entry->status,
 162                 __entry->timeout,
 163                 __get_str(q_name)
 164                 )
 165 );
 166
 167 DEFINE_EVENT(rpc_task_queued, rpc_task_sleep,
 168
 169         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
 170
 171         TP_ARGS(clnt, task, q)
 172
 173 );
 174
 175 DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,
 176
 177         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
 178
 179         TP_ARGS(clnt, task, q)
 180
 181 );
 182
 183 /*
 184  * First define the enums in the below macros to be exported to userspace
 185  * via TRACE_DEFINE_ENUM().
 186  */
 187 #undef EM
 188 #undef EMe
 189 #define EM(a, b)        TRACE_DEFINE_ENUM(a);
 190 #define EMe(a, b)       TRACE_DEFINE_ENUM(a);
 191
 192 #define RPC_SHOW_SOCKET                         \
 193         EM( SS_FREE, "FREE" )                   \
 194         EM( SS_UNCONNECTED, "UNCONNECTED" )     \
 195         EM( SS_CONNECTING, "CONNECTING," )      \
 196         EM( SS_CONNECTED, "CONNECTED," )        \
 197         EMe(SS_DISCONNECTING, "DISCONNECTING" )
 198
 199 #define rpc_show_socket_state(state) \
 200         __print_symbolic(state, RPC_SHOW_SOCKET)
 201
 202 RPC_SHOW_SOCKET
 203
 204 #define RPC_SHOW_SOCK                           \
 205         EM( TCP_ESTABLISHED, "ESTABLISHED" )    \
 206         EM( TCP_SYN_SENT, "SYN_SENT" )          \
 207         EM( TCP_SYN_RECV, "SYN_RECV" )          \
 208         EM( TCP_FIN_WAIT1, "FIN_WAIT1" )        \
 209         EM( TCP_FIN_WAIT2, "FIN_WAIT2" )        \
 210         EM( TCP_TIME_WAIT, "TIME_WAIT" )        \
 211         EM( TCP_CLOSE, "CLOSE" )                \
 212         EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" )      \
 213         EM( TCP_LAST_ACK, "LAST_ACK" )          \
 214         EM( TCP_LISTEN, "LISTEN" )              \
 215         EMe( TCP_CLOSING, "CLOSING" )
 216
 217 #define rpc_show_sock_state(state) \
 218         __print_symbolic(state, RPC_SHOW_SOCK)
 219
 220 RPC_SHOW_SOCK
 221
 222 /*
 223  * Now redefine the EM() and EMe() macros to map the enums to the strings
 224  * that will be printed in the output.
 225  */
 226 #undef EM
 227 #undef EMe
 228 #define EM(a, b)        {a, b},
 229 #define EMe(a, b)       {a, b}
 230
 231 DECLARE_EVENT_CLASS(xs_socket_event,
 232
 233                 TP_PROTO(
 234                         struct rpc_xprt *xprt,
 235                         struct socket *socket
 236                 ),
 237
 238                 TP_ARGS(xprt, socket),
 239
 240                 TP_STRUCT__entry(
 241                         __field(unsigned int, socket_state)
 242                         __field(unsigned int, sock_state)
 243                         __field(unsigned long long, ino)
 244                         __string(dstaddr,
 245                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 246                         __string(dstport,
 247                                 xprt->address_strings[RPC_DISPLAY_PORT])
 248                 ),
 249
 250                 TP_fast_assign(
 251                         struct inode *inode = SOCK_INODE(socket);
 252                         __entry->socket_state = socket->state;
 253                         __entry->sock_state = socket->sk->sk_state;
 254                         __entry->ino = (unsigned long long)inode->i_ino;
 255                         __assign_str(dstaddr,
 256                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 257                         __assign_str(dstport,
 258                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 259                 ),
 260
 261                 TP_printk(
 262                         "socket:[%llu] dstaddr=%s/%s "
 263                         "state=%u (%s) sk_state=%u (%s)",
 264                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 265                         __entry->socket_state,
 266                         rpc_show_socket_state(__entry->socket_state),
 267                         __entry->sock_state,
 268                         rpc_show_sock_state(__entry->sock_state)
 269                 )
 270 );
 271 #define DEFINE_RPC_SOCKET_EVENT(name) \
 272         DEFINE_EVENT(xs_socket_event, name, \
 273                         TP_PROTO( \
 274                                 struct rpc_xprt *xprt, \
 275                                 struct socket *socket \
 276                         ), \
 277                         TP_ARGS(xprt, socket))
 278
 279 DECLARE_EVENT_CLASS(xs_socket_event_done,
 280
 281                 TP_PROTO(
 282                         struct rpc_xprt *xprt,
 283                         struct socket *socket,
 284                         int error
 285                 ),
 286
 287                 TP_ARGS(xprt, socket, error),
 288
 289                 TP_STRUCT__entry(
 290                         __field(int, error)
 291                         __field(unsigned int, socket_state)
 292                         __field(unsigned int, sock_state)
 293                         __field(unsigned long long, ino)
 294                         __string(dstaddr,
 295                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 296                         __string(dstport,
 297                                 xprt->address_strings[RPC_DISPLAY_PORT])
 298                 ),
 299
 300                 TP_fast_assign(
 301                         struct inode *inode = SOCK_INODE(socket);
 302                         __entry->socket_state = socket->state;
 303                         __entry->sock_state = socket->sk->sk_state;
 304                         __entry->ino = (unsigned long long)inode->i_ino;
 305                         __entry->error = error;
 306                         __assign_str(dstaddr,
 307                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 308                         __assign_str(dstport,
 309                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 310                 ),
 311
 312                 TP_printk(
 313                         "error=%d socket:[%llu] dstaddr=%s/%s "
 314                         "state=%u (%s) sk_state=%u (%s)",
 315                         __entry->error,
 316                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 317                         __entry->socket_state,
 318                         rpc_show_socket_state(__entry->socket_state),
 319                         __entry->sock_state,
 320                         rpc_show_sock_state(__entry->sock_state)
 321                 )
 322 );
 323 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
 324         DEFINE_EVENT(xs_socket_event_done, name, \
 325                         TP_PROTO( \
 326                                 struct rpc_xprt *xprt, \
 327                                 struct socket *socket, \
 328                                 int error \
 329                         ), \
 330                         TP_ARGS(xprt, socket, error))
 331
 332 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
 333 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
 334 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
 335 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
 336 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
 337 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
 338
 339 DECLARE_EVENT_CLASS(rpc_xprt_event,
 340         TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
 341
 342         TP_ARGS(xprt, xid, status),
 343
 344         TP_STRUCT__entry(
 345                 __field(__be32, xid)
 346                 __field(int, status)
 347                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 348                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 349         ),
 350
 351         TP_fast_assign(
 352                 __entry->xid = xid;
 353                 __entry->status = status;
 354                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 355                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 356         ),
 357
 358         TP_printk("peer=[%s]:%s xid=0x%x status=%d", __get_str(addr),
 359                         __get_str(port), be32_to_cpu(__entry->xid),
 360                         __entry->status)
 361 );
 362
 363 DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst,
 364         TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
 365         TP_ARGS(xprt, xid, status));
 366
 367 DEFINE_EVENT(rpc_xprt_event, xprt_transmit,
 368         TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
 369         TP_ARGS(xprt, xid, status));
 370
 371 DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst,
 372         TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
 373         TP_ARGS(xprt, xid, status));
 374
 375 TRACE_EVENT(xs_tcp_data_ready,
 376         TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total),
 377
 378         TP_ARGS(xprt, err, total),
 379
 380         TP_STRUCT__entry(
 381                 __field(int, err)
 382                 __field(unsigned int, total)
 383                 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
 384                                 "(null)")
 385                 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
 386                                 "(null)")
 387         ),
 388
 389         TP_fast_assign(
 390                 __entry->err = err;
 391                 __entry->total = total;
 392                 __assign_str(addr, xprt ?
 393                         xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
 394                 __assign_str(port, xprt ?
 395                         xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
 396         ),
 397
 398         TP_printk("peer=[%s]:%s err=%d total=%u", __get_str(addr),
 399                         __get_str(port), __entry->err, __entry->total)
 400 );
 401
 402 #define rpc_show_sock_xprt_flags(flags) \
 403         __print_flags(flags, "|", \
 404                 { TCP_RCV_LAST_FRAG, "TCP_RCV_LAST_FRAG" }, \
 405                 { TCP_RCV_COPY_FRAGHDR, "TCP_RCV_COPY_FRAGHDR" }, \
 406                 { TCP_RCV_COPY_XID, "TCP_RCV_COPY_XID" }, \
 407                 { TCP_RCV_COPY_DATA, "TCP_RCV_COPY_DATA" }, \
 408                 { TCP_RCV_READ_CALLDIR, "TCP_RCV_READ_CALLDIR" }, \
 409                 { TCP_RCV_COPY_CALLDIR, "TCP_RCV_COPY_CALLDIR" }, \
 410                 { TCP_RPC_REPLY, "TCP_RPC_REPLY" })
 411
 412 TRACE_EVENT(xs_tcp_data_recv,
 413         TP_PROTO(struct sock_xprt *xs),
 414
 415         TP_ARGS(xs),
 416
 417         TP_STRUCT__entry(
 418                 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
 419                 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
 420                 __field(__be32, xid)
 421                 __field(unsigned long, flags)
 422                 __field(unsigned long, copied)
 423                 __field(unsigned int, reclen)
 424                 __field(unsigned long, offset)
 425         ),
 426
 427         TP_fast_assign(
 428                 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
 429                 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
 430                 __entry->xid = xs->tcp_xid;
 431                 __entry->flags = xs->tcp_flags;
 432                 __entry->copied = xs->tcp_copied;
 433                 __entry->reclen = xs->tcp_reclen;
 434                 __entry->offset = xs->tcp_offset;
 435         ),
 436
 437         TP_printk("peer=[%s]:%s xid=0x%x flags=%s copied=%lu reclen=%u offset=%lu",
 438                         __get_str(addr), __get_str(port), be32_to_cpu(__entry->xid),
 439                         rpc_show_sock_xprt_flags(__entry->flags),
 440                         __entry->copied, __entry->reclen, __entry->offset)
 441 );
 442
 443 #define show_rqstp_flags(flags)                                         \
 444         __print_flags(flags, "|",                                       \
 445                 { (1UL << RQ_SECURE),           "RQ_SECURE"},           \
 446                 { (1UL << RQ_LOCAL),            "RQ_LOCAL"},            \
 447                 { (1UL << RQ_USEDEFERRAL),      "RQ_USEDEFERRAL"},      \
 448                 { (1UL << RQ_DROPME),           "RQ_DROPME"},           \
 449                 { (1UL << RQ_SPLICE_OK),        "RQ_SPLICE_OK"},        \
 450                 { (1UL << RQ_VICTIM),           "RQ_VICTIM"},           \
 451                 { (1UL << RQ_BUSY),             "RQ_BUSY"})
 452
 453 TRACE_EVENT(svc_recv,
 454         TP_PROTO(struct svc_rqst *rqst, int status),
 455
 456         TP_ARGS(rqst, status),
 457
 458         TP_STRUCT__entry(
 459                 __field(struct sockaddr *, addr)
 460                 __field(__be32, xid)
 461                 __field(int, status)
 462                 __field(unsigned long, flags)
 463         ),
 464
 465         TP_fast_assign(
 466                 __entry->addr = (struct sockaddr *)&rqst->rq_addr;
 467                 __entry->xid = status > 0 ? rqst->rq_xid : 0;
 468                 __entry->status = status;
 469                 __entry->flags = rqst->rq_flags;
 470         ),
 471
 472         TP_printk("addr=%pIScp xid=0x%x status=%d flags=%s", __entry->addr,
 473                         be32_to_cpu(__entry->xid), __entry->status,
 474                         show_rqstp_flags(__entry->flags))
 475 );
 476
 477 DECLARE_EVENT_CLASS(svc_rqst_event,
 478
 479         TP_PROTO(struct svc_rqst *rqst),
 480
 481         TP_ARGS(rqst),
 482
 483         TP_STRUCT__entry(
 484                 __field(__be32, xid)
 485                 __field(unsigned long, flags)
 486                 __dynamic_array(unsigned char, addr, rqst->rq_addrlen)
 487         ),
 488
 489         TP_fast_assign(
 490                 __entry->xid = rqst->rq_xid;
 491                 __entry->flags = rqst->rq_flags;
 492                 memcpy(__get_dynamic_array(addr),
 493                         &rqst->rq_addr, rqst->rq_addrlen);
 494         ),
 495
 496         TP_printk("addr=%pIScp rq_xid=0x%x flags=%s",
 497                 (struct sockaddr *)__get_dynamic_array(addr),
 498                 be32_to_cpu(__entry->xid),
 499                 show_rqstp_flags(__entry->flags))
 500 );
 501
 502 DEFINE_EVENT(svc_rqst_event, svc_defer,
 503         TP_PROTO(struct svc_rqst *rqst),
 504         TP_ARGS(rqst));
 505
 506 DEFINE_EVENT(svc_rqst_event, svc_drop,
 507         TP_PROTO(struct svc_rqst *rqst),
 508         TP_ARGS(rqst));
 509
 510 DECLARE_EVENT_CLASS(svc_rqst_status,
 511
 512         TP_PROTO(struct svc_rqst *rqst, int status),
 513
 514         TP_ARGS(rqst, status),
 515
 516         TP_STRUCT__entry(
 517                 __field(struct sockaddr *, addr)
 518                 __field(__be32, xid)
 519                 __field(int, dropme)
 520                 __field(int, status)
 521                 __field(unsigned long, flags)
 522         ),
 523
 524         TP_fast_assign(
 525                 __entry->addr = (struct sockaddr *)&rqst->rq_addr;
 526                 __entry->xid = rqst->rq_xid;
 527                 __entry->status = status;
 528                 __entry->flags = rqst->rq_flags;
 529         ),
 530
 531         TP_printk("addr=%pIScp rq_xid=0x%x status=%d flags=%s",
 532                 __entry->addr, be32_to_cpu(__entry->xid),
 533                 __entry->status, show_rqstp_flags(__entry->flags))
 534 );
 535
 536 DEFINE_EVENT(svc_rqst_status, svc_process,
 537         TP_PROTO(struct svc_rqst *rqst, int status),
 538         TP_ARGS(rqst, status));
 539
 540 DEFINE_EVENT(svc_rqst_status, svc_send,
 541         TP_PROTO(struct svc_rqst *rqst, int status),
 542         TP_ARGS(rqst, status));
 543
 544 #define show_svc_xprt_flags(flags)                                      \
 545         __print_flags(flags, "|",                                       \
 546                 { (1UL << XPT_BUSY),            "XPT_BUSY"},            \
 547                 { (1UL << XPT_CONN),            "XPT_CONN"},            \
 548                 { (1UL << XPT_CLOSE),           "XPT_CLOSE"},           \
 549                 { (1UL << XPT_DATA),            "XPT_DATA"},            \
 550                 { (1UL << XPT_TEMP),            "XPT_TEMP"},            \
 551                 { (1UL << XPT_DEAD),            "XPT_DEAD"},            \
 552                 { (1UL << XPT_CHNGBUF),         "XPT_CHNGBUF"},         \
 553                 { (1UL << XPT_DEFERRED),        "XPT_DEFERRED"},        \
 554                 { (1UL << XPT_OLD),             "XPT_OLD"},             \
 555                 { (1UL << XPT_LISTENER),        "XPT_LISTENER"},        \
 556                 { (1UL << XPT_CACHE_AUTH),      "XPT_CACHE_AUTH"},      \
 557                 { (1UL << XPT_LOCAL),           "XPT_LOCAL"})
 558
 559 TRACE_EVENT(svc_xprt_do_enqueue,
 560         TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
 561
 562         TP_ARGS(xprt, rqst),
 563
 564         TP_STRUCT__entry(
 565                 __field(struct svc_xprt *, xprt)
 566                 __field(int, pid)
 567                 __field(unsigned long, flags)
 568                 __dynamic_array(unsigned char, addr, xprt != NULL ?
 569                         xprt->xpt_remotelen : 0)
 570         ),
 571
 572         TP_fast_assign(
 573                 __entry->xprt = xprt;
 574                 __entry->pid = rqst? rqst->rq_task->pid : 0;
 575                 if (xprt) {
 576                         memcpy(__get_dynamic_array(addr),
 577                                 &xprt->xpt_remote,
 578                                 xprt->xpt_remotelen);
 579                         __entry->flags = xprt->xpt_flags;
 580                 } else
 581                         __entry->flags = 0;
 582         ),
 583
 584         TP_printk("xprt=0x%p addr=%pIScp pid=%d flags=%s", __entry->xprt,
 585                 __get_dynamic_array_len(addr) != 0 ?
 586                         (struct sockaddr *)__get_dynamic_array(addr) : NULL,
 587                 __entry->pid, show_svc_xprt_flags(__entry->flags))
 588 );
 589
 590 DECLARE_EVENT_CLASS(svc_xprt_event,
 591         TP_PROTO(struct svc_xprt *xprt),
 592
 593         TP_ARGS(xprt),
 594
 595         TP_STRUCT__entry(
 596                 __field(struct svc_xprt *, xprt)
 597                 __field(unsigned long, flags)
 598                 __dynamic_array(unsigned char, addr, xprt != NULL ?
 599                         xprt->xpt_remotelen : 0)
 600         ),
 601
 602         TP_fast_assign(
 603                 __entry->xprt = xprt;
 604                 if (xprt) {
 605                         memcpy(__get_dynamic_array(addr),
 606                                         &xprt->xpt_remote,
 607                                         xprt->xpt_remotelen);
 608                         __entry->flags = xprt->xpt_flags;
 609                 } else
 610                         __entry->flags = 0;
 611         ),
 612
 613         TP_printk("xprt=0x%p addr=%pIScp flags=%s", __entry->xprt,
 614                 __get_dynamic_array_len(addr) != 0 ?
 615                         (struct sockaddr *)__get_dynamic_array(addr) : NULL,
 616                 show_svc_xprt_flags(__entry->flags))
 617 );
 618
 619 DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue,
 620         TP_PROTO(struct svc_xprt *xprt),
 621         TP_ARGS(xprt));
 622
 623 DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
 624         TP_PROTO(struct svc_xprt *xprt),
 625         TP_ARGS(xprt));
 626
 627 TRACE_EVENT(svc_wake_up,
 628         TP_PROTO(int pid),
 629
 630         TP_ARGS(pid),
 631
 632         TP_STRUCT__entry(
 633                 __field(int, pid)
 634         ),
 635
 636         TP_fast_assign(
 637                 __entry->pid = pid;
 638         ),
 639
 640         TP_printk("pid=%d", __entry->pid)
 641 );
 642
 643 TRACE_EVENT(svc_handle_xprt,
 644         TP_PROTO(struct svc_xprt *xprt, int len),
 645
 646         TP_ARGS(xprt, len),
 647
 648         TP_STRUCT__entry(
 649                 __field(struct svc_xprt *, xprt)
 650                 __field(int, len)
 651                 __field(unsigned long, flags)
 652                 __dynamic_array(unsigned char, addr, xprt != NULL ?
 653                         xprt->xpt_remotelen : 0)
 654         ),
 655
 656         TP_fast_assign(
 657                 __entry->xprt = xprt;
 658                 __entry->len = len;
 659                 if (xprt) {
 660                         memcpy(__get_dynamic_array(addr),
 661                                         &xprt->xpt_remote,
 662                                         xprt->xpt_remotelen);
 663                         __entry->flags = xprt->xpt_flags;
 664                 } else
 665                         __entry->flags = 0;
 666         ),
 667
 668         TP_printk("xprt=0x%p addr=%pIScp len=%d flags=%s", __entry->xprt,
 669                 __get_dynamic_array_len(addr) != 0 ?
 670                         (struct sockaddr *)__get_dynamic_array(addr) : NULL,
 671                 __entry->len, show_svc_xprt_flags(__entry->flags))
 672 );
 673
 674
 675 DECLARE_EVENT_CLASS(svc_deferred_event,
 676         TP_PROTO(struct svc_deferred_req *dr),
 677
 678         TP_ARGS(dr),
 679
 680         TP_STRUCT__entry(
 681                 __field(__be32, xid)
 682                 __dynamic_array(unsigned char, addr, dr->addrlen)
 683         ),
 684
 685         TP_fast_assign(
 686                 __entry->xid = *(__be32 *)(dr->args + (dr->xprt_hlen>>2));
 687                 memcpy(__get_dynamic_array(addr), &dr->addr, dr->addrlen);
 688         ),
 689
 690         TP_printk("addr=%pIScp xid=0x%x",
 691                 (struct sockaddr *)__get_dynamic_array(addr),
 692                 be32_to_cpu(__entry->xid))
 693 );
 694
 695 DEFINE_EVENT(svc_deferred_event, svc_drop_deferred,
 696         TP_PROTO(struct svc_deferred_req *dr),
 697         TP_ARGS(dr));
 698 DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred,
 699         TP_PROTO(struct svc_deferred_req *dr),
 700         TP_ARGS(dr));
 701 #endif /* _TRACE_SUNRPC_H */
 702
 703 #include <trace/define_trace.h>