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 #include <trace/misc/sunrpc.h>
  18
  19 TRACE_DEFINE_ENUM(SOCK_STREAM);
  20 TRACE_DEFINE_ENUM(SOCK_DGRAM);
  21 TRACE_DEFINE_ENUM(SOCK_RAW);
  22 TRACE_DEFINE_ENUM(SOCK_RDM);
  23 TRACE_DEFINE_ENUM(SOCK_SEQPACKET);
  24 TRACE_DEFINE_ENUM(SOCK_DCCP);
  25 TRACE_DEFINE_ENUM(SOCK_PACKET);
  26
  27 #define show_socket_type(type)                                  \
  28         __print_symbolic(type,                                  \
  29                 { SOCK_STREAM,          "STREAM" },             \
  30                 { SOCK_DGRAM,           "DGRAM" },              \
  31                 { SOCK_RAW,             "RAW" },                \
  32                 { SOCK_RDM,             "RDM" },                \
  33                 { SOCK_SEQPACKET,       "SEQPACKET" },          \
  34                 { SOCK_DCCP,            "DCCP" },               \
  35                 { SOCK_PACKET,          "PACKET" })
  36
  37 /* This list is known to be incomplete, add new enums as needed. */
  38 TRACE_DEFINE_ENUM(AF_UNSPEC);
  39 TRACE_DEFINE_ENUM(AF_UNIX);
  40 TRACE_DEFINE_ENUM(AF_LOCAL);
  41 TRACE_DEFINE_ENUM(AF_INET);
  42 TRACE_DEFINE_ENUM(AF_INET6);
  43
  44 #define rpc_show_address_family(family)                         \
  45         __print_symbolic(family,                                \
  46                 { AF_UNSPEC,            "AF_UNSPEC" },          \
  47                 { AF_UNIX,              "AF_UNIX" },            \
  48                 { AF_LOCAL,             "AF_LOCAL" },           \
  49                 { AF_INET,              "AF_INET" },            \
  50                 { AF_INET6,             "AF_INET6" })
  51
  52 DECLARE_EVENT_CLASS(rpc_xdr_buf_class,
  53         TP_PROTO(
  54                 const struct rpc_task *task,
  55                 const struct xdr_buf *xdr
  56         ),
  57
  58         TP_ARGS(task, xdr),
  59
  60         TP_STRUCT__entry(
  61                 __field(unsigned int, task_id)
  62                 __field(unsigned int, client_id)
  63                 __field(const void *, head_base)
  64                 __field(size_t, head_len)
  65                 __field(const void *, tail_base)
  66                 __field(size_t, tail_len)
  67                 __field(unsigned int, page_base)
  68                 __field(unsigned int, page_len)
  69                 __field(unsigned int, msg_len)
  70         ),
  71
  72         TP_fast_assign(
  73                 __entry->task_id = task->tk_pid;
  74                 __entry->client_id = task->tk_client ?
  75                                      task->tk_client->cl_clid : -1;
  76                 __entry->head_base = xdr->head[0].iov_base;
  77                 __entry->head_len = xdr->head[0].iov_len;
  78                 __entry->tail_base = xdr->tail[0].iov_base;
  79                 __entry->tail_len = xdr->tail[0].iov_len;
  80                 __entry->page_base = xdr->page_base;
  81                 __entry->page_len = xdr->page_len;
  82                 __entry->msg_len = xdr->len;
  83         ),
  84
  85         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
  86                   " head=[%p,%zu] page=%u(%u) tail=[%p,%zu] len=%u",
  87                 __entry->task_id, __entry->client_id,
  88                 __entry->head_base, __entry->head_len,
  89                 __entry->page_len, __entry->page_base,
  90                 __entry->tail_base, __entry->tail_len,
  91                 __entry->msg_len
  92         )
  93 );
  94
  95 #define DEFINE_RPCXDRBUF_EVENT(name)                                    \
  96                 DEFINE_EVENT(rpc_xdr_buf_class,                         \
  97                                 rpc_xdr_##name,                         \
  98                                 TP_PROTO(                               \
  99                                         const struct rpc_task *task,    \
 100                                         const struct xdr_buf *xdr       \
 101                                 ),                                      \
 102                                 TP_ARGS(task, xdr))
 103
 104 DEFINE_RPCXDRBUF_EVENT(sendto);
 105 DEFINE_RPCXDRBUF_EVENT(recvfrom);
 106 DEFINE_RPCXDRBUF_EVENT(reply_pages);
 107
 108
 109 DECLARE_EVENT_CLASS(rpc_clnt_class,
 110         TP_PROTO(
 111                 const struct rpc_clnt *clnt
 112         ),
 113
 114         TP_ARGS(clnt),
 115
 116         TP_STRUCT__entry(
 117                 __field(unsigned int, client_id)
 118         ),
 119
 120         TP_fast_assign(
 121                 __entry->client_id = clnt->cl_clid;
 122         ),
 123
 124         TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER, __entry->client_id)
 125 );
 126
 127 #define DEFINE_RPC_CLNT_EVENT(name)                                     \
 128                 DEFINE_EVENT(rpc_clnt_class,                            \
 129                                 rpc_clnt_##name,                        \
 130                                 TP_PROTO(                               \
 131                                         const struct rpc_clnt *clnt     \
 132                                 ),                                      \
 133                                 TP_ARGS(clnt))
 134
 135 DEFINE_RPC_CLNT_EVENT(free);
 136 DEFINE_RPC_CLNT_EVENT(killall);
 137 DEFINE_RPC_CLNT_EVENT(shutdown);
 138 DEFINE_RPC_CLNT_EVENT(release);
 139 DEFINE_RPC_CLNT_EVENT(replace_xprt);
 140 DEFINE_RPC_CLNT_EVENT(replace_xprt_err);
 141
 142 TRACE_EVENT(rpc_clnt_new,
 143         TP_PROTO(
 144                 const struct rpc_clnt *clnt,
 145                 const struct rpc_xprt *xprt,
 146                 const char *program,
 147                 const char *server
 148         ),
 149
 150         TP_ARGS(clnt, xprt, program, server),
 151
 152         TP_STRUCT__entry(
 153                 __field(unsigned int, client_id)
 154                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 155                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 156                 __string(program, program)
 157                 __string(server, server)
 158         ),
 159
 160         TP_fast_assign(
 161                 __entry->client_id = clnt->cl_clid;
 162                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 163                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 164                 __assign_str(program, program);
 165                 __assign_str(server, server);
 166         ),
 167
 168         TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER
 169                   " peer=[%s]:%s program=%s server=%s",
 170                 __entry->client_id, __get_str(addr), __get_str(port),
 171                 __get_str(program), __get_str(server))
 172 );
 173
 174 TRACE_EVENT(rpc_clnt_new_err,
 175         TP_PROTO(
 176                 const char *program,
 177                 const char *server,
 178                 int error
 179         ),
 180
 181         TP_ARGS(program, server, error),
 182
 183         TP_STRUCT__entry(
 184                 __field(int, error)
 185                 __string(program, program)
 186                 __string(server, server)
 187         ),
 188
 189         TP_fast_assign(
 190                 __entry->error = error;
 191                 __assign_str(program, program);
 192                 __assign_str(server, server);
 193         ),
 194
 195         TP_printk("program=%s server=%s error=%d",
 196                 __get_str(program), __get_str(server), __entry->error)
 197 );
 198
 199 TRACE_EVENT(rpc_clnt_clone_err,
 200         TP_PROTO(
 201                 const struct rpc_clnt *clnt,
 202                 int error
 203         ),
 204
 205         TP_ARGS(clnt, error),
 206
 207         TP_STRUCT__entry(
 208                 __field(unsigned int, client_id)
 209                 __field(int, error)
 210         ),
 211
 212         TP_fast_assign(
 213                 __entry->client_id = clnt->cl_clid;
 214                 __entry->error = error;
 215         ),
 216
 217         TP_printk("client=" SUNRPC_TRACE_CLID_SPECIFIER " error=%d",
 218                 __entry->client_id, __entry->error)
 219 );
 220
 221
 222 TRACE_DEFINE_ENUM(RPC_AUTH_OK);
 223 TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
 224 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
 225 TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
 226 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
 227 TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
 228 TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
 229 TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);
 230
 231 #define rpc_show_auth_stat(status)                                      \
 232         __print_symbolic(status,                                        \
 233                 { RPC_AUTH_OK,                  "AUTH_OK" },            \
 234                 { RPC_AUTH_BADCRED,             "BADCRED" },            \
 235                 { RPC_AUTH_REJECTEDCRED,        "REJECTEDCRED" },       \
 236                 { RPC_AUTH_BADVERF,             "BADVERF" },            \
 237                 { RPC_AUTH_REJECTEDVERF,        "REJECTEDVERF" },       \
 238                 { RPC_AUTH_TOOWEAK,             "TOOWEAK" },            \
 239                 { RPCSEC_GSS_CREDPROBLEM,       "GSS_CREDPROBLEM" },    \
 240                 { RPCSEC_GSS_CTXPROBLEM,        "GSS_CTXPROBLEM" })     \
 241
 242 DECLARE_EVENT_CLASS(rpc_task_status,
 243
 244         TP_PROTO(const struct rpc_task *task),
 245
 246         TP_ARGS(task),
 247
 248         TP_STRUCT__entry(
 249                 __field(unsigned int, task_id)
 250                 __field(unsigned int, client_id)
 251                 __field(int, status)
 252         ),
 253
 254         TP_fast_assign(
 255                 __entry->task_id = task->tk_pid;
 256                 __entry->client_id = task->tk_client->cl_clid;
 257                 __entry->status = task->tk_status;
 258         ),
 259
 260         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d",
 261                 __entry->task_id, __entry->client_id,
 262                 __entry->status)
 263 );
 264 #define DEFINE_RPC_STATUS_EVENT(name) \
 265         DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
 266                         TP_PROTO( \
 267                                 const struct rpc_task *task \
 268                         ), \
 269                         TP_ARGS(task))
 270
 271 DEFINE_RPC_STATUS_EVENT(call);
 272 DEFINE_RPC_STATUS_EVENT(connect);
 273 DEFINE_RPC_STATUS_EVENT(timeout);
 274 DEFINE_RPC_STATUS_EVENT(retry_refresh);
 275 DEFINE_RPC_STATUS_EVENT(refresh);
 276
 277 TRACE_EVENT(rpc_request,
 278         TP_PROTO(const struct rpc_task *task),
 279
 280         TP_ARGS(task),
 281
 282         TP_STRUCT__entry(
 283                 __field(unsigned int, task_id)
 284                 __field(unsigned int, client_id)
 285                 __field(int, version)
 286                 __field(bool, async)
 287                 __string(progname, task->tk_client->cl_program->name)
 288                 __string(procname, rpc_proc_name(task))
 289         ),
 290
 291         TP_fast_assign(
 292                 __entry->task_id = task->tk_pid;
 293                 __entry->client_id = task->tk_client->cl_clid;
 294                 __entry->version = task->tk_client->cl_vers;
 295                 __entry->async = RPC_IS_ASYNC(task);
 296                 __assign_str(progname, task->tk_client->cl_program->name);
 297                 __assign_str(procname, rpc_proc_name(task));
 298         ),
 299
 300         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " %sv%d %s (%ssync)",
 301                 __entry->task_id, __entry->client_id,
 302                 __get_str(progname), __entry->version,
 303                 __get_str(procname), __entry->async ? "a": ""
 304                 )
 305 );
 306
 307 #define rpc_show_task_flags(flags)                                      \
 308         __print_flags(flags, "|",                                       \
 309                 { RPC_TASK_ASYNC, "ASYNC" },                            \
 310                 { RPC_TASK_SWAPPER, "SWAPPER" },                        \
 311                 { RPC_TASK_MOVEABLE, "MOVEABLE" },                      \
 312                 { RPC_TASK_NULLCREDS, "NULLCREDS" },                    \
 313                 { RPC_CALL_MAJORSEEN, "MAJORSEEN" },                    \
 314                 { RPC_TASK_DYNAMIC, "DYNAMIC" },                        \
 315                 { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" },          \
 316                 { RPC_TASK_SOFT, "SOFT" },                              \
 317                 { RPC_TASK_SOFTCONN, "SOFTCONN" },                      \
 318                 { RPC_TASK_SENT, "SENT" },                              \
 319                 { RPC_TASK_TIMEOUT, "TIMEOUT" },                        \
 320                 { RPC_TASK_NOCONNECT, "NOCONNECT" },                    \
 321                 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" },               \
 322                 { RPC_TASK_CRED_NOREF, "CRED_NOREF" })
 323
 324 #define rpc_show_runstate(flags)                                        \
 325         __print_flags(flags, "|",                                       \
 326                 { (1UL << RPC_TASK_RUNNING), "RUNNING" },               \
 327                 { (1UL << RPC_TASK_QUEUED), "QUEUED" },                 \
 328                 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" },                 \
 329                 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" },           \
 330                 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" },           \
 331                 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" },     \
 332                 { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
 333
 334 DECLARE_EVENT_CLASS(rpc_task_running,
 335
 336         TP_PROTO(const struct rpc_task *task, const void *action),
 337
 338         TP_ARGS(task, action),
 339
 340         TP_STRUCT__entry(
 341                 __field(unsigned int, task_id)
 342                 __field(unsigned int, client_id)
 343                 __field(const void *, action)
 344                 __field(unsigned long, runstate)
 345                 __field(int, status)
 346                 __field(unsigned short, flags)
 347                 ),
 348
 349         TP_fast_assign(
 350                 __entry->client_id = task->tk_client ?
 351                                      task->tk_client->cl_clid : -1;
 352                 __entry->task_id = task->tk_pid;
 353                 __entry->action = action;
 354                 __entry->runstate = task->tk_runstate;
 355                 __entry->status = task->tk_status;
 356                 __entry->flags = task->tk_flags;
 357                 ),
 358
 359         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 360                   " flags=%s runstate=%s status=%d action=%ps",
 361                 __entry->task_id, __entry->client_id,
 362                 rpc_show_task_flags(__entry->flags),
 363                 rpc_show_runstate(__entry->runstate),
 364                 __entry->status,
 365                 __entry->action
 366                 )
 367 );
 368 #define DEFINE_RPC_RUNNING_EVENT(name) \
 369         DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
 370                         TP_PROTO( \
 371                                 const struct rpc_task *task, \
 372                                 const void *action \
 373                         ), \
 374                         TP_ARGS(task, action))
 375
 376 DEFINE_RPC_RUNNING_EVENT(begin);
 377 DEFINE_RPC_RUNNING_EVENT(run_action);
 378 DEFINE_RPC_RUNNING_EVENT(sync_sleep);
 379 DEFINE_RPC_RUNNING_EVENT(sync_wake);
 380 DEFINE_RPC_RUNNING_EVENT(complete);
 381 DEFINE_RPC_RUNNING_EVENT(timeout);
 382 DEFINE_RPC_RUNNING_EVENT(signalled);
 383 DEFINE_RPC_RUNNING_EVENT(end);
 384 DEFINE_RPC_RUNNING_EVENT(call_done);
 385
 386 DECLARE_EVENT_CLASS(rpc_task_queued,
 387
 388         TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
 389
 390         TP_ARGS(task, q),
 391
 392         TP_STRUCT__entry(
 393                 __field(unsigned int, task_id)
 394                 __field(unsigned int, client_id)
 395                 __field(unsigned long, timeout)
 396                 __field(unsigned long, runstate)
 397                 __field(int, status)
 398                 __field(unsigned short, flags)
 399                 __string(q_name, rpc_qname(q))
 400                 ),
 401
 402         TP_fast_assign(
 403                 __entry->client_id = task->tk_client ?
 404                                      task->tk_client->cl_clid : -1;
 405                 __entry->task_id = task->tk_pid;
 406                 __entry->timeout = rpc_task_timeout(task);
 407                 __entry->runstate = task->tk_runstate;
 408                 __entry->status = task->tk_status;
 409                 __entry->flags = task->tk_flags;
 410                 __assign_str(q_name, rpc_qname(q));
 411                 ),
 412
 413         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 414                   " flags=%s runstate=%s status=%d timeout=%lu queue=%s",
 415                 __entry->task_id, __entry->client_id,
 416                 rpc_show_task_flags(__entry->flags),
 417                 rpc_show_runstate(__entry->runstate),
 418                 __entry->status,
 419                 __entry->timeout,
 420                 __get_str(q_name)
 421                 )
 422 );
 423 #define DEFINE_RPC_QUEUED_EVENT(name) \
 424         DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
 425                         TP_PROTO( \
 426                                 const struct rpc_task *task, \
 427                                 const struct rpc_wait_queue *q \
 428                         ), \
 429                         TP_ARGS(task, q))
 430
 431 DEFINE_RPC_QUEUED_EVENT(sleep);
 432 DEFINE_RPC_QUEUED_EVENT(wakeup);
 433
 434 DECLARE_EVENT_CLASS(rpc_failure,
 435
 436         TP_PROTO(const struct rpc_task *task),
 437
 438         TP_ARGS(task),
 439
 440         TP_STRUCT__entry(
 441                 __field(unsigned int, task_id)
 442                 __field(unsigned int, client_id)
 443         ),
 444
 445         TP_fast_assign(
 446                 __entry->task_id = task->tk_pid;
 447                 __entry->client_id = task->tk_client->cl_clid;
 448         ),
 449
 450         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER,
 451                 __entry->task_id, __entry->client_id)
 452 );
 453
 454 #define DEFINE_RPC_FAILURE(name)                                        \
 455         DEFINE_EVENT(rpc_failure, rpc_bad_##name,                       \
 456                         TP_PROTO(                                       \
 457                                 const struct rpc_task *task             \
 458                         ),                                              \
 459                         TP_ARGS(task))
 460
 461 DEFINE_RPC_FAILURE(callhdr);
 462 DEFINE_RPC_FAILURE(verifier);
 463
 464 DECLARE_EVENT_CLASS(rpc_reply_event,
 465
 466         TP_PROTO(
 467                 const struct rpc_task *task
 468         ),
 469
 470         TP_ARGS(task),
 471
 472         TP_STRUCT__entry(
 473                 __field(unsigned int, task_id)
 474                 __field(unsigned int, client_id)
 475                 __field(u32, xid)
 476                 __string(progname, task->tk_client->cl_program->name)
 477                 __field(u32, version)
 478                 __string(procname, rpc_proc_name(task))
 479                 __string(servername, task->tk_xprt->servername)
 480         ),
 481
 482         TP_fast_assign(
 483                 __entry->task_id = task->tk_pid;
 484                 __entry->client_id = task->tk_client->cl_clid;
 485                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 486                 __assign_str(progname, task->tk_client->cl_program->name);
 487                 __entry->version = task->tk_client->cl_vers;
 488                 __assign_str(procname, rpc_proc_name(task));
 489                 __assign_str(servername, task->tk_xprt->servername);
 490         ),
 491
 492         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 493                   " server=%s xid=0x%08x %sv%d %s",
 494                 __entry->task_id, __entry->client_id, __get_str(servername),
 495                 __entry->xid, __get_str(progname), __entry->version,
 496                 __get_str(procname))
 497 )
 498
 499 #define DEFINE_RPC_REPLY_EVENT(name)                                    \
 500         DEFINE_EVENT(rpc_reply_event, rpc__##name,                      \
 501                         TP_PROTO(                                       \
 502                                 const struct rpc_task *task             \
 503                         ),                                              \
 504                         TP_ARGS(task))
 505
 506 DEFINE_RPC_REPLY_EVENT(prog_unavail);
 507 DEFINE_RPC_REPLY_EVENT(prog_mismatch);
 508 DEFINE_RPC_REPLY_EVENT(proc_unavail);
 509 DEFINE_RPC_REPLY_EVENT(garbage_args);
 510 DEFINE_RPC_REPLY_EVENT(unparsable);
 511 DEFINE_RPC_REPLY_EVENT(mismatch);
 512 DEFINE_RPC_REPLY_EVENT(stale_creds);
 513 DEFINE_RPC_REPLY_EVENT(bad_creds);
 514 DEFINE_RPC_REPLY_EVENT(auth_tooweak);
 515
 516 #define DEFINE_RPCB_ERROR_EVENT(name)                                   \
 517         DEFINE_EVENT(rpc_reply_event, rpcb_##name##_err,                \
 518                         TP_PROTO(                                       \
 519                                 const struct rpc_task *task             \
 520                         ),                                              \
 521                         TP_ARGS(task))
 522
 523 DEFINE_RPCB_ERROR_EVENT(prog_unavail);
 524 DEFINE_RPCB_ERROR_EVENT(timeout);
 525 DEFINE_RPCB_ERROR_EVENT(bind_version);
 526 DEFINE_RPCB_ERROR_EVENT(unreachable);
 527 DEFINE_RPCB_ERROR_EVENT(unrecognized);
 528
 529 TRACE_EVENT(rpc_buf_alloc,
 530         TP_PROTO(
 531                 const struct rpc_task *task,
 532                 int status
 533         ),
 534
 535         TP_ARGS(task, status),
 536
 537         TP_STRUCT__entry(
 538                 __field(unsigned int, task_id)
 539                 __field(unsigned int, client_id)
 540                 __field(size_t, callsize)
 541                 __field(size_t, recvsize)
 542                 __field(int, status)
 543         ),
 544
 545         TP_fast_assign(
 546                 __entry->task_id = task->tk_pid;
 547                 __entry->client_id = task->tk_client->cl_clid;
 548                 __entry->callsize = task->tk_rqstp->rq_callsize;
 549                 __entry->recvsize = task->tk_rqstp->rq_rcvsize;
 550                 __entry->status = status;
 551         ),
 552
 553         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 554                   " callsize=%zu recvsize=%zu status=%d",
 555                 __entry->task_id, __entry->client_id,
 556                 __entry->callsize, __entry->recvsize, __entry->status
 557         )
 558 );
 559
 560 TRACE_EVENT(rpc_call_rpcerror,
 561         TP_PROTO(
 562                 const struct rpc_task *task,
 563                 int tk_status,
 564                 int rpc_status
 565         ),
 566
 567         TP_ARGS(task, tk_status, rpc_status),
 568
 569         TP_STRUCT__entry(
 570                 __field(unsigned int, task_id)
 571                 __field(unsigned int, client_id)
 572                 __field(int, tk_status)
 573                 __field(int, rpc_status)
 574         ),
 575
 576         TP_fast_assign(
 577                 __entry->client_id = task->tk_client->cl_clid;
 578                 __entry->task_id = task->tk_pid;
 579                 __entry->tk_status = tk_status;
 580                 __entry->rpc_status = rpc_status;
 581         ),
 582
 583         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 584                   " tk_status=%d rpc_status=%d",
 585                 __entry->task_id, __entry->client_id,
 586                 __entry->tk_status, __entry->rpc_status)
 587 );
 588
 589 TRACE_EVENT(rpc_stats_latency,
 590
 591         TP_PROTO(
 592                 const struct rpc_task *task,
 593                 ktime_t backlog,
 594                 ktime_t rtt,
 595                 ktime_t execute
 596         ),
 597
 598         TP_ARGS(task, backlog, rtt, execute),
 599
 600         TP_STRUCT__entry(
 601                 __field(unsigned int, task_id)
 602                 __field(unsigned int, client_id)
 603                 __field(u32, xid)
 604                 __field(int, version)
 605                 __string(progname, task->tk_client->cl_program->name)
 606                 __string(procname, rpc_proc_name(task))
 607                 __field(unsigned long, backlog)
 608                 __field(unsigned long, rtt)
 609                 __field(unsigned long, execute)
 610         ),
 611
 612         TP_fast_assign(
 613                 __entry->client_id = task->tk_client->cl_clid;
 614                 __entry->task_id = task->tk_pid;
 615                 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
 616                 __entry->version = task->tk_client->cl_vers;
 617                 __assign_str(progname, task->tk_client->cl_program->name);
 618                 __assign_str(procname, rpc_proc_name(task));
 619                 __entry->backlog = ktime_to_us(backlog);
 620                 __entry->rtt = ktime_to_us(rtt);
 621                 __entry->execute = ktime_to_us(execute);
 622         ),
 623
 624         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 625                   " xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
 626                 __entry->task_id, __entry->client_id, __entry->xid,
 627                 __get_str(progname), __entry->version, __get_str(procname),
 628                 __entry->backlog, __entry->rtt, __entry->execute)
 629 );
 630
 631 TRACE_EVENT(rpc_xdr_overflow,
 632         TP_PROTO(
 633                 const struct xdr_stream *xdr,
 634                 size_t requested
 635         ),
 636
 637         TP_ARGS(xdr, requested),
 638
 639         TP_STRUCT__entry(
 640                 __field(unsigned int, task_id)
 641                 __field(unsigned int, client_id)
 642                 __field(int, version)
 643                 __field(size_t, requested)
 644                 __field(const void *, end)
 645                 __field(const void *, p)
 646                 __field(const void *, head_base)
 647                 __field(size_t, head_len)
 648                 __field(const void *, tail_base)
 649                 __field(size_t, tail_len)
 650                 __field(unsigned int, page_len)
 651                 __field(unsigned int, len)
 652                 __string(progname, xdr->rqst ?
 653                          xdr->rqst->rq_task->tk_client->cl_program->name : "unknown")
 654                 __string(procedure, xdr->rqst ?
 655                          xdr->rqst->rq_task->tk_msg.rpc_proc->p_name : "unknown")
 656         ),
 657
 658         TP_fast_assign(
 659                 if (xdr->rqst) {
 660                         const struct rpc_task *task = xdr->rqst->rq_task;
 661
 662                         __entry->task_id = task->tk_pid;
 663                         __entry->client_id = task->tk_client->cl_clid;
 664                         __assign_str(progname,
 665                                      task->tk_client->cl_program->name);
 666                         __entry->version = task->tk_client->cl_vers;
 667                         __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
 668                 } else {
 669                         __entry->task_id = -1;
 670                         __entry->client_id = -1;
 671                         __assign_str(progname, "unknown");
 672                         __entry->version = 0;
 673                         __assign_str(procedure, "unknown");
 674                 }
 675                 __entry->requested = requested;
 676                 __entry->end = xdr->end;
 677                 __entry->p = xdr->p;
 678                 __entry->head_base = xdr->buf->head[0].iov_base,
 679                 __entry->head_len = xdr->buf->head[0].iov_len,
 680                 __entry->page_len = xdr->buf->page_len,
 681                 __entry->tail_base = xdr->buf->tail[0].iov_base,
 682                 __entry->tail_len = xdr->buf->tail[0].iov_len,
 683                 __entry->len = xdr->buf->len;
 684         ),
 685
 686         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 687                   " %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
 688                 __entry->task_id, __entry->client_id,
 689                 __get_str(progname), __entry->version, __get_str(procedure),
 690                 __entry->requested, __entry->p, __entry->end,
 691                 __entry->head_base, __entry->head_len,
 692                 __entry->page_len,
 693                 __entry->tail_base, __entry->tail_len,
 694                 __entry->len
 695         )
 696 );
 697
 698 TRACE_EVENT(rpc_xdr_alignment,
 699         TP_PROTO(
 700                 const struct xdr_stream *xdr,
 701                 size_t offset,
 702                 unsigned int copied
 703         ),
 704
 705         TP_ARGS(xdr, offset, copied),
 706
 707         TP_STRUCT__entry(
 708                 __field(unsigned int, task_id)
 709                 __field(unsigned int, client_id)
 710                 __field(int, version)
 711                 __field(size_t, offset)
 712                 __field(unsigned int, copied)
 713                 __field(const void *, head_base)
 714                 __field(size_t, head_len)
 715                 __field(const void *, tail_base)
 716                 __field(size_t, tail_len)
 717                 __field(unsigned int, page_len)
 718                 __field(unsigned int, len)
 719                 __string(progname,
 720                          xdr->rqst->rq_task->tk_client->cl_program->name)
 721                 __string(procedure,
 722                          xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
 723         ),
 724
 725         TP_fast_assign(
 726                 const struct rpc_task *task = xdr->rqst->rq_task;
 727
 728                 __entry->task_id = task->tk_pid;
 729                 __entry->client_id = task->tk_client->cl_clid;
 730                 __assign_str(progname,
 731                              task->tk_client->cl_program->name);
 732                 __entry->version = task->tk_client->cl_vers;
 733                 __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
 734
 735                 __entry->offset = offset;
 736                 __entry->copied = copied;
 737                 __entry->head_base = xdr->buf->head[0].iov_base,
 738                 __entry->head_len = xdr->buf->head[0].iov_len,
 739                 __entry->page_len = xdr->buf->page_len,
 740                 __entry->tail_base = xdr->buf->tail[0].iov_base,
 741                 __entry->tail_len = xdr->buf->tail[0].iov_len,
 742                 __entry->len = xdr->buf->len;
 743         ),
 744
 745         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 746                   " %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
 747                 __entry->task_id, __entry->client_id,
 748                 __get_str(progname), __entry->version, __get_str(procedure),
 749                 __entry->offset, __entry->copied,
 750                 __entry->head_base, __entry->head_len,
 751                 __entry->page_len,
 752                 __entry->tail_base, __entry->tail_len,
 753                 __entry->len
 754         )
 755 );
 756
 757 /*
 758  * First define the enums in the below macros to be exported to userspace
 759  * via TRACE_DEFINE_ENUM().
 760  */
 761 #undef EM
 762 #undef EMe
 763 #define EM(a, b)        TRACE_DEFINE_ENUM(a);
 764 #define EMe(a, b)       TRACE_DEFINE_ENUM(a);
 765
 766 #define RPC_SHOW_SOCKET                         \
 767         EM( SS_FREE, "FREE" )                   \
 768         EM( SS_UNCONNECTED, "UNCONNECTED" )     \
 769         EM( SS_CONNECTING, "CONNECTING" )       \
 770         EM( SS_CONNECTED, "CONNECTED" )         \
 771         EMe( SS_DISCONNECTING, "DISCONNECTING" )
 772
 773 #define rpc_show_socket_state(state) \
 774         __print_symbolic(state, RPC_SHOW_SOCKET)
 775
 776 RPC_SHOW_SOCKET
 777
 778 #define RPC_SHOW_SOCK                           \
 779         EM( TCP_ESTABLISHED, "ESTABLISHED" )    \
 780         EM( TCP_SYN_SENT, "SYN_SENT" )          \
 781         EM( TCP_SYN_RECV, "SYN_RECV" )          \
 782         EM( TCP_FIN_WAIT1, "FIN_WAIT1" )        \
 783         EM( TCP_FIN_WAIT2, "FIN_WAIT2" )        \
 784         EM( TCP_TIME_WAIT, "TIME_WAIT" )        \
 785         EM( TCP_CLOSE, "CLOSE" )                \
 786         EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" )      \
 787         EM( TCP_LAST_ACK, "LAST_ACK" )          \
 788         EM( TCP_LISTEN, "LISTEN" )              \
 789         EMe( TCP_CLOSING, "CLOSING" )
 790
 791 #define rpc_show_sock_state(state) \
 792         __print_symbolic(state, RPC_SHOW_SOCK)
 793
 794 RPC_SHOW_SOCK
 795
 796
 797 #include <trace/events/net_probe_common.h>
 798
 799 /*
 800  * Now redefine the EM() and EMe() macros to map the enums to the strings
 801  * that will be printed in the output.
 802  */
 803 #undef EM
 804 #undef EMe
 805 #define EM(a, b)        {a, b},
 806 #define EMe(a, b)       {a, b}
 807
 808 DECLARE_EVENT_CLASS(xs_socket_event,
 809
 810                 TP_PROTO(
 811                         struct rpc_xprt *xprt,
 812                         struct socket *socket
 813                 ),
 814
 815                 TP_ARGS(xprt, socket),
 816
 817                 TP_STRUCT__entry(
 818                         __field(unsigned int, socket_state)
 819                         __field(unsigned int, sock_state)
 820                         __field(unsigned long long, ino)
 821                         __array(__u8, saddr, sizeof(struct sockaddr_in6))
 822                         __array(__u8, daddr, sizeof(struct sockaddr_in6))
 823                 ),
 824
 825                 TP_fast_assign(
 826                         struct inode *inode = SOCK_INODE(socket);
 827                         const struct sock *sk = socket->sk;
 828                         const struct inet_sock *inet = inet_sk(sk);
 829
 830                         memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
 831                         memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
 832
 833                         TP_STORE_ADDR_PORTS(__entry, inet, sk);
 834
 835                         __entry->socket_state = socket->state;
 836                         __entry->sock_state = socket->sk->sk_state;
 837                         __entry->ino = (unsigned long long)inode->i_ino;
 838
 839                 ),
 840
 841                 TP_printk(
 842                         "socket:[%llu] srcaddr=%pISpc dstaddr=%pISpc "
 843                         "state=%u (%s) sk_state=%u (%s)",
 844                         __entry->ino,
 845                         __entry->saddr,
 846                         __entry->daddr,
 847                         __entry->socket_state,
 848                         rpc_show_socket_state(__entry->socket_state),
 849                         __entry->sock_state,
 850                         rpc_show_sock_state(__entry->sock_state)
 851                 )
 852 );
 853 #define DEFINE_RPC_SOCKET_EVENT(name) \
 854         DEFINE_EVENT(xs_socket_event, name, \
 855                         TP_PROTO( \
 856                                 struct rpc_xprt *xprt, \
 857                                 struct socket *socket \
 858                         ), \
 859                         TP_ARGS(xprt, socket))
 860
 861 DECLARE_EVENT_CLASS(xs_socket_event_done,
 862
 863                 TP_PROTO(
 864                         struct rpc_xprt *xprt,
 865                         struct socket *socket,
 866                         int error
 867                 ),
 868
 869                 TP_ARGS(xprt, socket, error),
 870
 871                 TP_STRUCT__entry(
 872                         __field(int, error)
 873                         __field(unsigned int, socket_state)
 874                         __field(unsigned int, sock_state)
 875                         __field(unsigned long long, ino)
 876                         __array(__u8, saddr, sizeof(struct sockaddr_in6))
 877                         __array(__u8, daddr, sizeof(struct sockaddr_in6))
 878                 ),
 879
 880                 TP_fast_assign(
 881                         struct inode *inode = SOCK_INODE(socket);
 882                         const struct sock *sk = socket->sk;
 883                         const struct inet_sock *inet = inet_sk(sk);
 884
 885                         memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
 886                         memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
 887
 888                         TP_STORE_ADDR_PORTS(__entry, inet, sk);
 889
 890                         __entry->socket_state = socket->state;
 891                         __entry->sock_state = socket->sk->sk_state;
 892                         __entry->ino = (unsigned long long)inode->i_ino;
 893                         __entry->error = error;
 894                 ),
 895
 896                 TP_printk(
 897                         "error=%d socket:[%llu] srcaddr=%pISpc dstaddr=%pISpc "
 898                         "state=%u (%s) sk_state=%u (%s)",
 899                         __entry->error,
 900                         __entry->ino,
 901                         __entry->saddr,
 902                         __entry->daddr,
 903                         __entry->socket_state,
 904                         rpc_show_socket_state(__entry->socket_state),
 905                         __entry->sock_state,
 906                         rpc_show_sock_state(__entry->sock_state)
 907                 )
 908 );
 909 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
 910         DEFINE_EVENT(xs_socket_event_done, name, \
 911                         TP_PROTO( \
 912                                 struct rpc_xprt *xprt, \
 913                                 struct socket *socket, \
 914                                 int error \
 915                         ), \
 916                         TP_ARGS(xprt, socket, error))
 917
 918 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
 919 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
 920 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
 921 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
 922 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
 923 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
 924
 925 TRACE_EVENT(rpc_socket_nospace,
 926         TP_PROTO(
 927                 const struct rpc_rqst *rqst,
 928                 const struct sock_xprt *transport
 929         ),
 930
 931         TP_ARGS(rqst, transport),
 932
 933         TP_STRUCT__entry(
 934                 __field(unsigned int, task_id)
 935                 __field(unsigned int, client_id)
 936                 __field(unsigned int, total)
 937                 __field(unsigned int, remaining)
 938         ),
 939
 940         TP_fast_assign(
 941                 __entry->task_id = rqst->rq_task->tk_pid;
 942                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
 943                 __entry->total = rqst->rq_slen;
 944                 __entry->remaining = rqst->rq_slen - transport->xmit.offset;
 945         ),
 946
 947         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 948                   " total=%u remaining=%u",
 949                 __entry->task_id, __entry->client_id,
 950                 __entry->total, __entry->remaining
 951         )
 952 );
 953
 954 #define rpc_show_xprt_state(x)                                          \
 955         __print_flags(x, "|",                                           \
 956                 { BIT(XPRT_LOCKED),             "LOCKED" },             \
 957                 { BIT(XPRT_CONNECTED),          "CONNECTED" },          \
 958                 { BIT(XPRT_CONNECTING),         "CONNECTING" },         \
 959                 { BIT(XPRT_CLOSE_WAIT),         "CLOSE_WAIT" },         \
 960                 { BIT(XPRT_BOUND),              "BOUND" },              \
 961                 { BIT(XPRT_BINDING),            "BINDING" },            \
 962                 { BIT(XPRT_CLOSING),            "CLOSING" },            \
 963                 { BIT(XPRT_OFFLINE),            "OFFLINE" },            \
 964                 { BIT(XPRT_REMOVE),             "REMOVE" },             \
 965                 { BIT(XPRT_CONGESTED),          "CONGESTED" },          \
 966                 { BIT(XPRT_CWND_WAIT),          "CWND_WAIT" },          \
 967                 { BIT(XPRT_WRITE_SPACE),        "WRITE_SPACE" },        \
 968                 { BIT(XPRT_SND_IS_COOKIE),      "SND_IS_COOKIE" })
 969
 970 DECLARE_EVENT_CLASS(rpc_xprt_lifetime_class,
 971         TP_PROTO(
 972                 const struct rpc_xprt *xprt
 973         ),
 974
 975         TP_ARGS(xprt),
 976
 977         TP_STRUCT__entry(
 978                 __field(unsigned long, state)
 979                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 980                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 981         ),
 982
 983         TP_fast_assign(
 984                 __entry->state = xprt->state;
 985                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 986                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 987         ),
 988
 989         TP_printk("peer=[%s]:%s state=%s",
 990                 __get_str(addr), __get_str(port),
 991                 rpc_show_xprt_state(__entry->state))
 992 );
 993
 994 #define DEFINE_RPC_XPRT_LIFETIME_EVENT(name) \
 995         DEFINE_EVENT(rpc_xprt_lifetime_class, \
 996                         xprt_##name, \
 997                         TP_PROTO( \
 998                                 const struct rpc_xprt *xprt \
 999                         ), \
1000                         TP_ARGS(xprt))
1001
1002 DEFINE_RPC_XPRT_LIFETIME_EVENT(create);
1003 DEFINE_RPC_XPRT_LIFETIME_EVENT(connect);
1004 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto);
1005 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done);
1006 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force);
1007 DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy);
1008
1009 DECLARE_EVENT_CLASS(rpc_xprt_event,
1010         TP_PROTO(
1011                 const struct rpc_xprt *xprt,
1012                 __be32 xid,
1013                 int status
1014         ),
1015
1016         TP_ARGS(xprt, xid, status),
1017
1018         TP_STRUCT__entry(
1019                 __field(u32, xid)
1020                 __field(int, status)
1021                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
1022                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
1023         ),
1024
1025         TP_fast_assign(
1026                 __entry->xid = be32_to_cpu(xid);
1027                 __entry->status = status;
1028                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1029                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1030         ),
1031
1032         TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
1033                         __get_str(port), __entry->xid,
1034                         __entry->status)
1035 );
1036 #define DEFINE_RPC_XPRT_EVENT(name) \
1037         DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
1038                         TP_PROTO( \
1039                                 const struct rpc_xprt *xprt, \
1040                                 __be32 xid, \
1041                                 int status \
1042                         ), \
1043                         TP_ARGS(xprt, xid, status))
1044
1045 DEFINE_RPC_XPRT_EVENT(timer);
1046 DEFINE_RPC_XPRT_EVENT(lookup_rqst);
1047
1048 TRACE_EVENT(xprt_transmit,
1049         TP_PROTO(
1050                 const struct rpc_rqst *rqst,
1051                 int status
1052         ),
1053
1054         TP_ARGS(rqst, status),
1055
1056         TP_STRUCT__entry(
1057                 __field(unsigned int, task_id)
1058                 __field(unsigned int, client_id)
1059                 __field(u32, xid)
1060                 __field(u32, seqno)
1061                 __field(int, status)
1062         ),
1063
1064         TP_fast_assign(
1065                 __entry->task_id = rqst->rq_task->tk_pid;
1066                 __entry->client_id = rqst->rq_task->tk_client ?
1067                         rqst->rq_task->tk_client->cl_clid : -1;
1068                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1069                 __entry->seqno = rqst->rq_seqno;
1070                 __entry->status = status;
1071         ),
1072
1073         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1074                   " xid=0x%08x seqno=%u status=%d",
1075                 __entry->task_id, __entry->client_id, __entry->xid,
1076                 __entry->seqno, __entry->status)
1077 );
1078
1079 TRACE_EVENT(xprt_retransmit,
1080         TP_PROTO(
1081                 const struct rpc_rqst *rqst
1082         ),
1083
1084         TP_ARGS(rqst),
1085
1086         TP_STRUCT__entry(
1087                 __field(unsigned int, task_id)
1088                 __field(unsigned int, client_id)
1089                 __field(u32, xid)
1090                 __field(int, ntrans)
1091                 __field(int, version)
1092                 __field(unsigned long, timeout)
1093                 __string(progname,
1094                          rqst->rq_task->tk_client->cl_program->name)
1095                 __string(procname, rpc_proc_name(rqst->rq_task))
1096         ),
1097
1098         TP_fast_assign(
1099                 struct rpc_task *task = rqst->rq_task;
1100
1101                 __entry->task_id = task->tk_pid;
1102                 __entry->client_id = task->tk_client ?
1103                         task->tk_client->cl_clid : -1;
1104                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1105                 __entry->ntrans = rqst->rq_ntrans;
1106                 __entry->timeout = task->tk_timeout;
1107                 __assign_str(progname,
1108                              task->tk_client->cl_program->name);
1109                 __entry->version = task->tk_client->cl_vers;
1110                 __assign_str(procname, rpc_proc_name(task));
1111         ),
1112
1113         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1114                   " xid=0x%08x %sv%d %s ntrans=%d timeout=%lu",
1115                 __entry->task_id, __entry->client_id, __entry->xid,
1116                 __get_str(progname), __entry->version, __get_str(procname),
1117                 __entry->ntrans, __entry->timeout
1118         )
1119 );
1120
1121 TRACE_EVENT(xprt_ping,
1122         TP_PROTO(const struct rpc_xprt *xprt, int status),
1123
1124         TP_ARGS(xprt, status),
1125
1126         TP_STRUCT__entry(
1127                 __field(int, status)
1128                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
1129                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
1130         ),
1131
1132         TP_fast_assign(
1133                 __entry->status = status;
1134                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1135                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1136         ),
1137
1138         TP_printk("peer=[%s]:%s status=%d",
1139                         __get_str(addr), __get_str(port), __entry->status)
1140 );
1141
1142 DECLARE_EVENT_CLASS(xprt_writelock_event,
1143         TP_PROTO(
1144                 const struct rpc_xprt *xprt, const struct rpc_task *task
1145         ),
1146
1147         TP_ARGS(xprt, task),
1148
1149         TP_STRUCT__entry(
1150                 __field(unsigned int, task_id)
1151                 __field(unsigned int, client_id)
1152                 __field(unsigned int, snd_task_id)
1153         ),
1154
1155         TP_fast_assign(
1156                 if (task) {
1157                         __entry->task_id = task->tk_pid;
1158                         __entry->client_id = task->tk_client ?
1159                                              task->tk_client->cl_clid : -1;
1160                 } else {
1161                         __entry->task_id = -1;
1162                         __entry->client_id = -1;
1163                 }
1164                 if (xprt->snd_task &&
1165                     !test_bit(XPRT_SND_IS_COOKIE, &xprt->state))
1166                         __entry->snd_task_id = xprt->snd_task->tk_pid;
1167                 else
1168                         __entry->snd_task_id = -1;
1169         ),
1170
1171         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1172                   " snd_task:" SUNRPC_TRACE_PID_SPECIFIER,
1173                         __entry->task_id, __entry->client_id,
1174                         __entry->snd_task_id)
1175 );
1176
1177 #define DEFINE_WRITELOCK_EVENT(name) \
1178         DEFINE_EVENT(xprt_writelock_event, xprt_##name, \
1179                         TP_PROTO( \
1180                                 const struct rpc_xprt *xprt, \
1181                                 const struct rpc_task *task \
1182                         ), \
1183                         TP_ARGS(xprt, task))
1184
1185 DEFINE_WRITELOCK_EVENT(reserve_xprt);
1186 DEFINE_WRITELOCK_EVENT(release_xprt);
1187
1188 DECLARE_EVENT_CLASS(xprt_cong_event,
1189         TP_PROTO(
1190                 const struct rpc_xprt *xprt, const struct rpc_task *task
1191         ),
1192
1193         TP_ARGS(xprt, task),
1194
1195         TP_STRUCT__entry(
1196                 __field(unsigned int, task_id)
1197                 __field(unsigned int, client_id)
1198                 __field(unsigned int, snd_task_id)
1199                 __field(unsigned long, cong)
1200                 __field(unsigned long, cwnd)
1201                 __field(bool, wait)
1202         ),
1203
1204         TP_fast_assign(
1205                 if (task) {
1206                         __entry->task_id = task->tk_pid;
1207                         __entry->client_id = task->tk_client ?
1208                                              task->tk_client->cl_clid : -1;
1209                 } else {
1210                         __entry->task_id = -1;
1211                         __entry->client_id = -1;
1212                 }
1213                 if (xprt->snd_task &&
1214                     !test_bit(XPRT_SND_IS_COOKIE, &xprt->state))
1215                         __entry->snd_task_id = xprt->snd_task->tk_pid;
1216                 else
1217                         __entry->snd_task_id = -1;
1218
1219                 __entry->cong = xprt->cong;
1220                 __entry->cwnd = xprt->cwnd;
1221                 __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
1222         ),
1223
1224         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1225                   " snd_task:" SUNRPC_TRACE_PID_SPECIFIER
1226                   " cong=%lu cwnd=%lu%s",
1227                         __entry->task_id, __entry->client_id,
1228                         __entry->snd_task_id, __entry->cong, __entry->cwnd,
1229                         __entry->wait ? " (wait)" : "")
1230 );
1231
1232 #define DEFINE_CONG_EVENT(name) \
1233         DEFINE_EVENT(xprt_cong_event, xprt_##name, \
1234                         TP_PROTO( \
1235                                 const struct rpc_xprt *xprt, \
1236                                 const struct rpc_task *task \
1237                         ), \
1238                         TP_ARGS(xprt, task))
1239
1240 DEFINE_CONG_EVENT(reserve_cong);
1241 DEFINE_CONG_EVENT(release_cong);
1242 DEFINE_CONG_EVENT(get_cong);
1243 DEFINE_CONG_EVENT(put_cong);
1244
1245 TRACE_EVENT(xprt_reserve,
1246         TP_PROTO(
1247                 const struct rpc_rqst *rqst
1248         ),
1249
1250         TP_ARGS(rqst),
1251
1252         TP_STRUCT__entry(
1253                 __field(unsigned int, task_id)
1254                 __field(unsigned int, client_id)
1255                 __field(u32, xid)
1256         ),
1257
1258         TP_fast_assign(
1259                 __entry->task_id = rqst->rq_task->tk_pid;
1260                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
1261                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1262         ),
1263
1264         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x",
1265                 __entry->task_id, __entry->client_id, __entry->xid
1266         )
1267 );
1268
1269 TRACE_EVENT(xs_data_ready,
1270         TP_PROTO(
1271                 const struct rpc_xprt *xprt
1272         ),
1273
1274         TP_ARGS(xprt),
1275
1276         TP_STRUCT__entry(
1277                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
1278                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
1279         ),
1280
1281         TP_fast_assign(
1282                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1283                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1284         ),
1285
1286         TP_printk("peer=[%s]:%s", __get_str(addr), __get_str(port))
1287 );
1288
1289 TRACE_EVENT(xs_stream_read_data,
1290         TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
1291
1292         TP_ARGS(xprt, err, total),
1293
1294         TP_STRUCT__entry(
1295                 __field(ssize_t, err)
1296                 __field(size_t, total)
1297                 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
1298                                 "(null)")
1299                 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
1300                                 "(null)")
1301         ),
1302
1303         TP_fast_assign(
1304                 __entry->err = err;
1305                 __entry->total = total;
1306                 __assign_str(addr, xprt ?
1307                         xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
1308                 __assign_str(port, xprt ?
1309                         xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
1310         ),
1311
1312         TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
1313                         __get_str(port), __entry->err, __entry->total)
1314 );
1315
1316 TRACE_EVENT(xs_stream_read_request,
1317         TP_PROTO(struct sock_xprt *xs),
1318
1319         TP_ARGS(xs),
1320
1321         TP_STRUCT__entry(
1322                 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
1323                 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
1324                 __field(u32, xid)
1325                 __field(unsigned long, copied)
1326                 __field(unsigned int, reclen)
1327                 __field(unsigned int, offset)
1328         ),
1329
1330         TP_fast_assign(
1331                 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
1332                 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
1333                 __entry->xid = be32_to_cpu(xs->recv.xid);
1334                 __entry->copied = xs->recv.copied;
1335                 __entry->reclen = xs->recv.len;
1336                 __entry->offset = xs->recv.offset;
1337         ),
1338
1339         TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
1340                         __get_str(addr), __get_str(port), __entry->xid,
1341                         __entry->copied, __entry->reclen, __entry->offset)
1342 );
1343
1344 TRACE_EVENT(rpcb_getport,
1345         TP_PROTO(
1346                 const struct rpc_clnt *clnt,
1347                 const struct rpc_task *task,
1348                 unsigned int bind_version
1349         ),
1350
1351         TP_ARGS(clnt, task, bind_version),
1352
1353         TP_STRUCT__entry(
1354                 __field(unsigned int, task_id)
1355                 __field(unsigned int, client_id)
1356                 __field(unsigned int, program)
1357                 __field(unsigned int, version)
1358                 __field(int, protocol)
1359                 __field(unsigned int, bind_version)
1360                 __string(servername, task->tk_xprt->servername)
1361         ),
1362
1363         TP_fast_assign(
1364                 __entry->task_id = task->tk_pid;
1365                 __entry->client_id = clnt->cl_clid;
1366                 __entry->program = clnt->cl_prog;
1367                 __entry->version = clnt->cl_vers;
1368                 __entry->protocol = task->tk_xprt->prot;
1369                 __entry->bind_version = bind_version;
1370                 __assign_str(servername, task->tk_xprt->servername);
1371         ),
1372
1373         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
1374                   " server=%s program=%u version=%u protocol=%d bind_version=%u",
1375                 __entry->task_id, __entry->client_id, __get_str(servername),
1376                 __entry->program, __entry->version, __entry->protocol,
1377                 __entry->bind_version
1378         )
1379 );
1380
1381 TRACE_EVENT(rpcb_setport,
1382         TP_PROTO(
1383                 const struct rpc_task *task,
1384                 int status,
1385                 unsigned short port
1386         ),
1387
1388         TP_ARGS(task, status, port),
1389
1390         TP_STRUCT__entry(
1391                 __field(unsigned int, task_id)
1392                 __field(unsigned int, client_id)
1393                 __field(int, status)
1394                 __field(unsigned short, port)
1395         ),
1396
1397         TP_fast_assign(
1398                 __entry->task_id = task->tk_pid;
1399                 __entry->client_id = task->tk_client->cl_clid;
1400                 __entry->status = status;
1401                 __entry->port = port;
1402         ),
1403
1404         TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d port=%u",
1405                 __entry->task_id, __entry->client_id,
1406                 __entry->status, __entry->port
1407         )
1408 );
1409
1410 TRACE_EVENT(pmap_register,
1411         TP_PROTO(
1412                 u32 program,
1413                 u32 version,
1414                 int protocol,
1415                 unsigned short port
1416         ),
1417
1418         TP_ARGS(program, version, protocol, port),
1419
1420         TP_STRUCT__entry(
1421                 __field(unsigned int, program)
1422                 __field(unsigned int, version)
1423                 __field(int, protocol)
1424                 __field(unsigned int, port)
1425         ),
1426
1427         TP_fast_assign(
1428                 __entry->program = program;
1429                 __entry->version = version;
1430                 __entry->protocol = protocol;
1431                 __entry->port = port;
1432         ),
1433
1434         TP_printk("program=%u version=%u protocol=%d port=%u",
1435                 __entry->program, __entry->version,
1436                 __entry->protocol, __entry->port
1437         )
1438 );
1439
1440 TRACE_EVENT(rpcb_register,
1441         TP_PROTO(
1442                 u32 program,
1443                 u32 version,
1444                 const char *addr,
1445                 const char *netid
1446         ),
1447
1448         TP_ARGS(program, version, addr, netid),
1449
1450         TP_STRUCT__entry(
1451                 __field(unsigned int, program)
1452                 __field(unsigned int, version)
1453                 __string(addr, addr)
1454                 __string(netid, netid)
1455         ),
1456
1457         TP_fast_assign(
1458                 __entry->program = program;
1459                 __entry->version = version;
1460                 __assign_str(addr, addr);
1461                 __assign_str(netid, netid);
1462         ),
1463
1464         TP_printk("program=%u version=%u addr=%s netid=%s",
1465                 __entry->program, __entry->version,
1466                 __get_str(addr), __get_str(netid)
1467         )
1468 );
1469
1470 TRACE_EVENT(rpcb_unregister,
1471         TP_PROTO(
1472                 u32 program,
1473                 u32 version,
1474                 const char *netid
1475         ),
1476
1477         TP_ARGS(program, version, netid),
1478
1479         TP_STRUCT__entry(
1480                 __field(unsigned int, program)
1481                 __field(unsigned int, version)
1482                 __string(netid, netid)
1483         ),
1484
1485         TP_fast_assign(
1486                 __entry->program = program;
1487                 __entry->version = version;
1488                 __assign_str(netid, netid);
1489         ),
1490
1491         TP_printk("program=%u version=%u netid=%s",
1492                 __entry->program, __entry->version, __get_str(netid)
1493         )
1494 );
1495
1496 /* Record an xdr_buf containing a fully-formed RPC message */
1497 DECLARE_EVENT_CLASS(svc_xdr_msg_class,
1498         TP_PROTO(
1499                 const struct xdr_buf *xdr
1500         ),
1501
1502         TP_ARGS(xdr),
1503
1504         TP_STRUCT__entry(
1505                 __field(u32, xid)
1506                 __field(const void *, head_base)
1507                 __field(size_t, head_len)
1508                 __field(const void *, tail_base)
1509                 __field(size_t, tail_len)
1510                 __field(unsigned int, page_len)
1511                 __field(unsigned int, msg_len)
1512         ),
1513
1514         TP_fast_assign(
1515                 __be32 *p = (__be32 *)xdr->head[0].iov_base;
1516
1517                 __entry->xid = be32_to_cpu(*p);
1518                 __entry->head_base = p;
1519                 __entry->head_len = xdr->head[0].iov_len;
1520                 __entry->tail_base = xdr->tail[0].iov_base;
1521                 __entry->tail_len = xdr->tail[0].iov_len;
1522                 __entry->page_len = xdr->page_len;
1523                 __entry->msg_len = xdr->len;
1524         ),
1525
1526         TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
1527                 __entry->xid,
1528                 __entry->head_base, __entry->head_len, __entry->page_len,
1529                 __entry->tail_base, __entry->tail_len, __entry->msg_len
1530         )
1531 );
1532
1533 #define DEFINE_SVCXDRMSG_EVENT(name)                                    \
1534                 DEFINE_EVENT(svc_xdr_msg_class,                         \
1535                                 svc_xdr_##name,                         \
1536                                 TP_PROTO(                               \
1537                                         const struct xdr_buf *xdr       \
1538                                 ),                                      \
1539                                 TP_ARGS(xdr))
1540
1541 DEFINE_SVCXDRMSG_EVENT(recvfrom);
1542
1543 /* Record an xdr_buf containing arbitrary data, tagged with an XID */
1544 DECLARE_EVENT_CLASS(svc_xdr_buf_class,
1545         TP_PROTO(
1546                 __be32 xid,
1547                 const struct xdr_buf *xdr
1548         ),
1549
1550         TP_ARGS(xid, xdr),
1551
1552         TP_STRUCT__entry(
1553                 __field(u32, xid)
1554                 __field(const void *, head_base)
1555                 __field(size_t, head_len)
1556                 __field(const void *, tail_base)
1557                 __field(size_t, tail_len)
1558                 __field(unsigned int, page_base)
1559                 __field(unsigned int, page_len)
1560                 __field(unsigned int, msg_len)
1561         ),
1562
1563         TP_fast_assign(
1564                 __entry->xid = be32_to_cpu(xid);
1565                 __entry->head_base = xdr->head[0].iov_base;
1566                 __entry->head_len = xdr->head[0].iov_len;
1567                 __entry->tail_base = xdr->tail[0].iov_base;
1568                 __entry->tail_len = xdr->tail[0].iov_len;
1569                 __entry->page_base = xdr->page_base;
1570                 __entry->page_len = xdr->page_len;
1571                 __entry->msg_len = xdr->len;
1572         ),
1573
1574         TP_printk("xid=0x%08x head=[%p,%zu] page=%u(%u) tail=[%p,%zu] len=%u",
1575                 __entry->xid,
1576                 __entry->head_base, __entry->head_len,
1577                 __entry->page_len, __entry->page_base,
1578                 __entry->tail_base, __entry->tail_len,
1579                 __entry->msg_len
1580         )
1581 );
1582
1583 #define DEFINE_SVCXDRBUF_EVENT(name)                                    \
1584                 DEFINE_EVENT(svc_xdr_buf_class,                         \
1585                                 svc_xdr_##name,                         \
1586                                 TP_PROTO(                               \
1587                                         __be32 xid,                     \
1588                                         const struct xdr_buf *xdr       \
1589                                 ),                                      \
1590                                 TP_ARGS(xid, xdr))
1591
1592 DEFINE_SVCXDRBUF_EVENT(sendto);
1593
1594 /*
1595  * from include/linux/sunrpc/svc.h
1596  */
1597 #define SVC_RQST_FLAG_LIST                                              \
1598         svc_rqst_flag(SECURE)                                           \
1599         svc_rqst_flag(LOCAL)                                            \
1600         svc_rqst_flag(USEDEFERRAL)                                      \
1601         svc_rqst_flag(DROPME)                                           \
1602         svc_rqst_flag(SPLICE_OK)                                        \
1603         svc_rqst_flag(VICTIM)                                           \
1604         svc_rqst_flag(BUSY)                                             \
1605         svc_rqst_flag_end(DATA)
1606
1607 #undef svc_rqst_flag
1608 #undef svc_rqst_flag_end
1609 #define svc_rqst_flag(x)        TRACE_DEFINE_ENUM(RQ_##x);
1610 #define svc_rqst_flag_end(x)    TRACE_DEFINE_ENUM(RQ_##x);
1611
1612 SVC_RQST_FLAG_LIST
1613
1614 #undef svc_rqst_flag
1615 #undef svc_rqst_flag_end
1616 #define svc_rqst_flag(x)        { BIT(RQ_##x), #x },
1617 #define svc_rqst_flag_end(x)    { BIT(RQ_##x), #x }
1618
1619 #define show_rqstp_flags(flags)                                         \
1620                 __print_flags(flags, "|", SVC_RQST_FLAG_LIST)
1621
1622 TRACE_DEFINE_ENUM(SVC_GARBAGE);
1623 TRACE_DEFINE_ENUM(SVC_SYSERR);
1624 TRACE_DEFINE_ENUM(SVC_VALID);
1625 TRACE_DEFINE_ENUM(SVC_NEGATIVE);
1626 TRACE_DEFINE_ENUM(SVC_OK);
1627 TRACE_DEFINE_ENUM(SVC_DROP);
1628 TRACE_DEFINE_ENUM(SVC_CLOSE);
1629 TRACE_DEFINE_ENUM(SVC_DENIED);
1630 TRACE_DEFINE_ENUM(SVC_PENDING);
1631 TRACE_DEFINE_ENUM(SVC_COMPLETE);
1632
1633 #define svc_show_status(status)                         \
1634         __print_symbolic(status,                        \
1635                 { SVC_GARBAGE,  "SVC_GARBAGE" },        \
1636                 { SVC_SYSERR,   "SVC_SYSERR" },         \
1637                 { SVC_VALID,    "SVC_VALID" },          \
1638                 { SVC_NEGATIVE, "SVC_NEGATIVE" },       \
1639                 { SVC_OK,       "SVC_OK" },             \
1640                 { SVC_DROP,     "SVC_DROP" },           \
1641                 { SVC_CLOSE,    "SVC_CLOSE" },          \
1642                 { SVC_DENIED,   "SVC_DENIED" },         \
1643                 { SVC_PENDING,  "SVC_PENDING" },        \
1644                 { SVC_COMPLETE, "SVC_COMPLETE" })
1645
1646 #define SVC_RQST_ENDPOINT_FIELDS(r) \
1647                 __sockaddr(server, (r)->rq_xprt->xpt_locallen) \
1648                 __sockaddr(client, (r)->rq_xprt->xpt_remotelen) \
1649                 __field(unsigned int, netns_ino) \
1650                 __field(u32, xid)
1651
1652 #define SVC_RQST_ENDPOINT_ASSIGNMENTS(r) \
1653                 do { \
1654                         struct svc_xprt *xprt = (r)->rq_xprt; \
1655                         __assign_sockaddr(server, &xprt->xpt_local, \
1656                                           xprt->xpt_locallen); \
1657                         __assign_sockaddr(client, &xprt->xpt_remote, \
1658                                           xprt->xpt_remotelen); \
1659                         __entry->netns_ino = xprt->xpt_net->ns.inum; \
1660                         __entry->xid = be32_to_cpu((r)->rq_xid); \
1661                 } while (0)
1662
1663 #define SVC_RQST_ENDPOINT_FORMAT \
1664                 "xid=0x%08x server=%pISpc client=%pISpc"
1665
1666 #define SVC_RQST_ENDPOINT_VARARGS \
1667                 __entry->xid, __get_sockaddr(server), __get_sockaddr(client)
1668
1669 TRACE_EVENT_CONDITION(svc_authenticate,
1670         TP_PROTO(const struct svc_rqst *rqst, int auth_res),
1671
1672         TP_ARGS(rqst, auth_res),
1673
1674         TP_CONDITION(auth_res != SVC_OK && auth_res != SVC_COMPLETE),
1675
1676         TP_STRUCT__entry(
1677                 SVC_RQST_ENDPOINT_FIELDS(rqst)
1678
1679                 __field(unsigned long, svc_status)
1680                 __field(unsigned long, auth_stat)
1681         ),
1682
1683         TP_fast_assign(
1684                 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1685
1686                 __entry->svc_status = auth_res;
1687                 __entry->auth_stat = be32_to_cpu(rqst->rq_auth_stat);
1688         ),
1689
1690         TP_printk(SVC_RQST_ENDPOINT_FORMAT
1691                 " auth_res=%s auth_stat=%s",
1692                 SVC_RQST_ENDPOINT_VARARGS,
1693                 svc_show_status(__entry->svc_status),
1694                 rpc_show_auth_stat(__entry->auth_stat))
1695 );
1696
1697 TRACE_EVENT(svc_process,
1698         TP_PROTO(const struct svc_rqst *rqst, const char *name),
1699
1700         TP_ARGS(rqst, name),
1701
1702         TP_STRUCT__entry(
1703                 __field(u32, xid)
1704                 __field(u32, vers)
1705                 __field(u32, proc)
1706                 __string(service, name)
1707                 __string(procedure, svc_proc_name(rqst))
1708                 __string(addr, rqst->rq_xprt ?
1709                          rqst->rq_xprt->xpt_remotebuf : "(null)")
1710         ),
1711
1712         TP_fast_assign(
1713                 __entry->xid = be32_to_cpu(rqst->rq_xid);
1714                 __entry->vers = rqst->rq_vers;
1715                 __entry->proc = rqst->rq_proc;
1716                 __assign_str(service, name);
1717                 __assign_str(procedure, svc_proc_name(rqst));
1718                 __assign_str(addr, rqst->rq_xprt ?
1719                              rqst->rq_xprt->xpt_remotebuf : "(null)");
1720         ),
1721
1722         TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%s",
1723                         __get_str(addr), __entry->xid,
1724                         __get_str(service), __entry->vers,
1725                         __get_str(procedure)
1726         )
1727 );
1728
1729 DECLARE_EVENT_CLASS(svc_rqst_event,
1730         TP_PROTO(
1731                 const struct svc_rqst *rqst
1732         ),
1733
1734         TP_ARGS(rqst),
1735
1736         TP_STRUCT__entry(
1737                 SVC_RQST_ENDPOINT_FIELDS(rqst)
1738
1739                 __field(unsigned long, flags)
1740         ),
1741
1742         TP_fast_assign(
1743                 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1744
1745                 __entry->flags = rqst->rq_flags;
1746         ),
1747
1748         TP_printk(SVC_RQST_ENDPOINT_FORMAT " flags=%s",
1749                 SVC_RQST_ENDPOINT_VARARGS,
1750                 show_rqstp_flags(__entry->flags))
1751 );
1752 #define DEFINE_SVC_RQST_EVENT(name) \
1753         DEFINE_EVENT(svc_rqst_event, svc_##name, \
1754                         TP_PROTO( \
1755                                 const struct svc_rqst *rqst \
1756                         ), \
1757                         TP_ARGS(rqst))
1758
1759 DEFINE_SVC_RQST_EVENT(defer);
1760 DEFINE_SVC_RQST_EVENT(drop);
1761
1762 DECLARE_EVENT_CLASS(svc_rqst_status,
1763         TP_PROTO(
1764                 const struct svc_rqst *rqst,
1765                 int status
1766         ),
1767
1768         TP_ARGS(rqst, status),
1769
1770         TP_STRUCT__entry(
1771                 SVC_RQST_ENDPOINT_FIELDS(rqst)
1772
1773                 __field(int, status)
1774                 __field(unsigned long, flags)
1775         ),
1776
1777         TP_fast_assign(
1778                 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1779
1780                 __entry->status = status;
1781                 __entry->flags = rqst->rq_flags;
1782         ),
1783
1784         TP_printk(SVC_RQST_ENDPOINT_FORMAT " status=%d flags=%s",
1785                 SVC_RQST_ENDPOINT_VARARGS,
1786                 __entry->status, show_rqstp_flags(__entry->flags))
1787 );
1788
1789 DEFINE_EVENT(svc_rqst_status, svc_send,
1790         TP_PROTO(const struct svc_rqst *rqst, int status),
1791         TP_ARGS(rqst, status));
1792
1793 TRACE_EVENT(svc_replace_page_err,
1794         TP_PROTO(const struct svc_rqst *rqst),
1795
1796         TP_ARGS(rqst),
1797         TP_STRUCT__entry(
1798                 SVC_RQST_ENDPOINT_FIELDS(rqst)
1799
1800                 __field(const void *, begin)
1801                 __field(const void *, respages)
1802                 __field(const void *, nextpage)
1803         ),
1804
1805         TP_fast_assign(
1806                 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1807
1808                 __entry->begin = rqst->rq_pages;
1809                 __entry->respages = rqst->rq_respages;
1810                 __entry->nextpage = rqst->rq_next_page;
1811         ),
1812
1813         TP_printk(SVC_RQST_ENDPOINT_FORMAT " begin=%p respages=%p nextpage=%p",
1814                 SVC_RQST_ENDPOINT_VARARGS,
1815                 __entry->begin, __entry->respages, __entry->nextpage)
1816 );
1817
1818 TRACE_EVENT(svc_stats_latency,
1819         TP_PROTO(
1820                 const struct svc_rqst *rqst
1821         ),
1822
1823         TP_ARGS(rqst),
1824
1825         TP_STRUCT__entry(
1826                 SVC_RQST_ENDPOINT_FIELDS(rqst)
1827
1828                 __field(unsigned long, execute)
1829                 __string(procedure, svc_proc_name(rqst))
1830         ),
1831
1832         TP_fast_assign(
1833                 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1834
1835                 __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
1836                                                          rqst->rq_stime));
1837                 __assign_str(procedure, svc_proc_name(rqst));
1838         ),
1839
1840         TP_printk(SVC_RQST_ENDPOINT_FORMAT " proc=%s execute-us=%lu",
1841                 SVC_RQST_ENDPOINT_VARARGS,
1842                 __get_str(procedure), __entry->execute)
1843 );
1844
1845 #define show_svc_xprt_flags(flags)                                      \
1846         __print_flags(flags, "|",                                       \
1847                 { BIT(XPT_BUSY),                "BUSY" },               \
1848                 { BIT(XPT_CONN),                "CONN" },               \
1849                 { BIT(XPT_CLOSE),               "CLOSE" },              \
1850                 { BIT(XPT_DATA),                "DATA" },               \
1851                 { BIT(XPT_TEMP),                "TEMP" },               \
1852                 { BIT(XPT_DEAD),                "DEAD" },               \
1853                 { BIT(XPT_CHNGBUF),             "CHNGBUF" },            \
1854                 { BIT(XPT_DEFERRED),            "DEFERRED" },           \
1855                 { BIT(XPT_OLD),                 "OLD" },                \
1856                 { BIT(XPT_LISTENER),            "LISTENER" },           \
1857                 { BIT(XPT_CACHE_AUTH),          "CACHE_AUTH" },         \
1858                 { BIT(XPT_LOCAL),               "LOCAL" },              \
1859                 { BIT(XPT_KILL_TEMP),           "KILL_TEMP" },          \
1860                 { BIT(XPT_CONG_CTRL),           "CONG_CTRL" },          \
1861                 { BIT(XPT_HANDSHAKE),           "HANDSHAKE" },          \
1862                 { BIT(XPT_TLS_SESSION),         "TLS_SESSION" },        \
1863                 { BIT(XPT_PEER_AUTH),           "PEER_AUTH" })
1864
1865 TRACE_EVENT(svc_xprt_create_err,
1866         TP_PROTO(
1867                 const char *program,
1868                 const char *protocol,
1869                 struct sockaddr *sap,
1870                 size_t salen,
1871                 const struct svc_xprt *xprt
1872         ),
1873
1874         TP_ARGS(program, protocol, sap, salen, xprt),
1875
1876         TP_STRUCT__entry(
1877                 __field(long, error)
1878                 __string(program, program)
1879                 __string(protocol, protocol)
1880                 __sockaddr(addr, salen)
1881         ),
1882
1883         TP_fast_assign(
1884                 __entry->error = PTR_ERR(xprt);
1885                 __assign_str(program, program);
1886                 __assign_str(protocol, protocol);
1887                 __assign_sockaddr(addr, sap, salen);
1888         ),
1889
1890         TP_printk("addr=%pISpc program=%s protocol=%s error=%ld",
1891                 __get_sockaddr(addr), __get_str(program), __get_str(protocol),
1892                 __entry->error)
1893 );
1894
1895 #define SVC_XPRT_ENDPOINT_FIELDS(x) \
1896                 __sockaddr(server, (x)->xpt_locallen) \
1897                 __sockaddr(client, (x)->xpt_remotelen) \
1898                 __field(unsigned long, flags) \
1899                 __field(unsigned int, netns_ino)
1900
1901 #define SVC_XPRT_ENDPOINT_ASSIGNMENTS(x) \
1902                 do { \
1903                         __assign_sockaddr(server, &(x)->xpt_local, \
1904                                           (x)->xpt_locallen); \
1905                         __assign_sockaddr(client, &(x)->xpt_remote, \
1906                                           (x)->xpt_remotelen); \
1907                         __entry->flags = (x)->xpt_flags; \
1908                         __entry->netns_ino = (x)->xpt_net->ns.inum; \
1909                 } while (0)
1910
1911 #define SVC_XPRT_ENDPOINT_FORMAT \
1912                 "server=%pISpc client=%pISpc flags=%s"
1913
1914 #define SVC_XPRT_ENDPOINT_VARARGS \
1915                 __get_sockaddr(server), __get_sockaddr(client), \
1916                 show_svc_xprt_flags(__entry->flags)
1917
1918 TRACE_EVENT(svc_xprt_enqueue,
1919         TP_PROTO(
1920                 const struct svc_xprt *xprt,
1921                 const struct svc_rqst *rqst
1922         ),
1923
1924         TP_ARGS(xprt, rqst),
1925
1926         TP_STRUCT__entry(
1927                 SVC_XPRT_ENDPOINT_FIELDS(xprt)
1928
1929                 __field(int, pid)
1930         ),
1931
1932         TP_fast_assign(
1933                 SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
1934
1935                 __entry->pid = rqst? rqst->rq_task->pid : 0;
1936         ),
1937
1938         TP_printk(SVC_XPRT_ENDPOINT_FORMAT " pid=%d",
1939                 SVC_XPRT_ENDPOINT_VARARGS, __entry->pid)
1940 );
1941
1942 TRACE_EVENT(svc_xprt_dequeue,
1943         TP_PROTO(
1944                 const struct svc_rqst *rqst
1945         ),
1946
1947         TP_ARGS(rqst),
1948
1949         TP_STRUCT__entry(
1950                 SVC_XPRT_ENDPOINT_FIELDS(rqst->rq_xprt)
1951
1952                 __field(unsigned long, wakeup)
1953         ),
1954
1955         TP_fast_assign(
1956                 SVC_XPRT_ENDPOINT_ASSIGNMENTS(rqst->rq_xprt);
1957
1958                 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
1959                                                         rqst->rq_qtime));
1960         ),
1961
1962         TP_printk(SVC_XPRT_ENDPOINT_FORMAT " wakeup-us=%lu",
1963                 SVC_XPRT_ENDPOINT_VARARGS, __entry->wakeup)
1964 );
1965
1966 DECLARE_EVENT_CLASS(svc_xprt_event,
1967         TP_PROTO(
1968                 const struct svc_xprt *xprt
1969         ),
1970
1971         TP_ARGS(xprt),
1972
1973         TP_STRUCT__entry(
1974                 SVC_XPRT_ENDPOINT_FIELDS(xprt)
1975         ),
1976
1977         TP_fast_assign(
1978                 SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
1979         ),
1980
1981         TP_printk(SVC_XPRT_ENDPOINT_FORMAT, SVC_XPRT_ENDPOINT_VARARGS)
1982 );
1983
1984 #define DEFINE_SVC_XPRT_EVENT(name) \
1985         DEFINE_EVENT(svc_xprt_event, svc_xprt_##name, \
1986                         TP_PROTO( \
1987                                 const struct svc_xprt *xprt \
1988                         ), \
1989                         TP_ARGS(xprt))
1990
1991 DEFINE_SVC_XPRT_EVENT(no_write_space);
1992 DEFINE_SVC_XPRT_EVENT(close);
1993 DEFINE_SVC_XPRT_EVENT(detach);
1994 DEFINE_SVC_XPRT_EVENT(free);
1995
1996 #define DEFINE_SVC_TLS_EVENT(name) \
1997         DEFINE_EVENT(svc_xprt_event, svc_tls_##name, \
1998                 TP_PROTO(const struct svc_xprt *xprt), \
1999                 TP_ARGS(xprt))
2000
2001 DEFINE_SVC_TLS_EVENT(start);
2002 DEFINE_SVC_TLS_EVENT(upcall);
2003 DEFINE_SVC_TLS_EVENT(unavailable);
2004 DEFINE_SVC_TLS_EVENT(not_started);
2005 DEFINE_SVC_TLS_EVENT(timed_out);
2006
2007 TRACE_EVENT(svc_xprt_accept,
2008         TP_PROTO(
2009                 const struct svc_xprt *xprt,
2010                 const char *service
2011         ),
2012
2013         TP_ARGS(xprt, service),
2014
2015         TP_STRUCT__entry(
2016                 SVC_XPRT_ENDPOINT_FIELDS(xprt)
2017
2018                 __string(protocol, xprt->xpt_class->xcl_name)
2019                 __string(service, service)
2020         ),
2021
2022         TP_fast_assign(
2023                 SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
2024
2025                 __assign_str(protocol, xprt->xpt_class->xcl_name);
2026                 __assign_str(service, service);
2027         ),
2028
2029         TP_printk(SVC_XPRT_ENDPOINT_FORMAT " protocol=%s service=%s",
2030                 SVC_XPRT_ENDPOINT_VARARGS,
2031                 __get_str(protocol), __get_str(service)
2032         )
2033 );
2034
2035 TRACE_EVENT(svc_wake_up,
2036         TP_PROTO(int pid),
2037
2038         TP_ARGS(pid),
2039
2040         TP_STRUCT__entry(
2041                 __field(int, pid)
2042         ),
2043
2044         TP_fast_assign(
2045                 __entry->pid = pid;
2046         ),
2047
2048         TP_printk("pid=%d", __entry->pid)
2049 );
2050
2051 TRACE_EVENT(svc_alloc_arg_err,
2052         TP_PROTO(
2053                 unsigned int requested,
2054                 unsigned int allocated
2055         ),
2056
2057         TP_ARGS(requested, allocated),
2058
2059         TP_STRUCT__entry(
2060                 __field(unsigned int, requested)
2061                 __field(unsigned int, allocated)
2062         ),
2063
2064         TP_fast_assign(
2065                 __entry->requested = requested;
2066                 __entry->allocated = allocated;
2067         ),
2068
2069         TP_printk("requested=%u allocated=%u",
2070                 __entry->requested, __entry->allocated)
2071 );
2072
2073 DECLARE_EVENT_CLASS(svc_deferred_event,
2074         TP_PROTO(
2075                 const struct svc_deferred_req *dr
2076         ),
2077
2078         TP_ARGS(dr),
2079
2080         TP_STRUCT__entry(
2081                 __field(const void *, dr)
2082                 __field(u32, xid)
2083                 __sockaddr(addr, dr->addrlen)
2084         ),
2085
2086         TP_fast_assign(
2087                 __entry->dr = dr;
2088                 __entry->xid = be32_to_cpu(*(__be32 *)dr->args);
2089                 __assign_sockaddr(addr, &dr->addr, dr->addrlen);
2090         ),
2091
2092         TP_printk("addr=%pISpc dr=%p xid=0x%08x", __get_sockaddr(addr),
2093                 __entry->dr, __entry->xid)
2094 );
2095
2096 #define DEFINE_SVC_DEFERRED_EVENT(name) \
2097         DEFINE_EVENT(svc_deferred_event, svc_defer_##name, \
2098                         TP_PROTO( \
2099                                 const struct svc_deferred_req *dr \
2100                         ), \
2101                         TP_ARGS(dr))
2102
2103 DEFINE_SVC_DEFERRED_EVENT(drop);
2104 DEFINE_SVC_DEFERRED_EVENT(queue);
2105 DEFINE_SVC_DEFERRED_EVENT(recv);
2106
2107 TRACE_EVENT(svcsock_new_socket,
2108         TP_PROTO(
2109                 const struct socket *socket
2110         ),
2111
2112         TP_ARGS(socket),
2113
2114         TP_STRUCT__entry(
2115                 __field(unsigned long, type)
2116                 __field(unsigned long, family)
2117                 __field(bool, listener)
2118         ),
2119
2120         TP_fast_assign(
2121                 __entry->type = socket->type;
2122                 __entry->family = socket->sk->sk_family;
2123                 __entry->listener = (socket->sk->sk_state == TCP_LISTEN);
2124         ),
2125
2126         TP_printk("type=%s family=%s%s",
2127                 show_socket_type(__entry->type),
2128                 rpc_show_address_family(__entry->family),
2129                 __entry->listener ? " (listener)" : ""
2130         )
2131 );
2132
2133 TRACE_EVENT(svcsock_marker,
2134         TP_PROTO(
2135                 const struct svc_xprt *xprt,
2136                 __be32 marker
2137         ),
2138
2139         TP_ARGS(xprt, marker),
2140
2141         TP_STRUCT__entry(
2142                 __field(unsigned int, length)
2143                 __field(bool, last)
2144                 __string(addr, xprt->xpt_remotebuf)
2145         ),
2146
2147         TP_fast_assign(
2148                 __entry->length = be32_to_cpu(marker) & RPC_FRAGMENT_SIZE_MASK;
2149                 __entry->last = be32_to_cpu(marker) & RPC_LAST_STREAM_FRAGMENT;
2150                 __assign_str(addr, xprt->xpt_remotebuf);
2151         ),
2152
2153         TP_printk("addr=%s length=%u%s", __get_str(addr),
2154                 __entry->length, __entry->last ? " (last)" : "")
2155 );
2156
2157 DECLARE_EVENT_CLASS(svcsock_class,
2158         TP_PROTO(
2159                 const struct svc_xprt *xprt,
2160                 ssize_t result
2161         ),
2162
2163         TP_ARGS(xprt, result),
2164
2165         TP_STRUCT__entry(
2166                 __field(ssize_t, result)
2167                 __field(unsigned long, flags)
2168                 __string(addr, xprt->xpt_remotebuf)
2169         ),
2170
2171         TP_fast_assign(
2172                 __entry->result = result;
2173                 __entry->flags = xprt->xpt_flags;
2174                 __assign_str(addr, xprt->xpt_remotebuf);
2175         ),
2176
2177         TP_printk("addr=%s result=%zd flags=%s", __get_str(addr),
2178                 __entry->result, show_svc_xprt_flags(__entry->flags)
2179         )
2180 );
2181
2182 #define DEFINE_SVCSOCK_EVENT(name) \
2183         DEFINE_EVENT(svcsock_class, svcsock_##name, \
2184                         TP_PROTO( \
2185                                 const struct svc_xprt *xprt, \
2186                                 ssize_t result \
2187                         ), \
2188                         TP_ARGS(xprt, result))
2189
2190 DEFINE_SVCSOCK_EVENT(udp_send);
2191 DEFINE_SVCSOCK_EVENT(udp_recv);
2192 DEFINE_SVCSOCK_EVENT(udp_recv_err);
2193 DEFINE_SVCSOCK_EVENT(tcp_send);
2194 DEFINE_SVCSOCK_EVENT(tcp_recv);
2195 DEFINE_SVCSOCK_EVENT(tcp_recv_eagain);
2196 DEFINE_SVCSOCK_EVENT(tcp_recv_err);
2197 DEFINE_SVCSOCK_EVENT(data_ready);
2198 DEFINE_SVCSOCK_EVENT(write_space);
2199
2200 TRACE_EVENT(svcsock_tcp_recv_short,
2201         TP_PROTO(
2202                 const struct svc_xprt *xprt,
2203                 u32 expected,
2204                 u32 received
2205         ),
2206
2207         TP_ARGS(xprt, expected, received),
2208
2209         TP_STRUCT__entry(
2210                 __field(u32, expected)
2211                 __field(u32, received)
2212                 __field(unsigned long, flags)
2213                 __string(addr, xprt->xpt_remotebuf)
2214         ),
2215
2216         TP_fast_assign(
2217                 __entry->expected = expected;
2218                 __entry->received = received;
2219                 __entry->flags = xprt->xpt_flags;
2220                 __assign_str(addr, xprt->xpt_remotebuf);
2221         ),
2222
2223         TP_printk("addr=%s flags=%s expected=%u received=%u",
2224                 __get_str(addr), show_svc_xprt_flags(__entry->flags),
2225                 __entry->expected, __entry->received
2226         )
2227 );
2228
2229 TRACE_EVENT(svcsock_tcp_state,
2230         TP_PROTO(
2231                 const struct svc_xprt *xprt,
2232                 const struct socket *socket
2233         ),
2234
2235         TP_ARGS(xprt, socket),
2236
2237         TP_STRUCT__entry(
2238                 __field(unsigned long, socket_state)
2239                 __field(unsigned long, sock_state)
2240                 __field(unsigned long, flags)
2241                 __string(addr, xprt->xpt_remotebuf)
2242         ),
2243
2244         TP_fast_assign(
2245                 __entry->socket_state = socket->state;
2246                 __entry->sock_state = socket->sk->sk_state;
2247                 __entry->flags = xprt->xpt_flags;
2248                 __assign_str(addr, xprt->xpt_remotebuf);
2249         ),
2250
2251         TP_printk("addr=%s state=%s sk_state=%s flags=%s", __get_str(addr),
2252                 rpc_show_socket_state(__entry->socket_state),
2253                 rpc_show_sock_state(__entry->sock_state),
2254                 show_svc_xprt_flags(__entry->flags)
2255         )
2256 );
2257
2258 DECLARE_EVENT_CLASS(svcsock_accept_class,
2259         TP_PROTO(
2260                 const struct svc_xprt *xprt,
2261                 const char *service,
2262                 long status
2263         ),
2264
2265         TP_ARGS(xprt, service, status),
2266
2267         TP_STRUCT__entry(
2268                 __field(long, status)
2269                 __string(service, service)
2270                 __field(unsigned int, netns_ino)
2271         ),
2272
2273         TP_fast_assign(
2274                 __entry->status = status;
2275                 __assign_str(service, service);
2276                 __entry->netns_ino = xprt->xpt_net->ns.inum;
2277         ),
2278
2279         TP_printk("addr=listener service=%s status=%ld",
2280                 __get_str(service), __entry->status
2281         )
2282 );
2283
2284 #define DEFINE_ACCEPT_EVENT(name) \
2285         DEFINE_EVENT(svcsock_accept_class, svcsock_##name##_err, \
2286                         TP_PROTO( \
2287                                 const struct svc_xprt *xprt, \
2288                                 const char *service, \
2289                                 long status \
2290                         ), \
2291                         TP_ARGS(xprt, service, status))
2292
2293 DEFINE_ACCEPT_EVENT(accept);
2294 DEFINE_ACCEPT_EVENT(getpeername);
2295
2296 DECLARE_EVENT_CLASS(cache_event,
2297         TP_PROTO(
2298                 const struct cache_detail *cd,
2299                 const struct cache_head *h
2300         ),
2301
2302         TP_ARGS(cd, h),
2303
2304         TP_STRUCT__entry(
2305                 __field(const struct cache_head *, h)
2306                 __string(name, cd->name)
2307         ),
2308
2309         TP_fast_assign(
2310                 __entry->h = h;
2311                 __assign_str(name, cd->name);
2312         ),
2313
2314         TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)
2315 );
2316 #define DEFINE_CACHE_EVENT(name) \
2317         DEFINE_EVENT(cache_event, name, \
2318                         TP_PROTO( \
2319                                 const struct cache_detail *cd, \
2320                                 const struct cache_head *h \
2321                         ), \
2322                         TP_ARGS(cd, h))
2323 DEFINE_CACHE_EVENT(cache_entry_expired);
2324 DEFINE_CACHE_EVENT(cache_entry_upcall);
2325 DEFINE_CACHE_EVENT(cache_entry_update);
2326 DEFINE_CACHE_EVENT(cache_entry_make_negative);
2327 DEFINE_CACHE_EVENT(cache_entry_no_listener);
2328
2329 DECLARE_EVENT_CLASS(register_class,
2330         TP_PROTO(
2331                 const char *program,
2332                 const u32 version,
2333                 const int family,
2334                 const unsigned short protocol,
2335                 const unsigned short port,
2336                 int error
2337         ),
2338
2339         TP_ARGS(program, version, family, protocol, port, error),
2340
2341         TP_STRUCT__entry(
2342                 __field(u32, version)
2343                 __field(unsigned long, family)
2344                 __field(unsigned short, protocol)
2345                 __field(unsigned short, port)
2346                 __field(int, error)
2347                 __string(program, program)
2348         ),
2349
2350         TP_fast_assign(
2351                 __entry->version = version;
2352                 __entry->family = family;
2353                 __entry->protocol = protocol;
2354                 __entry->port = port;
2355                 __entry->error = error;
2356                 __assign_str(program, program);
2357         ),
2358
2359         TP_printk("program=%sv%u proto=%s port=%u family=%s error=%d",
2360                 __get_str(program), __entry->version,
2361                 __entry->protocol == IPPROTO_UDP ? "udp" : "tcp",
2362                 __entry->port, rpc_show_address_family(__entry->family),
2363                 __entry->error
2364         )
2365 );
2366
2367 #define DEFINE_REGISTER_EVENT(name) \
2368         DEFINE_EVENT(register_class, svc_##name, \
2369                         TP_PROTO( \
2370                                 const char *program, \
2371                                 const u32 version, \
2372                                 const int family, \
2373                                 const unsigned short protocol, \
2374                                 const unsigned short port, \
2375                                 int error \
2376                         ), \
2377                         TP_ARGS(program, version, family, protocol, \
2378                                 port, error))
2379
2380 DEFINE_REGISTER_EVENT(register);
2381 DEFINE_REGISTER_EVENT(noregister);
2382
2383 TRACE_EVENT(svc_unregister,
2384         TP_PROTO(
2385                 const char *program,
2386                 const u32 version,
2387                 int error
2388         ),
2389
2390         TP_ARGS(program, version, error),
2391
2392         TP_STRUCT__entry(
2393                 __field(u32, version)
2394                 __field(int, error)
2395                 __string(program, program)
2396         ),
2397
2398         TP_fast_assign(
2399                 __entry->version = version;
2400                 __entry->error = error;
2401                 __assign_str(program, program);
2402         ),
2403
2404         TP_printk("program=%sv%u error=%d",
2405                 __get_str(program), __entry->version, __entry->error
2406         )
2407 );
2408
2409 #endif /* _TRACE_SUNRPC_H */
2410
2411 #include <trace/define_trace.h>