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