]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - include/trace/events/sunrpc.h
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag '5.15-rc4-ksmbd-fixes' of git://git.samba.org/ksmbd
[mirror_ubuntu-jammy-kernel.git] / include / trace / events / sunrpc.h
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 TRACE_DEFINE_ENUM(SOCK_STREAM);
18 TRACE_DEFINE_ENUM(SOCK_DGRAM);
19 TRACE_DEFINE_ENUM(SOCK_RAW);
20 TRACE_DEFINE_ENUM(SOCK_RDM);
21 TRACE_DEFINE_ENUM(SOCK_SEQPACKET);
22 TRACE_DEFINE_ENUM(SOCK_DCCP);
23 TRACE_DEFINE_ENUM(SOCK_PACKET);
24
25 #define show_socket_type(type) \
26 __print_symbolic(type, \
27 { SOCK_STREAM, "STREAM" }, \
28 { SOCK_DGRAM, "DGRAM" }, \
29 { SOCK_RAW, "RAW" }, \
30 { SOCK_RDM, "RDM" }, \
31 { SOCK_SEQPACKET, "SEQPACKET" }, \
32 { SOCK_DCCP, "DCCP" }, \
33 { SOCK_PACKET, "PACKET" })
34
35 /* This list is known to be incomplete, add new enums as needed. */
36 TRACE_DEFINE_ENUM(AF_UNSPEC);
37 TRACE_DEFINE_ENUM(AF_UNIX);
38 TRACE_DEFINE_ENUM(AF_LOCAL);
39 TRACE_DEFINE_ENUM(AF_INET);
40 TRACE_DEFINE_ENUM(AF_INET6);
41
42 #define rpc_show_address_family(family) \
43 __print_symbolic(family, \
44 { AF_UNSPEC, "AF_UNSPEC" }, \
45 { AF_UNIX, "AF_UNIX" }, \
46 { AF_LOCAL, "AF_LOCAL" }, \
47 { AF_INET, "AF_INET" }, \
48 { AF_INET6, "AF_INET6" })
49
50 DECLARE_EVENT_CLASS(rpc_xdr_buf_class,
51 TP_PROTO(
52 const struct rpc_task *task,
53 const struct xdr_buf *xdr
54 ),
55
56 TP_ARGS(task, xdr),
57
58 TP_STRUCT__entry(
59 __field(unsigned int, task_id)
60 __field(unsigned int, client_id)
61 __field(const void *, head_base)
62 __field(size_t, head_len)
63 __field(const void *, tail_base)
64 __field(size_t, tail_len)
65 __field(unsigned int, page_len)
66 __field(unsigned int, msg_len)
67 ),
68
69 TP_fast_assign(
70 __entry->task_id = task->tk_pid;
71 __entry->client_id = task->tk_client ?
72 task->tk_client->cl_clid : -1;
73 __entry->head_base = xdr->head[0].iov_base;
74 __entry->head_len = xdr->head[0].iov_len;
75 __entry->tail_base = xdr->tail[0].iov_base;
76 __entry->tail_len = xdr->tail[0].iov_len;
77 __entry->page_len = xdr->page_len;
78 __entry->msg_len = xdr->len;
79 ),
80
81 TP_printk("task:%u@%u head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
82 __entry->task_id, __entry->client_id,
83 __entry->head_base, __entry->head_len, __entry->page_len,
84 __entry->tail_base, __entry->tail_len, __entry->msg_len
85 )
86 );
87
88 #define DEFINE_RPCXDRBUF_EVENT(name) \
89 DEFINE_EVENT(rpc_xdr_buf_class, \
90 rpc_xdr_##name, \
91 TP_PROTO( \
92 const struct rpc_task *task, \
93 const struct xdr_buf *xdr \
94 ), \
95 TP_ARGS(task, xdr))
96
97 DEFINE_RPCXDRBUF_EVENT(sendto);
98 DEFINE_RPCXDRBUF_EVENT(recvfrom);
99 DEFINE_RPCXDRBUF_EVENT(reply_pages);
100
101
102 DECLARE_EVENT_CLASS(rpc_clnt_class,
103 TP_PROTO(
104 const struct rpc_clnt *clnt
105 ),
106
107 TP_ARGS(clnt),
108
109 TP_STRUCT__entry(
110 __field(unsigned int, client_id)
111 ),
112
113 TP_fast_assign(
114 __entry->client_id = clnt->cl_clid;
115 ),
116
117 TP_printk("clid=%u", __entry->client_id)
118 );
119
120 #define DEFINE_RPC_CLNT_EVENT(name) \
121 DEFINE_EVENT(rpc_clnt_class, \
122 rpc_clnt_##name, \
123 TP_PROTO( \
124 const struct rpc_clnt *clnt \
125 ), \
126 TP_ARGS(clnt))
127
128 DEFINE_RPC_CLNT_EVENT(free);
129 DEFINE_RPC_CLNT_EVENT(killall);
130 DEFINE_RPC_CLNT_EVENT(shutdown);
131 DEFINE_RPC_CLNT_EVENT(release);
132 DEFINE_RPC_CLNT_EVENT(replace_xprt);
133 DEFINE_RPC_CLNT_EVENT(replace_xprt_err);
134
135 TRACE_EVENT(rpc_clnt_new,
136 TP_PROTO(
137 const struct rpc_clnt *clnt,
138 const struct rpc_xprt *xprt,
139 const char *program,
140 const char *server
141 ),
142
143 TP_ARGS(clnt, xprt, program, server),
144
145 TP_STRUCT__entry(
146 __field(unsigned int, client_id)
147 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
148 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
149 __string(program, program)
150 __string(server, server)
151 ),
152
153 TP_fast_assign(
154 __entry->client_id = clnt->cl_clid;
155 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
156 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
157 __assign_str(program, program);
158 __assign_str(server, server);
159 ),
160
161 TP_printk("client=%u peer=[%s]:%s program=%s server=%s",
162 __entry->client_id, __get_str(addr), __get_str(port),
163 __get_str(program), __get_str(server))
164 );
165
166 TRACE_EVENT(rpc_clnt_new_err,
167 TP_PROTO(
168 const char *program,
169 const char *server,
170 int error
171 ),
172
173 TP_ARGS(program, server, error),
174
175 TP_STRUCT__entry(
176 __field(int, error)
177 __string(program, program)
178 __string(server, server)
179 ),
180
181 TP_fast_assign(
182 __entry->error = error;
183 __assign_str(program, program);
184 __assign_str(server, server);
185 ),
186
187 TP_printk("program=%s server=%s error=%d",
188 __get_str(program), __get_str(server), __entry->error)
189 );
190
191 TRACE_EVENT(rpc_clnt_clone_err,
192 TP_PROTO(
193 const struct rpc_clnt *clnt,
194 int error
195 ),
196
197 TP_ARGS(clnt, error),
198
199 TP_STRUCT__entry(
200 __field(unsigned int, client_id)
201 __field(int, error)
202 ),
203
204 TP_fast_assign(
205 __entry->client_id = clnt->cl_clid;
206 __entry->error = error;
207 ),
208
209 TP_printk("client=%u error=%d", __entry->client_id, __entry->error)
210 );
211
212
213 TRACE_DEFINE_ENUM(RPC_AUTH_OK);
214 TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
215 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
216 TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
217 TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
218 TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
219 TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
220 TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);
221
222 #define rpc_show_auth_stat(status) \
223 __print_symbolic(status, \
224 { RPC_AUTH_OK, "AUTH_OK" }, \
225 { RPC_AUTH_BADCRED, "BADCRED" }, \
226 { RPC_AUTH_REJECTEDCRED, "REJECTEDCRED" }, \
227 { RPC_AUTH_BADVERF, "BADVERF" }, \
228 { RPC_AUTH_REJECTEDVERF, "REJECTEDVERF" }, \
229 { RPC_AUTH_TOOWEAK, "TOOWEAK" }, \
230 { RPCSEC_GSS_CREDPROBLEM, "GSS_CREDPROBLEM" }, \
231 { RPCSEC_GSS_CTXPROBLEM, "GSS_CTXPROBLEM" }) \
232
233 DECLARE_EVENT_CLASS(rpc_task_status,
234
235 TP_PROTO(const struct rpc_task *task),
236
237 TP_ARGS(task),
238
239 TP_STRUCT__entry(
240 __field(unsigned int, task_id)
241 __field(unsigned int, client_id)
242 __field(int, status)
243 ),
244
245 TP_fast_assign(
246 __entry->task_id = task->tk_pid;
247 __entry->client_id = task->tk_client->cl_clid;
248 __entry->status = task->tk_status;
249 ),
250
251 TP_printk("task:%u@%u status=%d",
252 __entry->task_id, __entry->client_id,
253 __entry->status)
254 );
255 #define DEFINE_RPC_STATUS_EVENT(name) \
256 DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
257 TP_PROTO( \
258 const struct rpc_task *task \
259 ), \
260 TP_ARGS(task))
261
262 DEFINE_RPC_STATUS_EVENT(call);
263 DEFINE_RPC_STATUS_EVENT(connect);
264 DEFINE_RPC_STATUS_EVENT(timeout);
265 DEFINE_RPC_STATUS_EVENT(retry_refresh);
266 DEFINE_RPC_STATUS_EVENT(refresh);
267
268 TRACE_EVENT(rpc_request,
269 TP_PROTO(const struct rpc_task *task),
270
271 TP_ARGS(task),
272
273 TP_STRUCT__entry(
274 __field(unsigned int, task_id)
275 __field(unsigned int, client_id)
276 __field(int, version)
277 __field(bool, async)
278 __string(progname, task->tk_client->cl_program->name)
279 __string(procname, rpc_proc_name(task))
280 ),
281
282 TP_fast_assign(
283 __entry->task_id = task->tk_pid;
284 __entry->client_id = task->tk_client->cl_clid;
285 __entry->version = task->tk_client->cl_vers;
286 __entry->async = RPC_IS_ASYNC(task);
287 __assign_str(progname, task->tk_client->cl_program->name);
288 __assign_str(procname, rpc_proc_name(task));
289 ),
290
291 TP_printk("task:%u@%u %sv%d %s (%ssync)",
292 __entry->task_id, __entry->client_id,
293 __get_str(progname), __entry->version,
294 __get_str(procname), __entry->async ? "a": ""
295 )
296 );
297
298 #define rpc_show_task_flags(flags) \
299 __print_flags(flags, "|", \
300 { RPC_TASK_ASYNC, "ASYNC" }, \
301 { RPC_TASK_SWAPPER, "SWAPPER" }, \
302 { RPC_TASK_MOVEABLE, "MOVEABLE" }, \
303 { RPC_TASK_NULLCREDS, "NULLCREDS" }, \
304 { RPC_CALL_MAJORSEEN, "MAJORSEEN" }, \
305 { RPC_TASK_ROOTCREDS, "ROOTCREDS" }, \
306 { RPC_TASK_DYNAMIC, "DYNAMIC" }, \
307 { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" }, \
308 { RPC_TASK_SOFT, "SOFT" }, \
309 { RPC_TASK_SOFTCONN, "SOFTCONN" }, \
310 { RPC_TASK_SENT, "SENT" }, \
311 { RPC_TASK_TIMEOUT, "TIMEOUT" }, \
312 { RPC_TASK_NOCONNECT, "NOCONNECT" }, \
313 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" }, \
314 { RPC_TASK_CRED_NOREF, "CRED_NOREF" })
315
316 #define rpc_show_runstate(flags) \
317 __print_flags(flags, "|", \
318 { (1UL << RPC_TASK_RUNNING), "RUNNING" }, \
319 { (1UL << RPC_TASK_QUEUED), "QUEUED" }, \
320 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" }, \
321 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" }, \
322 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" }, \
323 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" }, \
324 { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
325
326 DECLARE_EVENT_CLASS(rpc_task_running,
327
328 TP_PROTO(const struct rpc_task *task, const void *action),
329
330 TP_ARGS(task, action),
331
332 TP_STRUCT__entry(
333 __field(unsigned int, task_id)
334 __field(unsigned int, client_id)
335 __field(const void *, action)
336 __field(unsigned long, runstate)
337 __field(int, status)
338 __field(unsigned short, flags)
339 ),
340
341 TP_fast_assign(
342 __entry->client_id = task->tk_client ?
343 task->tk_client->cl_clid : -1;
344 __entry->task_id = task->tk_pid;
345 __entry->action = action;
346 __entry->runstate = task->tk_runstate;
347 __entry->status = task->tk_status;
348 __entry->flags = task->tk_flags;
349 ),
350
351 TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%ps",
352 __entry->task_id, __entry->client_id,
353 rpc_show_task_flags(__entry->flags),
354 rpc_show_runstate(__entry->runstate),
355 __entry->status,
356 __entry->action
357 )
358 );
359 #define DEFINE_RPC_RUNNING_EVENT(name) \
360 DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
361 TP_PROTO( \
362 const struct rpc_task *task, \
363 const void *action \
364 ), \
365 TP_ARGS(task, action))
366
367 DEFINE_RPC_RUNNING_EVENT(begin);
368 DEFINE_RPC_RUNNING_EVENT(run_action);
369 DEFINE_RPC_RUNNING_EVENT(sync_sleep);
370 DEFINE_RPC_RUNNING_EVENT(sync_wake);
371 DEFINE_RPC_RUNNING_EVENT(complete);
372 DEFINE_RPC_RUNNING_EVENT(timeout);
373 DEFINE_RPC_RUNNING_EVENT(signalled);
374 DEFINE_RPC_RUNNING_EVENT(end);
375
376 DECLARE_EVENT_CLASS(rpc_task_queued,
377
378 TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
379
380 TP_ARGS(task, q),
381
382 TP_STRUCT__entry(
383 __field(unsigned int, task_id)
384 __field(unsigned int, client_id)
385 __field(unsigned long, timeout)
386 __field(unsigned long, runstate)
387 __field(int, status)
388 __field(unsigned short, flags)
389 __string(q_name, rpc_qname(q))
390 ),
391
392 TP_fast_assign(
393 __entry->client_id = task->tk_client ?
394 task->tk_client->cl_clid : -1;
395 __entry->task_id = task->tk_pid;
396 __entry->timeout = rpc_task_timeout(task);
397 __entry->runstate = task->tk_runstate;
398 __entry->status = task->tk_status;
399 __entry->flags = task->tk_flags;
400 __assign_str(q_name, rpc_qname(q));
401 ),
402
403 TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s",
404 __entry->task_id, __entry->client_id,
405 rpc_show_task_flags(__entry->flags),
406 rpc_show_runstate(__entry->runstate),
407 __entry->status,
408 __entry->timeout,
409 __get_str(q_name)
410 )
411 );
412 #define DEFINE_RPC_QUEUED_EVENT(name) \
413 DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
414 TP_PROTO( \
415 const struct rpc_task *task, \
416 const struct rpc_wait_queue *q \
417 ), \
418 TP_ARGS(task, q))
419
420 DEFINE_RPC_QUEUED_EVENT(sleep);
421 DEFINE_RPC_QUEUED_EVENT(wakeup);
422
423 DECLARE_EVENT_CLASS(rpc_failure,
424
425 TP_PROTO(const struct rpc_task *task),
426
427 TP_ARGS(task),
428
429 TP_STRUCT__entry(
430 __field(unsigned int, task_id)
431 __field(unsigned int, client_id)
432 ),
433
434 TP_fast_assign(
435 __entry->task_id = task->tk_pid;
436 __entry->client_id = task->tk_client->cl_clid;
437 ),
438
439 TP_printk("task:%u@%u",
440 __entry->task_id, __entry->client_id)
441 );
442
443 #define DEFINE_RPC_FAILURE(name) \
444 DEFINE_EVENT(rpc_failure, rpc_bad_##name, \
445 TP_PROTO( \
446 const struct rpc_task *task \
447 ), \
448 TP_ARGS(task))
449
450 DEFINE_RPC_FAILURE(callhdr);
451 DEFINE_RPC_FAILURE(verifier);
452
453 DECLARE_EVENT_CLASS(rpc_reply_event,
454
455 TP_PROTO(
456 const struct rpc_task *task
457 ),
458
459 TP_ARGS(task),
460
461 TP_STRUCT__entry(
462 __field(unsigned int, task_id)
463 __field(unsigned int, client_id)
464 __field(u32, xid)
465 __string(progname, task->tk_client->cl_program->name)
466 __field(u32, version)
467 __string(procname, rpc_proc_name(task))
468 __string(servername, task->tk_xprt->servername)
469 ),
470
471 TP_fast_assign(
472 __entry->task_id = task->tk_pid;
473 __entry->client_id = task->tk_client->cl_clid;
474 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
475 __assign_str(progname, task->tk_client->cl_program->name);
476 __entry->version = task->tk_client->cl_vers;
477 __assign_str(procname, rpc_proc_name(task));
478 __assign_str(servername, task->tk_xprt->servername);
479 ),
480
481 TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
482 __entry->task_id, __entry->client_id, __get_str(servername),
483 __entry->xid, __get_str(progname), __entry->version,
484 __get_str(procname))
485 )
486
487 #define DEFINE_RPC_REPLY_EVENT(name) \
488 DEFINE_EVENT(rpc_reply_event, rpc__##name, \
489 TP_PROTO( \
490 const struct rpc_task *task \
491 ), \
492 TP_ARGS(task))
493
494 DEFINE_RPC_REPLY_EVENT(prog_unavail);
495 DEFINE_RPC_REPLY_EVENT(prog_mismatch);
496 DEFINE_RPC_REPLY_EVENT(proc_unavail);
497 DEFINE_RPC_REPLY_EVENT(garbage_args);
498 DEFINE_RPC_REPLY_EVENT(unparsable);
499 DEFINE_RPC_REPLY_EVENT(mismatch);
500 DEFINE_RPC_REPLY_EVENT(stale_creds);
501 DEFINE_RPC_REPLY_EVENT(bad_creds);
502 DEFINE_RPC_REPLY_EVENT(auth_tooweak);
503
504 #define DEFINE_RPCB_ERROR_EVENT(name) \
505 DEFINE_EVENT(rpc_reply_event, rpcb_##name##_err, \
506 TP_PROTO( \
507 const struct rpc_task *task \
508 ), \
509 TP_ARGS(task))
510
511 DEFINE_RPCB_ERROR_EVENT(prog_unavail);
512 DEFINE_RPCB_ERROR_EVENT(timeout);
513 DEFINE_RPCB_ERROR_EVENT(bind_version);
514 DEFINE_RPCB_ERROR_EVENT(unreachable);
515 DEFINE_RPCB_ERROR_EVENT(unrecognized);
516
517 TRACE_EVENT(rpc_buf_alloc,
518 TP_PROTO(
519 const struct rpc_task *task,
520 int status
521 ),
522
523 TP_ARGS(task, status),
524
525 TP_STRUCT__entry(
526 __field(unsigned int, task_id)
527 __field(unsigned int, client_id)
528 __field(size_t, callsize)
529 __field(size_t, recvsize)
530 __field(int, status)
531 ),
532
533 TP_fast_assign(
534 __entry->task_id = task->tk_pid;
535 __entry->client_id = task->tk_client->cl_clid;
536 __entry->callsize = task->tk_rqstp->rq_callsize;
537 __entry->recvsize = task->tk_rqstp->rq_rcvsize;
538 __entry->status = status;
539 ),
540
541 TP_printk("task:%u@%u callsize=%zu recvsize=%zu status=%d",
542 __entry->task_id, __entry->client_id,
543 __entry->callsize, __entry->recvsize, __entry->status
544 )
545 );
546
547 TRACE_EVENT(rpc_call_rpcerror,
548 TP_PROTO(
549 const struct rpc_task *task,
550 int tk_status,
551 int rpc_status
552 ),
553
554 TP_ARGS(task, tk_status, rpc_status),
555
556 TP_STRUCT__entry(
557 __field(unsigned int, task_id)
558 __field(unsigned int, client_id)
559 __field(int, tk_status)
560 __field(int, rpc_status)
561 ),
562
563 TP_fast_assign(
564 __entry->client_id = task->tk_client->cl_clid;
565 __entry->task_id = task->tk_pid;
566 __entry->tk_status = tk_status;
567 __entry->rpc_status = rpc_status;
568 ),
569
570 TP_printk("task:%u@%u tk_status=%d rpc_status=%d",
571 __entry->task_id, __entry->client_id,
572 __entry->tk_status, __entry->rpc_status)
573 );
574
575 TRACE_EVENT(rpc_stats_latency,
576
577 TP_PROTO(
578 const struct rpc_task *task,
579 ktime_t backlog,
580 ktime_t rtt,
581 ktime_t execute
582 ),
583
584 TP_ARGS(task, backlog, rtt, execute),
585
586 TP_STRUCT__entry(
587 __field(unsigned int, task_id)
588 __field(unsigned int, client_id)
589 __field(u32, xid)
590 __field(int, version)
591 __string(progname, task->tk_client->cl_program->name)
592 __string(procname, rpc_proc_name(task))
593 __field(unsigned long, backlog)
594 __field(unsigned long, rtt)
595 __field(unsigned long, execute)
596 ),
597
598 TP_fast_assign(
599 __entry->client_id = task->tk_client->cl_clid;
600 __entry->task_id = task->tk_pid;
601 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
602 __entry->version = task->tk_client->cl_vers;
603 __assign_str(progname, task->tk_client->cl_program->name);
604 __assign_str(procname, rpc_proc_name(task));
605 __entry->backlog = ktime_to_us(backlog);
606 __entry->rtt = ktime_to_us(rtt);
607 __entry->execute = ktime_to_us(execute);
608 ),
609
610 TP_printk("task:%u@%d xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
611 __entry->task_id, __entry->client_id, __entry->xid,
612 __get_str(progname), __entry->version, __get_str(procname),
613 __entry->backlog, __entry->rtt, __entry->execute)
614 );
615
616 TRACE_EVENT(rpc_xdr_overflow,
617 TP_PROTO(
618 const struct xdr_stream *xdr,
619 size_t requested
620 ),
621
622 TP_ARGS(xdr, requested),
623
624 TP_STRUCT__entry(
625 __field(unsigned int, task_id)
626 __field(unsigned int, client_id)
627 __field(int, version)
628 __field(size_t, requested)
629 __field(const void *, end)
630 __field(const void *, p)
631 __field(const void *, head_base)
632 __field(size_t, head_len)
633 __field(const void *, tail_base)
634 __field(size_t, tail_len)
635 __field(unsigned int, page_len)
636 __field(unsigned int, len)
637 __string(progname, xdr->rqst ?
638 xdr->rqst->rq_task->tk_client->cl_program->name : "unknown")
639 __string(procedure, xdr->rqst ?
640 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name : "unknown")
641 ),
642
643 TP_fast_assign(
644 if (xdr->rqst) {
645 const struct rpc_task *task = xdr->rqst->rq_task;
646
647 __entry->task_id = task->tk_pid;
648 __entry->client_id = task->tk_client->cl_clid;
649 __assign_str(progname,
650 task->tk_client->cl_program->name);
651 __entry->version = task->tk_client->cl_vers;
652 __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
653 } else {
654 __entry->task_id = 0;
655 __entry->client_id = 0;
656 __assign_str(progname, "unknown");
657 __entry->version = 0;
658 __assign_str(procedure, "unknown");
659 }
660 __entry->requested = requested;
661 __entry->end = xdr->end;
662 __entry->p = xdr->p;
663 __entry->head_base = xdr->buf->head[0].iov_base,
664 __entry->head_len = xdr->buf->head[0].iov_len,
665 __entry->page_len = xdr->buf->page_len,
666 __entry->tail_base = xdr->buf->tail[0].iov_base,
667 __entry->tail_len = xdr->buf->tail[0].iov_len,
668 __entry->len = xdr->buf->len;
669 ),
670
671 TP_printk(
672 "task:%u@%u %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
673 __entry->task_id, __entry->client_id,
674 __get_str(progname), __entry->version, __get_str(procedure),
675 __entry->requested, __entry->p, __entry->end,
676 __entry->head_base, __entry->head_len,
677 __entry->page_len,
678 __entry->tail_base, __entry->tail_len,
679 __entry->len
680 )
681 );
682
683 TRACE_EVENT(rpc_xdr_alignment,
684 TP_PROTO(
685 const struct xdr_stream *xdr,
686 size_t offset,
687 unsigned int copied
688 ),
689
690 TP_ARGS(xdr, offset, copied),
691
692 TP_STRUCT__entry(
693 __field(unsigned int, task_id)
694 __field(unsigned int, client_id)
695 __field(int, version)
696 __field(size_t, offset)
697 __field(unsigned int, copied)
698 __field(const void *, head_base)
699 __field(size_t, head_len)
700 __field(const void *, tail_base)
701 __field(size_t, tail_len)
702 __field(unsigned int, page_len)
703 __field(unsigned int, len)
704 __string(progname,
705 xdr->rqst->rq_task->tk_client->cl_program->name)
706 __string(procedure,
707 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
708 ),
709
710 TP_fast_assign(
711 const struct rpc_task *task = xdr->rqst->rq_task;
712
713 __entry->task_id = task->tk_pid;
714 __entry->client_id = task->tk_client->cl_clid;
715 __assign_str(progname,
716 task->tk_client->cl_program->name);
717 __entry->version = task->tk_client->cl_vers;
718 __assign_str(procedure, task->tk_msg.rpc_proc->p_name);
719
720 __entry->offset = offset;
721 __entry->copied = copied;
722 __entry->head_base = xdr->buf->head[0].iov_base,
723 __entry->head_len = xdr->buf->head[0].iov_len,
724 __entry->page_len = xdr->buf->page_len,
725 __entry->tail_base = xdr->buf->tail[0].iov_base,
726 __entry->tail_len = xdr->buf->tail[0].iov_len,
727 __entry->len = xdr->buf->len;
728 ),
729
730 TP_printk(
731 "task:%u@%u %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
732 __entry->task_id, __entry->client_id,
733 __get_str(progname), __entry->version, __get_str(procedure),
734 __entry->offset, __entry->copied,
735 __entry->head_base, __entry->head_len,
736 __entry->page_len,
737 __entry->tail_base, __entry->tail_len,
738 __entry->len
739 )
740 );
741
742 /*
743 * First define the enums in the below macros to be exported to userspace
744 * via TRACE_DEFINE_ENUM().
745 */
746 #undef EM
747 #undef EMe
748 #define EM(a, b) TRACE_DEFINE_ENUM(a);
749 #define EMe(a, b) TRACE_DEFINE_ENUM(a);
750
751 #define RPC_SHOW_SOCKET \
752 EM( SS_FREE, "FREE" ) \
753 EM( SS_UNCONNECTED, "UNCONNECTED" ) \
754 EM( SS_CONNECTING, "CONNECTING" ) \
755 EM( SS_CONNECTED, "CONNECTED" ) \
756 EMe( SS_DISCONNECTING, "DISCONNECTING" )
757
758 #define rpc_show_socket_state(state) \
759 __print_symbolic(state, RPC_SHOW_SOCKET)
760
761 RPC_SHOW_SOCKET
762
763 #define RPC_SHOW_SOCK \
764 EM( TCP_ESTABLISHED, "ESTABLISHED" ) \
765 EM( TCP_SYN_SENT, "SYN_SENT" ) \
766 EM( TCP_SYN_RECV, "SYN_RECV" ) \
767 EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \
768 EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \
769 EM( TCP_TIME_WAIT, "TIME_WAIT" ) \
770 EM( TCP_CLOSE, "CLOSE" ) \
771 EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \
772 EM( TCP_LAST_ACK, "LAST_ACK" ) \
773 EM( TCP_LISTEN, "LISTEN" ) \
774 EMe( TCP_CLOSING, "CLOSING" )
775
776 #define rpc_show_sock_state(state) \
777 __print_symbolic(state, RPC_SHOW_SOCK)
778
779 RPC_SHOW_SOCK
780
781 /*
782 * Now redefine the EM() and EMe() macros to map the enums to the strings
783 * that will be printed in the output.
784 */
785 #undef EM
786 #undef EMe
787 #define EM(a, b) {a, b},
788 #define EMe(a, b) {a, b}
789
790 DECLARE_EVENT_CLASS(xs_socket_event,
791
792 TP_PROTO(
793 struct rpc_xprt *xprt,
794 struct socket *socket
795 ),
796
797 TP_ARGS(xprt, socket),
798
799 TP_STRUCT__entry(
800 __field(unsigned int, socket_state)
801 __field(unsigned int, sock_state)
802 __field(unsigned long long, ino)
803 __string(dstaddr,
804 xprt->address_strings[RPC_DISPLAY_ADDR])
805 __string(dstport,
806 xprt->address_strings[RPC_DISPLAY_PORT])
807 ),
808
809 TP_fast_assign(
810 struct inode *inode = SOCK_INODE(socket);
811 __entry->socket_state = socket->state;
812 __entry->sock_state = socket->sk->sk_state;
813 __entry->ino = (unsigned long long)inode->i_ino;
814 __assign_str(dstaddr,
815 xprt->address_strings[RPC_DISPLAY_ADDR]);
816 __assign_str(dstport,
817 xprt->address_strings[RPC_DISPLAY_PORT]);
818 ),
819
820 TP_printk(
821 "socket:[%llu] dstaddr=%s/%s "
822 "state=%u (%s) sk_state=%u (%s)",
823 __entry->ino, __get_str(dstaddr), __get_str(dstport),
824 __entry->socket_state,
825 rpc_show_socket_state(__entry->socket_state),
826 __entry->sock_state,
827 rpc_show_sock_state(__entry->sock_state)
828 )
829 );
830 #define DEFINE_RPC_SOCKET_EVENT(name) \
831 DEFINE_EVENT(xs_socket_event, name, \
832 TP_PROTO( \
833 struct rpc_xprt *xprt, \
834 struct socket *socket \
835 ), \
836 TP_ARGS(xprt, socket))
837
838 DECLARE_EVENT_CLASS(xs_socket_event_done,
839
840 TP_PROTO(
841 struct rpc_xprt *xprt,
842 struct socket *socket,
843 int error
844 ),
845
846 TP_ARGS(xprt, socket, error),
847
848 TP_STRUCT__entry(
849 __field(int, error)
850 __field(unsigned int, socket_state)
851 __field(unsigned int, sock_state)
852 __field(unsigned long long, ino)
853 __string(dstaddr,
854 xprt->address_strings[RPC_DISPLAY_ADDR])
855 __string(dstport,
856 xprt->address_strings[RPC_DISPLAY_PORT])
857 ),
858
859 TP_fast_assign(
860 struct inode *inode = SOCK_INODE(socket);
861 __entry->socket_state = socket->state;
862 __entry->sock_state = socket->sk->sk_state;
863 __entry->ino = (unsigned long long)inode->i_ino;
864 __entry->error = error;
865 __assign_str(dstaddr,
866 xprt->address_strings[RPC_DISPLAY_ADDR]);
867 __assign_str(dstport,
868 xprt->address_strings[RPC_DISPLAY_PORT]);
869 ),
870
871 TP_printk(
872 "error=%d socket:[%llu] dstaddr=%s/%s "
873 "state=%u (%s) sk_state=%u (%s)",
874 __entry->error,
875 __entry->ino, __get_str(dstaddr), __get_str(dstport),
876 __entry->socket_state,
877 rpc_show_socket_state(__entry->socket_state),
878 __entry->sock_state,
879 rpc_show_sock_state(__entry->sock_state)
880 )
881 );
882 #define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
883 DEFINE_EVENT(xs_socket_event_done, name, \
884 TP_PROTO( \
885 struct rpc_xprt *xprt, \
886 struct socket *socket, \
887 int error \
888 ), \
889 TP_ARGS(xprt, socket, error))
890
891 DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
892 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
893 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
894 DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
895 DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
896 DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
897
898 TRACE_EVENT(rpc_socket_nospace,
899 TP_PROTO(
900 const struct rpc_rqst *rqst,
901 const struct sock_xprt *transport
902 ),
903
904 TP_ARGS(rqst, transport),
905
906 TP_STRUCT__entry(
907 __field(unsigned int, task_id)
908 __field(unsigned int, client_id)
909 __field(unsigned int, total)
910 __field(unsigned int, remaining)
911 ),
912
913 TP_fast_assign(
914 __entry->task_id = rqst->rq_task->tk_pid;
915 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
916 __entry->total = rqst->rq_slen;
917 __entry->remaining = rqst->rq_slen - transport->xmit.offset;
918 ),
919
920 TP_printk("task:%u@%u total=%u remaining=%u",
921 __entry->task_id, __entry->client_id,
922 __entry->total, __entry->remaining
923 )
924 );
925
926 #define rpc_show_xprt_state(x) \
927 __print_flags(x, "|", \
928 { (1UL << XPRT_LOCKED), "LOCKED"}, \
929 { (1UL << XPRT_CONNECTED), "CONNECTED"}, \
930 { (1UL << XPRT_CONNECTING), "CONNECTING"}, \
931 { (1UL << XPRT_CLOSE_WAIT), "CLOSE_WAIT"}, \
932 { (1UL << XPRT_BOUND), "BOUND"}, \
933 { (1UL << XPRT_BINDING), "BINDING"}, \
934 { (1UL << XPRT_CLOSING), "CLOSING"}, \
935 { (1UL << XPRT_OFFLINE), "OFFLINE"}, \
936 { (1UL << XPRT_REMOVE), "REMOVE"}, \
937 { (1UL << XPRT_CONGESTED), "CONGESTED"}, \
938 { (1UL << XPRT_CWND_WAIT), "CWND_WAIT"}, \
939 { (1UL << XPRT_WRITE_SPACE), "WRITE_SPACE"})
940
941 DECLARE_EVENT_CLASS(rpc_xprt_lifetime_class,
942 TP_PROTO(
943 const struct rpc_xprt *xprt
944 ),
945
946 TP_ARGS(xprt),
947
948 TP_STRUCT__entry(
949 __field(unsigned long, state)
950 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
951 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
952 ),
953
954 TP_fast_assign(
955 __entry->state = xprt->state;
956 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
957 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
958 ),
959
960 TP_printk("peer=[%s]:%s state=%s",
961 __get_str(addr), __get_str(port),
962 rpc_show_xprt_state(__entry->state))
963 );
964
965 #define DEFINE_RPC_XPRT_LIFETIME_EVENT(name) \
966 DEFINE_EVENT(rpc_xprt_lifetime_class, \
967 xprt_##name, \
968 TP_PROTO( \
969 const struct rpc_xprt *xprt \
970 ), \
971 TP_ARGS(xprt))
972
973 DEFINE_RPC_XPRT_LIFETIME_EVENT(create);
974 DEFINE_RPC_XPRT_LIFETIME_EVENT(connect);
975 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_auto);
976 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_done);
977 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_force);
978 DEFINE_RPC_XPRT_LIFETIME_EVENT(disconnect_cleanup);
979 DEFINE_RPC_XPRT_LIFETIME_EVENT(destroy);
980
981 DECLARE_EVENT_CLASS(rpc_xprt_event,
982 TP_PROTO(
983 const struct rpc_xprt *xprt,
984 __be32 xid,
985 int status
986 ),
987
988 TP_ARGS(xprt, xid, status),
989
990 TP_STRUCT__entry(
991 __field(u32, xid)
992 __field(int, status)
993 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
994 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
995 ),
996
997 TP_fast_assign(
998 __entry->xid = be32_to_cpu(xid);
999 __entry->status = status;
1000 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1001 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1002 ),
1003
1004 TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
1005 __get_str(port), __entry->xid,
1006 __entry->status)
1007 );
1008 #define DEFINE_RPC_XPRT_EVENT(name) \
1009 DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
1010 TP_PROTO( \
1011 const struct rpc_xprt *xprt, \
1012 __be32 xid, \
1013 int status \
1014 ), \
1015 TP_ARGS(xprt, xid, status))
1016
1017 DEFINE_RPC_XPRT_EVENT(timer);
1018 DEFINE_RPC_XPRT_EVENT(lookup_rqst);
1019
1020 TRACE_EVENT(xprt_transmit,
1021 TP_PROTO(
1022 const struct rpc_rqst *rqst,
1023 int status
1024 ),
1025
1026 TP_ARGS(rqst, status),
1027
1028 TP_STRUCT__entry(
1029 __field(unsigned int, task_id)
1030 __field(unsigned int, client_id)
1031 __field(u32, xid)
1032 __field(u32, seqno)
1033 __field(int, status)
1034 ),
1035
1036 TP_fast_assign(
1037 __entry->task_id = rqst->rq_task->tk_pid;
1038 __entry->client_id = rqst->rq_task->tk_client ?
1039 rqst->rq_task->tk_client->cl_clid : -1;
1040 __entry->xid = be32_to_cpu(rqst->rq_xid);
1041 __entry->seqno = rqst->rq_seqno;
1042 __entry->status = status;
1043 ),
1044
1045 TP_printk(
1046 "task:%u@%u xid=0x%08x seqno=%u status=%d",
1047 __entry->task_id, __entry->client_id, __entry->xid,
1048 __entry->seqno, __entry->status)
1049 );
1050
1051 TRACE_EVENT(xprt_retransmit,
1052 TP_PROTO(
1053 const struct rpc_rqst *rqst
1054 ),
1055
1056 TP_ARGS(rqst),
1057
1058 TP_STRUCT__entry(
1059 __field(unsigned int, task_id)
1060 __field(unsigned int, client_id)
1061 __field(u32, xid)
1062 __field(int, ntrans)
1063 __field(int, version)
1064 __field(unsigned long, timeout)
1065 __string(progname,
1066 rqst->rq_task->tk_client->cl_program->name)
1067 __string(procname, rpc_proc_name(rqst->rq_task))
1068 ),
1069
1070 TP_fast_assign(
1071 struct rpc_task *task = rqst->rq_task;
1072
1073 __entry->task_id = task->tk_pid;
1074 __entry->client_id = task->tk_client ?
1075 task->tk_client->cl_clid : -1;
1076 __entry->xid = be32_to_cpu(rqst->rq_xid);
1077 __entry->ntrans = rqst->rq_ntrans;
1078 __entry->timeout = task->tk_timeout;
1079 __assign_str(progname,
1080 task->tk_client->cl_program->name);
1081 __entry->version = task->tk_client->cl_vers;
1082 __assign_str(procname, rpc_proc_name(task));
1083 ),
1084
1085 TP_printk(
1086 "task:%u@%u xid=0x%08x %sv%d %s ntrans=%d timeout=%lu",
1087 __entry->task_id, __entry->client_id, __entry->xid,
1088 __get_str(progname), __entry->version, __get_str(procname),
1089 __entry->ntrans, __entry->timeout
1090 )
1091 );
1092
1093 TRACE_EVENT(xprt_ping,
1094 TP_PROTO(const struct rpc_xprt *xprt, int status),
1095
1096 TP_ARGS(xprt, status),
1097
1098 TP_STRUCT__entry(
1099 __field(int, status)
1100 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
1101 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
1102 ),
1103
1104 TP_fast_assign(
1105 __entry->status = status;
1106 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
1107 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
1108 ),
1109
1110 TP_printk("peer=[%s]:%s status=%d",
1111 __get_str(addr), __get_str(port), __entry->status)
1112 );
1113
1114 DECLARE_EVENT_CLASS(xprt_writelock_event,
1115 TP_PROTO(
1116 const struct rpc_xprt *xprt, const struct rpc_task *task
1117 ),
1118
1119 TP_ARGS(xprt, task),
1120
1121 TP_STRUCT__entry(
1122 __field(unsigned int, task_id)
1123 __field(unsigned int, client_id)
1124 __field(unsigned int, snd_task_id)
1125 ),
1126
1127 TP_fast_assign(
1128 if (task) {
1129 __entry->task_id = task->tk_pid;
1130 __entry->client_id = task->tk_client ?
1131 task->tk_client->cl_clid : -1;
1132 } else {
1133 __entry->task_id = -1;
1134 __entry->client_id = -1;
1135 }
1136 __entry->snd_task_id = xprt->snd_task ?
1137 xprt->snd_task->tk_pid : -1;
1138 ),
1139
1140 TP_printk("task:%u@%u snd_task:%u",
1141 __entry->task_id, __entry->client_id,
1142 __entry->snd_task_id)
1143 );
1144
1145 #define DEFINE_WRITELOCK_EVENT(name) \
1146 DEFINE_EVENT(xprt_writelock_event, xprt_##name, \
1147 TP_PROTO( \
1148 const struct rpc_xprt *xprt, \
1149 const struct rpc_task *task \
1150 ), \
1151 TP_ARGS(xprt, task))
1152
1153 DEFINE_WRITELOCK_EVENT(reserve_xprt);
1154 DEFINE_WRITELOCK_EVENT(release_xprt);
1155
1156 DECLARE_EVENT_CLASS(xprt_cong_event,
1157 TP_PROTO(
1158 const struct rpc_xprt *xprt, const struct rpc_task *task
1159 ),
1160
1161 TP_ARGS(xprt, task),
1162
1163 TP_STRUCT__entry(
1164 __field(unsigned int, task_id)
1165 __field(unsigned int, client_id)
1166 __field(unsigned int, snd_task_id)
1167 __field(unsigned long, cong)
1168 __field(unsigned long, cwnd)
1169 __field(bool, wait)
1170 ),
1171
1172 TP_fast_assign(
1173 if (task) {
1174 __entry->task_id = task->tk_pid;
1175 __entry->client_id = task->tk_client ?
1176 task->tk_client->cl_clid : -1;
1177 } else {
1178 __entry->task_id = -1;
1179 __entry->client_id = -1;
1180 }
1181 __entry->snd_task_id = xprt->snd_task ?
1182 xprt->snd_task->tk_pid : -1;
1183 __entry->cong = xprt->cong;
1184 __entry->cwnd = xprt->cwnd;
1185 __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
1186 ),
1187
1188 TP_printk("task:%u@%u snd_task:%u cong=%lu cwnd=%lu%s",
1189 __entry->task_id, __entry->client_id,
1190 __entry->snd_task_id, __entry->cong, __entry->cwnd,
1191 __entry->wait ? " (wait)" : "")
1192 );
1193
1194 #define DEFINE_CONG_EVENT(name) \
1195 DEFINE_EVENT(xprt_cong_event, xprt_##name, \
1196 TP_PROTO( \
1197 const struct rpc_xprt *xprt, \
1198 const struct rpc_task *task \
1199 ), \
1200 TP_ARGS(xprt, task))
1201
1202 DEFINE_CONG_EVENT(reserve_cong);
1203 DEFINE_CONG_EVENT(release_cong);
1204 DEFINE_CONG_EVENT(get_cong);
1205 DEFINE_CONG_EVENT(put_cong);
1206
1207 TRACE_EVENT(xprt_reserve,
1208 TP_PROTO(
1209 const struct rpc_rqst *rqst
1210 ),
1211
1212 TP_ARGS(rqst),
1213
1214 TP_STRUCT__entry(
1215 __field(unsigned int, task_id)
1216 __field(unsigned int, client_id)
1217 __field(u32, xid)
1218 ),
1219
1220 TP_fast_assign(
1221 __entry->task_id = rqst->rq_task->tk_pid;
1222 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
1223 __entry->xid = be32_to_cpu(rqst->rq_xid);
1224 ),
1225
1226 TP_printk("task:%u@%u xid=0x%08x",
1227 __entry->task_id, __entry->client_id, __entry->xid
1228 )
1229 );
1230
1231 TRACE_EVENT(xs_stream_read_data,
1232 TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
1233
1234 TP_ARGS(xprt, err, total),
1235
1236 TP_STRUCT__entry(
1237 __field(ssize_t, err)
1238 __field(size_t, total)
1239 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
1240 "(null)")
1241 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
1242 "(null)")
1243 ),
1244
1245 TP_fast_assign(
1246 __entry->err = err;
1247 __entry->total = total;
1248 __assign_str(addr, xprt ?
1249 xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
1250 __assign_str(port, xprt ?
1251 xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
1252 ),
1253
1254 TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
1255 __get_str(port), __entry->err, __entry->total)
1256 );
1257
1258 TRACE_EVENT(xs_stream_read_request,
1259 TP_PROTO(struct sock_xprt *xs),
1260
1261 TP_ARGS(xs),
1262
1263 TP_STRUCT__entry(
1264 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
1265 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
1266 __field(u32, xid)
1267 __field(unsigned long, copied)
1268 __field(unsigned int, reclen)
1269 __field(unsigned int, offset)
1270 ),
1271
1272 TP_fast_assign(
1273 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
1274 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
1275 __entry->xid = be32_to_cpu(xs->recv.xid);
1276 __entry->copied = xs->recv.copied;
1277 __entry->reclen = xs->recv.len;
1278 __entry->offset = xs->recv.offset;
1279 ),
1280
1281 TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
1282 __get_str(addr), __get_str(port), __entry->xid,
1283 __entry->copied, __entry->reclen, __entry->offset)
1284 );
1285
1286 TRACE_EVENT(rpcb_getport,
1287 TP_PROTO(
1288 const struct rpc_clnt *clnt,
1289 const struct rpc_task *task,
1290 unsigned int bind_version
1291 ),
1292
1293 TP_ARGS(clnt, task, bind_version),
1294
1295 TP_STRUCT__entry(
1296 __field(unsigned int, task_id)
1297 __field(unsigned int, client_id)
1298 __field(unsigned int, program)
1299 __field(unsigned int, version)
1300 __field(int, protocol)
1301 __field(unsigned int, bind_version)
1302 __string(servername, task->tk_xprt->servername)
1303 ),
1304
1305 TP_fast_assign(
1306 __entry->task_id = task->tk_pid;
1307 __entry->client_id = clnt->cl_clid;
1308 __entry->program = clnt->cl_prog;
1309 __entry->version = clnt->cl_vers;
1310 __entry->protocol = task->tk_xprt->prot;
1311 __entry->bind_version = bind_version;
1312 __assign_str(servername, task->tk_xprt->servername);
1313 ),
1314
1315 TP_printk("task:%u@%u server=%s program=%u version=%u protocol=%d bind_version=%u",
1316 __entry->task_id, __entry->client_id, __get_str(servername),
1317 __entry->program, __entry->version, __entry->protocol,
1318 __entry->bind_version
1319 )
1320 );
1321
1322 TRACE_EVENT(rpcb_setport,
1323 TP_PROTO(
1324 const struct rpc_task *task,
1325 int status,
1326 unsigned short port
1327 ),
1328
1329 TP_ARGS(task, status, port),
1330
1331 TP_STRUCT__entry(
1332 __field(unsigned int, task_id)
1333 __field(unsigned int, client_id)
1334 __field(int, status)
1335 __field(unsigned short, port)
1336 ),
1337
1338 TP_fast_assign(
1339 __entry->task_id = task->tk_pid;
1340 __entry->client_id = task->tk_client->cl_clid;
1341 __entry->status = status;
1342 __entry->port = port;
1343 ),
1344
1345 TP_printk("task:%u@%u status=%d port=%u",
1346 __entry->task_id, __entry->client_id,
1347 __entry->status, __entry->port
1348 )
1349 );
1350
1351 TRACE_EVENT(pmap_register,
1352 TP_PROTO(
1353 u32 program,
1354 u32 version,
1355 int protocol,
1356 unsigned short port
1357 ),
1358
1359 TP_ARGS(program, version, protocol, port),
1360
1361 TP_STRUCT__entry(
1362 __field(unsigned int, program)
1363 __field(unsigned int, version)
1364 __field(int, protocol)
1365 __field(unsigned int, port)
1366 ),
1367
1368 TP_fast_assign(
1369 __entry->program = program;
1370 __entry->version = version;
1371 __entry->protocol = protocol;
1372 __entry->port = port;
1373 ),
1374
1375 TP_printk("program=%u version=%u protocol=%d port=%u",
1376 __entry->program, __entry->version,
1377 __entry->protocol, __entry->port
1378 )
1379 );
1380
1381 TRACE_EVENT(rpcb_register,
1382 TP_PROTO(
1383 u32 program,
1384 u32 version,
1385 const char *addr,
1386 const char *netid
1387 ),
1388
1389 TP_ARGS(program, version, addr, netid),
1390
1391 TP_STRUCT__entry(
1392 __field(unsigned int, program)
1393 __field(unsigned int, version)
1394 __string(addr, addr)
1395 __string(netid, netid)
1396 ),
1397
1398 TP_fast_assign(
1399 __entry->program = program;
1400 __entry->version = version;
1401 __assign_str(addr, addr);
1402 __assign_str(netid, netid);
1403 ),
1404
1405 TP_printk("program=%u version=%u addr=%s netid=%s",
1406 __entry->program, __entry->version,
1407 __get_str(addr), __get_str(netid)
1408 )
1409 );
1410
1411 TRACE_EVENT(rpcb_unregister,
1412 TP_PROTO(
1413 u32 program,
1414 u32 version,
1415 const char *netid
1416 ),
1417
1418 TP_ARGS(program, version, netid),
1419
1420 TP_STRUCT__entry(
1421 __field(unsigned int, program)
1422 __field(unsigned int, version)
1423 __string(netid, netid)
1424 ),
1425
1426 TP_fast_assign(
1427 __entry->program = program;
1428 __entry->version = version;
1429 __assign_str(netid, netid);
1430 ),
1431
1432 TP_printk("program=%u version=%u netid=%s",
1433 __entry->program, __entry->version, __get_str(netid)
1434 )
1435 );
1436
1437 /* Record an xdr_buf containing a fully-formed RPC message */
1438 DECLARE_EVENT_CLASS(svc_xdr_msg_class,
1439 TP_PROTO(
1440 const struct xdr_buf *xdr
1441 ),
1442
1443 TP_ARGS(xdr),
1444
1445 TP_STRUCT__entry(
1446 __field(u32, xid)
1447 __field(const void *, head_base)
1448 __field(size_t, head_len)
1449 __field(const void *, tail_base)
1450 __field(size_t, tail_len)
1451 __field(unsigned int, page_len)
1452 __field(unsigned int, msg_len)
1453 ),
1454
1455 TP_fast_assign(
1456 __be32 *p = (__be32 *)xdr->head[0].iov_base;
1457
1458 __entry->xid = be32_to_cpu(*p);
1459 __entry->head_base = p;
1460 __entry->head_len = xdr->head[0].iov_len;
1461 __entry->tail_base = xdr->tail[0].iov_base;
1462 __entry->tail_len = xdr->tail[0].iov_len;
1463 __entry->page_len = xdr->page_len;
1464 __entry->msg_len = xdr->len;
1465 ),
1466
1467 TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
1468 __entry->xid,
1469 __entry->head_base, __entry->head_len, __entry->page_len,
1470 __entry->tail_base, __entry->tail_len, __entry->msg_len
1471 )
1472 );
1473
1474 #define DEFINE_SVCXDRMSG_EVENT(name) \
1475 DEFINE_EVENT(svc_xdr_msg_class, \
1476 svc_xdr_##name, \
1477 TP_PROTO( \
1478 const struct xdr_buf *xdr \
1479 ), \
1480 TP_ARGS(xdr))
1481
1482 DEFINE_SVCXDRMSG_EVENT(recvfrom);
1483
1484 /* Record an xdr_buf containing arbitrary data, tagged with an XID */
1485 DECLARE_EVENT_CLASS(svc_xdr_buf_class,
1486 TP_PROTO(
1487 __be32 xid,
1488 const struct xdr_buf *xdr
1489 ),
1490
1491 TP_ARGS(xid, xdr),
1492
1493 TP_STRUCT__entry(
1494 __field(u32, xid)
1495 __field(const void *, head_base)
1496 __field(size_t, head_len)
1497 __field(const void *, tail_base)
1498 __field(size_t, tail_len)
1499 __field(unsigned int, page_len)
1500 __field(unsigned int, msg_len)
1501 ),
1502
1503 TP_fast_assign(
1504 __entry->xid = be32_to_cpu(xid);
1505 __entry->head_base = xdr->head[0].iov_base;
1506 __entry->head_len = xdr->head[0].iov_len;
1507 __entry->tail_base = xdr->tail[0].iov_base;
1508 __entry->tail_len = xdr->tail[0].iov_len;
1509 __entry->page_len = xdr->page_len;
1510 __entry->msg_len = xdr->len;
1511 ),
1512
1513 TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
1514 __entry->xid,
1515 __entry->head_base, __entry->head_len, __entry->page_len,
1516 __entry->tail_base, __entry->tail_len, __entry->msg_len
1517 )
1518 );
1519
1520 #define DEFINE_SVCXDRBUF_EVENT(name) \
1521 DEFINE_EVENT(svc_xdr_buf_class, \
1522 svc_xdr_##name, \
1523 TP_PROTO( \
1524 __be32 xid, \
1525 const struct xdr_buf *xdr \
1526 ), \
1527 TP_ARGS(xid, xdr))
1528
1529 DEFINE_SVCXDRBUF_EVENT(sendto);
1530
1531 /*
1532 * from include/linux/sunrpc/svc.h
1533 */
1534 #define SVC_RQST_FLAG_LIST \
1535 svc_rqst_flag(SECURE) \
1536 svc_rqst_flag(LOCAL) \
1537 svc_rqst_flag(USEDEFERRAL) \
1538 svc_rqst_flag(DROPME) \
1539 svc_rqst_flag(SPLICE_OK) \
1540 svc_rqst_flag(VICTIM) \
1541 svc_rqst_flag(BUSY) \
1542 svc_rqst_flag_end(DATA)
1543
1544 #undef svc_rqst_flag
1545 #undef svc_rqst_flag_end
1546 #define svc_rqst_flag(x) TRACE_DEFINE_ENUM(RQ_##x);
1547 #define svc_rqst_flag_end(x) TRACE_DEFINE_ENUM(RQ_##x);
1548
1549 SVC_RQST_FLAG_LIST
1550
1551 #undef svc_rqst_flag
1552 #undef svc_rqst_flag_end
1553 #define svc_rqst_flag(x) { BIT(RQ_##x), #x },
1554 #define svc_rqst_flag_end(x) { BIT(RQ_##x), #x }
1555
1556 #define show_rqstp_flags(flags) \
1557 __print_flags(flags, "|", SVC_RQST_FLAG_LIST)
1558
1559 TRACE_DEFINE_ENUM(SVC_GARBAGE);
1560 TRACE_DEFINE_ENUM(SVC_SYSERR);
1561 TRACE_DEFINE_ENUM(SVC_VALID);
1562 TRACE_DEFINE_ENUM(SVC_NEGATIVE);
1563 TRACE_DEFINE_ENUM(SVC_OK);
1564 TRACE_DEFINE_ENUM(SVC_DROP);
1565 TRACE_DEFINE_ENUM(SVC_CLOSE);
1566 TRACE_DEFINE_ENUM(SVC_DENIED);
1567 TRACE_DEFINE_ENUM(SVC_PENDING);
1568 TRACE_DEFINE_ENUM(SVC_COMPLETE);
1569
1570 #define svc_show_status(status) \
1571 __print_symbolic(status, \
1572 { SVC_GARBAGE, "SVC_GARBAGE" }, \
1573 { SVC_SYSERR, "SVC_SYSERR" }, \
1574 { SVC_VALID, "SVC_VALID" }, \
1575 { SVC_NEGATIVE, "SVC_NEGATIVE" }, \
1576 { SVC_OK, "SVC_OK" }, \
1577 { SVC_DROP, "SVC_DROP" }, \
1578 { SVC_CLOSE, "SVC_CLOSE" }, \
1579 { SVC_DENIED, "SVC_DENIED" }, \
1580 { SVC_PENDING, "SVC_PENDING" }, \
1581 { SVC_COMPLETE, "SVC_COMPLETE" })
1582
1583 TRACE_EVENT(svc_authenticate,
1584 TP_PROTO(const struct svc_rqst *rqst, int auth_res),
1585
1586 TP_ARGS(rqst, auth_res),
1587
1588 TP_STRUCT__entry(
1589 __field(u32, xid)
1590 __field(unsigned long, svc_status)
1591 __field(unsigned long, auth_stat)
1592 ),
1593
1594 TP_fast_assign(
1595 __entry->xid = be32_to_cpu(rqst->rq_xid);
1596 __entry->svc_status = auth_res;
1597 __entry->auth_stat = be32_to_cpu(rqst->rq_auth_stat);
1598 ),
1599
1600 TP_printk("xid=0x%08x auth_res=%s auth_stat=%s",
1601 __entry->xid, svc_show_status(__entry->svc_status),
1602 rpc_show_auth_stat(__entry->auth_stat))
1603 );
1604
1605 TRACE_EVENT(svc_process,
1606 TP_PROTO(const struct svc_rqst *rqst, const char *name),
1607
1608 TP_ARGS(rqst, name),
1609
1610 TP_STRUCT__entry(
1611 __field(u32, xid)
1612 __field(u32, vers)
1613 __field(u32, proc)
1614 __string(service, name)
1615 __string(procedure, svc_proc_name(rqst))
1616 __string(addr, rqst->rq_xprt ?
1617 rqst->rq_xprt->xpt_remotebuf : "(null)")
1618 ),
1619
1620 TP_fast_assign(
1621 __entry->xid = be32_to_cpu(rqst->rq_xid);
1622 __entry->vers = rqst->rq_vers;
1623 __entry->proc = rqst->rq_proc;
1624 __assign_str(service, name);
1625 __assign_str(procedure, svc_proc_name(rqst));
1626 __assign_str(addr, rqst->rq_xprt ?
1627 rqst->rq_xprt->xpt_remotebuf : "(null)");
1628 ),
1629
1630 TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%s",
1631 __get_str(addr), __entry->xid,
1632 __get_str(service), __entry->vers,
1633 __get_str(procedure)
1634 )
1635 );
1636
1637 DECLARE_EVENT_CLASS(svc_rqst_event,
1638
1639 TP_PROTO(
1640 const struct svc_rqst *rqst
1641 ),
1642
1643 TP_ARGS(rqst),
1644
1645 TP_STRUCT__entry(
1646 __field(u32, xid)
1647 __field(unsigned long, flags)
1648 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1649 ),
1650
1651 TP_fast_assign(
1652 __entry->xid = be32_to_cpu(rqst->rq_xid);
1653 __entry->flags = rqst->rq_flags;
1654 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1655 ),
1656
1657 TP_printk("addr=%s xid=0x%08x flags=%s",
1658 __get_str(addr), __entry->xid,
1659 show_rqstp_flags(__entry->flags))
1660 );
1661 #define DEFINE_SVC_RQST_EVENT(name) \
1662 DEFINE_EVENT(svc_rqst_event, svc_##name, \
1663 TP_PROTO( \
1664 const struct svc_rqst *rqst \
1665 ), \
1666 TP_ARGS(rqst))
1667
1668 DEFINE_SVC_RQST_EVENT(defer);
1669 DEFINE_SVC_RQST_EVENT(drop);
1670
1671 DECLARE_EVENT_CLASS(svc_rqst_status,
1672
1673 TP_PROTO(struct svc_rqst *rqst, int status),
1674
1675 TP_ARGS(rqst, status),
1676
1677 TP_STRUCT__entry(
1678 __field(u32, xid)
1679 __field(int, status)
1680 __field(unsigned long, flags)
1681 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1682 ),
1683
1684 TP_fast_assign(
1685 __entry->xid = be32_to_cpu(rqst->rq_xid);
1686 __entry->status = status;
1687 __entry->flags = rqst->rq_flags;
1688 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1689 ),
1690
1691 TP_printk("addr=%s xid=0x%08x status=%d flags=%s",
1692 __get_str(addr), __entry->xid,
1693 __entry->status, show_rqstp_flags(__entry->flags))
1694 );
1695
1696 DEFINE_EVENT(svc_rqst_status, svc_send,
1697 TP_PROTO(struct svc_rqst *rqst, int status),
1698 TP_ARGS(rqst, status));
1699
1700 #define show_svc_xprt_flags(flags) \
1701 __print_flags(flags, "|", \
1702 { (1UL << XPT_BUSY), "XPT_BUSY"}, \
1703 { (1UL << XPT_CONN), "XPT_CONN"}, \
1704 { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \
1705 { (1UL << XPT_DATA), "XPT_DATA"}, \
1706 { (1UL << XPT_TEMP), "XPT_TEMP"}, \
1707 { (1UL << XPT_DEAD), "XPT_DEAD"}, \
1708 { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \
1709 { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \
1710 { (1UL << XPT_OLD), "XPT_OLD"}, \
1711 { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \
1712 { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \
1713 { (1UL << XPT_LOCAL), "XPT_LOCAL"}, \
1714 { (1UL << XPT_KILL_TEMP), "XPT_KILL_TEMP"}, \
1715 { (1UL << XPT_CONG_CTRL), "XPT_CONG_CTRL"})
1716
1717 TRACE_EVENT(svc_xprt_create_err,
1718 TP_PROTO(
1719 const char *program,
1720 const char *protocol,
1721 struct sockaddr *sap,
1722 const struct svc_xprt *xprt
1723 ),
1724
1725 TP_ARGS(program, protocol, sap, xprt),
1726
1727 TP_STRUCT__entry(
1728 __field(long, error)
1729 __string(program, program)
1730 __string(protocol, protocol)
1731 __array(unsigned char, addr, sizeof(struct sockaddr_in6))
1732 ),
1733
1734 TP_fast_assign(
1735 __entry->error = PTR_ERR(xprt);
1736 __assign_str(program, program);
1737 __assign_str(protocol, protocol);
1738 memcpy(__entry->addr, sap, sizeof(__entry->addr));
1739 ),
1740
1741 TP_printk("addr=%pISpc program=%s protocol=%s error=%ld",
1742 __entry->addr, __get_str(program), __get_str(protocol),
1743 __entry->error)
1744 );
1745
1746 TRACE_EVENT(svc_xprt_do_enqueue,
1747 TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
1748
1749 TP_ARGS(xprt, rqst),
1750
1751 TP_STRUCT__entry(
1752 __field(int, pid)
1753 __field(unsigned long, flags)
1754 __string(addr, xprt->xpt_remotebuf)
1755 ),
1756
1757 TP_fast_assign(
1758 __entry->pid = rqst? rqst->rq_task->pid : 0;
1759 __entry->flags = xprt->xpt_flags;
1760 __assign_str(addr, xprt->xpt_remotebuf);
1761 ),
1762
1763 TP_printk("addr=%s pid=%d flags=%s", __get_str(addr),
1764 __entry->pid, show_svc_xprt_flags(__entry->flags))
1765 );
1766
1767 DECLARE_EVENT_CLASS(svc_xprt_event,
1768 TP_PROTO(struct svc_xprt *xprt),
1769
1770 TP_ARGS(xprt),
1771
1772 TP_STRUCT__entry(
1773 __field(unsigned long, flags)
1774 __string(addr, xprt->xpt_remotebuf)
1775 ),
1776
1777 TP_fast_assign(
1778 __entry->flags = xprt->xpt_flags;
1779 __assign_str(addr, xprt->xpt_remotebuf);
1780 ),
1781
1782 TP_printk("addr=%s flags=%s", __get_str(addr),
1783 show_svc_xprt_flags(__entry->flags))
1784 );
1785
1786 #define DEFINE_SVC_XPRT_EVENT(name) \
1787 DEFINE_EVENT(svc_xprt_event, svc_xprt_##name, \
1788 TP_PROTO( \
1789 struct svc_xprt *xprt \
1790 ), \
1791 TP_ARGS(xprt))
1792
1793 DEFINE_SVC_XPRT_EVENT(received);
1794 DEFINE_SVC_XPRT_EVENT(no_write_space);
1795 DEFINE_SVC_XPRT_EVENT(close);
1796 DEFINE_SVC_XPRT_EVENT(detach);
1797 DEFINE_SVC_XPRT_EVENT(free);
1798
1799 TRACE_EVENT(svc_xprt_accept,
1800 TP_PROTO(
1801 const struct svc_xprt *xprt,
1802 const char *service
1803 ),
1804
1805 TP_ARGS(xprt, service),
1806
1807 TP_STRUCT__entry(
1808 __string(addr, xprt->xpt_remotebuf)
1809 __string(protocol, xprt->xpt_class->xcl_name)
1810 __string(service, service)
1811 ),
1812
1813 TP_fast_assign(
1814 __assign_str(addr, xprt->xpt_remotebuf);
1815 __assign_str(protocol, xprt->xpt_class->xcl_name);
1816 __assign_str(service, service);
1817 ),
1818
1819 TP_printk("addr=%s protocol=%s service=%s",
1820 __get_str(addr), __get_str(protocol), __get_str(service)
1821 )
1822 );
1823
1824 TRACE_EVENT(svc_xprt_dequeue,
1825 TP_PROTO(struct svc_rqst *rqst),
1826
1827 TP_ARGS(rqst),
1828
1829 TP_STRUCT__entry(
1830 __field(unsigned long, flags)
1831 __field(unsigned long, wakeup)
1832 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1833 ),
1834
1835 TP_fast_assign(
1836 __entry->flags = rqst->rq_xprt->xpt_flags;
1837 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
1838 rqst->rq_qtime));
1839 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1840 ),
1841
1842 TP_printk("addr=%s flags=%s wakeup-us=%lu", __get_str(addr),
1843 show_svc_xprt_flags(__entry->flags), __entry->wakeup)
1844 );
1845
1846 TRACE_EVENT(svc_wake_up,
1847 TP_PROTO(int pid),
1848
1849 TP_ARGS(pid),
1850
1851 TP_STRUCT__entry(
1852 __field(int, pid)
1853 ),
1854
1855 TP_fast_assign(
1856 __entry->pid = pid;
1857 ),
1858
1859 TP_printk("pid=%d", __entry->pid)
1860 );
1861
1862 TRACE_EVENT(svc_handle_xprt,
1863 TP_PROTO(struct svc_xprt *xprt, int len),
1864
1865 TP_ARGS(xprt, len),
1866
1867 TP_STRUCT__entry(
1868 __field(int, len)
1869 __field(unsigned long, flags)
1870 __string(addr, xprt->xpt_remotebuf)
1871 ),
1872
1873 TP_fast_assign(
1874 __entry->len = len;
1875 __entry->flags = xprt->xpt_flags;
1876 __assign_str(addr, xprt->xpt_remotebuf);
1877 ),
1878
1879 TP_printk("addr=%s len=%d flags=%s", __get_str(addr),
1880 __entry->len, show_svc_xprt_flags(__entry->flags))
1881 );
1882
1883 TRACE_EVENT(svc_stats_latency,
1884 TP_PROTO(const struct svc_rqst *rqst),
1885
1886 TP_ARGS(rqst),
1887
1888 TP_STRUCT__entry(
1889 __field(u32, xid)
1890 __field(unsigned long, execute)
1891 __string(procedure, svc_proc_name(rqst))
1892 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1893 ),
1894
1895 TP_fast_assign(
1896 __entry->xid = be32_to_cpu(rqst->rq_xid);
1897 __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
1898 rqst->rq_stime));
1899 __assign_str(procedure, svc_proc_name(rqst));
1900 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1901 ),
1902
1903 TP_printk("addr=%s xid=0x%08x proc=%s execute-us=%lu",
1904 __get_str(addr), __entry->xid, __get_str(procedure),
1905 __entry->execute)
1906 );
1907
1908 DECLARE_EVENT_CLASS(svc_deferred_event,
1909 TP_PROTO(
1910 const struct svc_deferred_req *dr
1911 ),
1912
1913 TP_ARGS(dr),
1914
1915 TP_STRUCT__entry(
1916 __field(const void *, dr)
1917 __field(u32, xid)
1918 __string(addr, dr->xprt->xpt_remotebuf)
1919 ),
1920
1921 TP_fast_assign(
1922 __entry->dr = dr;
1923 __entry->xid = be32_to_cpu(*(__be32 *)(dr->args +
1924 (dr->xprt_hlen>>2)));
1925 __assign_str(addr, dr->xprt->xpt_remotebuf);
1926 ),
1927
1928 TP_printk("addr=%s dr=%p xid=0x%08x", __get_str(addr), __entry->dr,
1929 __entry->xid)
1930 );
1931
1932 #define DEFINE_SVC_DEFERRED_EVENT(name) \
1933 DEFINE_EVENT(svc_deferred_event, svc_defer_##name, \
1934 TP_PROTO( \
1935 const struct svc_deferred_req *dr \
1936 ), \
1937 TP_ARGS(dr))
1938
1939 DEFINE_SVC_DEFERRED_EVENT(drop);
1940 DEFINE_SVC_DEFERRED_EVENT(queue);
1941 DEFINE_SVC_DEFERRED_EVENT(recv);
1942
1943 TRACE_EVENT(svcsock_new_socket,
1944 TP_PROTO(
1945 const struct socket *socket
1946 ),
1947
1948 TP_ARGS(socket),
1949
1950 TP_STRUCT__entry(
1951 __field(unsigned long, type)
1952 __field(unsigned long, family)
1953 __field(bool, listener)
1954 ),
1955
1956 TP_fast_assign(
1957 __entry->type = socket->type;
1958 __entry->family = socket->sk->sk_family;
1959 __entry->listener = (socket->sk->sk_state == TCP_LISTEN);
1960 ),
1961
1962 TP_printk("type=%s family=%s%s",
1963 show_socket_type(__entry->type),
1964 rpc_show_address_family(__entry->family),
1965 __entry->listener ? " (listener)" : ""
1966 )
1967 );
1968
1969 TRACE_EVENT(svcsock_marker,
1970 TP_PROTO(
1971 const struct svc_xprt *xprt,
1972 __be32 marker
1973 ),
1974
1975 TP_ARGS(xprt, marker),
1976
1977 TP_STRUCT__entry(
1978 __field(unsigned int, length)
1979 __field(bool, last)
1980 __string(addr, xprt->xpt_remotebuf)
1981 ),
1982
1983 TP_fast_assign(
1984 __entry->length = be32_to_cpu(marker) & RPC_FRAGMENT_SIZE_MASK;
1985 __entry->last = be32_to_cpu(marker) & RPC_LAST_STREAM_FRAGMENT;
1986 __assign_str(addr, xprt->xpt_remotebuf);
1987 ),
1988
1989 TP_printk("addr=%s length=%u%s", __get_str(addr),
1990 __entry->length, __entry->last ? " (last)" : "")
1991 );
1992
1993 DECLARE_EVENT_CLASS(svcsock_class,
1994 TP_PROTO(
1995 const struct svc_xprt *xprt,
1996 ssize_t result
1997 ),
1998
1999 TP_ARGS(xprt, result),
2000
2001 TP_STRUCT__entry(
2002 __field(ssize_t, result)
2003 __field(unsigned long, flags)
2004 __string(addr, xprt->xpt_remotebuf)
2005 ),
2006
2007 TP_fast_assign(
2008 __entry->result = result;
2009 __entry->flags = xprt->xpt_flags;
2010 __assign_str(addr, xprt->xpt_remotebuf);
2011 ),
2012
2013 TP_printk("addr=%s result=%zd flags=%s", __get_str(addr),
2014 __entry->result, show_svc_xprt_flags(__entry->flags)
2015 )
2016 );
2017
2018 #define DEFINE_SVCSOCK_EVENT(name) \
2019 DEFINE_EVENT(svcsock_class, svcsock_##name, \
2020 TP_PROTO( \
2021 const struct svc_xprt *xprt, \
2022 ssize_t result \
2023 ), \
2024 TP_ARGS(xprt, result))
2025
2026 DEFINE_SVCSOCK_EVENT(udp_send);
2027 DEFINE_SVCSOCK_EVENT(udp_recv);
2028 DEFINE_SVCSOCK_EVENT(udp_recv_err);
2029 DEFINE_SVCSOCK_EVENT(tcp_send);
2030 DEFINE_SVCSOCK_EVENT(tcp_recv);
2031 DEFINE_SVCSOCK_EVENT(tcp_recv_eagain);
2032 DEFINE_SVCSOCK_EVENT(tcp_recv_err);
2033 DEFINE_SVCSOCK_EVENT(data_ready);
2034 DEFINE_SVCSOCK_EVENT(write_space);
2035
2036 TRACE_EVENT(svcsock_tcp_recv_short,
2037 TP_PROTO(
2038 const struct svc_xprt *xprt,
2039 u32 expected,
2040 u32 received
2041 ),
2042
2043 TP_ARGS(xprt, expected, received),
2044
2045 TP_STRUCT__entry(
2046 __field(u32, expected)
2047 __field(u32, received)
2048 __field(unsigned long, flags)
2049 __string(addr, xprt->xpt_remotebuf)
2050 ),
2051
2052 TP_fast_assign(
2053 __entry->expected = expected;
2054 __entry->received = received;
2055 __entry->flags = xprt->xpt_flags;
2056 __assign_str(addr, xprt->xpt_remotebuf);
2057 ),
2058
2059 TP_printk("addr=%s flags=%s expected=%u received=%u",
2060 __get_str(addr), show_svc_xprt_flags(__entry->flags),
2061 __entry->expected, __entry->received
2062 )
2063 );
2064
2065 TRACE_EVENT(svcsock_tcp_state,
2066 TP_PROTO(
2067 const struct svc_xprt *xprt,
2068 const struct socket *socket
2069 ),
2070
2071 TP_ARGS(xprt, socket),
2072
2073 TP_STRUCT__entry(
2074 __field(unsigned long, socket_state)
2075 __field(unsigned long, sock_state)
2076 __field(unsigned long, flags)
2077 __string(addr, xprt->xpt_remotebuf)
2078 ),
2079
2080 TP_fast_assign(
2081 __entry->socket_state = socket->state;
2082 __entry->sock_state = socket->sk->sk_state;
2083 __entry->flags = xprt->xpt_flags;
2084 __assign_str(addr, xprt->xpt_remotebuf);
2085 ),
2086
2087 TP_printk("addr=%s state=%s sk_state=%s flags=%s", __get_str(addr),
2088 rpc_show_socket_state(__entry->socket_state),
2089 rpc_show_sock_state(__entry->sock_state),
2090 show_svc_xprt_flags(__entry->flags)
2091 )
2092 );
2093
2094 DECLARE_EVENT_CLASS(svcsock_accept_class,
2095 TP_PROTO(
2096 const struct svc_xprt *xprt,
2097 const char *service,
2098 long status
2099 ),
2100
2101 TP_ARGS(xprt, service, status),
2102
2103 TP_STRUCT__entry(
2104 __field(long, status)
2105 __string(service, service)
2106 __array(unsigned char, addr, sizeof(struct sockaddr_in6))
2107 ),
2108
2109 TP_fast_assign(
2110 __entry->status = status;
2111 __assign_str(service, service);
2112 memcpy(__entry->addr, &xprt->xpt_local, sizeof(__entry->addr));
2113 ),
2114
2115 TP_printk("listener=%pISpc service=%s status=%ld",
2116 __entry->addr, __get_str(service), __entry->status
2117 )
2118 );
2119
2120 #define DEFINE_ACCEPT_EVENT(name) \
2121 DEFINE_EVENT(svcsock_accept_class, svcsock_##name##_err, \
2122 TP_PROTO( \
2123 const struct svc_xprt *xprt, \
2124 const char *service, \
2125 long status \
2126 ), \
2127 TP_ARGS(xprt, service, status))
2128
2129 DEFINE_ACCEPT_EVENT(accept);
2130 DEFINE_ACCEPT_EVENT(getpeername);
2131
2132 DECLARE_EVENT_CLASS(cache_event,
2133 TP_PROTO(
2134 const struct cache_detail *cd,
2135 const struct cache_head *h
2136 ),
2137
2138 TP_ARGS(cd, h),
2139
2140 TP_STRUCT__entry(
2141 __field(const struct cache_head *, h)
2142 __string(name, cd->name)
2143 ),
2144
2145 TP_fast_assign(
2146 __entry->h = h;
2147 __assign_str(name, cd->name);
2148 ),
2149
2150 TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)
2151 );
2152 #define DEFINE_CACHE_EVENT(name) \
2153 DEFINE_EVENT(cache_event, name, \
2154 TP_PROTO( \
2155 const struct cache_detail *cd, \
2156 const struct cache_head *h \
2157 ), \
2158 TP_ARGS(cd, h))
2159 DEFINE_CACHE_EVENT(cache_entry_expired);
2160 DEFINE_CACHE_EVENT(cache_entry_upcall);
2161 DEFINE_CACHE_EVENT(cache_entry_update);
2162 DEFINE_CACHE_EVENT(cache_entry_make_negative);
2163 DEFINE_CACHE_EVENT(cache_entry_no_listener);
2164
2165 DECLARE_EVENT_CLASS(register_class,
2166 TP_PROTO(
2167 const char *program,
2168 const u32 version,
2169 const int family,
2170 const unsigned short protocol,
2171 const unsigned short port,
2172 int error
2173 ),
2174
2175 TP_ARGS(program, version, family, protocol, port, error),
2176
2177 TP_STRUCT__entry(
2178 __field(u32, version)
2179 __field(unsigned long, family)
2180 __field(unsigned short, protocol)
2181 __field(unsigned short, port)
2182 __field(int, error)
2183 __string(program, program)
2184 ),
2185
2186 TP_fast_assign(
2187 __entry->version = version;
2188 __entry->family = family;
2189 __entry->protocol = protocol;
2190 __entry->port = port;
2191 __entry->error = error;
2192 __assign_str(program, program);
2193 ),
2194
2195 TP_printk("program=%sv%u proto=%s port=%u family=%s error=%d",
2196 __get_str(program), __entry->version,
2197 __entry->protocol == IPPROTO_UDP ? "udp" : "tcp",
2198 __entry->port, rpc_show_address_family(__entry->family),
2199 __entry->error
2200 )
2201 );
2202
2203 #define DEFINE_REGISTER_EVENT(name) \
2204 DEFINE_EVENT(register_class, svc_##name, \
2205 TP_PROTO( \
2206 const char *program, \
2207 const u32 version, \
2208 const int family, \
2209 const unsigned short protocol, \
2210 const unsigned short port, \
2211 int error \
2212 ), \
2213 TP_ARGS(program, version, family, protocol, \
2214 port, error))
2215
2216 DEFINE_REGISTER_EVENT(register);
2217 DEFINE_REGISTER_EVENT(noregister);
2218
2219 TRACE_EVENT(svc_unregister,
2220 TP_PROTO(
2221 const char *program,
2222 const u32 version,
2223 int error
2224 ),
2225
2226 TP_ARGS(program, version, error),
2227
2228 TP_STRUCT__entry(
2229 __field(u32, version)
2230 __field(int, error)
2231 __string(program, program)
2232 ),
2233
2234 TP_fast_assign(
2235 __entry->version = version;
2236 __entry->error = error;
2237 __assign_str(program, program);
2238 ),
2239
2240 TP_printk("program=%sv%u error=%d",
2241 __get_str(program), __entry->version, __entry->error
2242 )
2243 );
2244
2245 #endif /* _TRACE_SUNRPC_H */
2246
2247 #include <trace/define_trace.h>
Ubuntu Jammy Linux kernel mirror