1 /* SPDX-License-Identifier: GPL-2.0 */
3 #define TRACE_SYSTEM sunrpc
5 #if !defined(_TRACE_SUNRPC_H) || defined(TRACE_HEADER_MULTI_READ)
6 #define _TRACE_SUNRPC_H
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>
17 DECLARE_EVENT_CLASS(rpc_task_status
,
19 TP_PROTO(struct rpc_task
*task
),
24 __field(unsigned int, task_id
)
25 __field(unsigned int, client_id
)
30 __entry
->task_id
= task
->tk_pid
;
31 __entry
->client_id
= task
->tk_client
->cl_clid
;
32 __entry
->status
= task
->tk_status
;
35 TP_printk("task:%u@%u, status %d",
36 __entry
->task_id
, __entry
->client_id
,
40 DEFINE_EVENT(rpc_task_status
, rpc_call_status
,
41 TP_PROTO(struct rpc_task
*task
),
46 DEFINE_EVENT(rpc_task_status
, rpc_bind_status
,
47 TP_PROTO(struct rpc_task
*task
),
52 TRACE_EVENT(rpc_connect_status
,
53 TP_PROTO(struct rpc_task
*task
, int status
),
55 TP_ARGS(task
, status
),
58 __field(unsigned int, task_id
)
59 __field(unsigned int, client_id
)
64 __entry
->task_id
= task
->tk_pid
;
65 __entry
->client_id
= task
->tk_client
->cl_clid
;
66 __entry
->status
= status
;
69 TP_printk("task:%u@%u, status %d",
70 __entry
->task_id
, __entry
->client_id
,
74 TRACE_EVENT(rpc_request
,
75 TP_PROTO(const struct rpc_task
*task
),
80 __field(unsigned int, task_id
)
81 __field(unsigned int, client_id
)
84 __string(progname
, task
->tk_client
->cl_program
->name
)
85 __string(procname
, rpc_proc_name(task
))
89 __entry
->task_id
= task
->tk_pid
;
90 __entry
->client_id
= task
->tk_client
->cl_clid
;
91 __entry
->version
= task
->tk_client
->cl_vers
;
92 __entry
->async
= RPC_IS_ASYNC(task
);
93 __assign_str(progname
, task
->tk_client
->cl_program
->name
)
94 __assign_str(procname
, rpc_proc_name(task
))
97 TP_printk("task:%u@%u %sv%d %s (%ssync)",
98 __entry
->task_id
, __entry
->client_id
,
99 __get_str(progname
), __entry
->version
,
100 __get_str(procname
), __entry
->async
? "a": ""
104 DECLARE_EVENT_CLASS(rpc_task_running
,
106 TP_PROTO(const struct rpc_clnt
*clnt
, const struct rpc_task
*task
, const void *action
),
108 TP_ARGS(clnt
, task
, action
),
111 __field(unsigned int, task_id
)
112 __field(unsigned int, client_id
)
113 __field(const void *, action
)
114 __field(unsigned long, runstate
)
116 __field(unsigned short, flags
)
120 __entry
->client_id
= clnt
? clnt
->cl_clid
: -1;
121 __entry
->task_id
= task
->tk_pid
;
122 __entry
->action
= action
;
123 __entry
->runstate
= task
->tk_runstate
;
124 __entry
->status
= task
->tk_status
;
125 __entry
->flags
= task
->tk_flags
;
128 TP_printk("task:%u@%d flags=%4.4x state=%4.4lx status=%d action=%pf",
129 __entry
->task_id
, __entry
->client_id
,
137 DEFINE_EVENT(rpc_task_running
, rpc_task_begin
,
139 TP_PROTO(const struct rpc_clnt
*clnt
, const struct rpc_task
*task
, const void *action
),
141 TP_ARGS(clnt
, task
, action
)
145 DEFINE_EVENT(rpc_task_running
, rpc_task_run_action
,
147 TP_PROTO(const struct rpc_clnt
*clnt
, const struct rpc_task
*task
, const void *action
),
149 TP_ARGS(clnt
, task
, action
)
153 DEFINE_EVENT(rpc_task_running
, rpc_task_complete
,
155 TP_PROTO(const struct rpc_clnt
*clnt
, const struct rpc_task
*task
, const void *action
),
157 TP_ARGS(clnt
, task
, action
)
161 DECLARE_EVENT_CLASS(rpc_task_queued
,
163 TP_PROTO(const struct rpc_clnt
*clnt
, const struct rpc_task
*task
, const struct rpc_wait_queue
*q
),
165 TP_ARGS(clnt
, task
, q
),
168 __field(unsigned int, task_id
)
169 __field(unsigned int, client_id
)
170 __field(unsigned long, timeout
)
171 __field(unsigned long, runstate
)
173 __field(unsigned short, flags
)
174 __string(q_name
, rpc_qname(q
))
178 __entry
->client_id
= clnt
->cl_clid
;
179 __entry
->task_id
= task
->tk_pid
;
180 __entry
->timeout
= task
->tk_timeout
;
181 __entry
->runstate
= task
->tk_runstate
;
182 __entry
->status
= task
->tk_status
;
183 __entry
->flags
= task
->tk_flags
;
184 __assign_str(q_name
, rpc_qname(q
));
187 TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
188 __entry
->task_id
, __entry
->client_id
,
197 DEFINE_EVENT(rpc_task_queued
, rpc_task_sleep
,
199 TP_PROTO(const struct rpc_clnt
*clnt
, const struct rpc_task
*task
, const struct rpc_wait_queue
*q
),
201 TP_ARGS(clnt
, task
, q
)
205 DEFINE_EVENT(rpc_task_queued
, rpc_task_wakeup
,
207 TP_PROTO(const struct rpc_clnt
*clnt
, const struct rpc_task
*task
, const struct rpc_wait_queue
*q
),
209 TP_ARGS(clnt
, task
, q
)
214 * First define the enums in the below macros to be exported to userspace
215 * via TRACE_DEFINE_ENUM().
219 #define EM(a, b) TRACE_DEFINE_ENUM(a);
220 #define EMe(a, b) TRACE_DEFINE_ENUM(a);
222 #define RPC_SHOW_SOCKET \
223 EM( SS_FREE, "FREE" ) \
224 EM( SS_UNCONNECTED, "UNCONNECTED" ) \
225 EM( SS_CONNECTING, "CONNECTING," ) \
226 EM( SS_CONNECTED, "CONNECTED," ) \
227 EMe(SS_DISCONNECTING, "DISCONNECTING" )
229 #define rpc_show_socket_state(state) \
230 __print_symbolic(state, RPC_SHOW_SOCKET)
234 #define RPC_SHOW_SOCK \
235 EM( TCP_ESTABLISHED, "ESTABLISHED" ) \
236 EM( TCP_SYN_SENT, "SYN_SENT" ) \
237 EM( TCP_SYN_RECV, "SYN_RECV" ) \
238 EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \
239 EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \
240 EM( TCP_TIME_WAIT, "TIME_WAIT" ) \
241 EM( TCP_CLOSE, "CLOSE" ) \
242 EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \
243 EM( TCP_LAST_ACK, "LAST_ACK" ) \
244 EM( TCP_LISTEN, "LISTEN" ) \
245 EMe( TCP_CLOSING, "CLOSING" )
247 #define rpc_show_sock_state(state) \
248 __print_symbolic(state, RPC_SHOW_SOCK)
253 * Now redefine the EM() and EMe() macros to map the enums to the strings
254 * that will be printed in the output.
258 #define EM(a, b) {a, b},
259 #define EMe(a, b) {a, b}
261 DECLARE_EVENT_CLASS(xs_socket_event
,
264 struct rpc_xprt
*xprt
,
265 struct socket
*socket
268 TP_ARGS(xprt
, socket
),
271 __field(unsigned int, socket_state
)
272 __field(unsigned int, sock_state
)
273 __field(unsigned long long, ino
)
275 xprt
->address_strings
[RPC_DISPLAY_ADDR
])
277 xprt
->address_strings
[RPC_DISPLAY_PORT
])
281 struct inode
*inode
= SOCK_INODE(socket
);
282 __entry
->socket_state
= socket
->state
;
283 __entry
->sock_state
= socket
->sk
->sk_state
;
284 __entry
->ino
= (unsigned long long)inode
->i_ino
;
285 __assign_str(dstaddr
,
286 xprt
->address_strings
[RPC_DISPLAY_ADDR
]);
287 __assign_str(dstport
,
288 xprt
->address_strings
[RPC_DISPLAY_PORT
]);
292 "socket:[%llu] dstaddr=%s/%s "
293 "state=%u (%s) sk_state=%u (%s)",
294 __entry
->ino
, __get_str(dstaddr
), __get_str(dstport
),
295 __entry
->socket_state
,
296 rpc_show_socket_state(__entry
->socket_state
),
298 rpc_show_sock_state(__entry
->sock_state
)
301 #define DEFINE_RPC_SOCKET_EVENT(name) \
302 DEFINE_EVENT(xs_socket_event, name, \
304 struct rpc_xprt *xprt, \
305 struct socket *socket \
307 TP_ARGS(xprt, socket))
309 DECLARE_EVENT_CLASS(xs_socket_event_done
,
312 struct rpc_xprt
*xprt
,
313 struct socket
*socket
,
317 TP_ARGS(xprt
, socket
, error
),
321 __field(unsigned int, socket_state
)
322 __field(unsigned int, sock_state
)
323 __field(unsigned long long, ino
)
325 xprt
->address_strings
[RPC_DISPLAY_ADDR
])
327 xprt
->address_strings
[RPC_DISPLAY_PORT
])
331 struct inode
*inode
= SOCK_INODE(socket
);
332 __entry
->socket_state
= socket
->state
;
333 __entry
->sock_state
= socket
->sk
->sk_state
;
334 __entry
->ino
= (unsigned long long)inode
->i_ino
;
335 __entry
->error
= error
;
336 __assign_str(dstaddr
,
337 xprt
->address_strings
[RPC_DISPLAY_ADDR
]);
338 __assign_str(dstport
,
339 xprt
->address_strings
[RPC_DISPLAY_PORT
]);
343 "error=%d socket:[%llu] dstaddr=%s/%s "
344 "state=%u (%s) sk_state=%u (%s)",
346 __entry
->ino
, __get_str(dstaddr
), __get_str(dstport
),
347 __entry
->socket_state
,
348 rpc_show_socket_state(__entry
->socket_state
),
350 rpc_show_sock_state(__entry
->sock_state
)
353 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
354 DEFINE_EVENT(xs_socket_event_done, name, \
356 struct rpc_xprt *xprt, \
357 struct socket *socket, \
360 TP_ARGS(xprt, socket, error))
362 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change
);
363 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect
);
364 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error
);
365 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection
);
366 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close
);
367 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown
);
369 DECLARE_EVENT_CLASS(rpc_xprt_event
,
370 TP_PROTO(struct rpc_xprt
*xprt
, __be32 xid
, int status
),
372 TP_ARGS(xprt
, xid
, status
),
377 __string(addr
, xprt
->address_strings
[RPC_DISPLAY_ADDR
])
378 __string(port
, xprt
->address_strings
[RPC_DISPLAY_PORT
])
382 __entry
->xid
= be32_to_cpu(xid
);
383 __entry
->status
= status
;
384 __assign_str(addr
, xprt
->address_strings
[RPC_DISPLAY_ADDR
]);
385 __assign_str(port
, xprt
->address_strings
[RPC_DISPLAY_PORT
]);
388 TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr
),
389 __get_str(port
), __entry
->xid
,
393 DEFINE_EVENT(rpc_xprt_event
, xprt_lookup_rqst
,
394 TP_PROTO(struct rpc_xprt
*xprt
, __be32 xid
, int status
),
395 TP_ARGS(xprt
, xid
, status
));
397 DEFINE_EVENT(rpc_xprt_event
, xprt_transmit
,
398 TP_PROTO(struct rpc_xprt
*xprt
, __be32 xid
, int status
),
399 TP_ARGS(xprt
, xid
, status
));
401 DEFINE_EVENT(rpc_xprt_event
, xprt_complete_rqst
,
402 TP_PROTO(struct rpc_xprt
*xprt
, __be32 xid
, int status
),
403 TP_ARGS(xprt
, xid
, status
));
405 TRACE_EVENT(xs_tcp_data_ready
,
406 TP_PROTO(struct rpc_xprt
*xprt
, int err
, unsigned int total
),
408 TP_ARGS(xprt
, err
, total
),
412 __field(unsigned int, total
)
413 __string(addr
, xprt
? xprt
->address_strings
[RPC_DISPLAY_ADDR
] :
415 __string(port
, xprt
? xprt
->address_strings
[RPC_DISPLAY_PORT
] :
421 __entry
->total
= total
;
422 __assign_str(addr
, xprt
?
423 xprt
->address_strings
[RPC_DISPLAY_ADDR
] : "(null)");
424 __assign_str(port
, xprt
?
425 xprt
->address_strings
[RPC_DISPLAY_PORT
] : "(null)");
428 TP_printk("peer=[%s]:%s err=%d total=%u", __get_str(addr
),
429 __get_str(port
), __entry
->err
, __entry
->total
)
432 #define rpc_show_sock_xprt_flags(flags) \
433 __print_flags(flags, "|", \
434 { TCP_RCV_LAST_FRAG, "TCP_RCV_LAST_FRAG" }, \
435 { TCP_RCV_COPY_FRAGHDR, "TCP_RCV_COPY_FRAGHDR" }, \
436 { TCP_RCV_COPY_XID, "TCP_RCV_COPY_XID" }, \
437 { TCP_RCV_COPY_DATA, "TCP_RCV_COPY_DATA" }, \
438 { TCP_RCV_READ_CALLDIR, "TCP_RCV_READ_CALLDIR" }, \
439 { TCP_RCV_COPY_CALLDIR, "TCP_RCV_COPY_CALLDIR" }, \
440 { TCP_RPC_REPLY, "TCP_RPC_REPLY" })
442 TRACE_EVENT(xs_tcp_data_recv
,
443 TP_PROTO(struct sock_xprt
*xs
),
448 __string(addr
, xs
->xprt
.address_strings
[RPC_DISPLAY_ADDR
])
449 __string(port
, xs
->xprt
.address_strings
[RPC_DISPLAY_PORT
])
451 __field(unsigned long, flags
)
452 __field(unsigned long, copied
)
453 __field(unsigned int, reclen
)
454 __field(unsigned long, offset
)
458 __assign_str(addr
, xs
->xprt
.address_strings
[RPC_DISPLAY_ADDR
]);
459 __assign_str(port
, xs
->xprt
.address_strings
[RPC_DISPLAY_PORT
]);
460 __entry
->xid
= be32_to_cpu(xs
->tcp_xid
);
461 __entry
->flags
= xs
->tcp_flags
;
462 __entry
->copied
= xs
->tcp_copied
;
463 __entry
->reclen
= xs
->tcp_reclen
;
464 __entry
->offset
= xs
->tcp_offset
;
467 TP_printk("peer=[%s]:%s xid=0x%08x flags=%s copied=%lu reclen=%u offset=%lu",
468 __get_str(addr
), __get_str(port
), __entry
->xid
,
469 rpc_show_sock_xprt_flags(__entry
->flags
),
470 __entry
->copied
, __entry
->reclen
, __entry
->offset
)
473 #define show_rqstp_flags(flags) \
474 __print_flags(flags, "|", \
475 { (1UL << RQ_SECURE), "RQ_SECURE"}, \
476 { (1UL << RQ_LOCAL), "RQ_LOCAL"}, \
477 { (1UL << RQ_USEDEFERRAL), "RQ_USEDEFERRAL"}, \
478 { (1UL << RQ_DROPME), "RQ_DROPME"}, \
479 { (1UL << RQ_SPLICE_OK), "RQ_SPLICE_OK"}, \
480 { (1UL << RQ_VICTIM), "RQ_VICTIM"}, \
481 { (1UL << RQ_BUSY), "RQ_BUSY"})
483 TRACE_EVENT(svc_recv
,
484 TP_PROTO(struct svc_rqst
*rqst
, int status
),
486 TP_ARGS(rqst
, status
),
491 __field(unsigned long, flags
)
492 __dynamic_array(unsigned char, addr
, rqst
->rq_addrlen
)
496 __entry
->xid
= status
> 0 ? be32_to_cpu(rqst
->rq_xid
) : 0;
497 __entry
->status
= status
;
498 __entry
->flags
= rqst
->rq_flags
;
499 memcpy(__get_dynamic_array(addr
),
500 &rqst
->rq_addr
, rqst
->rq_addrlen
);
503 TP_printk("addr=%pIScp xid=0x%08x status=%d flags=%s",
504 (struct sockaddr
*)__get_dynamic_array(addr
),
505 __entry
->xid
, __entry
->status
,
506 show_rqstp_flags(__entry
->flags
))
509 DECLARE_EVENT_CLASS(svc_rqst_event
,
511 TP_PROTO(struct svc_rqst
*rqst
),
517 __field(unsigned long, flags
)
518 __dynamic_array(unsigned char, addr
, rqst
->rq_addrlen
)
522 __entry
->xid
= be32_to_cpu(rqst
->rq_xid
);
523 __entry
->flags
= rqst
->rq_flags
;
524 memcpy(__get_dynamic_array(addr
),
525 &rqst
->rq_addr
, rqst
->rq_addrlen
);
528 TP_printk("addr=%pIScp rq_xid=0x%08x flags=%s",
529 (struct sockaddr
*)__get_dynamic_array(addr
),
531 show_rqstp_flags(__entry
->flags
))
534 DEFINE_EVENT(svc_rqst_event
, svc_defer
,
535 TP_PROTO(struct svc_rqst
*rqst
),
538 DEFINE_EVENT(svc_rqst_event
, svc_drop
,
539 TP_PROTO(struct svc_rqst
*rqst
),
542 DECLARE_EVENT_CLASS(svc_rqst_status
,
544 TP_PROTO(struct svc_rqst
*rqst
, int status
),
546 TP_ARGS(rqst
, status
),
551 __field(unsigned long, flags
)
552 __dynamic_array(unsigned char, addr
, rqst
->rq_addrlen
)
556 __entry
->xid
= be32_to_cpu(rqst
->rq_xid
);
557 __entry
->status
= status
;
558 __entry
->flags
= rqst
->rq_flags
;
559 memcpy(__get_dynamic_array(addr
),
560 &rqst
->rq_addr
, rqst
->rq_addrlen
);
563 TP_printk("addr=%pIScp rq_xid=0x%08x status=%d flags=%s",
564 (struct sockaddr
*)__get_dynamic_array(addr
),
566 __entry
->status
, show_rqstp_flags(__entry
->flags
))
569 DEFINE_EVENT(svc_rqst_status
, svc_process
,
570 TP_PROTO(struct svc_rqst
*rqst
, int status
),
571 TP_ARGS(rqst
, status
));
573 DEFINE_EVENT(svc_rqst_status
, svc_send
,
574 TP_PROTO(struct svc_rqst
*rqst
, int status
),
575 TP_ARGS(rqst
, status
));
577 #define show_svc_xprt_flags(flags) \
578 __print_flags(flags, "|", \
579 { (1UL << XPT_BUSY), "XPT_BUSY"}, \
580 { (1UL << XPT_CONN), "XPT_CONN"}, \
581 { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \
582 { (1UL << XPT_DATA), "XPT_DATA"}, \
583 { (1UL << XPT_TEMP), "XPT_TEMP"}, \
584 { (1UL << XPT_DEAD), "XPT_DEAD"}, \
585 { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \
586 { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \
587 { (1UL << XPT_OLD), "XPT_OLD"}, \
588 { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \
589 { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \
590 { (1UL << XPT_LOCAL), "XPT_LOCAL"})
592 TRACE_EVENT(svc_xprt_do_enqueue
,
593 TP_PROTO(struct svc_xprt
*xprt
, struct svc_rqst
*rqst
),
598 __field(struct svc_xprt
*, xprt
)
600 __field(unsigned long, flags
)
601 __dynamic_array(unsigned char, addr
, xprt
!= NULL
?
602 xprt
->xpt_remotelen
: 0)
606 __entry
->xprt
= xprt
;
607 __entry
->pid
= rqst
? rqst
->rq_task
->pid
: 0;
609 memcpy(__get_dynamic_array(addr
),
611 xprt
->xpt_remotelen
);
612 __entry
->flags
= xprt
->xpt_flags
;
617 TP_printk("xprt=0x%p addr=%pIScp pid=%d flags=%s", __entry
->xprt
,
618 __get_dynamic_array_len(addr
) != 0 ?
619 (struct sockaddr
*)__get_dynamic_array(addr
) : NULL
,
620 __entry
->pid
, show_svc_xprt_flags(__entry
->flags
))
623 DECLARE_EVENT_CLASS(svc_xprt_event
,
624 TP_PROTO(struct svc_xprt
*xprt
),
629 __field(struct svc_xprt
*, xprt
)
630 __field(unsigned long, flags
)
631 __dynamic_array(unsigned char, addr
, xprt
!= NULL
?
632 xprt
->xpt_remotelen
: 0)
636 __entry
->xprt
= xprt
;
638 memcpy(__get_dynamic_array(addr
),
640 xprt
->xpt_remotelen
);
641 __entry
->flags
= xprt
->xpt_flags
;
646 TP_printk("xprt=0x%p addr=%pIScp flags=%s", __entry
->xprt
,
647 __get_dynamic_array_len(addr
) != 0 ?
648 (struct sockaddr
*)__get_dynamic_array(addr
) : NULL
,
649 show_svc_xprt_flags(__entry
->flags
))
652 DEFINE_EVENT(svc_xprt_event
, svc_xprt_dequeue
,
653 TP_PROTO(struct svc_xprt
*xprt
),
656 DEFINE_EVENT(svc_xprt_event
, svc_xprt_no_write_space
,
657 TP_PROTO(struct svc_xprt
*xprt
),
660 TRACE_EVENT(svc_wake_up
,
673 TP_printk("pid=%d", __entry
->pid
)
676 TRACE_EVENT(svc_handle_xprt
,
677 TP_PROTO(struct svc_xprt
*xprt
, int len
),
682 __field(struct svc_xprt
*, xprt
)
684 __field(unsigned long, flags
)
685 __dynamic_array(unsigned char, addr
, xprt
!= NULL
?
686 xprt
->xpt_remotelen
: 0)
690 __entry
->xprt
= xprt
;
693 memcpy(__get_dynamic_array(addr
),
695 xprt
->xpt_remotelen
);
696 __entry
->flags
= xprt
->xpt_flags
;
701 TP_printk("xprt=0x%p addr=%pIScp len=%d flags=%s", __entry
->xprt
,
702 __get_dynamic_array_len(addr
) != 0 ?
703 (struct sockaddr
*)__get_dynamic_array(addr
) : NULL
,
704 __entry
->len
, show_svc_xprt_flags(__entry
->flags
))
708 DECLARE_EVENT_CLASS(svc_deferred_event
,
709 TP_PROTO(struct svc_deferred_req
*dr
),
715 __dynamic_array(unsigned char, addr
, dr
->addrlen
)
719 __entry
->xid
= be32_to_cpu(*(__be32
*)(dr
->args
+
720 (dr
->xprt_hlen
>>2)));
721 memcpy(__get_dynamic_array(addr
), &dr
->addr
, dr
->addrlen
);
724 TP_printk("addr=%pIScp xid=0x%08x",
725 (struct sockaddr
*)__get_dynamic_array(addr
),
729 DEFINE_EVENT(svc_deferred_event
, svc_drop_deferred
,
730 TP_PROTO(struct svc_deferred_req
*dr
),
732 DEFINE_EVENT(svc_deferred_event
, svc_revisit_deferred
,
733 TP_PROTO(struct svc_deferred_req
*dr
),
735 #endif /* _TRACE_SUNRPC_H */
737 #include <trace/define_trace.h>