]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - include/trace/events/sunrpc.h
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
SUNRPC: Split the xdr_buf event class
[mirror_ubuntu-jammy-kernel.git] / include / trace / events / sunrpc.h
CommitLineData
b2441318 1/* SPDX-License-Identifier: GPL-2.0 */
82b0a4c3
TM		 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>
860a0d9e 10#include <linux/sunrpc/svc.h>
1a867a08 11#include <linux/sunrpc/xprtsock.h>
83a712e0 12#include <linux/sunrpc/svc_xprt.h>
40b5ea0c
TM		 13#include <net/tcp_states.h>
14#include <linux/net.h>
82b0a4c3
TM		 15#include <linux/tracepoint.h>
16
c509f15a 17DECLARE_EVENT_CLASS(rpc_xdr_buf_class,
b20dfc3f 18 TP_PROTO(
c509f15a 19 const struct rpc_task *task,
b20dfc3f
CL		 20 const struct xdr_buf *xdr
21 ),
22
c509f15a 23 TP_ARGS(task, xdr),
b20dfc3f
CL		 24
25 TP_STRUCT__entry(
c509f15a
CL		 26 __field(unsigned int, task_id)
27 __field(unsigned int, client_id)
b20dfc3f
CL		 28 __field(const void *, head_base)
29 __field(size_t, head_len)
30 __field(const void *, tail_base)
31 __field(size_t, tail_len)
32 __field(unsigned int, page_len)
33 __field(unsigned int, msg_len)
34 ),
35
36 TP_fast_assign(
c509f15a
CL		 37 __entry->task_id = task->tk_pid;
38 __entry->client_id = task->tk_client->cl_clid;
b20dfc3f
CL		 39 __entry->head_base = xdr->head[0].iov_base;
40 __entry->head_len = xdr->head[0].iov_len;
41 __entry->tail_base = xdr->tail[0].iov_base;
42 __entry->tail_len = xdr->tail[0].iov_len;
43 __entry->page_len = xdr->page_len;
44 __entry->msg_len = xdr->len;
45 ),
46
c509f15a
CL		 47 TP_printk("task:%u@%u head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
48 __entry->task_id, __entry->client_id,
b20dfc3f
CL		 49 __entry->head_base, __entry->head_len, __entry->page_len,
50 __entry->tail_base, __entry->tail_len, __entry->msg_len
51 )
52);
53
c509f15a
CL		 54#define DEFINE_RPCXDRBUF_EVENT(name) \
55 DEFINE_EVENT(rpc_xdr_buf_class, \
56 rpc_xdr_##name, \
b20dfc3f 57 TP_PROTO( \
c509f15a 58 const struct rpc_task *task, \
b20dfc3f
CL		 59 const struct xdr_buf *xdr \
60 ), \
c509f15a
CL		 61 TP_ARGS(task, xdr))
62
63DEFINE_RPCXDRBUF_EVENT(sendto);
64DEFINE_RPCXDRBUF_EVENT(recvfrom);
65DEFINE_RPCXDRBUF_EVENT(reply_pages);
b20dfc3f 66
b20dfc3f 67
ff27e9f7
CL		 68TRACE_DEFINE_ENUM(RPC_AUTH_OK);
69TRACE_DEFINE_ENUM(RPC_AUTH_BADCRED);
70TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDCRED);
71TRACE_DEFINE_ENUM(RPC_AUTH_BADVERF);
72TRACE_DEFINE_ENUM(RPC_AUTH_REJECTEDVERF);
73TRACE_DEFINE_ENUM(RPC_AUTH_TOOWEAK);
74TRACE_DEFINE_ENUM(RPCSEC_GSS_CREDPROBLEM);
75TRACE_DEFINE_ENUM(RPCSEC_GSS_CTXPROBLEM);
76
77#define rpc_show_auth_stat(status) \
78 __print_symbolic(status, \
79 { RPC_AUTH_OK, "AUTH_OK" }, \
80 { RPC_AUTH_BADCRED, "BADCRED" }, \
81 { RPC_AUTH_REJECTEDCRED, "REJECTEDCRED" }, \
82 { RPC_AUTH_BADVERF, "BADVERF" }, \
83 { RPC_AUTH_REJECTEDVERF, "REJECTEDVERF" }, \
84 { RPC_AUTH_TOOWEAK, "TOOWEAK" }, \
85 { RPCSEC_GSS_CREDPROBLEM, "GSS_CREDPROBLEM" }, \
86 { RPCSEC_GSS_CTXPROBLEM, "GSS_CTXPROBLEM" }) \
87
5753cba1
SD		 88DECLARE_EVENT_CLASS(rpc_task_status,
89
e671edb9 90 TP_PROTO(const struct rpc_task *task),
5753cba1 91
e671edb9 92 TP_ARGS(task),
5753cba1
SD		 93
94 TP_STRUCT__entry(
92cb6c5b
TM		 95 __field(unsigned int, task_id)
96 __field(unsigned int, client_id)
5753cba1
SD		 97 __field(int, status)
98 ),
99
100 TP_fast_assign(
92cb6c5b
TM		 101 __entry->task_id = task->tk_pid;
102 __entry->client_id = task->tk_client->cl_clid;
e671edb9 103 __entry->status = task->tk_status;
5753cba1
SD		 104 ),
105
52069449 106 TP_printk("task:%u@%u status=%d",
92cb6c5b
TM		 107 __entry->task_id, __entry->client_id,
108 __entry->status)
5753cba1 109);
dc5820bd
CL		 110#define DEFINE_RPC_STATUS_EVENT(name) \
111 DEFINE_EVENT(rpc_task_status, rpc_##name##_status, \
112 TP_PROTO( \
113 const struct rpc_task *task \
114 ), \
115 TP_ARGS(task))
116
117DEFINE_RPC_STATUS_EVENT(call);
118DEFINE_RPC_STATUS_EVENT(bind);
119DEFINE_RPC_STATUS_EVENT(connect);
5753cba1 120
c435da68
CL		 121TRACE_EVENT(rpc_request,
122 TP_PROTO(const struct rpc_task *task),
123
124 TP_ARGS(task),
125
126 TP_STRUCT__entry(
127 __field(unsigned int, task_id)
128 __field(unsigned int, client_id)
129 __field(int, version)
130 __field(bool, async)
131 __string(progname, task->tk_client->cl_program->name)
132 __string(procname, rpc_proc_name(task))
133 ),
134
135 TP_fast_assign(
136 __entry->task_id = task->tk_pid;
137 __entry->client_id = task->tk_client->cl_clid;
138 __entry->version = task->tk_client->cl_vers;
139 __entry->async = RPC_IS_ASYNC(task);
140 __assign_str(progname, task->tk_client->cl_program->name)
141 __assign_str(procname, rpc_proc_name(task))
142 ),
143
144 TP_printk("task:%u@%u %sv%d %s (%ssync)",
145 __entry->task_id, __entry->client_id,
146 __get_str(progname), __entry->version,
147 __get_str(procname), __entry->async ? "a": ""
148 )
149);
150
6f701383
CL		 151TRACE_DEFINE_ENUM(RPC_TASK_ASYNC);
152TRACE_DEFINE_ENUM(RPC_TASK_SWAPPER);
7a34c8e0 153TRACE_DEFINE_ENUM(RPC_TASK_NULLCREDS);
6f701383
CL		 154TRACE_DEFINE_ENUM(RPC_CALL_MAJORSEEN);
155TRACE_DEFINE_ENUM(RPC_TASK_ROOTCREDS);
156TRACE_DEFINE_ENUM(RPC_TASK_DYNAMIC);
7a34c8e0 157TRACE_DEFINE_ENUM(RPC_TASK_NO_ROUND_ROBIN);
6f701383
CL		 158TRACE_DEFINE_ENUM(RPC_TASK_SOFT);
159TRACE_DEFINE_ENUM(RPC_TASK_SOFTCONN);
160TRACE_DEFINE_ENUM(RPC_TASK_SENT);
161TRACE_DEFINE_ENUM(RPC_TASK_TIMEOUT);
162TRACE_DEFINE_ENUM(RPC_TASK_NOCONNECT);
163TRACE_DEFINE_ENUM(RPC_TASK_NO_RETRANS_TIMEOUT);
7a34c8e0 164TRACE_DEFINE_ENUM(RPC_TASK_CRED_NOREF);
6f701383
CL		 165
166#define rpc_show_task_flags(flags) \
167 __print_flags(flags, "|", \
168 { RPC_TASK_ASYNC, "ASYNC" }, \
169 { RPC_TASK_SWAPPER, "SWAPPER" }, \
7a34c8e0 170 { RPC_TASK_NULLCREDS, "NULLCREDS" }, \
6f701383
CL		 171 { RPC_CALL_MAJORSEEN, "MAJORSEEN" }, \
172 { RPC_TASK_ROOTCREDS, "ROOTCREDS" }, \
173 { RPC_TASK_DYNAMIC, "DYNAMIC" }, \
7a34c8e0 174 { RPC_TASK_NO_ROUND_ROBIN, "NO_ROUND_ROBIN" }, \
6f701383
CL		 175 { RPC_TASK_SOFT, "SOFT" }, \
176 { RPC_TASK_SOFTCONN, "SOFTCONN" }, \
177 { RPC_TASK_SENT, "SENT" }, \
178 { RPC_TASK_TIMEOUT, "TIMEOUT" }, \
179 { RPC_TASK_NOCONNECT, "NOCONNECT" }, \
7a34c8e0
CL		 180 { RPC_TASK_NO_RETRANS_TIMEOUT, "NORTO" }, \
181 { RPC_TASK_CRED_NOREF, "CRED_NOREF" })
6f701383
CL		 182
183TRACE_DEFINE_ENUM(RPC_TASK_RUNNING);
184TRACE_DEFINE_ENUM(RPC_TASK_QUEUED);
185TRACE_DEFINE_ENUM(RPC_TASK_ACTIVE);
186TRACE_DEFINE_ENUM(RPC_TASK_NEED_XMIT);
187TRACE_DEFINE_ENUM(RPC_TASK_NEED_RECV);
188TRACE_DEFINE_ENUM(RPC_TASK_MSG_PIN_WAIT);
ae67bd38 189TRACE_DEFINE_ENUM(RPC_TASK_SIGNALLED);
6f701383
CL		 190
191#define rpc_show_runstate(flags) \
192 __print_flags(flags, "|", \
193 { (1UL << RPC_TASK_RUNNING), "RUNNING" }, \
194 { (1UL << RPC_TASK_QUEUED), "QUEUED" }, \
195 { (1UL << RPC_TASK_ACTIVE), "ACTIVE" }, \
196 { (1UL << RPC_TASK_NEED_XMIT), "NEED_XMIT" }, \
197 { (1UL << RPC_TASK_NEED_RECV), "NEED_RECV" }, \
ae67bd38
TM		 198 { (1UL << RPC_TASK_MSG_PIN_WAIT), "MSG_PIN_WAIT" }, \
199 { (1UL << RPC_TASK_SIGNALLED), "SIGNALLED" })
6f701383 200
82b0a4c3
TM		 201DECLARE_EVENT_CLASS(rpc_task_running,
202
e671edb9 203 TP_PROTO(const struct rpc_task *task, const void *action),
82b0a4c3 204
e671edb9 205 TP_ARGS(task, action),
82b0a4c3
TM		 206
207 TP_STRUCT__entry(
92cb6c5b
TM		 208 __field(unsigned int, task_id)
209 __field(unsigned int, client_id)
82b0a4c3
TM		 210 __field(const void *, action)
211 __field(unsigned long, runstate)
212 __field(int, status)
213 __field(unsigned short, flags)
214 ),
215
216 TP_fast_assign(
e671edb9
CL		 217 __entry->client_id = task->tk_client ?
218 task->tk_client->cl_clid : -1;
92cb6c5b 219 __entry->task_id = task->tk_pid;
82b0a4c3
TM		 220 __entry->action = action;
221 __entry->runstate = task->tk_runstate;
222 __entry->status = task->tk_status;
223 __entry->flags = task->tk_flags;
224 ),
225
09686219 226 TP_printk("task:%u@%d flags=%s runstate=%s status=%d action=%ps",
92cb6c5b 227 __entry->task_id, __entry->client_id,
6f701383
CL		 228 rpc_show_task_flags(__entry->flags),
229 rpc_show_runstate(__entry->runstate),
82b0a4c3
TM		 230 __entry->status,
231 __entry->action
232 )
233);
dc5820bd
CL		 234#define DEFINE_RPC_RUNNING_EVENT(name) \
235 DEFINE_EVENT(rpc_task_running, rpc_task_##name, \
236 TP_PROTO( \
237 const struct rpc_task *task, \
238 const void *action \
239 ), \
240 TP_ARGS(task, action))
82b0a4c3 241
dc5820bd
CL		 242DEFINE_RPC_RUNNING_EVENT(begin);
243DEFINE_RPC_RUNNING_EVENT(run_action);
244DEFINE_RPC_RUNNING_EVENT(complete);
abf8af78 245DEFINE_RPC_RUNNING_EVENT(signalled);
a264abad 246DEFINE_RPC_RUNNING_EVENT(end);
82b0a4c3
TM		 247
248DECLARE_EVENT_CLASS(rpc_task_queued,
249
e671edb9 250 TP_PROTO(const struct rpc_task *task, const struct rpc_wait_queue *q),
82b0a4c3 251
e671edb9 252 TP_ARGS(task, q),
82b0a4c3
TM		 253
254 TP_STRUCT__entry(
92cb6c5b
TM		 255 __field(unsigned int, task_id)
256 __field(unsigned int, client_id)
82b0a4c3
TM		 257 __field(unsigned long, timeout)
258 __field(unsigned long, runstate)
259 __field(int, status)
260 __field(unsigned short, flags)
85c0d24f 261 __string(q_name, rpc_qname(q))
82b0a4c3
TM		 262 ),
263
264 TP_fast_assign(
e671edb9
CL		 265 __entry->client_id = task->tk_client ?
266 task->tk_client->cl_clid : -1;
92cb6c5b 267 __entry->task_id = task->tk_pid;
5efd1876 268 __entry->timeout = rpc_task_timeout(task);
82b0a4c3
TM		 269 __entry->runstate = task->tk_runstate;
270 __entry->status = task->tk_status;
271 __entry->flags = task->tk_flags;
85c0d24f 272 __assign_str(q_name, rpc_qname(q));
82b0a4c3
TM		 273 ),
274
6f701383 275 TP_printk("task:%u@%d flags=%s runstate=%s status=%d timeout=%lu queue=%s",
92cb6c5b 276 __entry->task_id, __entry->client_id,
6f701383
CL		 277 rpc_show_task_flags(__entry->flags),
278 rpc_show_runstate(__entry->runstate),
82b0a4c3
TM		 279 __entry->status,
280 __entry->timeout,
85c0d24f 281 __get_str(q_name)
82b0a4c3
TM		 282 )
283);
dc5820bd
CL		 284#define DEFINE_RPC_QUEUED_EVENT(name) \
285 DEFINE_EVENT(rpc_task_queued, rpc_task_##name, \
286 TP_PROTO( \
287 const struct rpc_task *task, \
288 const struct rpc_wait_queue *q \
289 ), \
290 TP_ARGS(task, q))
82b0a4c3 291
dc5820bd
CL		 292DEFINE_RPC_QUEUED_EVENT(sleep);
293DEFINE_RPC_QUEUED_EVENT(wakeup);
82b0a4c3 294
e8680a24
CL		 295DECLARE_EVENT_CLASS(rpc_failure,
296
297 TP_PROTO(const struct rpc_task *task),
298
299 TP_ARGS(task),
300
301 TP_STRUCT__entry(
302 __field(unsigned int, task_id)
303 __field(unsigned int, client_id)
304 ),
305
306 TP_fast_assign(
307 __entry->task_id = task->tk_pid;
308 __entry->client_id = task->tk_client->cl_clid;
309 ),
310
311 TP_printk("task:%u@%u",
312 __entry->task_id, __entry->client_id)
313);
314
315#define DEFINE_RPC_FAILURE(name) \
316 DEFINE_EVENT(rpc_failure, rpc_bad_##name, \
317 TP_PROTO( \
318 const struct rpc_task *task \
319 ), \
320 TP_ARGS(task))
321
322DEFINE_RPC_FAILURE(callhdr);
7f5667a5
CL		 323DEFINE_RPC_FAILURE(verifier);
324
325DECLARE_EVENT_CLASS(rpc_reply_event,
326
327 TP_PROTO(
328 const struct rpc_task *task
329 ),
330
331 TP_ARGS(task),
332
333 TP_STRUCT__entry(
334 __field(unsigned int, task_id)
335 __field(unsigned int, client_id)
336 __field(u32, xid)
337 __string(progname, task->tk_client->cl_program->name)
338 __field(u32, version)
339 __string(procname, rpc_proc_name(task))
340 __string(servername, task->tk_xprt->servername)
341 ),
342
343 TP_fast_assign(
344 __entry->task_id = task->tk_pid;
345 __entry->client_id = task->tk_client->cl_clid;
346 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
347 __assign_str(progname, task->tk_client->cl_program->name)
348 __entry->version = task->tk_client->cl_vers;
349 __assign_str(procname, rpc_proc_name(task))
350 __assign_str(servername, task->tk_xprt->servername)
351 ),
352
353 TP_printk("task:%u@%d server=%s xid=0x%08x %sv%d %s",
354 __entry->task_id, __entry->client_id, __get_str(servername),
355 __entry->xid, __get_str(progname), __entry->version,
356 __get_str(procname))
357)
358
359#define DEFINE_RPC_REPLY_EVENT(name) \
360 DEFINE_EVENT(rpc_reply_event, rpc__##name, \
361 TP_PROTO( \
362 const struct rpc_task *task \
363 ), \
364 TP_ARGS(task))
365
366DEFINE_RPC_REPLY_EVENT(prog_unavail);
367DEFINE_RPC_REPLY_EVENT(prog_mismatch);
368DEFINE_RPC_REPLY_EVENT(proc_unavail);
369DEFINE_RPC_REPLY_EVENT(garbage_args);
370DEFINE_RPC_REPLY_EVENT(unparsable);
371DEFINE_RPC_REPLY_EVENT(mismatch);
372DEFINE_RPC_REPLY_EVENT(stale_creds);
373DEFINE_RPC_REPLY_EVENT(bad_creds);
374DEFINE_RPC_REPLY_EVENT(auth_tooweak);
e8680a24 375
0125ecbb
CL		 376TRACE_EVENT(rpc_call_rpcerror,
377 TP_PROTO(
378 const struct rpc_task *task,
379 int tk_status,
380 int rpc_status
381 ),
382
383 TP_ARGS(task, tk_status, rpc_status),
384
385 TP_STRUCT__entry(
386 __field(unsigned int, task_id)
387 __field(unsigned int, client_id)
388 __field(int, tk_status)
389 __field(int, rpc_status)
390 ),
391
392 TP_fast_assign(
393 __entry->client_id = task->tk_client->cl_clid;
394 __entry->task_id = task->tk_pid;
395 __entry->tk_status = tk_status;
396 __entry->rpc_status = rpc_status;
397 ),
398
399 TP_printk("task:%u@%u tk_status=%d rpc_status=%d",
400 __entry->task_id, __entry->client_id,
401 __entry->tk_status, __entry->rpc_status)
402);
403
40bf7eb3
CL		 404TRACE_EVENT(rpc_stats_latency,
405
406 TP_PROTO(
407 const struct rpc_task *task,
408 ktime_t backlog,
409 ktime_t rtt,
410 ktime_t execute
411 ),
412
413 TP_ARGS(task, backlog, rtt, execute),
414
415 TP_STRUCT__entry(
98eb6cf2
CL		 416 __field(unsigned int, task_id)
417 __field(unsigned int, client_id)
40bf7eb3
CL		 418 __field(u32, xid)
419 __field(int, version)
420 __string(progname, task->tk_client->cl_program->name)
421 __string(procname, rpc_proc_name(task))
422 __field(unsigned long, backlog)
423 __field(unsigned long, rtt)
424 __field(unsigned long, execute)
40bf7eb3
CL		 425 ),
426
427 TP_fast_assign(
98eb6cf2
CL		 428 __entry->client_id = task->tk_client->cl_clid;
429 __entry->task_id = task->tk_pid;
40bf7eb3
CL		 430 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
431 __entry->version = task->tk_client->cl_vers;
432 __assign_str(progname, task->tk_client->cl_program->name)
433 __assign_str(procname, rpc_proc_name(task))
434 __entry->backlog = ktime_to_us(backlog);
435 __entry->rtt = ktime_to_us(rtt);
436 __entry->execute = ktime_to_us(execute);
40bf7eb3
CL		 437 ),
438
98eb6cf2
CL		 439 TP_printk("task:%u@%d xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu",
440 __entry->task_id, __entry->client_id, __entry->xid,
40bf7eb3
CL		 441 __get_str(progname), __entry->version, __get_str(procname),
442 __entry->backlog, __entry->rtt, __entry->execute)
443);
444
5582863f
CL		 445TRACE_EVENT(rpc_xdr_overflow,
446 TP_PROTO(
447 const struct xdr_stream *xdr,
448 size_t requested
449 ),
450
451 TP_ARGS(xdr, requested),
452
453 TP_STRUCT__entry(
454 __field(unsigned int, task_id)
455 __field(unsigned int, client_id)
456 __field(int, version)
457 __field(size_t, requested)
458 __field(const void *, end)
459 __field(const void *, p)
460 __field(const void *, head_base)
461 __field(size_t, head_len)
462 __field(const void *, tail_base)
463 __field(size_t, tail_len)
464 __field(unsigned int, page_len)
465 __field(unsigned int, len)
466 __string(progname,
467 xdr->rqst->rq_task->tk_client->cl_program->name)
468 __string(procedure,
469 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
470 ),
471
472 TP_fast_assign(
473 if (xdr->rqst) {
474 const struct rpc_task *task = xdr->rqst->rq_task;
475
476 __entry->task_id = task->tk_pid;
477 __entry->client_id = task->tk_client->cl_clid;
478 __assign_str(progname,
479 task->tk_client->cl_program->name)
480 __entry->version = task->tk_client->cl_vers;
481 __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
482 } else {
483 __entry->task_id = 0;
484 __entry->client_id = 0;
485 __assign_str(progname, "unknown")
486 __entry->version = 0;
487 __assign_str(procedure, "unknown")
488 }
489 __entry->requested = requested;
490 __entry->end = xdr->end;
491 __entry->p = xdr->p;
492 __entry->head_base = xdr->buf->head[0].iov_base,
493 __entry->head_len = xdr->buf->head[0].iov_len,
494 __entry->page_len = xdr->buf->page_len,
495 __entry->tail_base = xdr->buf->tail[0].iov_base,
496 __entry->tail_len = xdr->buf->tail[0].iov_len,
497 __entry->len = xdr->buf->len;
498 ),
499
500 TP_printk(
501 "task:%u@%u %sv%d %s requested=%zu p=%p end=%p xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
502 __entry->task_id, __entry->client_id,
503 __get_str(progname), __entry->version, __get_str(procedure),
504 __entry->requested, __entry->p, __entry->end,
505 __entry->head_base, __entry->head_len,
506 __entry->page_len,
507 __entry->tail_base, __entry->tail_len,
508 __entry->len
509 )
510);
511
7be9cea3
CL		 512TRACE_EVENT(rpc_xdr_alignment,
513 TP_PROTO(
514 const struct xdr_stream *xdr,
515 size_t offset,
516 unsigned int copied
517 ),
518
519 TP_ARGS(xdr, offset, copied),
520
521 TP_STRUCT__entry(
522 __field(unsigned int, task_id)
523 __field(unsigned int, client_id)
524 __field(int, version)
525 __field(size_t, offset)
526 __field(unsigned int, copied)
527 __field(const void *, head_base)
528 __field(size_t, head_len)
529 __field(const void *, tail_base)
530 __field(size_t, tail_len)
531 __field(unsigned int, page_len)
532 __field(unsigned int, len)
533 __string(progname,
534 xdr->rqst->rq_task->tk_client->cl_program->name)
535 __string(procedure,
536 xdr->rqst->rq_task->tk_msg.rpc_proc->p_name)
537 ),
538
539 TP_fast_assign(
540 const struct rpc_task *task = xdr->rqst->rq_task;
541
542 __entry->task_id = task->tk_pid;
543 __entry->client_id = task->tk_client->cl_clid;
544 __assign_str(progname,
545 task->tk_client->cl_program->name)
546 __entry->version = task->tk_client->cl_vers;
547 __assign_str(procedure, task->tk_msg.rpc_proc->p_name)
548
549 __entry->offset = offset;
550 __entry->copied = copied;
551 __entry->head_base = xdr->buf->head[0].iov_base,
552 __entry->head_len = xdr->buf->head[0].iov_len,
553 __entry->page_len = xdr->buf->page_len,
554 __entry->tail_base = xdr->buf->tail[0].iov_base,
555 __entry->tail_len = xdr->buf->tail[0].iov_len,
556 __entry->len = xdr->buf->len;
557 ),
558
559 TP_printk(
560 "task:%u@%u %sv%d %s offset=%zu copied=%u xdr=[%p,%zu]/%u/[%p,%zu]/%u\n",
561 __entry->task_id, __entry->client_id,
562 __get_str(progname), __entry->version, __get_str(procedure),
563 __entry->offset, __entry->copied,
564 __entry->head_base, __entry->head_len,
565 __entry->page_len,
566 __entry->tail_base, __entry->tail_len,
567 __entry->len
568 )
569);
570
6ba16eef
SRRH		 571/*
572 * First define the enums in the below macros to be exported to userspace
573 * via TRACE_DEFINE_ENUM().
574 */
575#undef EM
576#undef EMe
577#define EM(a, b) TRACE_DEFINE_ENUM(a);
578#define EMe(a, b) TRACE_DEFINE_ENUM(a);
579
580#define RPC_SHOW_SOCKET \
581 EM( SS_FREE, "FREE" ) \
582 EM( SS_UNCONNECTED, "UNCONNECTED" ) \
82909dc5
CL		 583 EM( SS_CONNECTING, "CONNECTING" ) \
584 EM( SS_CONNECTED, "CONNECTED" ) \
585 EMe( SS_DISCONNECTING, "DISCONNECTING" )
6ba16eef 586
40b5ea0c 587#define rpc_show_socket_state(state) \
6ba16eef
SRRH		 588 __print_symbolic(state, RPC_SHOW_SOCKET)
589
590RPC_SHOW_SOCKET
591
592#define RPC_SHOW_SOCK \
593 EM( TCP_ESTABLISHED, "ESTABLISHED" ) \
594 EM( TCP_SYN_SENT, "SYN_SENT" ) \
595 EM( TCP_SYN_RECV, "SYN_RECV" ) \
596 EM( TCP_FIN_WAIT1, "FIN_WAIT1" ) \
597 EM( TCP_FIN_WAIT2, "FIN_WAIT2" ) \
598 EM( TCP_TIME_WAIT, "TIME_WAIT" ) \
599 EM( TCP_CLOSE, "CLOSE" ) \
600 EM( TCP_CLOSE_WAIT, "CLOSE_WAIT" ) \
601 EM( TCP_LAST_ACK, "LAST_ACK" ) \
602 EM( TCP_LISTEN, "LISTEN" ) \
603 EMe( TCP_CLOSING, "CLOSING" )
40b5ea0c
TM		 604
605#define rpc_show_sock_state(state) \
6ba16eef
SRRH		 606 __print_symbolic(state, RPC_SHOW_SOCK)
607
608RPC_SHOW_SOCK
609
610/*
611 * Now redefine the EM() and EMe() macros to map the enums to the strings
612 * that will be printed in the output.
613 */
614#undef EM
615#undef EMe
616#define EM(a, b) {a, b},
617#define EMe(a, b) {a, b}
40b5ea0c
TM		 618
619DECLARE_EVENT_CLASS(xs_socket_event,
620
621 TP_PROTO(
622 struct rpc_xprt *xprt,
623 struct socket *socket
624 ),
625
626 TP_ARGS(xprt, socket),
627
628 TP_STRUCT__entry(
629 __field(unsigned int, socket_state)
630 __field(unsigned int, sock_state)
631 __field(unsigned long long, ino)
632 __string(dstaddr,
633 xprt->address_strings[RPC_DISPLAY_ADDR])
634 __string(dstport,
635 xprt->address_strings[RPC_DISPLAY_PORT])
636 ),
637
638 TP_fast_assign(
639 struct inode *inode = SOCK_INODE(socket);
640 __entry->socket_state = socket->state;
641 __entry->sock_state = socket->sk->sk_state;
642 __entry->ino = (unsigned long long)inode->i_ino;
643 __assign_str(dstaddr,
644 xprt->address_strings[RPC_DISPLAY_ADDR]);
645 __assign_str(dstport,
646 xprt->address_strings[RPC_DISPLAY_PORT]);
647 ),
648
649 TP_printk(
650 "socket:[%llu] dstaddr=%s/%s "
651 "state=%u (%s) sk_state=%u (%s)",
652 __entry->ino, __get_str(dstaddr), __get_str(dstport),
653 __entry->socket_state,
654 rpc_show_socket_state(__entry->socket_state),
655 __entry->sock_state,
656 rpc_show_sock_state(__entry->sock_state)
657 )
658);
659#define DEFINE_RPC_SOCKET_EVENT(name) \
660 DEFINE_EVENT(xs_socket_event, name, \
661 TP_PROTO( \
662 struct rpc_xprt *xprt, \
663 struct socket *socket \
664 ), \
665 TP_ARGS(xprt, socket))
666
667DECLARE_EVENT_CLASS(xs_socket_event_done,
668
669 TP_PROTO(
670 struct rpc_xprt *xprt,
671 struct socket *socket,
672 int error
673 ),
674
675 TP_ARGS(xprt, socket, error),
676
677 TP_STRUCT__entry(
678 __field(int, error)
679 __field(unsigned int, socket_state)
680 __field(unsigned int, sock_state)
681 __field(unsigned long long, ino)
682 __string(dstaddr,
683 xprt->address_strings[RPC_DISPLAY_ADDR])
684 __string(dstport,
685 xprt->address_strings[RPC_DISPLAY_PORT])
686 ),
687
688 TP_fast_assign(
689 struct inode *inode = SOCK_INODE(socket);
690 __entry->socket_state = socket->state;
691 __entry->sock_state = socket->sk->sk_state;
692 __entry->ino = (unsigned long long)inode->i_ino;
693 __entry->error = error;
694 __assign_str(dstaddr,
695 xprt->address_strings[RPC_DISPLAY_ADDR]);
696 __assign_str(dstport,
697 xprt->address_strings[RPC_DISPLAY_PORT]);
698 ),
699
700 TP_printk(
701 "error=%d socket:[%llu] dstaddr=%s/%s "
702 "state=%u (%s) sk_state=%u (%s)",
703 __entry->error,
704 __entry->ino, __get_str(dstaddr), __get_str(dstport),
705 __entry->socket_state,
706 rpc_show_socket_state(__entry->socket_state),
707 __entry->sock_state,
708 rpc_show_sock_state(__entry->sock_state)
709 )
710);
711#define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
712 DEFINE_EVENT(xs_socket_event_done, name, \
713 TP_PROTO( \
714 struct rpc_xprt *xprt, \
715 struct socket *socket, \
716 int error \
717 ), \
718 TP_ARGS(xprt, socket, error))
719
720DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
721DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
e8353c76 722DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error);
40b5ea0c
TM		 723DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
724DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
725DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
726
3705ad64 727DECLARE_EVENT_CLASS(rpc_xprt_event,
dc5820bd
CL		 728 TP_PROTO(
729 const struct rpc_xprt *xprt,
730 __be32 xid,
731 int status
732 ),
3705ad64
JL		 733
734 TP_ARGS(xprt, xid, status),
735
736 TP_STRUCT__entry(
a30ccf1a 737 __field(u32, xid)
3705ad64
JL		 738 __field(int, status)
739 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
740 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
741 ),
742
743 TP_fast_assign(
a30ccf1a 744 __entry->xid = be32_to_cpu(xid);
3705ad64
JL		 745 __entry->status = status;
746 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
747 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
748 ),
749
a30ccf1a
CL		 750 TP_printk("peer=[%s]:%s xid=0x%08x status=%d", __get_str(addr),
751 __get_str(port), __entry->xid,
3705ad64
JL		 752 __entry->status)
753);
dc5820bd
CL		 754#define DEFINE_RPC_XPRT_EVENT(name) \
755 DEFINE_EVENT(rpc_xprt_event, xprt_##name, \
756 TP_PROTO( \
757 const struct rpc_xprt *xprt, \
758 __be32 xid, \
759 int status \
760 ), \
761 TP_ARGS(xprt, xid, status))
3705ad64 762
dc5820bd
CL		 763DEFINE_RPC_XPRT_EVENT(timer);
764DEFINE_RPC_XPRT_EVENT(lookup_rqst);
dc5820bd 765DEFINE_RPC_XPRT_EVENT(complete_rqst);
3705ad64 766
0c77668d
CL		 767TRACE_EVENT(xprt_transmit,
768 TP_PROTO(
769 const struct rpc_rqst *rqst,
770 int status
771 ),
772
773 TP_ARGS(rqst, status),
774
775 TP_STRUCT__entry(
776 __field(unsigned int, task_id)
777 __field(unsigned int, client_id)
778 __field(u32, xid)
779 __field(u32, seqno)
780 __field(int, status)
781 ),
782
783 TP_fast_assign(
784 __entry->task_id = rqst->rq_task->tk_pid;
f87b543a
OK		 785 __entry->client_id = rqst->rq_task->tk_client ?
786 rqst->rq_task->tk_client->cl_clid : -1;
0c77668d
CL		 787 __entry->xid = be32_to_cpu(rqst->rq_xid);
788 __entry->seqno = rqst->rq_seqno;
789 __entry->status = status;
790 ),
791
792 TP_printk(
793 "task:%u@%u xid=0x%08x seqno=%u status=%d",
794 __entry->task_id, __entry->client_id, __entry->xid,
795 __entry->seqno, __entry->status)
796);
797
798TRACE_EVENT(xprt_enq_xmit,
799 TP_PROTO(
800 const struct rpc_task *task,
801 int stage
802 ),
803
804 TP_ARGS(task, stage),
805
806 TP_STRUCT__entry(
807 __field(unsigned int, task_id)
808 __field(unsigned int, client_id)
809 __field(u32, xid)
810 __field(u32, seqno)
811 __field(int, stage)
812 ),
813
814 TP_fast_assign(
815 __entry->task_id = task->tk_pid;
f87b543a
OK		 816 __entry->client_id = task->tk_client ?
817 task->tk_client->cl_clid : -1;
0c77668d
CL		 818 __entry->xid = be32_to_cpu(task->tk_rqstp->rq_xid);
819 __entry->seqno = task->tk_rqstp->rq_seqno;
820 __entry->stage = stage;
821 ),
822
823 TP_printk(
824 "task:%u@%u xid=0x%08x seqno=%u stage=%d",
825 __entry->task_id, __entry->client_id, __entry->xid,
826 __entry->seqno, __entry->stage)
827);
828
a25a4cb3
CL		 829TRACE_EVENT(xprt_ping,
830 TP_PROTO(const struct rpc_xprt *xprt, int status),
831
832 TP_ARGS(xprt, status),
833
834 TP_STRUCT__entry(
835 __field(int, status)
836 __string(addr, xprt->address_strings[RPC_DISPLAY_ADDR])
837 __string(port, xprt->address_strings[RPC_DISPLAY_PORT])
838 ),
839
840 TP_fast_assign(
841 __entry->status = status;
842 __assign_str(addr, xprt->address_strings[RPC_DISPLAY_ADDR]);
843 __assign_str(port, xprt->address_strings[RPC_DISPLAY_PORT]);
844 ),
845
846 TP_printk("peer=[%s]:%s status=%d",
847 __get_str(addr), __get_str(port), __entry->status)
848);
849
bf7ca707
CL		 850DECLARE_EVENT_CLASS(xprt_writelock_event,
851 TP_PROTO(
852 const struct rpc_xprt *xprt, const struct rpc_task *task
853 ),
854
855 TP_ARGS(xprt, task),
856
857 TP_STRUCT__entry(
858 __field(unsigned int, task_id)
859 __field(unsigned int, client_id)
860 __field(unsigned int, snd_task_id)
861 ),
862
863 TP_fast_assign(
864 if (task) {
865 __entry->task_id = task->tk_pid;
866 __entry->client_id = task->tk_client ?
867 task->tk_client->cl_clid : -1;
868 } else {
869 __entry->task_id = -1;
870 __entry->client_id = -1;
871 }
872 __entry->snd_task_id = xprt->snd_task ?
873 xprt->snd_task->tk_pid : -1;
874 ),
875
876 TP_printk("task:%u@%u snd_task:%u",
877 __entry->task_id, __entry->client_id,
878 __entry->snd_task_id)
879);
880
881#define DEFINE_WRITELOCK_EVENT(name) \
882 DEFINE_EVENT(xprt_writelock_event, xprt_##name, \
883 TP_PROTO( \
884 const struct rpc_xprt *xprt, \
885 const struct rpc_task *task \
886 ), \
887 TP_ARGS(xprt, task))
888
889DEFINE_WRITELOCK_EVENT(reserve_xprt);
890DEFINE_WRITELOCK_EVENT(release_xprt);
891
892DECLARE_EVENT_CLASS(xprt_cong_event,
893 TP_PROTO(
894 const struct rpc_xprt *xprt, const struct rpc_task *task
895 ),
896
897 TP_ARGS(xprt, task),
898
899 TP_STRUCT__entry(
900 __field(unsigned int, task_id)
901 __field(unsigned int, client_id)
902 __field(unsigned int, snd_task_id)
903 __field(unsigned long, cong)
904 __field(unsigned long, cwnd)
905 __field(bool, wait)
906 ),
907
908 TP_fast_assign(
909 if (task) {
910 __entry->task_id = task->tk_pid;
911 __entry->client_id = task->tk_client ?
912 task->tk_client->cl_clid : -1;
913 } else {
914 __entry->task_id = -1;
915 __entry->client_id = -1;
916 }
917 __entry->snd_task_id = xprt->snd_task ?
918 xprt->snd_task->tk_pid : -1;
919 __entry->cong = xprt->cong;
920 __entry->cwnd = xprt->cwnd;
921 __entry->wait = test_bit(XPRT_CWND_WAIT, &xprt->state);
922 ),
923
924 TP_printk("task:%u@%u snd_task:%u cong=%lu cwnd=%lu%s",
925 __entry->task_id, __entry->client_id,
926 __entry->snd_task_id, __entry->cong, __entry->cwnd,
927 __entry->wait ? " (wait)" : "")
928);
929
930#define DEFINE_CONG_EVENT(name) \
931 DEFINE_EVENT(xprt_cong_event, xprt_##name, \
932 TP_PROTO( \
933 const struct rpc_xprt *xprt, \
934 const struct rpc_task *task \
935 ), \
936 TP_ARGS(xprt, task))
937
938DEFINE_CONG_EVENT(reserve_cong);
939DEFINE_CONG_EVENT(release_cong);
940DEFINE_CONG_EVENT(get_cong);
941DEFINE_CONG_EVENT(put_cong);
942
c50b8ee0
TM		 943TRACE_EVENT(xs_stream_read_data,
944 TP_PROTO(struct rpc_xprt *xprt, ssize_t err, size_t total),
3705ad64
JL		 945
946 TP_ARGS(xprt, err, total),
947
948 TP_STRUCT__entry(
c50b8ee0
TM		 949 __field(ssize_t, err)
950 __field(size_t, total)
3705ad64
JL		 951 __string(addr, xprt ? xprt->address_strings[RPC_DISPLAY_ADDR] :
952 "(null)")
953 __string(port, xprt ? xprt->address_strings[RPC_DISPLAY_PORT] :
954 "(null)")
955 ),
956
957 TP_fast_assign(
958 __entry->err = err;
959 __entry->total = total;
960 __assign_str(addr, xprt ?
961 xprt->address_strings[RPC_DISPLAY_ADDR] : "(null)");
962 __assign_str(port, xprt ?
963 xprt->address_strings[RPC_DISPLAY_PORT] : "(null)");
964 ),
965
c50b8ee0 966 TP_printk("peer=[%s]:%s err=%zd total=%zu", __get_str(addr),
3705ad64
JL		 967 __get_str(port), __entry->err, __entry->total)
968);
969
c50b8ee0 970TRACE_EVENT(xs_stream_read_request,
1a867a08
JL		 971 TP_PROTO(struct sock_xprt *xs),
972
973 TP_ARGS(xs),
974
975 TP_STRUCT__entry(
976 __string(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR])
977 __string(port, xs->xprt.address_strings[RPC_DISPLAY_PORT])
a30ccf1a 978 __field(u32, xid)
1a867a08
JL		 979 __field(unsigned long, copied)
980 __field(unsigned int, reclen)
c50b8ee0 981 __field(unsigned int, offset)
1a867a08
JL		 982 ),
983
984 TP_fast_assign(
985 __assign_str(addr, xs->xprt.address_strings[RPC_DISPLAY_ADDR]);
986 __assign_str(port, xs->xprt.address_strings[RPC_DISPLAY_PORT]);
d1109aa5 987 __entry->xid = be32_to_cpu(xs->recv.xid);
d1109aa5
TM		 988 __entry->copied = xs->recv.copied;
989 __entry->reclen = xs->recv.len;
990 __entry->offset = xs->recv.offset;
1a867a08
JL		 991 ),
992
c50b8ee0 993 TP_printk("peer=[%s]:%s xid=0x%08x copied=%lu reclen=%u offset=%u",
a30ccf1a 994 __get_str(addr), __get_str(port), __entry->xid,
1a867a08
JL		 995 __entry->copied, __entry->reclen, __entry->offset)
996);
997
c509f15a
CL		 998
999DECLARE_EVENT_CLASS(svc_xdr_buf_class,
1000 TP_PROTO(
1001 const struct svc_rqst *rqst,
1002 const struct xdr_buf *xdr
1003 ),
1004
1005 TP_ARGS(rqst, xdr),
1006
1007 TP_STRUCT__entry(
1008 __field(u32, xid)
1009 __field(const void *, head_base)
1010 __field(size_t, head_len)
1011 __field(const void *, tail_base)
1012 __field(size_t, tail_len)
1013 __field(unsigned int, page_len)
1014 __field(unsigned int, msg_len)
1015 ),
1016
1017 TP_fast_assign(
1018 __entry->xid = be32_to_cpu(rqst->rq_xid);
1019 __entry->head_base = xdr->head[0].iov_base;
1020 __entry->head_len = xdr->head[0].iov_len;
1021 __entry->tail_base = xdr->tail[0].iov_base;
1022 __entry->tail_len = xdr->tail[0].iov_len;
1023 __entry->page_len = xdr->page_len;
1024 __entry->msg_len = xdr->len;
1025 ),
1026
1027 TP_printk("xid=0x%08x head=[%p,%zu] page=%u tail=[%p,%zu] len=%u",
1028 __entry->xid,
1029 __entry->head_base, __entry->head_len, __entry->page_len,
1030 __entry->tail_base, __entry->tail_len, __entry->msg_len
1031 )
1032);
1033
1034#define DEFINE_SVCXDRBUF_EVENT(name) \
1035 DEFINE_EVENT(svc_xdr_buf_class, \
1036 svc_xdr_##name, \
1037 TP_PROTO( \
1038 const struct svc_rqst *rqst, \
1039 const struct xdr_buf *xdr \
1040 ), \
1041 TP_ARGS(rqst, xdr))
1042
1043DEFINE_SVCXDRBUF_EVENT(recvfrom);
1044DEFINE_SVCXDRBUF_EVENT(sendto);
1045
30660e04
JL		 1046#define show_rqstp_flags(flags) \
1047 __print_flags(flags, "|", \
1048 { (1UL << RQ_SECURE), "RQ_SECURE"}, \
1049 { (1UL << RQ_LOCAL), "RQ_LOCAL"}, \
78b65eb3 1050 { (1UL << RQ_USEDEFERRAL), "RQ_USEDEFERRAL"}, \
779fb0f3 1051 { (1UL << RQ_DROPME), "RQ_DROPME"}, \
81244386 1052 { (1UL << RQ_SPLICE_OK), "RQ_SPLICE_OK"}, \
b1691bc0
JL		 1053 { (1UL << RQ_VICTIM), "RQ_VICTIM"}, \
1054 { (1UL << RQ_BUSY), "RQ_BUSY"})
4d152e2c 1055
860a0d9e 1056TRACE_EVENT(svc_recv,
41f306d0 1057 TP_PROTO(struct svc_rqst *rqst, int len),
860a0d9e 1058
41f306d0 1059 TP_ARGS(rqst, len),
860a0d9e
JL		 1060
1061 TP_STRUCT__entry(
a30ccf1a 1062 __field(u32, xid)
41f306d0 1063 __field(int, len)
4d152e2c 1064 __field(unsigned long, flags)
ece200dd 1065 __string(addr, rqst->rq_xprt->xpt_remotebuf)
860a0d9e
JL		 1066 ),
1067
1068 TP_fast_assign(
41f306d0
CL		 1069 __entry->xid = be32_to_cpu(rqst->rq_xid);
1070 __entry->len = len;
4d152e2c 1071 __entry->flags = rqst->rq_flags;
ece200dd 1072 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
860a0d9e
JL		 1073 ),
1074
ece200dd
CL		 1075 TP_printk("addr=%s xid=0x%08x len=%d flags=%s",
1076 __get_str(addr), __entry->xid, __entry->len,
4d152e2c 1077 show_rqstp_flags(__entry->flags))
860a0d9e
JL		 1078);
1079
ff27e9f7
CL		 1080#define svc_show_status(status) \
1081 __print_symbolic(status, \
1082 { SVC_GARBAGE, "SVC_GARBAGE" }, \
1083 { SVC_SYSERR, "SVC_SYSERR" }, \
1084 { SVC_VALID, "SVC_VALID" }, \
1085 { SVC_NEGATIVE, "SVC_NEGATIVE" }, \
1086 { SVC_OK, "SVC_OK" }, \
1087 { SVC_DROP, "SVC_DROP" }, \
1088 { SVC_CLOSE, "SVC_CLOSE" }, \
1089 { SVC_DENIED, "SVC_DENIED" }, \
1090 { SVC_PENDING, "SVC_PENDING" }, \
1091 { SVC_COMPLETE, "SVC_COMPLETE" })
1092
1093TRACE_EVENT(svc_authenticate,
1094 TP_PROTO(const struct svc_rqst *rqst, int auth_res, __be32 auth_stat),
1095
1096 TP_ARGS(rqst, auth_res, auth_stat),
1097
1098 TP_STRUCT__entry(
1099 __field(u32, xid)
1100 __field(unsigned long, svc_status)
1101 __field(unsigned long, auth_stat)
1102 ),
1103
1104 TP_fast_assign(
1105 __entry->xid = be32_to_cpu(rqst->rq_xid);
1106 __entry->svc_status = auth_res;
1107 __entry->auth_stat = be32_to_cpu(auth_stat);
1108 ),
1109
1110 TP_printk("xid=0x%08x auth_res=%s auth_stat=%s",
1111 __entry->xid, svc_show_status(__entry->svc_status),
1112 rpc_show_auth_stat(__entry->auth_stat))
1113);
1114
0b9547bf
CL		 1115TRACE_EVENT(svc_process,
1116 TP_PROTO(const struct svc_rqst *rqst, const char *name),
1117
1118 TP_ARGS(rqst, name),
1119
1120 TP_STRUCT__entry(
1121 __field(u32, xid)
1122 __field(u32, vers)
1123 __field(u32, proc)
1124 __string(service, name)
d4b09acf
VA		 1125 __string(addr, rqst->rq_xprt ?
1126 rqst->rq_xprt->xpt_remotebuf : "(null)")
0b9547bf
CL		 1127 ),
1128
1129 TP_fast_assign(
1130 __entry->xid = be32_to_cpu(rqst->rq_xid);
1131 __entry->vers = rqst->rq_vers;
1132 __entry->proc = rqst->rq_proc;
1133 __assign_str(service, name);
d4b09acf
VA		 1134 __assign_str(addr, rqst->rq_xprt ?
1135 rqst->rq_xprt->xpt_remotebuf : "(null)");
0b9547bf
CL		 1136 ),
1137
1138 TP_printk("addr=%s xid=0x%08x service=%s vers=%u proc=%u",
1139 __get_str(addr), __entry->xid,
1140 __get_str(service), __entry->vers, __entry->proc)
1141);
1142
104f6351
TM		 1143DECLARE_EVENT_CLASS(svc_rqst_event,
1144
dc5820bd
CL		 1145 TP_PROTO(
1146 const struct svc_rqst *rqst
1147 ),
104f6351
TM		 1148
1149 TP_ARGS(rqst),
1150
1151 TP_STRUCT__entry(
a30ccf1a 1152 __field(u32, xid)
104f6351 1153 __field(unsigned long, flags)
ece200dd 1154 __string(addr, rqst->rq_xprt->xpt_remotebuf)
104f6351
TM		 1155 ),
1156
1157 TP_fast_assign(
a30ccf1a 1158 __entry->xid = be32_to_cpu(rqst->rq_xid);
104f6351 1159 __entry->flags = rqst->rq_flags;
ece200dd 1160 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
104f6351
TM		 1161 ),
1162
ece200dd
CL		 1163 TP_printk("addr=%s xid=0x%08x flags=%s",
1164 __get_str(addr), __entry->xid,
1165 show_rqstp_flags(__entry->flags))
104f6351 1166);
dc5820bd
CL		 1167#define DEFINE_SVC_RQST_EVENT(name) \
1168 DEFINE_EVENT(svc_rqst_event, svc_##name, \
1169 TP_PROTO( \
1170 const struct svc_rqst *rqst \
1171 ), \
1172 TP_ARGS(rqst))
104f6351 1173
dc5820bd
CL		 1174DEFINE_SVC_RQST_EVENT(defer);
1175DEFINE_SVC_RQST_EVENT(drop);
104f6351 1176
860a0d9e
JL		 1177DECLARE_EVENT_CLASS(svc_rqst_status,
1178
1179 TP_PROTO(struct svc_rqst *rqst, int status),
1180
1181 TP_ARGS(rqst, status),
1182
1183 TP_STRUCT__entry(
a30ccf1a 1184 __field(u32, xid)
860a0d9e 1185 __field(int, status)
4d152e2c 1186 __field(unsigned long, flags)
ece200dd 1187 __string(addr, rqst->rq_xprt->xpt_remotebuf)
860a0d9e
JL		 1188 ),
1189
1190 TP_fast_assign(
a30ccf1a 1191 __entry->xid = be32_to_cpu(rqst->rq_xid);
860a0d9e 1192 __entry->status = status;
4d152e2c 1193 __entry->flags = rqst->rq_flags;
ece200dd 1194 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
860a0d9e
JL		 1195 ),
1196
ece200dd
CL		 1197 TP_printk("addr=%s xid=0x%08x status=%d flags=%s",
1198 __get_str(addr), __entry->xid,
1199 __entry->status, show_rqstp_flags(__entry->flags))
860a0d9e
JL		 1200);
1201
860a0d9e
JL		 1202DEFINE_EVENT(svc_rqst_status, svc_send,
1203 TP_PROTO(struct svc_rqst *rqst, int status),
1204 TP_ARGS(rqst, status));
1205
83a712e0
JL		 1206#define show_svc_xprt_flags(flags) \
1207 __print_flags(flags, "|", \
1208 { (1UL << XPT_BUSY), "XPT_BUSY"}, \
1209 { (1UL << XPT_CONN), "XPT_CONN"}, \
1210 { (1UL << XPT_CLOSE), "XPT_CLOSE"}, \
1211 { (1UL << XPT_DATA), "XPT_DATA"}, \
1212 { (1UL << XPT_TEMP), "XPT_TEMP"}, \
1213 { (1UL << XPT_DEAD), "XPT_DEAD"}, \
1214 { (1UL << XPT_CHNGBUF), "XPT_CHNGBUF"}, \
1215 { (1UL << XPT_DEFERRED), "XPT_DEFERRED"}, \
1216 { (1UL << XPT_OLD), "XPT_OLD"}, \
1217 { (1UL << XPT_LISTENER), "XPT_LISTENER"}, \
1218 { (1UL << XPT_CACHE_AUTH), "XPT_CACHE_AUTH"}, \
03edb90f
CL		 1219 { (1UL << XPT_LOCAL), "XPT_LOCAL"}, \
1220 { (1UL << XPT_KILL_TEMP), "XPT_KILL_TEMP"}, \
1221 { (1UL << XPT_CONG_CTRL), "XPT_CONG_CTRL"})
83a712e0
JL		 1222
1223TRACE_EVENT(svc_xprt_do_enqueue,
1224 TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
1225
1226 TP_ARGS(xprt, rqst),
1227
1228 TP_STRUCT__entry(
1229 __field(struct svc_xprt *, xprt)
051ac384
PA		 1230 __field(int, pid)
1231 __field(unsigned long, flags)
ece200dd 1232 __string(addr, xprt->xpt_remotebuf)
83a712e0
JL		 1233 ),
1234
1235 TP_fast_assign(
1236 __entry->xprt = xprt;
051ac384 1237 __entry->pid = rqst? rqst->rq_task->pid : 0;
ece200dd
CL		 1238 __entry->flags = xprt->xpt_flags;
1239 __assign_str(addr, xprt->xpt_remotebuf);
83a712e0
JL		 1240 ),
1241
ece200dd
CL		 1242 TP_printk("xprt=%p addr=%s pid=%d flags=%s",
1243 __entry->xprt, __get_str(addr),
1244 __entry->pid, show_svc_xprt_flags(__entry->flags))
83a712e0
JL		 1245);
1246
82ea2d76 1247DECLARE_EVENT_CLASS(svc_xprt_event,
83a712e0
JL		 1248 TP_PROTO(struct svc_xprt *xprt),
1249
1250 TP_ARGS(xprt),
1251
1252 TP_STRUCT__entry(
1253 __field(struct svc_xprt *, xprt)
83a712e0 1254 __field(unsigned long, flags)
ece200dd 1255 __string(addr, xprt->xpt_remotebuf)
83a712e0
JL		 1256 ),
1257
1258 TP_fast_assign(
db1bb44c 1259 __entry->xprt = xprt;
caa3e106 1260 __entry->flags = xprt->xpt_flags;
ece200dd 1261 __assign_str(addr, xprt->xpt_remotebuf);
83a712e0
JL		 1262 ),
1263
ece200dd
CL		 1264 TP_printk("xprt=%p addr=%s flags=%s",
1265 __entry->xprt, __get_str(addr),
1266 show_svc_xprt_flags(__entry->flags))
83a712e0
JL		 1267);
1268
82ea2d76
TM		 1269DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space,
1270 TP_PROTO(struct svc_xprt *xprt),
1271 TP_ARGS(xprt));
1272
55f5088c
CL		 1273TRACE_EVENT(svc_xprt_dequeue,
1274 TP_PROTO(struct svc_rqst *rqst),
1275
1276 TP_ARGS(rqst),
1277
1278 TP_STRUCT__entry(
1279 __field(struct svc_xprt *, xprt)
1280 __field(unsigned long, flags)
1281 __field(unsigned long, wakeup)
1282 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1283 ),
1284
1285 TP_fast_assign(
1286 __entry->xprt = rqst->rq_xprt;
1287 __entry->flags = rqst->rq_xprt->xpt_flags;
1288 __entry->wakeup = ktime_to_us(ktime_sub(ktime_get(),
1289 rqst->rq_qtime));
1290 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1291 ),
1292
1293 TP_printk("xprt=%p addr=%s flags=%s wakeup-us=%lu",
1294 __entry->xprt, __get_str(addr),
1295 show_svc_xprt_flags(__entry->flags),
1296 __entry->wakeup)
1297);
1298
83a712e0
JL		 1299TRACE_EVENT(svc_wake_up,
1300 TP_PROTO(int pid),
1301
1302 TP_ARGS(pid),
1303
1304 TP_STRUCT__entry(
1305 __field(int, pid)
1306 ),
1307
1308 TP_fast_assign(
1309 __entry->pid = pid;
1310 ),
1311
1312 TP_printk("pid=%d", __entry->pid)
1313);
1314
1315TRACE_EVENT(svc_handle_xprt,
1316 TP_PROTO(struct svc_xprt *xprt, int len),
1317
1318 TP_ARGS(xprt, len),
1319
1320 TP_STRUCT__entry(
1321 __field(struct svc_xprt *, xprt)
1322 __field(int, len)
051ac384 1323 __field(unsigned long, flags)
ece200dd 1324 __string(addr, xprt->xpt_remotebuf)
83a712e0
JL		 1325 ),
1326
1327 TP_fast_assign(
1328 __entry->xprt = xprt;
1329 __entry->len = len;
ece200dd
CL		 1330 __entry->flags = xprt->xpt_flags;
1331 __assign_str(addr, xprt->xpt_remotebuf);
83a712e0
JL		 1332 ),
1333
ece200dd
CL		 1334 TP_printk("xprt=%p addr=%s len=%d flags=%s",
1335 __entry->xprt, __get_str(addr),
051ac384 1336 __entry->len, show_svc_xprt_flags(__entry->flags))
83a712e0 1337);
104f6351 1338
aaba72cd
CL		 1339TRACE_EVENT(svc_stats_latency,
1340 TP_PROTO(const struct svc_rqst *rqst),
1341
1342 TP_ARGS(rqst),
1343
1344 TP_STRUCT__entry(
1345 __field(u32, xid)
1346 __field(unsigned long, execute)
1347 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1348 ),
1349
1350 TP_fast_assign(
1351 __entry->xid = be32_to_cpu(rqst->rq_xid);
1352 __entry->execute = ktime_to_us(ktime_sub(ktime_get(),
1353 rqst->rq_stime));
1354 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1355 ),
1356
1357 TP_printk("addr=%s xid=0x%08x execute-us=%lu",
1358 __get_str(addr), __entry->xid, __entry->execute)
1359);
104f6351
TM		 1360
1361DECLARE_EVENT_CLASS(svc_deferred_event,
dc5820bd
CL		 1362 TP_PROTO(
1363 const struct svc_deferred_req *dr
1364 ),
104f6351
TM		 1365
1366 TP_ARGS(dr),
1367
1368 TP_STRUCT__entry(
a30ccf1a 1369 __field(u32, xid)
ece200dd 1370 __string(addr, dr->xprt->xpt_remotebuf)
104f6351
TM		 1371 ),
1372
1373 TP_fast_assign(
a30ccf1a
CL		 1374 __entry->xid = be32_to_cpu(*(__be32 *)(dr->args +
1375 (dr->xprt_hlen>>2)));
ece200dd 1376 __assign_str(addr, dr->xprt->xpt_remotebuf);
104f6351
TM		 1377 ),
1378
ece200dd 1379 TP_printk("addr=%s xid=0x%08x", __get_str(addr), __entry->xid)
104f6351 1380);
dc5820bd
CL		 1381#define DEFINE_SVC_DEFERRED_EVENT(name) \
1382 DEFINE_EVENT(svc_deferred_event, svc_##name##_deferred, \
1383 TP_PROTO( \
1384 const struct svc_deferred_req *dr \
1385 ), \
1386 TP_ARGS(dr))
1387
1388DEFINE_SVC_DEFERRED_EVENT(drop);
1389DEFINE_SVC_DEFERRED_EVENT(revisit);
104f6351 1390
78a947f5
TM		 1391DECLARE_EVENT_CLASS(cache_event,
1392 TP_PROTO(
1393 const struct cache_detail *cd,
1394 const struct cache_head *h
1395 ),
1396
1397 TP_ARGS(cd, h),
1398
1399 TP_STRUCT__entry(
1400 __field(const struct cache_head *, h)
1401 __string(name, cd->name)
1402 ),
1403
1404 TP_fast_assign(
1405 __entry->h = h;
1406 __assign_str(name, cd->name);
1407 ),
1408
1409 TP_printk("cache=%s entry=%p", __get_str(name), __entry->h)
1410);
1411#define DEFINE_CACHE_EVENT(name) \
1412 DEFINE_EVENT(cache_event, name, \
1413 TP_PROTO( \
1414 const struct cache_detail *cd, \
1415 const struct cache_head *h \
1416 ), \
1417 TP_ARGS(cd, h))
1418DEFINE_CACHE_EVENT(cache_entry_expired);
1419DEFINE_CACHE_EVENT(cache_entry_upcall);
1420DEFINE_CACHE_EVENT(cache_entry_update);
1421DEFINE_CACHE_EVENT(cache_entry_make_negative);
1422DEFINE_CACHE_EVENT(cache_entry_no_listener);
1423
82b0a4c3
TM		 1424#endif /* _TRACE_SUNRPC_H */
1425
1426#include <trace/define_trace.h>
Ubuntu Jammy Linux kernel mirror