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