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