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