include/trace/events/sunrpc.h

   1 #undef TRACE_SYSTEM
   2 #define TRACE_SYSTEM sunrpc
   3
   4 #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
   5 #define _TRACE_SUNRPC_H
   6
   7 #include <linux/sunrpc/sched.h>
   8 #include <linux/sunrpc/clnt.h>
   9 #include <linux/sunrpc/svc.h>
  10 #include <linux/sunrpc/xprtsock.h>
  11 #include <net/tcp_states.h>
  12 #include <linux/net.h>
  13 #include <linux/tracepoint.h>
  14
  15 DECLARE_EVENT_CLASS(rpc_task_status,
  16
  17         TP_PROTO(struct rpc_task *task),
  18
  19         TP_ARGS(task),
  20
  21         TP_STRUCT__entry(
  22                 __field(unsigned int, task_id)
  23                 __field(unsigned int, client_id)
  24                 __field(int, status)
  25         ),
  26
  27         TP_fast_assign(
  28                 __entry->task_id = task->tk_pid;
  29                 __entry->client_id = task->tk_client->cl_clid;
  30                 __entry->status = task->tk_status;
  31         ),
  32
  33         TP_printk("task:%u@%u, status %d",
  34                 __entry->task_id, __entry->client_id,
  35                 __entry->status)
  36 );
  37
  38 DEFINE_EVENT(rpc_task_status, rpc_call_status,
  39         TP_PROTO(struct rpc_task *task),
  40
  41         TP_ARGS(task)
  42 );
  43
  44 DEFINE_EVENT(rpc_task_status, rpc_bind_status,
  45         TP_PROTO(struct rpc_task *task),
  46
  47         TP_ARGS(task)
  48 );
  49
  50 TRACE_EVENT(rpc_connect_status,
  51         TP_PROTO(struct rpc_task *task, int status),
  52
  53         TP_ARGS(task, status),
  54
  55         TP_STRUCT__entry(
  56                 __field(unsigned int, task_id)
  57                 __field(unsigned int, client_id)
  58                 __field(int, status)
  59         ),
  60
  61         TP_fast_assign(
  62                 __entry->task_id = task->tk_pid;
  63                 __entry->client_id = task->tk_client->cl_clid;
  64                 __entry->status = status;
  65         ),
  66
  67         TP_printk("task:%u@%u, status %d",
  68                 __entry->task_id, __entry->client_id,
  69                 __entry->status)
  70 );
  71
  72 DECLARE_EVENT_CLASS(rpc_task_running,
  73
  74         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
  75
  76         TP_ARGS(clnt, task, action),
  77
  78         TP_STRUCT__entry(
  79                 __field(unsigned int, task_id)
  80                 __field(unsigned int, client_id)
  81                 __field(const void *, action)
  82                 __field(unsigned long, runstate)
  83                 __field(int, status)
  84                 __field(unsigned short, flags)
  85                 ),
  86
  87         TP_fast_assign(
  88                 __entry->client_id = clnt ? clnt->cl_clid : -1;
  89                 __entry->task_id = task->tk_pid;
  90                 __entry->action = action;
  91                 __entry->runstate = task->tk_runstate;
  92                 __entry->status = task->tk_status;
  93                 __entry->flags = task->tk_flags;
  94                 ),
  95
  96         TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf",
  97                 __entry->task_id, __entry->client_id,
  98                 __entry->flags,
  99                 __entry->runstate,
 100                 __entry->status,
 101                 __entry->action
 102                 )
 103 );
 104
 105 DEFINE_EVENT(rpc_task_running, rpc_task_begin,
 106
 107         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
 108
 109         TP_ARGS(clnt, task, action)
 110
 111 );
 112
 113 DEFINE_EVENT(rpc_task_running, rpc_task_run_action,
 114
 115         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
 116
 117         TP_ARGS(clnt, task, action)
 118
 119 );
 120
 121 DEFINE_EVENT(rpc_task_running, rpc_task_complete,
 122
 123         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action),
 124
 125         TP_ARGS(clnt, task, action)
 126
 127 );
 128
 129 DECLARE_EVENT_CLASS(rpc_task_queued,
 130
 131         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
 132
 133         TP_ARGS(clnt, task, q),
 134
 135         TP_STRUCT__entry(
 136                 __field(unsigned int, task_id)
 137                 __field(unsigned int, client_id)
 138                 __field(unsigned long, timeout)
 139                 __field(unsigned long, runstate)
 140                 __field(int, status)
 141                 __field(unsigned short, flags)
 142                 __string(q_name, rpc_qname(q))
 143                 ),
 144
 145         TP_fast_assign(
 146                 __entry->client_id = clnt->cl_clid;
 147                 __entry->task_id = task->tk_pid;
 148                 __entry->timeout = task->tk_timeout;
 149                 __entry->runstate = task->tk_runstate;
 150                 __entry->status = task->tk_status;
 151                 __entry->flags = task->tk_flags;
 152                 __assign_str(q_name, rpc_qname(q));
 153                 ),
 154
 155         TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
 156                 __entry->task_id, __entry->client_id,
 157                 __entry->flags,
 158                 __entry->runstate,
 159                 __entry->status,
 160                 __entry->timeout,
 161                 __get_str(q_name)
 162                 )
 163 );
 164
 165 DEFINE_EVENT(rpc_task_queued, rpc_task_sleep,
 166
 167         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
 168
 169         TP_ARGS(clnt, task, q)
 170
 171 );
 172
 173 DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,
 174
 175         TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q),
 176
 177         TP_ARGS(clnt, task, q)
 178
 179 );
 180
 181 #define rpc_show_socket_state(state) \
 182         __print_symbolic(state, \
 183                 { SS_FREE, "FREE" }, \
 184                 { SS_UNCONNECTED, "UNCONNECTED" }, \
 185                 { SS_CONNECTING, "CONNECTING," }, \
 186                 { SS_CONNECTED, "CONNECTED," }, \
 187                 { SS_DISCONNECTING, "DISCONNECTING" })
 188
 189 #define rpc_show_sock_state(state) \
 190         __print_symbolic(state, \
 191                 { TCP_ESTABLISHED, "ESTABLISHED" }, \
 192                 { TCP_SYN_SENT, "SYN_SENT" }, \
 193                 { TCP_SYN_RECV, "SYN_RECV" }, \
 194                 { TCP_FIN_WAIT1, "FIN_WAIT1" }, \
 195                 { TCP_FIN_WAIT2, "FIN_WAIT2" }, \
 196                 { TCP_TIME_WAIT, "TIME_WAIT" }, \
 197                 { TCP_CLOSE, "CLOSE" }, \
 198                 { TCP_CLOSE_WAIT, "CLOSE_WAIT" }, \
 199                 { TCP_LAST_ACK, "LAST_ACK" }, \
 200                 { TCP_LISTEN, "LISTEN" }, \
 201                 { TCP_CLOSING, "CLOSING" })
 202
 203 DECLARE_EVENT_CLASS(xs_socket_event,
 204
 205                 TP_PROTO(
 206                         struct rpc_xprt *xprt,
 207                         struct socket *socket
 208                 ),
 209
 210                 TP_ARGS(xprt, socket),
 211
 212                 TP_STRUCT__entry(
 213                         __field(unsigned int, socket_state)
 214                         __field(unsigned int, sock_state)
 215                         __field(unsigned long long, ino)
 216                         __string(dstaddr,
 217                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 218                         __string(dstport,
 219                                 xprt->address_strings[RPC_DISPLAY_PORT])
 220                 ),
 221
 222                 TP_fast_assign(
 223                         struct inode *inode = SOCK_INODE(socket);
 224                         __entry->socket_state = socket->state;
 225                         __entry->sock_state = socket->sk->sk_state;
 226                         __entry->ino = (unsigned long long)inode->i_ino;
 227                         __assign_str(dstaddr,
 228                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 229                         __assign_str(dstport,
 230                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 231                 ),
 232
 233                 TP_printk(
 234                         "socket:[%llu] dstaddr=%s/%s "
 235                         "state=%u (%s) sk_state=%u (%s)",
 236                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 237                         __entry->socket_state,
 238                         rpc_show_socket_state(__entry->socket_state),
 239                         __entry->sock_state,
 240                         rpc_show_sock_state(__entry->sock_state)
 241                 )
 242 );
 243 #define DEFINE_RPC_SOCKET_EVENT(name) \
 244         DEFINE_EVENT(xs_socket_event, name, \
 245                         TP_PROTO( \
 246                                 struct rpc_xprt *xprt, \
 247                                 struct socket *socket \
 248                         ), \
 249                         TP_ARGS(xprt, socket))
 250
 251 DECLARE_EVENT_CLASS(xs_socket_event_done,
 252
 253                 TP_PROTO(
 254                         struct rpc_xprt *xprt,
 255                         struct socket *socket,
 256                         int error
 257                 ),
 258
 259                 TP_ARGS(xprt, socket, error),
 260
 261                 TP_STRUCT__entry(
 262                         __field(int, error)
 263                         __field(unsigned int, socket_state)
 264                         __field(unsigned int, sock_state)
 265                         __field(unsigned long long, ino)
 266                         __string(dstaddr,
 267                                 xprt->address_strings[RPC_DISPLAY_ADDR])
 268                         __string(dstport,
 269                                 xprt->address_strings[RPC_DISPLAY_PORT])
 270                 ),
 271
 272                 TP_fast_assign(
 273                         struct inode *inode = SOCK_INODE(socket);
 274                         __entry->socket_state = socket->state;
 275                         __entry->sock_state = socket->sk->sk_state;
 276                         __entry->ino = (unsigned long long)inode->i_ino;
 277                         __entry->error = error;
 278                         __assign_str(dstaddr,
 279                                 xprt->address_strings[RPC_DISPLAY_ADDR]);
 280                         __assign_str(dstport,
 281                                 xprt->address_strings[RPC_DISPLAY_PORT]);
 282                 ),
 283
 284                 TP_printk(
 285                         "error=%d socket:[%llu] dstaddr=%s/%s "
 286                         "state=%u (%s) sk_state=%u (%s)",
 287                         __entry->error,
 288                         __entry->ino, __get_str(dstaddr), __get_str(dstport),
 289                         __entry->socket_state,
 290                         rpc_show_socket_state(__entry->socket_state),
 291                         __entry->sock_state,
 292                         rpc_show_sock_state(__entry->sock_state)
 293                 )
 294 );
 295 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
 296         DEFINE_EVENT(xs_socket_event_done, name, \
 297                         TP_PROTO( \
 298                                 struct rpc_xprt *xprt, \
 299                                 struct socket *socket, \
 300                                 int error \
 301                         ), \
 302                         TP_ARGS(xprt, socket, error))
 303
 304 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
 305 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
 306 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
 307 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
 308 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
 309 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
 310
 311 DECLARE_EVENT_CLASS(rpc_xprt_event,
 312         TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
 313
 314         TP_ARGS(xprt, xid, status),
 315
 316         TP_STRUCT__entry(
 317                 __field(__be32, xid)
 318                 __field(int, status)
 319                 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
 320                 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
 321         ),
 322
 323         TP_fast_assign(
 324                 __entry->xid = xid;
 325                 __entry->status = status;
 326                 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
 327                 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
 328         ),
 329
 330         TP_printk("peer=[%s]:%s xid=0x%x status=%d", __get_str(addr),
 331                         __get_str(port), be32_to_cpu(__entry->xid),
 332                         __entry->status)
 333 );
 334
 335 DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst,
 336         TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
 337         TP_ARGS(xprt, xid, status));
 338
 339 DEFINE_EVENT(rpc_xprt_event, xprt_transmit,
 340         TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
 341         TP_ARGS(xprt, xid, status));
 342
 343 DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst,
 344         TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status),
 345         TP_ARGS(xprt, xid, status));
 346
 347 TRACE_EVENT(xs_tcp_data_ready,
 348         TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total),
 349
 350         TP_ARGS(xprt, err, total),
 351
 352         TP_STRUCT__entry(
 353                 __field(int, err)
 354                 __field(unsigned int, total)
 355                 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
 356                                 "(null)")
 357                 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
 358                                 "(null)")
 359         ),
 360
 361         TP_fast_assign(
 362                 __entry->err = err;
 363                 __entry->total = total;
 364                 __assign_str(addr, xprt ?
 365                         xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
 366                 __assign_str(port, xprt ?
 367                         xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
 368         ),
 369
 370         TP_printk("peer=[%s]:%s err=%d total=%u", __get_str(addr),
 371                         __get_str(port), __entry->err, __entry->total)
 372 );
 373
 374 #define rpc_show_sock_xprt_flags(flags) \
 375         __print_flags(flags, "|", \
 376                 { TCP_RCV_LAST_FRAG, "TCP_RCV_LAST_FRAG" }, \
 377                 { TCP_RCV_COPY_FRAGHDR, "TCP_RCV_COPY_FRAGHDR" }, \
 378                 { TCP_RCV_COPY_XID, "TCP_RCV_COPY_XID" }, \
 379                 { TCP_RCV_COPY_DATA, "TCP_RCV_COPY_DATA" }, \
 380                 { TCP_RCV_READ_CALLDIR, "TCP_RCV_READ_CALLDIR" }, \
 381                 { TCP_RCV_COPY_CALLDIR, "TCP_RCV_COPY_CALLDIR" }, \
 382                 { TCP_RPC_REPLY, "TCP_RPC_REPLY" })
 383
 384 TRACE_EVENT(xs_tcp_data_recv,
 385         TP_PROTO(struct sock_xprt *xs),
 386
 387         TP_ARGS(xs),
 388
 389         TP_STRUCT__entry(
 390                 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
 391                 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
 392                 __field(__be32, xid)
 393                 __field(unsigned long, flags)
 394                 __field(unsigned long, copied)
 395                 __field(unsigned int, reclen)
 396                 __field(unsigned long, offset)
 397         ),
 398
 399         TP_fast_assign(
 400                 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
 401                 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
 402                 __entry->xid = xs->tcp_xid;
 403                 __entry->flags = xs->tcp_flags;
 404                 __entry->copied = xs->tcp_copied;
 405                 __entry->reclen = xs->tcp_reclen;
 406                 __entry->offset = xs->tcp_offset;
 407         ),
 408
 409         TP_printk("peer=[%s]:%s xid=0x%x flags=%s copied=%lu reclen=%u offset=%lu",
 410                         __get_str(addr), __get_str(port), be32_to_cpu(__entry->xid),
 411                         rpc_show_sock_xprt_flags(__entry->flags),
 412                         __entry->copied, __entry->reclen, __entry->offset)
 413 );
 414
 415 #define show_rqstp_flags(flags)                         \
 416         __print_flags(flags, "|",                       \
 417                 { (1UL << RQ_SECURE),   "RQ_SECURE"},   \
 418                 { (1UL << RQ_LOCAL),    "RQ_LOCAL"})
 419
 420 TRACE_EVENT(svc_recv,
 421         TP_PROTO(struct svc_rqst *rqst, int status),
 422
 423         TP_ARGS(rqst, status),
 424
 425         TP_STRUCT__entry(
 426                 __field(struct sockaddr *, addr)
 427                 __field(__be32, xid)
 428                 __field(int, status)
 429                 __field(unsigned long, flags)
 430         ),
 431
 432         TP_fast_assign(
 433                 __entry->addr = (struct sockaddr *)&rqst->rq_addr;
 434                 __entry->xid = status > 0 ? rqst->rq_xid : 0;
 435                 __entry->status = status;
 436                 __entry->flags = rqst->rq_flags;
 437         ),
 438
 439         TP_printk("addr=%pIScp xid=0x%x status=%d flags=%s", __entry->addr,
 440                         be32_to_cpu(__entry->xid), __entry->status,
 441                         show_rqstp_flags(__entry->flags))
 442 );
 443
 444 DECLARE_EVENT_CLASS(svc_rqst_status,
 445
 446         TP_PROTO(struct svc_rqst *rqst, int status),
 447
 448         TP_ARGS(rqst, status),
 449
 450         TP_STRUCT__entry(
 451                 __field(struct sockaddr *, addr)
 452                 __field(__be32, xid)
 453                 __field(int, dropme)
 454                 __field(int, status)
 455                 __field(unsigned long, flags)
 456         ),
 457
 458         TP_fast_assign(
 459                 __entry->addr = (struct sockaddr *)&rqst->rq_addr;
 460                 __entry->xid = rqst->rq_xid;
 461                 __entry->dropme = (int)rqst->rq_dropme;
 462                 __entry->status = status;
 463                 __entry->flags = rqst->rq_flags;
 464         ),
 465
 466         TP_printk("addr=%pIScp rq_xid=0x%x dropme=%d status=%d flags=%s",
 467                 __entry->addr, be32_to_cpu(__entry->xid), __entry->dropme,
 468                 __entry->status, show_rqstp_flags(__entry->flags))
 469 );
 470
 471 DEFINE_EVENT(svc_rqst_status, svc_process,
 472         TP_PROTO(struct svc_rqst *rqst, int status),
 473         TP_ARGS(rqst, status));
 474
 475 DEFINE_EVENT(svc_rqst_status, svc_send,
 476         TP_PROTO(struct svc_rqst *rqst, int status),
 477         TP_ARGS(rqst, status));
 478
 479 #endif /* _TRACE_SUNRPC_H */
 480
 481 #include <trace/define_trace.h>