Loading...
Note: File does not exist in v3.1.
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
19TRACE_DEFINE_ENUM(SOCK_STREAM);
20TRACE_DEFINE_ENUM(SOCK_DGRAM);
21TRACE_DEFINE_ENUM(SOCK_RAW);
22TRACE_DEFINE_ENUM(SOCK_RDM);
23TRACE_DEFINE_ENUM(SOCK_SEQPACKET);
24TRACE_DEFINE_ENUM(SOCK_DCCP);
25TRACE_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. */
38TRACE_DEFINE_ENUM(AF_UNSPEC);
39TRACE_DEFINE_ENUM(AF_UNIX);
40TRACE_DEFINE_ENUM(AF_LOCAL);
41TRACE_DEFINE_ENUM(AF_INET);
42TRACE_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
52DECLARE_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
104DEFINE_RPCXDRBUF_EVENT(sendto);
105DEFINE_RPCXDRBUF_EVENT(recvfrom);
106DEFINE_RPCXDRBUF_EVENT(reply_pages);
107
108
109DECLARE_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
135DEFINE_RPC_CLNT_EVENT(free);
136DEFINE_RPC_CLNT_EVENT(killall);
137DEFINE_RPC_CLNT_EVENT(shutdown);
138DEFINE_RPC_CLNT_EVENT(release);
139DEFINE_RPC_CLNT_EVENT(replace_xprt);
140DEFINE_RPC_CLNT_EVENT(replace_xprt_err);
141
142TRACE_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
174TRACE_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
199TRACE_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
222TRACE_DEFINE_ENUM(RPC_AUTH_OK);
223TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
224TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
225TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
226TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
227TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
228TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
229TRACE_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
242DECLARE_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
271DEFINE_RPC_STATUS_EVENT(call);
272DEFINE_RPC_STATUS_EVENT(connect);
273DEFINE_RPC_STATUS_EVENT(timeout);
274DEFINE_RPC_STATUS_EVENT(retry_refresh);
275DEFINE_RPC_STATUS_EVENT(refresh);
276
277TRACE_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
334DECLARE_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
376DEFINE_RPC_RUNNING_EVENT(begin);
377DEFINE_RPC_RUNNING_EVENT(run_action);
378DEFINE_RPC_RUNNING_EVENT(sync_sleep);
379DEFINE_RPC_RUNNING_EVENT(sync_wake);
380DEFINE_RPC_RUNNING_EVENT(complete);
381DEFINE_RPC_RUNNING_EVENT(timeout);
382DEFINE_RPC_RUNNING_EVENT(signalled);
383DEFINE_RPC_RUNNING_EVENT(end);
384DEFINE_RPC_RUNNING_EVENT(call_done);
385
386DECLARE_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
431DEFINE_RPC_QUEUED_EVENT(sleep);
432DEFINE_RPC_QUEUED_EVENT(wakeup);
433
434DECLARE_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
461DEFINE_RPC_FAILURE(callhdr);
462DEFINE_RPC_FAILURE(verifier);
463
464DECLARE_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
506DEFINE_RPC_REPLY_EVENT(prog_unavail);
507DEFINE_RPC_REPLY_EVENT(prog_mismatch);
508DEFINE_RPC_REPLY_EVENT(proc_unavail);
509DEFINE_RPC_REPLY_EVENT(garbage_args);
510DEFINE_RPC_REPLY_EVENT(unparsable);
511DEFINE_RPC_REPLY_EVENT(mismatch);
512DEFINE_RPC_REPLY_EVENT(stale_creds);
513DEFINE_RPC_REPLY_EVENT(bad_creds);
514DEFINE_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
523DEFINE_RPCB_ERROR_EVENT(prog_unavail);
524DEFINE_RPCB_ERROR_EVENT(timeout);
525DEFINE_RPCB_ERROR_EVENT(bind_version);
526DEFINE_RPCB_ERROR_EVENT(unreachable);
527DEFINE_RPCB_ERROR_EVENT(unrecognized);
528
529TRACE_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
560TRACE_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
589TRACE_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
631TRACE_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
698TRACE_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
776RPC_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
794RPC_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
808DECLARE_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
861DECLARE_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
918DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
919DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
920DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
921DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
922DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
923DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
924
925TRACE_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
970DECLARE_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
1002DEFINE_RPC_XPRT_LIFETIME_EVENT(create);
1003DEFINE_RPC_XPRT_LIFETIME_EVENT(connect);
1004DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto);
1005DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done);
1006DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force);
1007DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy);
1008
1009DECLARE_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
1045DEFINE_RPC_XPRT_EVENT(timer);
1046DEFINE_RPC_XPRT_EVENT(lookup_rqst);
1047
1048TRACE_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
1079TRACE_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
1121TRACE_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
1142DECLARE_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
1185DEFINE_WRITELOCK_EVENT(reserve_xprt);
1186DEFINE_WRITELOCK_EVENT(release_xprt);
1187
1188DECLARE_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
1240DEFINE_CONG_EVENT(reserve_cong);
1241DEFINE_CONG_EVENT(release_cong);
1242DEFINE_CONG_EVENT(get_cong);
1243DEFINE_CONG_EVENT(put_cong);
1244
1245TRACE_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
1269TRACE_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
1289TRACE_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
1316TRACE_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
1344TRACE_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
1381TRACE_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
1410TRACE_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
1440TRACE_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
1470TRACE_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 */
1497DECLARE_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
1541DEFINE_SVCXDRMSG_EVENT(recvfrom);
1542
1543/* Record an xdr_buf containing arbitrary data, tagged with an XID */
1544DECLARE_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
1592DEFINE_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
1612SVC_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
1622TRACE_DEFINE_ENUM(SVC_GARBAGE);
1623TRACE_DEFINE_ENUM(SVC_SYSERR);
1624TRACE_DEFINE_ENUM(SVC_VALID);
1625TRACE_DEFINE_ENUM(SVC_NEGATIVE);
1626TRACE_DEFINE_ENUM(SVC_OK);
1627TRACE_DEFINE_ENUM(SVC_DROP);
1628TRACE_DEFINE_ENUM(SVC_CLOSE);
1629TRACE_DEFINE_ENUM(SVC_DENIED);
1630TRACE_DEFINE_ENUM(SVC_PENDING);
1631TRACE_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
1669TRACE_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
1697TRACE_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
1729DECLARE_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
1759DEFINE_SVC_RQST_EVENT(defer);
1760DEFINE_SVC_RQST_EVENT(drop);
1761
1762DECLARE_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
1789DEFINE_EVENT(svc_rqst_status, svc_send,
1790 TP_PROTO(const struct svc_rqst *rqst, int status),
1791 TP_ARGS(rqst, status));
1792
1793TRACE_EVENT(svc_stats_latency,
1794 TP_PROTO(
1795 const struct svc_rqst *rqst
1796 ),
1797
1798 TP_ARGS(rqst),
1799
1800 TP_STRUCT__entry(
1801 SVC_RQST_ENDPOINT_FIELDS(rqst)
1802
1803 __field(unsigned long, execute)
1804 __string(procedure, svc_proc_name(rqst))
1805 ),
1806
1807 TP_fast_assign(
1808 SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
1809
1810 __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
1811 rqst->rq_stime));
1812 __assign_str(procedure, svc_proc_name(rqst));
1813 ),
1814
1815 TP_printk(SVC_RQST_ENDPOINT_FORMAT " proc=%s execute-us=%lu",
1816 SVC_RQST_ENDPOINT_VARARGS,
1817 __get_str(procedure), __entry->execute)
1818);
1819
1820#define show_svc_xprt_flags(flags) \
1821 __print_flags(flags, "|", \
1822 { (1UL << XPT_BUSY), "XPT_BUSY"}, \
1823 { (1UL << XPT_CONN), "XPT_CONN"}, \
1824 { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \
1825 { (1UL << XPT_DATA), "XPT_DATA"}, \
1826 { (1UL << XPT_TEMP), "XPT_TEMP"}, \
1827 { (1UL << XPT_DEAD), "XPT_DEAD"}, \
1828 { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \
1829 { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \
1830 { (1UL << XPT_OLD), "XPT_OLD"}, \
1831 { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \
1832 { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \
1833 { (1UL << XPT_LOCAL), "XPT_LOCAL"}, \
1834 { (1UL << XPT_KILL_TEMP), "XPT_KILL_TEMP"}, \
1835 { (1UL << XPT_CONG_CTRL), "XPT_CONG_CTRL"})
1836
1837TRACE_EVENT(svc_xprt_create_err,
1838 TP_PROTO(
1839 const char *program,
1840 const char *protocol,
1841 struct sockaddr *sap,
1842 size_t salen,
1843 const struct svc_xprt *xprt
1844 ),
1845
1846 TP_ARGS(program, protocol, sap, salen, xprt),
1847
1848 TP_STRUCT__entry(
1849 __field(long, error)
1850 __string(program, program)
1851 __string(protocol, protocol)
1852 __sockaddr(addr, salen)
1853 ),
1854
1855 TP_fast_assign(
1856 __entry->error = PTR_ERR(xprt);
1857 __assign_str(program, program);
1858 __assign_str(protocol, protocol);
1859 __assign_sockaddr(addr, sap, salen);
1860 ),
1861
1862 TP_printk("addr=%pISpc program=%s protocol=%s error=%ld",
1863 __get_sockaddr(addr), __get_str(program), __get_str(protocol),
1864 __entry->error)
1865);
1866
1867#define SVC_XPRT_ENDPOINT_FIELDS(x) \
1868 __sockaddr(server, (x)->xpt_locallen) \
1869 __sockaddr(client, (x)->xpt_remotelen) \
1870 __field(unsigned long, flags) \
1871 __field(unsigned int, netns_ino)
1872
1873#define SVC_XPRT_ENDPOINT_ASSIGNMENTS(x) \
1874 do { \
1875 __assign_sockaddr(server, &(x)->xpt_local, \
1876 (x)->xpt_locallen); \
1877 __assign_sockaddr(client, &(x)->xpt_remote, \
1878 (x)->xpt_remotelen); \
1879 __entry->flags = (x)->xpt_flags; \
1880 __entry->netns_ino = (x)->xpt_net->ns.inum; \
1881 } while (0)
1882
1883#define SVC_XPRT_ENDPOINT_FORMAT \
1884 "server=%pISpc client=%pISpc flags=%s"
1885
1886#define SVC_XPRT_ENDPOINT_VARARGS \
1887 __get_sockaddr(server), __get_sockaddr(client), \
1888 show_svc_xprt_flags(__entry->flags)
1889
1890TRACE_EVENT(svc_xprt_enqueue,
1891 TP_PROTO(
1892 const struct svc_xprt *xprt,
1893 const struct svc_rqst *rqst
1894 ),
1895
1896 TP_ARGS(xprt, rqst),
1897
1898 TP_STRUCT__entry(
1899 SVC_XPRT_ENDPOINT_FIELDS(xprt)
1900
1901 __field(int, pid)
1902 ),
1903
1904 TP_fast_assign(
1905 SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
1906
1907 __entry->pid = rqst? rqst->rq_task->pid : 0;
1908 ),
1909
1910 TP_printk(SVC_XPRT_ENDPOINT_FORMAT " pid=%d",
1911 SVC_XPRT_ENDPOINT_VARARGS, __entry->pid)
1912);
1913
1914TRACE_EVENT(svc_xprt_dequeue,
1915 TP_PROTO(
1916 const struct svc_rqst *rqst
1917 ),
1918
1919 TP_ARGS(rqst),
1920
1921 TP_STRUCT__entry(
1922 SVC_XPRT_ENDPOINT_FIELDS(rqst->rq_xprt)
1923
1924 __field(unsigned long, wakeup)
1925 ),
1926
1927 TP_fast_assign(
1928 SVC_XPRT_ENDPOINT_ASSIGNMENTS(rqst->rq_xprt);
1929
1930 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
1931 rqst->rq_qtime));
1932 ),
1933
1934 TP_printk(SVC_XPRT_ENDPOINT_FORMAT " wakeup-us=%lu",
1935 SVC_XPRT_ENDPOINT_VARARGS, __entry->wakeup)
1936);
1937
1938DECLARE_EVENT_CLASS(svc_xprt_event,
1939 TP_PROTO(
1940 const struct svc_xprt *xprt
1941 ),
1942
1943 TP_ARGS(xprt),
1944
1945 TP_STRUCT__entry(
1946 SVC_XPRT_ENDPOINT_FIELDS(xprt)
1947 ),
1948
1949 TP_fast_assign(
1950 SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
1951 ),
1952
1953 TP_printk(SVC_XPRT_ENDPOINT_FORMAT, SVC_XPRT_ENDPOINT_VARARGS)
1954);
1955
1956#define DEFINE_SVC_XPRT_EVENT(name) \
1957 DEFINE_EVENT(svc_xprt_event, svc_xprt_##name, \
1958 TP_PROTO( \
1959 const struct svc_xprt *xprt \
1960 ), \
1961 TP_ARGS(xprt))
1962
1963DEFINE_SVC_XPRT_EVENT(no_write_space);
1964DEFINE_SVC_XPRT_EVENT(close);
1965DEFINE_SVC_XPRT_EVENT(detach);
1966DEFINE_SVC_XPRT_EVENT(free);
1967
1968TRACE_EVENT(svc_xprt_accept,
1969 TP_PROTO(
1970 const struct svc_xprt *xprt,
1971 const char *service
1972 ),
1973
1974 TP_ARGS(xprt, service),
1975
1976 TP_STRUCT__entry(
1977 SVC_XPRT_ENDPOINT_FIELDS(xprt)
1978
1979 __string(protocol, xprt->xpt_class->xcl_name)
1980 __string(service, service)
1981 ),
1982
1983 TP_fast_assign(
1984 SVC_XPRT_ENDPOINT_ASSIGNMENTS(xprt);
1985
1986 __assign_str(protocol, xprt->xpt_class->xcl_name);
1987 __assign_str(service, service);
1988 ),
1989
1990 TP_printk(SVC_XPRT_ENDPOINT_FORMAT " protocol=%s service=%s",
1991 SVC_XPRT_ENDPOINT_VARARGS,
1992 __get_str(protocol), __get_str(service)
1993 )
1994);
1995
1996TRACE_EVENT(svc_wake_up,
1997 TP_PROTO(int pid),
1998
1999 TP_ARGS(pid),
2000
2001 TP_STRUCT__entry(
2002 __field(int, pid)
2003 ),
2004
2005 TP_fast_assign(
2006 __entry->pid = pid;
2007 ),
2008
2009 TP_printk("pid=%d", __entry->pid)
2010);
2011
2012TRACE_EVENT(svc_alloc_arg_err,
2013 TP_PROTO(
2014 unsigned int requested,
2015 unsigned int allocated
2016 ),
2017
2018 TP_ARGS(requested, allocated),
2019
2020 TP_STRUCT__entry(
2021 __field(unsigned int, requested)
2022 __field(unsigned int, allocated)
2023 ),
2024
2025 TP_fast_assign(
2026 __entry->requested = requested;
2027 __entry->allocated = allocated;
2028 ),
2029
2030 TP_printk("requested=%u allocated=%u",
2031 __entry->requested, __entry->allocated)
2032);
2033
2034DECLARE_EVENT_CLASS(svc_deferred_event,
2035 TP_PROTO(
2036 const struct svc_deferred_req *dr
2037 ),
2038
2039 TP_ARGS(dr),
2040
2041 TP_STRUCT__entry(
2042 __field(const void *, dr)
2043 __field(u32, xid)
2044 __sockaddr(addr, dr->addrlen)
2045 ),
2046
2047 TP_fast_assign(
2048 __entry->dr = dr;
2049 __entry->xid = be32_to_cpu(*(__be32 *)dr->args);
2050 __assign_sockaddr(addr, &dr->addr, dr->addrlen);
2051 ),
2052
2053 TP_printk("addr=%pISpc dr=%p xid=0x%08x", __get_sockaddr(addr),
2054 __entry->dr, __entry->xid)
2055);
2056
2057#define DEFINE_SVC_DEFERRED_EVENT(name) \
2058 DEFINE_EVENT(svc_deferred_event, svc_defer_##name, \
2059 TP_PROTO( \
2060 const struct svc_deferred_req *dr \
2061 ), \
2062 TP_ARGS(dr))
2063
2064DEFINE_SVC_DEFERRED_EVENT(drop);
2065DEFINE_SVC_DEFERRED_EVENT(queue);
2066DEFINE_SVC_DEFERRED_EVENT(recv);
2067
2068TRACE_EVENT(svcsock_new_socket,
2069 TP_PROTO(
2070 const struct socket *socket
2071 ),
2072
2073 TP_ARGS(socket),
2074
2075 TP_STRUCT__entry(
2076 __field(unsigned long, type)
2077 __field(unsigned long, family)
2078 __field(bool, listener)
2079 ),
2080
2081 TP_fast_assign(
2082 __entry->type = socket->type;
2083 __entry->family = socket->sk->sk_family;
2084 __entry->listener = (socket->sk->sk_state == TCP_LISTEN);
2085 ),
2086
2087 TP_printk("type=%s family=%s%s",
2088 show_socket_type(__entry->type),
2089 rpc_show_address_family(__entry->family),
2090 __entry->listener ? " (listener)" : ""
2091 )
2092);
2093
2094TRACE_EVENT(svcsock_marker,
2095 TP_PROTO(
2096 const struct svc_xprt *xprt,
2097 __be32 marker
2098 ),
2099
2100 TP_ARGS(xprt, marker),
2101
2102 TP_STRUCT__entry(
2103 __field(unsigned int, length)
2104 __field(bool, last)
2105 __string(addr, xprt->xpt_remotebuf)
2106 ),
2107
2108 TP_fast_assign(
2109 __entry->length = be32_to_cpu(marker) & RPC_FRAGMENT_SIZE_MASK;
2110 __entry->last = be32_to_cpu(marker) & RPC_LAST_STREAM_FRAGMENT;
2111 __assign_str(addr, xprt->xpt_remotebuf);
2112 ),
2113
2114 TP_printk("addr=%s length=%u%s", __get_str(addr),
2115 __entry->length, __entry->last ? " (last)" : "")
2116);
2117
2118DECLARE_EVENT_CLASS(svcsock_class,
2119 TP_PROTO(
2120 const struct svc_xprt *xprt,
2121 ssize_t result
2122 ),
2123
2124 TP_ARGS(xprt, result),
2125
2126 TP_STRUCT__entry(
2127 __field(ssize_t, result)
2128 __field(unsigned long, flags)
2129 __string(addr, xprt->xpt_remotebuf)
2130 ),
2131
2132 TP_fast_assign(
2133 __entry->result = result;
2134 __entry->flags = xprt->xpt_flags;
2135 __assign_str(addr, xprt->xpt_remotebuf);
2136 ),
2137
2138 TP_printk("addr=%s result=%zd flags=%s", __get_str(addr),
2139 __entry->result, show_svc_xprt_flags(__entry->flags)
2140 )
2141);
2142
2143#define DEFINE_SVCSOCK_EVENT(name) \
2144 DEFINE_EVENT(svcsock_class, svcsock_##name, \
2145 TP_PROTO( \
2146 const struct svc_xprt *xprt, \
2147 ssize_t result \
2148 ), \
2149 TP_ARGS(xprt, result))
2150
2151DEFINE_SVCSOCK_EVENT(udp_send);
2152DEFINE_SVCSOCK_EVENT(udp_recv);
2153DEFINE_SVCSOCK_EVENT(udp_recv_err);
2154DEFINE_SVCSOCK_EVENT(tcp_send);
2155DEFINE_SVCSOCK_EVENT(tcp_recv);
2156DEFINE_SVCSOCK_EVENT(tcp_recv_eagain);
2157DEFINE_SVCSOCK_EVENT(tcp_recv_err);
2158DEFINE_SVCSOCK_EVENT(data_ready);
2159DEFINE_SVCSOCK_EVENT(write_space);
2160
2161TRACE_EVENT(svcsock_tcp_recv_short,
2162 TP_PROTO(
2163 const struct svc_xprt *xprt,
2164 u32 expected,
2165 u32 received
2166 ),
2167
2168 TP_ARGS(xprt, expected, received),
2169
2170 TP_STRUCT__entry(
2171 __field(u32, expected)
2172 __field(u32, received)
2173 __field(unsigned long, flags)
2174 __string(addr, xprt->xpt_remotebuf)
2175 ),
2176
2177 TP_fast_assign(
2178 __entry->expected = expected;
2179 __entry->received = received;
2180 __entry->flags = xprt->xpt_flags;
2181 __assign_str(addr, xprt->xpt_remotebuf);
2182 ),
2183
2184 TP_printk("addr=%s flags=%s expected=%u received=%u",
2185 __get_str(addr), show_svc_xprt_flags(__entry->flags),
2186 __entry->expected, __entry->received
2187 )
2188);
2189
2190TRACE_EVENT(svcsock_tcp_state,
2191 TP_PROTO(
2192 const struct svc_xprt *xprt,
2193 const struct socket *socket
2194 ),
2195
2196 TP_ARGS(xprt, socket),
2197
2198 TP_STRUCT__entry(
2199 __field(unsigned long, socket_state)
2200 __field(unsigned long, sock_state)
2201 __field(unsigned long, flags)
2202 __string(addr, xprt->xpt_remotebuf)
2203 ),
2204
2205 TP_fast_assign(
2206 __entry->socket_state = socket->state;
2207 __entry->sock_state = socket->sk->sk_state;
2208 __entry->flags = xprt->xpt_flags;
2209 __assign_str(addr, xprt->xpt_remotebuf);
2210 ),
2211
2212 TP_printk("addr=%s state=%s sk_state=%s flags=%s", __get_str(addr),
2213 rpc_show_socket_state(__entry->socket_state),
2214 rpc_show_sock_state(__entry->sock_state),
2215 show_svc_xprt_flags(__entry->flags)
2216 )
2217);
2218
2219DECLARE_EVENT_CLASS(svcsock_accept_class,
2220 TP_PROTO(
2221 const struct svc_xprt *xprt,
2222 const char *service,
2223 long status
2224 ),
2225
2226 TP_ARGS(xprt, service, status),
2227
2228 TP_STRUCT__entry(
2229 __field(long, status)
2230 __string(service, service)
2231 __field(unsigned int, netns_ino)
2232 ),
2233
2234 TP_fast_assign(
2235 __entry->status = status;
2236 __assign_str(service, service);
2237 __entry->netns_ino = xprt->xpt_net->ns.inum;
2238 ),
2239
2240 TP_printk("addr=listener service=%s status=%ld",
2241 __get_str(service), __entry->status
2242 )
2243);
2244
2245#define DEFINE_ACCEPT_EVENT(name) \
2246 DEFINE_EVENT(svcsock_accept_class, svcsock_##name##_err, \
2247 TP_PROTO( \
2248 const struct svc_xprt *xprt, \
2249 const char *service, \
2250 long status \
2251 ), \
2252 TP_ARGS(xprt, service, status))
2253
2254DEFINE_ACCEPT_EVENT(accept);
2255DEFINE_ACCEPT_EVENT(getpeername);
2256
2257DECLARE_EVENT_CLASS(cache_event,
2258 TP_PROTO(
2259 const struct cache_detail *cd,
2260 const struct cache_head *h
2261 ),
2262
2263 TP_ARGS(cd, h),
2264
2265 TP_STRUCT__entry(
2266 __field(const struct cache_head *, h)
2267 __string(name, cd->name)
2268 ),
2269
2270 TP_fast_assign(
2271 __entry->h = h;
2272 __assign_str(name, cd->name);
2273 ),
2274
2275 TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)
2276);
2277#define DEFINE_CACHE_EVENT(name) \
2278 DEFINE_EVENT(cache_event, name, \
2279 TP_PROTO( \
2280 const struct cache_detail *cd, \
2281 const struct cache_head *h \
2282 ), \
2283 TP_ARGS(cd, h))
2284DEFINE_CACHE_EVENT(cache_entry_expired);
2285DEFINE_CACHE_EVENT(cache_entry_upcall);
2286DEFINE_CACHE_EVENT(cache_entry_update);
2287DEFINE_CACHE_EVENT(cache_entry_make_negative);
2288DEFINE_CACHE_EVENT(cache_entry_no_listener);
2289
2290DECLARE_EVENT_CLASS(register_class,
2291 TP_PROTO(
2292 const char *program,
2293 const u32 version,
2294 const int family,
2295 const unsigned short protocol,
2296 const unsigned short port,
2297 int error
2298 ),
2299
2300 TP_ARGS(program, version, family, protocol, port, error),
2301
2302 TP_STRUCT__entry(
2303 __field(u32, version)
2304 __field(unsigned long, family)
2305 __field(unsigned short, protocol)
2306 __field(unsigned short, port)
2307 __field(int, error)
2308 __string(program, program)
2309 ),
2310
2311 TP_fast_assign(
2312 __entry->version = version;
2313 __entry->family = family;
2314 __entry->protocol = protocol;
2315 __entry->port = port;
2316 __entry->error = error;
2317 __assign_str(program, program);
2318 ),
2319
2320 TP_printk("program=%sv%u proto=%s port=%u family=%s error=%d",
2321 __get_str(program), __entry->version,
2322 __entry->protocol == IPPROTO_UDP ? "udp" : "tcp",
2323 __entry->port, rpc_show_address_family(__entry->family),
2324 __entry->error
2325 )
2326);
2327
2328#define DEFINE_REGISTER_EVENT(name) \
2329 DEFINE_EVENT(register_class, svc_##name, \
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 TP_ARGS(program, version, family, protocol, \
2339 port, error))
2340
2341DEFINE_REGISTER_EVENT(register);
2342DEFINE_REGISTER_EVENT(noregister);
2343
2344TRACE_EVENT(svc_unregister,
2345 TP_PROTO(
2346 const char *program,
2347 const u32 version,
2348 int error
2349 ),
2350
2351 TP_ARGS(program, version, error),
2352
2353 TP_STRUCT__entry(
2354 __field(u32, version)
2355 __field(int, error)
2356 __string(program, program)
2357 ),
2358
2359 TP_fast_assign(
2360 __entry->version = version;
2361 __entry->error = error;
2362 __assign_str(program, program);
2363 ),
2364
2365 TP_printk("program=%sv%u error=%d",
2366 __get_str(program), __entry->version, __entry->error
2367 )
2368);
2369
2370#endif /* _TRACE_SUNRPC_H */
2371
2372#include <trace/define_trace.h>