include/trace/events/sunrpc.h

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