Loading...
Note: File does not exist in v3.1.
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Copyright (c) 2017, 2018 Oracle. All rights reserved.
4 *
5 * Trace point definitions for the "rpcrdma" subsystem.
6 */
7#undef TRACE_SYSTEM
8#define TRACE_SYSTEM rpcrdma
9
10#if !defined(_TRACE_RPCRDMA_H) || defined(TRACE_HEADER_MULTI_READ)
11#define _TRACE_RPCRDMA_H
12
13#include <linux/scatterlist.h>
14#include <linux/sunrpc/rpc_rdma_cid.h>
15#include <linux/tracepoint.h>
16#include <rdma/ib_cm.h>
17
18#include <trace/misc/rdma.h>
19#include <trace/misc/sunrpc.h>
20
21/**
22 ** Event classes
23 **/
24
25DECLARE_EVENT_CLASS(rpcrdma_simple_cid_class,
26 TP_PROTO(
27 const struct rpc_rdma_cid *cid
28 ),
29
30 TP_ARGS(cid),
31
32 TP_STRUCT__entry(
33 __field(u32, cq_id)
34 __field(int, completion_id)
35 ),
36
37 TP_fast_assign(
38 __entry->cq_id = cid->ci_queue_id;
39 __entry->completion_id = cid->ci_completion_id;
40 ),
41
42 TP_printk("cq.id=%d cid=%d",
43 __entry->cq_id, __entry->completion_id
44 )
45);
46
47#define DEFINE_SIMPLE_CID_EVENT(name) \
48 DEFINE_EVENT(rpcrdma_simple_cid_class, name, \
49 TP_PROTO( \
50 const struct rpc_rdma_cid *cid \
51 ), \
52 TP_ARGS(cid) \
53 )
54
55DECLARE_EVENT_CLASS(rpcrdma_completion_class,
56 TP_PROTO(
57 const struct ib_wc *wc,
58 const struct rpc_rdma_cid *cid
59 ),
60
61 TP_ARGS(wc, cid),
62
63 TP_STRUCT__entry(
64 __field(u32, cq_id)
65 __field(int, completion_id)
66 __field(unsigned long, status)
67 __field(unsigned int, vendor_err)
68 ),
69
70 TP_fast_assign(
71 __entry->cq_id = cid->ci_queue_id;
72 __entry->completion_id = cid->ci_completion_id;
73 __entry->status = wc->status;
74 if (wc->status)
75 __entry->vendor_err = wc->vendor_err;
76 else
77 __entry->vendor_err = 0;
78 ),
79
80 TP_printk("cq.id=%u cid=%d status=%s (%lu/0x%x)",
81 __entry->cq_id, __entry->completion_id,
82 rdma_show_wc_status(__entry->status),
83 __entry->status, __entry->vendor_err
84 )
85);
86
87#define DEFINE_COMPLETION_EVENT(name) \
88 DEFINE_EVENT(rpcrdma_completion_class, name, \
89 TP_PROTO( \
90 const struct ib_wc *wc, \
91 const struct rpc_rdma_cid *cid \
92 ), \
93 TP_ARGS(wc, cid))
94
95DECLARE_EVENT_CLASS(rpcrdma_send_flush_class,
96 TP_PROTO(
97 const struct ib_wc *wc,
98 const struct rpc_rdma_cid *cid
99 ),
100
101 TP_ARGS(wc, cid),
102
103 TP_STRUCT__entry(
104 __field(u32, cq_id)
105 __field(int, completion_id)
106 __field(unsigned long, status)
107 __field(unsigned int, vendor_err)
108 ),
109
110 TP_fast_assign(
111 __entry->cq_id = cid->ci_queue_id;
112 __entry->completion_id = cid->ci_completion_id;
113 __entry->status = wc->status;
114 __entry->vendor_err = wc->vendor_err;
115 ),
116
117 TP_printk("cq.id=%u cid=%d status=%s (%lu/0x%x)",
118 __entry->cq_id, __entry->completion_id,
119 rdma_show_wc_status(__entry->status),
120 __entry->status, __entry->vendor_err
121 )
122);
123
124#define DEFINE_SEND_FLUSH_EVENT(name) \
125 DEFINE_EVENT(rpcrdma_send_flush_class, name, \
126 TP_PROTO( \
127 const struct ib_wc *wc, \
128 const struct rpc_rdma_cid *cid \
129 ), \
130 TP_ARGS(wc, cid))
131
132DECLARE_EVENT_CLASS(rpcrdma_mr_completion_class,
133 TP_PROTO(
134 const struct ib_wc *wc,
135 const struct rpc_rdma_cid *cid
136 ),
137
138 TP_ARGS(wc, cid),
139
140 TP_STRUCT__entry(
141 __field(u32, cq_id)
142 __field(int, completion_id)
143 __field(unsigned long, status)
144 __field(unsigned int, vendor_err)
145 ),
146
147 TP_fast_assign(
148 __entry->cq_id = cid->ci_queue_id;
149 __entry->completion_id = cid->ci_completion_id;
150 __entry->status = wc->status;
151 if (wc->status)
152 __entry->vendor_err = wc->vendor_err;
153 else
154 __entry->vendor_err = 0;
155 ),
156
157 TP_printk("cq.id=%u mr.id=%d status=%s (%lu/0x%x)",
158 __entry->cq_id, __entry->completion_id,
159 rdma_show_wc_status(__entry->status),
160 __entry->status, __entry->vendor_err
161 )
162);
163
164#define DEFINE_MR_COMPLETION_EVENT(name) \
165 DEFINE_EVENT(rpcrdma_mr_completion_class, name, \
166 TP_PROTO( \
167 const struct ib_wc *wc, \
168 const struct rpc_rdma_cid *cid \
169 ), \
170 TP_ARGS(wc, cid))
171
172DECLARE_EVENT_CLASS(rpcrdma_receive_completion_class,
173 TP_PROTO(
174 const struct ib_wc *wc,
175 const struct rpc_rdma_cid *cid
176 ),
177
178 TP_ARGS(wc, cid),
179
180 TP_STRUCT__entry(
181 __field(u32, cq_id)
182 __field(int, completion_id)
183 __field(u32, received)
184 __field(unsigned long, status)
185 __field(unsigned int, vendor_err)
186 ),
187
188 TP_fast_assign(
189 __entry->cq_id = cid->ci_queue_id;
190 __entry->completion_id = cid->ci_completion_id;
191 __entry->status = wc->status;
192 if (wc->status) {
193 __entry->received = 0;
194 __entry->vendor_err = wc->vendor_err;
195 } else {
196 __entry->received = wc->byte_len;
197 __entry->vendor_err = 0;
198 }
199 ),
200
201 TP_printk("cq.id=%u cid=%d status=%s (%lu/0x%x) received=%u",
202 __entry->cq_id, __entry->completion_id,
203 rdma_show_wc_status(__entry->status),
204 __entry->status, __entry->vendor_err,
205 __entry->received
206 )
207);
208
209#define DEFINE_RECEIVE_COMPLETION_EVENT(name) \
210 DEFINE_EVENT(rpcrdma_receive_completion_class, name, \
211 TP_PROTO( \
212 const struct ib_wc *wc, \
213 const struct rpc_rdma_cid *cid \
214 ), \
215 TP_ARGS(wc, cid))
216
217DECLARE_EVENT_CLASS(rpcrdma_receive_success_class,
218 TP_PROTO(
219 const struct ib_wc *wc,
220 const struct rpc_rdma_cid *cid
221 ),
222
223 TP_ARGS(wc, cid),
224
225 TP_STRUCT__entry(
226 __field(u32, cq_id)
227 __field(int, completion_id)
228 __field(u32, received)
229 ),
230
231 TP_fast_assign(
232 __entry->cq_id = cid->ci_queue_id;
233 __entry->completion_id = cid->ci_completion_id;
234 __entry->received = wc->byte_len;
235 ),
236
237 TP_printk("cq.id=%u cid=%d received=%u",
238 __entry->cq_id, __entry->completion_id,
239 __entry->received
240 )
241);
242
243#define DEFINE_RECEIVE_SUCCESS_EVENT(name) \
244 DEFINE_EVENT(rpcrdma_receive_success_class, name, \
245 TP_PROTO( \
246 const struct ib_wc *wc, \
247 const struct rpc_rdma_cid *cid \
248 ), \
249 TP_ARGS(wc, cid))
250
251DECLARE_EVENT_CLASS(rpcrdma_receive_flush_class,
252 TP_PROTO(
253 const struct ib_wc *wc,
254 const struct rpc_rdma_cid *cid
255 ),
256
257 TP_ARGS(wc, cid),
258
259 TP_STRUCT__entry(
260 __field(u32, cq_id)
261 __field(int, completion_id)
262 __field(unsigned long, status)
263 __field(unsigned int, vendor_err)
264 ),
265
266 TP_fast_assign(
267 __entry->cq_id = cid->ci_queue_id;
268 __entry->completion_id = cid->ci_completion_id;
269 __entry->status = wc->status;
270 __entry->vendor_err = wc->vendor_err;
271 ),
272
273 TP_printk("cq.id=%u cid=%d status=%s (%lu/0x%x)",
274 __entry->cq_id, __entry->completion_id,
275 rdma_show_wc_status(__entry->status),
276 __entry->status, __entry->vendor_err
277 )
278);
279
280#define DEFINE_RECEIVE_FLUSH_EVENT(name) \
281 DEFINE_EVENT(rpcrdma_receive_flush_class, name, \
282 TP_PROTO( \
283 const struct ib_wc *wc, \
284 const struct rpc_rdma_cid *cid \
285 ), \
286 TP_ARGS(wc, cid))
287
288DECLARE_EVENT_CLASS(xprtrdma_reply_class,
289 TP_PROTO(
290 const struct rpcrdma_rep *rep
291 ),
292
293 TP_ARGS(rep),
294
295 TP_STRUCT__entry(
296 __field(u32, xid)
297 __field(u32, version)
298 __field(u32, proc)
299 __string(addr, rpcrdma_addrstr(rep->rr_rxprt))
300 __string(port, rpcrdma_portstr(rep->rr_rxprt))
301 ),
302
303 TP_fast_assign(
304 __entry->xid = be32_to_cpu(rep->rr_xid);
305 __entry->version = be32_to_cpu(rep->rr_vers);
306 __entry->proc = be32_to_cpu(rep->rr_proc);
307 __assign_str(addr, rpcrdma_addrstr(rep->rr_rxprt));
308 __assign_str(port, rpcrdma_portstr(rep->rr_rxprt));
309 ),
310
311 TP_printk("peer=[%s]:%s xid=0x%08x version=%u proc=%u",
312 __get_str(addr), __get_str(port),
313 __entry->xid, __entry->version, __entry->proc
314 )
315);
316
317#define DEFINE_REPLY_EVENT(name) \
318 DEFINE_EVENT(xprtrdma_reply_class, \
319 xprtrdma_reply_##name##_err, \
320 TP_PROTO( \
321 const struct rpcrdma_rep *rep \
322 ), \
323 TP_ARGS(rep))
324
325DECLARE_EVENT_CLASS(xprtrdma_rxprt,
326 TP_PROTO(
327 const struct rpcrdma_xprt *r_xprt
328 ),
329
330 TP_ARGS(r_xprt),
331
332 TP_STRUCT__entry(
333 __string(addr, rpcrdma_addrstr(r_xprt))
334 __string(port, rpcrdma_portstr(r_xprt))
335 ),
336
337 TP_fast_assign(
338 __assign_str(addr, rpcrdma_addrstr(r_xprt));
339 __assign_str(port, rpcrdma_portstr(r_xprt));
340 ),
341
342 TP_printk("peer=[%s]:%s",
343 __get_str(addr), __get_str(port)
344 )
345);
346
347#define DEFINE_RXPRT_EVENT(name) \
348 DEFINE_EVENT(xprtrdma_rxprt, name, \
349 TP_PROTO( \
350 const struct rpcrdma_xprt *r_xprt \
351 ), \
352 TP_ARGS(r_xprt))
353
354DECLARE_EVENT_CLASS(xprtrdma_connect_class,
355 TP_PROTO(
356 const struct rpcrdma_xprt *r_xprt,
357 int rc
358 ),
359
360 TP_ARGS(r_xprt, rc),
361
362 TP_STRUCT__entry(
363 __field(int, rc)
364 __field(int, connect_status)
365 __string(addr, rpcrdma_addrstr(r_xprt))
366 __string(port, rpcrdma_portstr(r_xprt))
367 ),
368
369 TP_fast_assign(
370 __entry->rc = rc;
371 __entry->connect_status = r_xprt->rx_ep->re_connect_status;
372 __assign_str(addr, rpcrdma_addrstr(r_xprt));
373 __assign_str(port, rpcrdma_portstr(r_xprt));
374 ),
375
376 TP_printk("peer=[%s]:%s rc=%d connection status=%d",
377 __get_str(addr), __get_str(port),
378 __entry->rc, __entry->connect_status
379 )
380);
381
382#define DEFINE_CONN_EVENT(name) \
383 DEFINE_EVENT(xprtrdma_connect_class, xprtrdma_##name, \
384 TP_PROTO( \
385 const struct rpcrdma_xprt *r_xprt, \
386 int rc \
387 ), \
388 TP_ARGS(r_xprt, rc))
389
390DECLARE_EVENT_CLASS(xprtrdma_rdch_event,
391 TP_PROTO(
392 const struct rpc_task *task,
393 unsigned int pos,
394 struct rpcrdma_mr *mr,
395 int nsegs
396 ),
397
398 TP_ARGS(task, pos, mr, nsegs),
399
400 TP_STRUCT__entry(
401 __field(unsigned int, task_id)
402 __field(unsigned int, client_id)
403 __field(unsigned int, pos)
404 __field(int, nents)
405 __field(u32, handle)
406 __field(u32, length)
407 __field(u64, offset)
408 __field(int, nsegs)
409 ),
410
411 TP_fast_assign(
412 __entry->task_id = task->tk_pid;
413 __entry->client_id = task->tk_client->cl_clid;
414 __entry->pos = pos;
415 __entry->nents = mr->mr_nents;
416 __entry->handle = mr->mr_handle;
417 __entry->length = mr->mr_length;
418 __entry->offset = mr->mr_offset;
419 __entry->nsegs = nsegs;
420 ),
421
422 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
423 " pos=%u %u@0x%016llx:0x%08x (%s)",
424 __entry->task_id, __entry->client_id,
425 __entry->pos, __entry->length,
426 (unsigned long long)__entry->offset, __entry->handle,
427 __entry->nents < __entry->nsegs ? "more" : "last"
428 )
429);
430
431#define DEFINE_RDCH_EVENT(name) \
432 DEFINE_EVENT(xprtrdma_rdch_event, xprtrdma_chunk_##name,\
433 TP_PROTO( \
434 const struct rpc_task *task, \
435 unsigned int pos, \
436 struct rpcrdma_mr *mr, \
437 int nsegs \
438 ), \
439 TP_ARGS(task, pos, mr, nsegs))
440
441DECLARE_EVENT_CLASS(xprtrdma_wrch_event,
442 TP_PROTO(
443 const struct rpc_task *task,
444 struct rpcrdma_mr *mr,
445 int nsegs
446 ),
447
448 TP_ARGS(task, mr, nsegs),
449
450 TP_STRUCT__entry(
451 __field(unsigned int, task_id)
452 __field(unsigned int, client_id)
453 __field(int, nents)
454 __field(u32, handle)
455 __field(u32, length)
456 __field(u64, offset)
457 __field(int, nsegs)
458 ),
459
460 TP_fast_assign(
461 __entry->task_id = task->tk_pid;
462 __entry->client_id = task->tk_client->cl_clid;
463 __entry->nents = mr->mr_nents;
464 __entry->handle = mr->mr_handle;
465 __entry->length = mr->mr_length;
466 __entry->offset = mr->mr_offset;
467 __entry->nsegs = nsegs;
468 ),
469
470 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
471 " %u@0x%016llx:0x%08x (%s)",
472 __entry->task_id, __entry->client_id,
473 __entry->length, (unsigned long long)__entry->offset,
474 __entry->handle,
475 __entry->nents < __entry->nsegs ? "more" : "last"
476 )
477);
478
479#define DEFINE_WRCH_EVENT(name) \
480 DEFINE_EVENT(xprtrdma_wrch_event, xprtrdma_chunk_##name,\
481 TP_PROTO( \
482 const struct rpc_task *task, \
483 struct rpcrdma_mr *mr, \
484 int nsegs \
485 ), \
486 TP_ARGS(task, mr, nsegs))
487
488TRACE_DEFINE_ENUM(DMA_BIDIRECTIONAL);
489TRACE_DEFINE_ENUM(DMA_TO_DEVICE);
490TRACE_DEFINE_ENUM(DMA_FROM_DEVICE);
491TRACE_DEFINE_ENUM(DMA_NONE);
492
493#define xprtrdma_show_direction(x) \
494 __print_symbolic(x, \
495 { DMA_BIDIRECTIONAL, "BIDIR" }, \
496 { DMA_TO_DEVICE, "TO_DEVICE" }, \
497 { DMA_FROM_DEVICE, "FROM_DEVICE" }, \
498 { DMA_NONE, "NONE" })
499
500DECLARE_EVENT_CLASS(xprtrdma_mr_class,
501 TP_PROTO(
502 const struct rpcrdma_mr *mr
503 ),
504
505 TP_ARGS(mr),
506
507 TP_STRUCT__entry(
508 __field(unsigned int, task_id)
509 __field(unsigned int, client_id)
510 __field(u32, mr_id)
511 __field(int, nents)
512 __field(u32, handle)
513 __field(u32, length)
514 __field(u64, offset)
515 __field(u32, dir)
516 ),
517
518 TP_fast_assign(
519 const struct rpcrdma_req *req = mr->mr_req;
520
521 if (req) {
522 const struct rpc_task *task = req->rl_slot.rq_task;
523
524 __entry->task_id = task->tk_pid;
525 __entry->client_id = task->tk_client->cl_clid;
526 } else {
527 __entry->task_id = 0;
528 __entry->client_id = -1;
529 }
530 __entry->mr_id = mr->mr_ibmr->res.id;
531 __entry->nents = mr->mr_nents;
532 __entry->handle = mr->mr_handle;
533 __entry->length = mr->mr_length;
534 __entry->offset = mr->mr_offset;
535 __entry->dir = mr->mr_dir;
536 ),
537
538 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
539 " mr.id=%u nents=%d %u@0x%016llx:0x%08x (%s)",
540 __entry->task_id, __entry->client_id,
541 __entry->mr_id, __entry->nents, __entry->length,
542 (unsigned long long)__entry->offset, __entry->handle,
543 xprtrdma_show_direction(__entry->dir)
544 )
545);
546
547#define DEFINE_MR_EVENT(name) \
548 DEFINE_EVENT(xprtrdma_mr_class, \
549 xprtrdma_mr_##name, \
550 TP_PROTO( \
551 const struct rpcrdma_mr *mr \
552 ), \
553 TP_ARGS(mr))
554
555DECLARE_EVENT_CLASS(xprtrdma_anonymous_mr_class,
556 TP_PROTO(
557 const struct rpcrdma_mr *mr
558 ),
559
560 TP_ARGS(mr),
561
562 TP_STRUCT__entry(
563 __field(u32, mr_id)
564 __field(int, nents)
565 __field(u32, handle)
566 __field(u32, length)
567 __field(u64, offset)
568 __field(u32, dir)
569 ),
570
571 TP_fast_assign(
572 __entry->mr_id = mr->mr_ibmr->res.id;
573 __entry->nents = mr->mr_nents;
574 __entry->handle = mr->mr_handle;
575 __entry->length = mr->mr_length;
576 __entry->offset = mr->mr_offset;
577 __entry->dir = mr->mr_dir;
578 ),
579
580 TP_printk("mr.id=%u nents=%d %u@0x%016llx:0x%08x (%s)",
581 __entry->mr_id, __entry->nents, __entry->length,
582 (unsigned long long)__entry->offset, __entry->handle,
583 xprtrdma_show_direction(__entry->dir)
584 )
585);
586
587#define DEFINE_ANON_MR_EVENT(name) \
588 DEFINE_EVENT(xprtrdma_anonymous_mr_class, \
589 xprtrdma_mr_##name, \
590 TP_PROTO( \
591 const struct rpcrdma_mr *mr \
592 ), \
593 TP_ARGS(mr))
594
595DECLARE_EVENT_CLASS(xprtrdma_callback_class,
596 TP_PROTO(
597 const struct rpcrdma_xprt *r_xprt,
598 const struct rpc_rqst *rqst
599 ),
600
601 TP_ARGS(r_xprt, rqst),
602
603 TP_STRUCT__entry(
604 __field(u32, xid)
605 __string(addr, rpcrdma_addrstr(r_xprt))
606 __string(port, rpcrdma_portstr(r_xprt))
607 ),
608
609 TP_fast_assign(
610 __entry->xid = be32_to_cpu(rqst->rq_xid);
611 __assign_str(addr, rpcrdma_addrstr(r_xprt));
612 __assign_str(port, rpcrdma_portstr(r_xprt));
613 ),
614
615 TP_printk("peer=[%s]:%s xid=0x%08x",
616 __get_str(addr), __get_str(port), __entry->xid
617 )
618);
619
620#define DEFINE_CALLBACK_EVENT(name) \
621 DEFINE_EVENT(xprtrdma_callback_class, \
622 xprtrdma_cb_##name, \
623 TP_PROTO( \
624 const struct rpcrdma_xprt *r_xprt, \
625 const struct rpc_rqst *rqst \
626 ), \
627 TP_ARGS(r_xprt, rqst))
628
629/**
630 ** Connection events
631 **/
632
633TRACE_EVENT(xprtrdma_inline_thresh,
634 TP_PROTO(
635 const struct rpcrdma_ep *ep
636 ),
637
638 TP_ARGS(ep),
639
640 TP_STRUCT__entry(
641 __field(unsigned int, inline_send)
642 __field(unsigned int, inline_recv)
643 __field(unsigned int, max_send)
644 __field(unsigned int, max_recv)
645 __array(unsigned char, srcaddr, sizeof(struct sockaddr_in6))
646 __array(unsigned char, dstaddr, sizeof(struct sockaddr_in6))
647 ),
648
649 TP_fast_assign(
650 const struct rdma_cm_id *id = ep->re_id;
651
652 __entry->inline_send = ep->re_inline_send;
653 __entry->inline_recv = ep->re_inline_recv;
654 __entry->max_send = ep->re_max_inline_send;
655 __entry->max_recv = ep->re_max_inline_recv;
656 memcpy(__entry->srcaddr, &id->route.addr.src_addr,
657 sizeof(struct sockaddr_in6));
658 memcpy(__entry->dstaddr, &id->route.addr.dst_addr,
659 sizeof(struct sockaddr_in6));
660 ),
661
662 TP_printk("%pISpc -> %pISpc neg send/recv=%u/%u, calc send/recv=%u/%u",
663 __entry->srcaddr, __entry->dstaddr,
664 __entry->inline_send, __entry->inline_recv,
665 __entry->max_send, __entry->max_recv
666 )
667);
668
669DEFINE_CONN_EVENT(connect);
670DEFINE_CONN_EVENT(disconnect);
671
672DEFINE_RXPRT_EVENT(xprtrdma_op_inject_dsc);
673
674TRACE_EVENT(xprtrdma_op_connect,
675 TP_PROTO(
676 const struct rpcrdma_xprt *r_xprt,
677 unsigned long delay
678 ),
679
680 TP_ARGS(r_xprt, delay),
681
682 TP_STRUCT__entry(
683 __field(unsigned long, delay)
684 __string(addr, rpcrdma_addrstr(r_xprt))
685 __string(port, rpcrdma_portstr(r_xprt))
686 ),
687
688 TP_fast_assign(
689 __entry->delay = delay;
690 __assign_str(addr, rpcrdma_addrstr(r_xprt));
691 __assign_str(port, rpcrdma_portstr(r_xprt));
692 ),
693
694 TP_printk("peer=[%s]:%s delay=%lu",
695 __get_str(addr), __get_str(port), __entry->delay
696 )
697);
698
699
700TRACE_EVENT(xprtrdma_op_set_cto,
701 TP_PROTO(
702 const struct rpcrdma_xprt *r_xprt,
703 unsigned long connect,
704 unsigned long reconnect
705 ),
706
707 TP_ARGS(r_xprt, connect, reconnect),
708
709 TP_STRUCT__entry(
710 __field(unsigned long, connect)
711 __field(unsigned long, reconnect)
712 __string(addr, rpcrdma_addrstr(r_xprt))
713 __string(port, rpcrdma_portstr(r_xprt))
714 ),
715
716 TP_fast_assign(
717 __entry->connect = connect;
718 __entry->reconnect = reconnect;
719 __assign_str(addr, rpcrdma_addrstr(r_xprt));
720 __assign_str(port, rpcrdma_portstr(r_xprt));
721 ),
722
723 TP_printk("peer=[%s]:%s connect=%lu reconnect=%lu",
724 __get_str(addr), __get_str(port),
725 __entry->connect / HZ, __entry->reconnect / HZ
726 )
727);
728
729/**
730 ** Call events
731 **/
732
733TRACE_EVENT(xprtrdma_createmrs,
734 TP_PROTO(
735 const struct rpcrdma_xprt *r_xprt,
736 unsigned int count
737 ),
738
739 TP_ARGS(r_xprt, count),
740
741 TP_STRUCT__entry(
742 __string(addr, rpcrdma_addrstr(r_xprt))
743 __string(port, rpcrdma_portstr(r_xprt))
744 __field(unsigned int, count)
745 ),
746
747 TP_fast_assign(
748 __entry->count = count;
749 __assign_str(addr, rpcrdma_addrstr(r_xprt));
750 __assign_str(port, rpcrdma_portstr(r_xprt));
751 ),
752
753 TP_printk("peer=[%s]:%s created %u MRs",
754 __get_str(addr), __get_str(port), __entry->count
755 )
756);
757
758TRACE_EVENT(xprtrdma_nomrs_err,
759 TP_PROTO(
760 const struct rpcrdma_xprt *r_xprt,
761 const struct rpcrdma_req *req
762 ),
763
764 TP_ARGS(r_xprt, req),
765
766 TP_STRUCT__entry(
767 __field(unsigned int, task_id)
768 __field(unsigned int, client_id)
769 __string(addr, rpcrdma_addrstr(r_xprt))
770 __string(port, rpcrdma_portstr(r_xprt))
771 ),
772
773 TP_fast_assign(
774 const struct rpc_rqst *rqst = &req->rl_slot;
775
776 __entry->task_id = rqst->rq_task->tk_pid;
777 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
778 __assign_str(addr, rpcrdma_addrstr(r_xprt));
779 __assign_str(port, rpcrdma_portstr(r_xprt));
780 ),
781
782 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " peer=[%s]:%s",
783 __entry->task_id, __entry->client_id,
784 __get_str(addr), __get_str(port)
785 )
786);
787
788DEFINE_RDCH_EVENT(read);
789DEFINE_WRCH_EVENT(write);
790DEFINE_WRCH_EVENT(reply);
791DEFINE_WRCH_EVENT(wp);
792
793TRACE_DEFINE_ENUM(rpcrdma_noch);
794TRACE_DEFINE_ENUM(rpcrdma_noch_pullup);
795TRACE_DEFINE_ENUM(rpcrdma_noch_mapped);
796TRACE_DEFINE_ENUM(rpcrdma_readch);
797TRACE_DEFINE_ENUM(rpcrdma_areadch);
798TRACE_DEFINE_ENUM(rpcrdma_writech);
799TRACE_DEFINE_ENUM(rpcrdma_replych);
800
801#define xprtrdma_show_chunktype(x) \
802 __print_symbolic(x, \
803 { rpcrdma_noch, "inline" }, \
804 { rpcrdma_noch_pullup, "pullup" }, \
805 { rpcrdma_noch_mapped, "mapped" }, \
806 { rpcrdma_readch, "read list" }, \
807 { rpcrdma_areadch, "*read list" }, \
808 { rpcrdma_writech, "write list" }, \
809 { rpcrdma_replych, "reply chunk" })
810
811TRACE_EVENT(xprtrdma_marshal,
812 TP_PROTO(
813 const struct rpcrdma_req *req,
814 unsigned int rtype,
815 unsigned int wtype
816 ),
817
818 TP_ARGS(req, rtype, wtype),
819
820 TP_STRUCT__entry(
821 __field(unsigned int, task_id)
822 __field(unsigned int, client_id)
823 __field(u32, xid)
824 __field(unsigned int, hdrlen)
825 __field(unsigned int, headlen)
826 __field(unsigned int, pagelen)
827 __field(unsigned int, taillen)
828 __field(unsigned int, rtype)
829 __field(unsigned int, wtype)
830 ),
831
832 TP_fast_assign(
833 const struct rpc_rqst *rqst = &req->rl_slot;
834
835 __entry->task_id = rqst->rq_task->tk_pid;
836 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
837 __entry->xid = be32_to_cpu(rqst->rq_xid);
838 __entry->hdrlen = req->rl_hdrbuf.len;
839 __entry->headlen = rqst->rq_snd_buf.head[0].iov_len;
840 __entry->pagelen = rqst->rq_snd_buf.page_len;
841 __entry->taillen = rqst->rq_snd_buf.tail[0].iov_len;
842 __entry->rtype = rtype;
843 __entry->wtype = wtype;
844 ),
845
846 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
847 " xid=0x%08x hdr=%u xdr=%u/%u/%u %s/%s",
848 __entry->task_id, __entry->client_id, __entry->xid,
849 __entry->hdrlen,
850 __entry->headlen, __entry->pagelen, __entry->taillen,
851 xprtrdma_show_chunktype(__entry->rtype),
852 xprtrdma_show_chunktype(__entry->wtype)
853 )
854);
855
856TRACE_EVENT(xprtrdma_marshal_failed,
857 TP_PROTO(const struct rpc_rqst *rqst,
858 int ret
859 ),
860
861 TP_ARGS(rqst, ret),
862
863 TP_STRUCT__entry(
864 __field(unsigned int, task_id)
865 __field(unsigned int, client_id)
866 __field(u32, xid)
867 __field(int, ret)
868 ),
869
870 TP_fast_assign(
871 __entry->task_id = rqst->rq_task->tk_pid;
872 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
873 __entry->xid = be32_to_cpu(rqst->rq_xid);
874 __entry->ret = ret;
875 ),
876
877 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x ret=%d",
878 __entry->task_id, __entry->client_id, __entry->xid,
879 __entry->ret
880 )
881);
882
883TRACE_EVENT(xprtrdma_prepsend_failed,
884 TP_PROTO(const struct rpc_rqst *rqst,
885 int ret
886 ),
887
888 TP_ARGS(rqst, ret),
889
890 TP_STRUCT__entry(
891 __field(unsigned int, task_id)
892 __field(unsigned int, client_id)
893 __field(u32, xid)
894 __field(int, ret)
895 ),
896
897 TP_fast_assign(
898 __entry->task_id = rqst->rq_task->tk_pid;
899 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
900 __entry->xid = be32_to_cpu(rqst->rq_xid);
901 __entry->ret = ret;
902 ),
903
904 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x ret=%d",
905 __entry->task_id, __entry->client_id, __entry->xid,
906 __entry->ret
907 )
908);
909
910TRACE_EVENT(xprtrdma_post_send,
911 TP_PROTO(
912 const struct rpcrdma_req *req
913 ),
914
915 TP_ARGS(req),
916
917 TP_STRUCT__entry(
918 __field(u32, cq_id)
919 __field(int, completion_id)
920 __field(unsigned int, task_id)
921 __field(unsigned int, client_id)
922 __field(int, num_sge)
923 __field(int, signaled)
924 ),
925
926 TP_fast_assign(
927 const struct rpc_rqst *rqst = &req->rl_slot;
928 const struct rpcrdma_sendctx *sc = req->rl_sendctx;
929
930 __entry->cq_id = sc->sc_cid.ci_queue_id;
931 __entry->completion_id = sc->sc_cid.ci_completion_id;
932 __entry->task_id = rqst->rq_task->tk_pid;
933 __entry->client_id = rqst->rq_task->tk_client ?
934 rqst->rq_task->tk_client->cl_clid : -1;
935 __entry->num_sge = req->rl_wr.num_sge;
936 __entry->signaled = req->rl_wr.send_flags & IB_SEND_SIGNALED;
937 ),
938
939 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " cq.id=%u cid=%d (%d SGE%s) %s",
940 __entry->task_id, __entry->client_id,
941 __entry->cq_id, __entry->completion_id,
942 __entry->num_sge, (__entry->num_sge == 1 ? "" : "s"),
943 (__entry->signaled ? "signaled" : "")
944 )
945);
946
947TRACE_EVENT(xprtrdma_post_send_err,
948 TP_PROTO(
949 const struct rpcrdma_xprt *r_xprt,
950 const struct rpcrdma_req *req,
951 int rc
952 ),
953
954 TP_ARGS(r_xprt, req, rc),
955
956 TP_STRUCT__entry(
957 __field(u32, cq_id)
958 __field(unsigned int, task_id)
959 __field(unsigned int, client_id)
960 __field(int, rc)
961 ),
962
963 TP_fast_assign(
964 const struct rpc_rqst *rqst = &req->rl_slot;
965 const struct rpcrdma_ep *ep = r_xprt->rx_ep;
966
967 __entry->cq_id = ep ? ep->re_attr.recv_cq->res.id : 0;
968 __entry->task_id = rqst->rq_task->tk_pid;
969 __entry->client_id = rqst->rq_task->tk_client ?
970 rqst->rq_task->tk_client->cl_clid : -1;
971 __entry->rc = rc;
972 ),
973
974 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " cq.id=%u rc=%d",
975 __entry->task_id, __entry->client_id,
976 __entry->cq_id, __entry->rc
977 )
978);
979
980DEFINE_SIMPLE_CID_EVENT(xprtrdma_post_recv);
981
982TRACE_EVENT(xprtrdma_post_recvs,
983 TP_PROTO(
984 const struct rpcrdma_xprt *r_xprt,
985 unsigned int count
986 ),
987
988 TP_ARGS(r_xprt, count),
989
990 TP_STRUCT__entry(
991 __field(u32, cq_id)
992 __field(unsigned int, count)
993 __field(int, posted)
994 __string(addr, rpcrdma_addrstr(r_xprt))
995 __string(port, rpcrdma_portstr(r_xprt))
996 ),
997
998 TP_fast_assign(
999 const struct rpcrdma_ep *ep = r_xprt->rx_ep;
1000
1001 __entry->cq_id = ep->re_attr.recv_cq->res.id;
1002 __entry->count = count;
1003 __entry->posted = ep->re_receive_count;
1004 __assign_str(addr, rpcrdma_addrstr(r_xprt));
1005 __assign_str(port, rpcrdma_portstr(r_xprt));
1006 ),
1007
1008 TP_printk("peer=[%s]:%s cq.id=%d %u new recvs, %d active",
1009 __get_str(addr), __get_str(port), __entry->cq_id,
1010 __entry->count, __entry->posted
1011 )
1012);
1013
1014TRACE_EVENT(xprtrdma_post_recvs_err,
1015 TP_PROTO(
1016 const struct rpcrdma_xprt *r_xprt,
1017 int status
1018 ),
1019
1020 TP_ARGS(r_xprt, status),
1021
1022 TP_STRUCT__entry(
1023 __field(u32, cq_id)
1024 __field(int, status)
1025 __string(addr, rpcrdma_addrstr(r_xprt))
1026 __string(port, rpcrdma_portstr(r_xprt))
1027 ),
1028
1029 TP_fast_assign(
1030 const struct rpcrdma_ep *ep = r_xprt->rx_ep;
1031
1032 __entry->cq_id = ep->re_attr.recv_cq->res.id;
1033 __entry->status = status;
1034 __assign_str(addr, rpcrdma_addrstr(r_xprt));
1035 __assign_str(port, rpcrdma_portstr(r_xprt));
1036 ),
1037
1038 TP_printk("peer=[%s]:%s cq.id=%d rc=%d",
1039 __get_str(addr), __get_str(port), __entry->cq_id,
1040 __entry->status
1041 )
1042);
1043
1044TRACE_EVENT(xprtrdma_post_linv_err,
1045 TP_PROTO(
1046 const struct rpcrdma_req *req,
1047 int status
1048 ),
1049
1050 TP_ARGS(req, status),
1051
1052 TP_STRUCT__entry(
1053 __field(unsigned int, task_id)
1054 __field(unsigned int, client_id)
1055 __field(int, status)
1056 ),
1057
1058 TP_fast_assign(
1059 const struct rpc_task *task = req->rl_slot.rq_task;
1060
1061 __entry->task_id = task->tk_pid;
1062 __entry->client_id = task->tk_client->cl_clid;
1063 __entry->status = status;
1064 ),
1065
1066 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d",
1067 __entry->task_id, __entry->client_id, __entry->status
1068 )
1069);
1070
1071/**
1072 ** Completion events
1073 **/
1074
1075DEFINE_RECEIVE_COMPLETION_EVENT(xprtrdma_wc_receive);
1076
1077DEFINE_COMPLETION_EVENT(xprtrdma_wc_send);
1078DEFINE_MR_COMPLETION_EVENT(xprtrdma_wc_fastreg);
1079DEFINE_MR_COMPLETION_EVENT(xprtrdma_wc_li);
1080DEFINE_MR_COMPLETION_EVENT(xprtrdma_wc_li_wake);
1081DEFINE_MR_COMPLETION_EVENT(xprtrdma_wc_li_done);
1082
1083TRACE_EVENT(xprtrdma_frwr_alloc,
1084 TP_PROTO(
1085 const struct rpcrdma_mr *mr,
1086 int rc
1087 ),
1088
1089 TP_ARGS(mr, rc),
1090
1091 TP_STRUCT__entry(
1092 __field(u32, mr_id)
1093 __field(int, rc)
1094 ),
1095
1096 TP_fast_assign(
1097 __entry->mr_id = mr->mr_ibmr->res.id;
1098 __entry->rc = rc;
1099 ),
1100
1101 TP_printk("mr.id=%u: rc=%d",
1102 __entry->mr_id, __entry->rc
1103 )
1104);
1105
1106TRACE_EVENT(xprtrdma_frwr_dereg,
1107 TP_PROTO(
1108 const struct rpcrdma_mr *mr,
1109 int rc
1110 ),
1111
1112 TP_ARGS(mr, rc),
1113
1114 TP_STRUCT__entry(
1115 __field(u32, mr_id)
1116 __field(int, nents)
1117 __field(u32, handle)
1118 __field(u32, length)
1119 __field(u64, offset)
1120 __field(u32, dir)
1121 __field(int, rc)
1122 ),
1123
1124 TP_fast_assign(
1125 __entry->mr_id = mr->mr_ibmr->res.id;
1126 __entry->nents = mr->mr_nents;
1127 __entry->handle = mr->mr_handle;
1128 __entry->length = mr->mr_length;
1129 __entry->offset = mr->mr_offset;
1130 __entry->dir = mr->mr_dir;
1131 __entry->rc = rc;
1132 ),
1133
1134 TP_printk("mr.id=%u nents=%d %u@0x%016llx:0x%08x (%s): rc=%d",
1135 __entry->mr_id, __entry->nents, __entry->length,
1136 (unsigned long long)__entry->offset, __entry->handle,
1137 xprtrdma_show_direction(__entry->dir),
1138 __entry->rc
1139 )
1140);
1141
1142TRACE_EVENT(xprtrdma_frwr_sgerr,
1143 TP_PROTO(
1144 const struct rpcrdma_mr *mr,
1145 int sg_nents
1146 ),
1147
1148 TP_ARGS(mr, sg_nents),
1149
1150 TP_STRUCT__entry(
1151 __field(u32, mr_id)
1152 __field(u64, addr)
1153 __field(u32, dir)
1154 __field(int, nents)
1155 ),
1156
1157 TP_fast_assign(
1158 __entry->mr_id = mr->mr_ibmr->res.id;
1159 __entry->addr = mr->mr_sg->dma_address;
1160 __entry->dir = mr->mr_dir;
1161 __entry->nents = sg_nents;
1162 ),
1163
1164 TP_printk("mr.id=%u DMA addr=0x%llx (%s) sg_nents=%d",
1165 __entry->mr_id, __entry->addr,
1166 xprtrdma_show_direction(__entry->dir),
1167 __entry->nents
1168 )
1169);
1170
1171TRACE_EVENT(xprtrdma_frwr_maperr,
1172 TP_PROTO(
1173 const struct rpcrdma_mr *mr,
1174 int num_mapped
1175 ),
1176
1177 TP_ARGS(mr, num_mapped),
1178
1179 TP_STRUCT__entry(
1180 __field(u32, mr_id)
1181 __field(u64, addr)
1182 __field(u32, dir)
1183 __field(int, num_mapped)
1184 __field(int, nents)
1185 ),
1186
1187 TP_fast_assign(
1188 __entry->mr_id = mr->mr_ibmr->res.id;
1189 __entry->addr = mr->mr_sg->dma_address;
1190 __entry->dir = mr->mr_dir;
1191 __entry->num_mapped = num_mapped;
1192 __entry->nents = mr->mr_nents;
1193 ),
1194
1195 TP_printk("mr.id=%u DMA addr=0x%llx (%s) nents=%d of %d",
1196 __entry->mr_id, __entry->addr,
1197 xprtrdma_show_direction(__entry->dir),
1198 __entry->num_mapped, __entry->nents
1199 )
1200);
1201
1202DEFINE_MR_EVENT(fastreg);
1203DEFINE_MR_EVENT(localinv);
1204DEFINE_MR_EVENT(reminv);
1205DEFINE_MR_EVENT(map);
1206
1207DEFINE_ANON_MR_EVENT(unmap);
1208
1209TRACE_EVENT(xprtrdma_dma_maperr,
1210 TP_PROTO(
1211 u64 addr
1212 ),
1213
1214 TP_ARGS(addr),
1215
1216 TP_STRUCT__entry(
1217 __field(u64, addr)
1218 ),
1219
1220 TP_fast_assign(
1221 __entry->addr = addr;
1222 ),
1223
1224 TP_printk("dma addr=0x%llx\n", __entry->addr)
1225);
1226
1227/**
1228 ** Reply events
1229 **/
1230
1231TRACE_EVENT(xprtrdma_reply,
1232 TP_PROTO(
1233 const struct rpc_task *task,
1234 const struct rpcrdma_rep *rep,
1235 unsigned int credits
1236 ),
1237
1238 TP_ARGS(task, rep, credits),
1239
1240 TP_STRUCT__entry(
1241 __field(unsigned int, task_id)
1242 __field(unsigned int, client_id)
1243 __field(u32, xid)
1244 __field(unsigned int, credits)
1245 ),
1246
1247 TP_fast_assign(
1248 __entry->task_id = task->tk_pid;
1249 __entry->client_id = task->tk_client->cl_clid;
1250 __entry->xid = be32_to_cpu(rep->rr_xid);
1251 __entry->credits = credits;
1252 ),
1253
1254 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x credits=%u",
1255 __entry->task_id, __entry->client_id, __entry->xid,
1256 __entry->credits
1257 )
1258);
1259
1260DEFINE_REPLY_EVENT(vers);
1261DEFINE_REPLY_EVENT(rqst);
1262DEFINE_REPLY_EVENT(short);
1263DEFINE_REPLY_EVENT(hdr);
1264
1265TRACE_EVENT(xprtrdma_err_vers,
1266 TP_PROTO(
1267 const struct rpc_rqst *rqst,
1268 __be32 *min,
1269 __be32 *max
1270 ),
1271
1272 TP_ARGS(rqst, min, max),
1273
1274 TP_STRUCT__entry(
1275 __field(unsigned int, task_id)
1276 __field(unsigned int, client_id)
1277 __field(u32, xid)
1278 __field(u32, min)
1279 __field(u32, max)
1280 ),
1281
1282 TP_fast_assign(
1283 __entry->task_id = rqst->rq_task->tk_pid;
1284 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
1285 __entry->xid = be32_to_cpu(rqst->rq_xid);
1286 __entry->min = be32_to_cpup(min);
1287 __entry->max = be32_to_cpup(max);
1288 ),
1289
1290 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x versions=[%u, %u]",
1291 __entry->task_id, __entry->client_id, __entry->xid,
1292 __entry->min, __entry->max
1293 )
1294);
1295
1296TRACE_EVENT(xprtrdma_err_chunk,
1297 TP_PROTO(
1298 const struct rpc_rqst *rqst
1299 ),
1300
1301 TP_ARGS(rqst),
1302
1303 TP_STRUCT__entry(
1304 __field(unsigned int, task_id)
1305 __field(unsigned int, client_id)
1306 __field(u32, xid)
1307 ),
1308
1309 TP_fast_assign(
1310 __entry->task_id = rqst->rq_task->tk_pid;
1311 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
1312 __entry->xid = be32_to_cpu(rqst->rq_xid);
1313 ),
1314
1315 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x",
1316 __entry->task_id, __entry->client_id, __entry->xid
1317 )
1318);
1319
1320TRACE_EVENT(xprtrdma_err_unrecognized,
1321 TP_PROTO(
1322 const struct rpc_rqst *rqst,
1323 __be32 *procedure
1324 ),
1325
1326 TP_ARGS(rqst, procedure),
1327
1328 TP_STRUCT__entry(
1329 __field(unsigned int, task_id)
1330 __field(unsigned int, client_id)
1331 __field(u32, xid)
1332 __field(u32, procedure)
1333 ),
1334
1335 TP_fast_assign(
1336 __entry->task_id = rqst->rq_task->tk_pid;
1337 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
1338 __entry->procedure = be32_to_cpup(procedure);
1339 ),
1340
1341 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x procedure=%u",
1342 __entry->task_id, __entry->client_id, __entry->xid,
1343 __entry->procedure
1344 )
1345);
1346
1347TRACE_EVENT(xprtrdma_fixup,
1348 TP_PROTO(
1349 const struct rpc_rqst *rqst,
1350 unsigned long fixup
1351 ),
1352
1353 TP_ARGS(rqst, fixup),
1354
1355 TP_STRUCT__entry(
1356 __field(unsigned int, task_id)
1357 __field(unsigned int, client_id)
1358 __field(unsigned long, fixup)
1359 __field(size_t, headlen)
1360 __field(unsigned int, pagelen)
1361 __field(size_t, taillen)
1362 ),
1363
1364 TP_fast_assign(
1365 __entry->task_id = rqst->rq_task->tk_pid;
1366 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
1367 __entry->fixup = fixup;
1368 __entry->headlen = rqst->rq_rcv_buf.head[0].iov_len;
1369 __entry->pagelen = rqst->rq_rcv_buf.page_len;
1370 __entry->taillen = rqst->rq_rcv_buf.tail[0].iov_len;
1371 ),
1372
1373 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " fixup=%lu xdr=%zu/%u/%zu",
1374 __entry->task_id, __entry->client_id, __entry->fixup,
1375 __entry->headlen, __entry->pagelen, __entry->taillen
1376 )
1377);
1378
1379TRACE_EVENT(xprtrdma_decode_seg,
1380 TP_PROTO(
1381 u32 handle,
1382 u32 length,
1383 u64 offset
1384 ),
1385
1386 TP_ARGS(handle, length, offset),
1387
1388 TP_STRUCT__entry(
1389 __field(u32, handle)
1390 __field(u32, length)
1391 __field(u64, offset)
1392 ),
1393
1394 TP_fast_assign(
1395 __entry->handle = handle;
1396 __entry->length = length;
1397 __entry->offset = offset;
1398 ),
1399
1400 TP_printk("%u@0x%016llx:0x%08x",
1401 __entry->length, (unsigned long long)__entry->offset,
1402 __entry->handle
1403 )
1404);
1405
1406TRACE_EVENT(xprtrdma_mrs_zap,
1407 TP_PROTO(
1408 const struct rpc_task *task
1409 ),
1410
1411 TP_ARGS(task),
1412
1413 TP_STRUCT__entry(
1414 __field(unsigned int, task_id)
1415 __field(unsigned int, client_id)
1416 ),
1417
1418 TP_fast_assign(
1419 __entry->task_id = task->tk_pid;
1420 __entry->client_id = task->tk_client->cl_clid;
1421 ),
1422
1423 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER,
1424 __entry->task_id, __entry->client_id
1425 )
1426);
1427
1428/**
1429 ** Callback events
1430 **/
1431
1432TRACE_EVENT(xprtrdma_cb_setup,
1433 TP_PROTO(
1434 const struct rpcrdma_xprt *r_xprt,
1435 unsigned int reqs
1436 ),
1437
1438 TP_ARGS(r_xprt, reqs),
1439
1440 TP_STRUCT__entry(
1441 __field(unsigned int, reqs)
1442 __string(addr, rpcrdma_addrstr(r_xprt))
1443 __string(port, rpcrdma_portstr(r_xprt))
1444 ),
1445
1446 TP_fast_assign(
1447 __entry->reqs = reqs;
1448 __assign_str(addr, rpcrdma_addrstr(r_xprt));
1449 __assign_str(port, rpcrdma_portstr(r_xprt));
1450 ),
1451
1452 TP_printk("peer=[%s]:%s %u reqs",
1453 __get_str(addr), __get_str(port), __entry->reqs
1454 )
1455);
1456
1457DEFINE_CALLBACK_EVENT(call);
1458DEFINE_CALLBACK_EVENT(reply);
1459
1460/**
1461 ** Server-side RPC/RDMA events
1462 **/
1463
1464DECLARE_EVENT_CLASS(svcrdma_accept_class,
1465 TP_PROTO(
1466 const struct svcxprt_rdma *rdma,
1467 long status
1468 ),
1469
1470 TP_ARGS(rdma, status),
1471
1472 TP_STRUCT__entry(
1473 __field(long, status)
1474 __string(addr, rdma->sc_xprt.xpt_remotebuf)
1475 ),
1476
1477 TP_fast_assign(
1478 __entry->status = status;
1479 __assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
1480 ),
1481
1482 TP_printk("addr=%s status=%ld",
1483 __get_str(addr), __entry->status
1484 )
1485);
1486
1487#define DEFINE_ACCEPT_EVENT(name) \
1488 DEFINE_EVENT(svcrdma_accept_class, svcrdma_##name##_err, \
1489 TP_PROTO( \
1490 const struct svcxprt_rdma *rdma, \
1491 long status \
1492 ), \
1493 TP_ARGS(rdma, status))
1494
1495DEFINE_ACCEPT_EVENT(pd);
1496DEFINE_ACCEPT_EVENT(qp);
1497DEFINE_ACCEPT_EVENT(fabric);
1498DEFINE_ACCEPT_EVENT(initdepth);
1499DEFINE_ACCEPT_EVENT(accept);
1500
1501TRACE_DEFINE_ENUM(RDMA_MSG);
1502TRACE_DEFINE_ENUM(RDMA_NOMSG);
1503TRACE_DEFINE_ENUM(RDMA_MSGP);
1504TRACE_DEFINE_ENUM(RDMA_DONE);
1505TRACE_DEFINE_ENUM(RDMA_ERROR);
1506
1507#define show_rpcrdma_proc(x) \
1508 __print_symbolic(x, \
1509 { RDMA_MSG, "RDMA_MSG" }, \
1510 { RDMA_NOMSG, "RDMA_NOMSG" }, \
1511 { RDMA_MSGP, "RDMA_MSGP" }, \
1512 { RDMA_DONE, "RDMA_DONE" }, \
1513 { RDMA_ERROR, "RDMA_ERROR" })
1514
1515TRACE_EVENT(svcrdma_decode_rqst,
1516 TP_PROTO(
1517 const struct svc_rdma_recv_ctxt *ctxt,
1518 __be32 *p,
1519 unsigned int hdrlen
1520 ),
1521
1522 TP_ARGS(ctxt, p, hdrlen),
1523
1524 TP_STRUCT__entry(
1525 __field(u32, cq_id)
1526 __field(int, completion_id)
1527 __field(u32, xid)
1528 __field(u32, vers)
1529 __field(u32, proc)
1530 __field(u32, credits)
1531 __field(unsigned int, hdrlen)
1532 ),
1533
1534 TP_fast_assign(
1535 __entry->cq_id = ctxt->rc_cid.ci_queue_id;
1536 __entry->completion_id = ctxt->rc_cid.ci_completion_id;
1537 __entry->xid = be32_to_cpup(p++);
1538 __entry->vers = be32_to_cpup(p++);
1539 __entry->credits = be32_to_cpup(p++);
1540 __entry->proc = be32_to_cpup(p);
1541 __entry->hdrlen = hdrlen;
1542 ),
1543
1544 TP_printk("cq.id=%u cid=%d xid=0x%08x vers=%u credits=%u proc=%s hdrlen=%u",
1545 __entry->cq_id, __entry->completion_id,
1546 __entry->xid, __entry->vers, __entry->credits,
1547 show_rpcrdma_proc(__entry->proc), __entry->hdrlen)
1548);
1549
1550TRACE_EVENT(svcrdma_decode_short_err,
1551 TP_PROTO(
1552 const struct svc_rdma_recv_ctxt *ctxt,
1553 unsigned int hdrlen
1554 ),
1555
1556 TP_ARGS(ctxt, hdrlen),
1557
1558 TP_STRUCT__entry(
1559 __field(u32, cq_id)
1560 __field(int, completion_id)
1561 __field(unsigned int, hdrlen)
1562 ),
1563
1564 TP_fast_assign(
1565 __entry->cq_id = ctxt->rc_cid.ci_queue_id;
1566 __entry->completion_id = ctxt->rc_cid.ci_completion_id;
1567 __entry->hdrlen = hdrlen;
1568 ),
1569
1570 TP_printk("cq.id=%u cid=%d hdrlen=%u",
1571 __entry->cq_id, __entry->completion_id,
1572 __entry->hdrlen)
1573);
1574
1575DECLARE_EVENT_CLASS(svcrdma_badreq_event,
1576 TP_PROTO(
1577 const struct svc_rdma_recv_ctxt *ctxt,
1578 __be32 *p
1579 ),
1580
1581 TP_ARGS(ctxt, p),
1582
1583 TP_STRUCT__entry(
1584 __field(u32, cq_id)
1585 __field(int, completion_id)
1586 __field(u32, xid)
1587 __field(u32, vers)
1588 __field(u32, proc)
1589 __field(u32, credits)
1590 ),
1591
1592 TP_fast_assign(
1593 __entry->cq_id = ctxt->rc_cid.ci_queue_id;
1594 __entry->completion_id = ctxt->rc_cid.ci_completion_id;
1595 __entry->xid = be32_to_cpup(p++);
1596 __entry->vers = be32_to_cpup(p++);
1597 __entry->credits = be32_to_cpup(p++);
1598 __entry->proc = be32_to_cpup(p);
1599 ),
1600
1601 TP_printk("cq.id=%u cid=%d xid=0x%08x vers=%u credits=%u proc=%u",
1602 __entry->cq_id, __entry->completion_id,
1603 __entry->xid, __entry->vers, __entry->credits, __entry->proc)
1604);
1605
1606#define DEFINE_BADREQ_EVENT(name) \
1607 DEFINE_EVENT(svcrdma_badreq_event, \
1608 svcrdma_decode_##name##_err, \
1609 TP_PROTO( \
1610 const struct svc_rdma_recv_ctxt *ctxt, \
1611 __be32 *p \
1612 ), \
1613 TP_ARGS(ctxt, p))
1614
1615DEFINE_BADREQ_EVENT(badvers);
1616DEFINE_BADREQ_EVENT(drop);
1617DEFINE_BADREQ_EVENT(badproc);
1618DEFINE_BADREQ_EVENT(parse);
1619
1620TRACE_EVENT(svcrdma_encode_wseg,
1621 TP_PROTO(
1622 const struct svc_rdma_send_ctxt *ctxt,
1623 u32 segno,
1624 u32 handle,
1625 u32 length,
1626 u64 offset
1627 ),
1628
1629 TP_ARGS(ctxt, segno, handle, length, offset),
1630
1631 TP_STRUCT__entry(
1632 __field(u32, cq_id)
1633 __field(int, completion_id)
1634 __field(u32, segno)
1635 __field(u32, handle)
1636 __field(u32, length)
1637 __field(u64, offset)
1638 ),
1639
1640 TP_fast_assign(
1641 __entry->cq_id = ctxt->sc_cid.ci_queue_id;
1642 __entry->completion_id = ctxt->sc_cid.ci_completion_id;
1643 __entry->segno = segno;
1644 __entry->handle = handle;
1645 __entry->length = length;
1646 __entry->offset = offset;
1647 ),
1648
1649 TP_printk("cq.id=%u cid=%d segno=%u %u@0x%016llx:0x%08x",
1650 __entry->cq_id, __entry->completion_id,
1651 __entry->segno, __entry->length,
1652 (unsigned long long)__entry->offset, __entry->handle
1653 )
1654);
1655
1656TRACE_EVENT(svcrdma_decode_rseg,
1657 TP_PROTO(
1658 const struct rpc_rdma_cid *cid,
1659 const struct svc_rdma_chunk *chunk,
1660 const struct svc_rdma_segment *segment
1661 ),
1662
1663 TP_ARGS(cid, chunk, segment),
1664
1665 TP_STRUCT__entry(
1666 __field(u32, cq_id)
1667 __field(int, completion_id)
1668 __field(u32, segno)
1669 __field(u32, position)
1670 __field(u32, handle)
1671 __field(u32, length)
1672 __field(u64, offset)
1673 ),
1674
1675 TP_fast_assign(
1676 __entry->cq_id = cid->ci_queue_id;
1677 __entry->completion_id = cid->ci_completion_id;
1678 __entry->segno = chunk->ch_segcount;
1679 __entry->position = chunk->ch_position;
1680 __entry->handle = segment->rs_handle;
1681 __entry->length = segment->rs_length;
1682 __entry->offset = segment->rs_offset;
1683 ),
1684
1685 TP_printk("cq.id=%u cid=%d segno=%u position=%u %u@0x%016llx:0x%08x",
1686 __entry->cq_id, __entry->completion_id,
1687 __entry->segno, __entry->position, __entry->length,
1688 (unsigned long long)__entry->offset, __entry->handle
1689 )
1690);
1691
1692TRACE_EVENT(svcrdma_decode_wseg,
1693 TP_PROTO(
1694 const struct rpc_rdma_cid *cid,
1695 const struct svc_rdma_chunk *chunk,
1696 u32 segno
1697 ),
1698
1699 TP_ARGS(cid, chunk, segno),
1700
1701 TP_STRUCT__entry(
1702 __field(u32, cq_id)
1703 __field(int, completion_id)
1704 __field(u32, segno)
1705 __field(u32, handle)
1706 __field(u32, length)
1707 __field(u64, offset)
1708 ),
1709
1710 TP_fast_assign(
1711 const struct svc_rdma_segment *segment =
1712 &chunk->ch_segments[segno];
1713
1714 __entry->cq_id = cid->ci_queue_id;
1715 __entry->completion_id = cid->ci_completion_id;
1716 __entry->segno = segno;
1717 __entry->handle = segment->rs_handle;
1718 __entry->length = segment->rs_length;
1719 __entry->offset = segment->rs_offset;
1720 ),
1721
1722 TP_printk("cq.id=%u cid=%d segno=%u %u@0x%016llx:0x%08x",
1723 __entry->cq_id, __entry->completion_id,
1724 __entry->segno, __entry->length,
1725 (unsigned long long)__entry->offset, __entry->handle
1726 )
1727);
1728
1729DECLARE_EVENT_CLASS(svcrdma_error_event,
1730 TP_PROTO(
1731 __be32 xid
1732 ),
1733
1734 TP_ARGS(xid),
1735
1736 TP_STRUCT__entry(
1737 __field(u32, xid)
1738 ),
1739
1740 TP_fast_assign(
1741 __entry->xid = be32_to_cpu(xid);
1742 ),
1743
1744 TP_printk("xid=0x%08x",
1745 __entry->xid
1746 )
1747);
1748
1749#define DEFINE_ERROR_EVENT(name) \
1750 DEFINE_EVENT(svcrdma_error_event, svcrdma_err_##name, \
1751 TP_PROTO( \
1752 __be32 xid \
1753 ), \
1754 TP_ARGS(xid))
1755
1756DEFINE_ERROR_EVENT(vers);
1757DEFINE_ERROR_EVENT(chunk);
1758
1759/**
1760 ** Server-side RDMA API events
1761 **/
1762
1763DECLARE_EVENT_CLASS(svcrdma_dma_map_class,
1764 TP_PROTO(
1765 const struct rpc_rdma_cid *cid,
1766 u64 dma_addr,
1767 u32 length
1768 ),
1769
1770 TP_ARGS(cid, dma_addr, length),
1771
1772 TP_STRUCT__entry(
1773 __field(u32, cq_id)
1774 __field(int, completion_id)
1775 __field(u64, dma_addr)
1776 __field(u32, length)
1777 ),
1778
1779 TP_fast_assign(
1780 __entry->cq_id = cid->ci_queue_id;
1781 __entry->completion_id = cid->ci_completion_id;
1782 __entry->dma_addr = dma_addr;
1783 __entry->length = length;
1784 ),
1785
1786 TP_printk("cq.id=%u cid=%d dma_addr=%llu length=%u",
1787 __entry->cq_id, __entry->completion_id,
1788 __entry->dma_addr, __entry->length
1789 )
1790);
1791
1792#define DEFINE_SVC_DMA_EVENT(name) \
1793 DEFINE_EVENT(svcrdma_dma_map_class, svcrdma_##name, \
1794 TP_PROTO( \
1795 const struct rpc_rdma_cid *cid, \
1796 u64 dma_addr, \
1797 u32 length \
1798 ), \
1799 TP_ARGS(cid, dma_addr, length) \
1800 )
1801
1802DEFINE_SVC_DMA_EVENT(dma_map_page);
1803DEFINE_SVC_DMA_EVENT(dma_map_err);
1804DEFINE_SVC_DMA_EVENT(dma_unmap_page);
1805
1806TRACE_EVENT(svcrdma_dma_map_rw_err,
1807 TP_PROTO(
1808 const struct svcxprt_rdma *rdma,
1809 u64 offset,
1810 u32 handle,
1811 unsigned int nents,
1812 int status
1813 ),
1814
1815 TP_ARGS(rdma, offset, handle, nents, status),
1816
1817 TP_STRUCT__entry(
1818 __field(u32, cq_id)
1819 __field(u32, handle)
1820 __field(u64, offset)
1821 __field(unsigned int, nents)
1822 __field(int, status)
1823 ),
1824
1825 TP_fast_assign(
1826 __entry->cq_id = rdma->sc_sq_cq->res.id;
1827 __entry->handle = handle;
1828 __entry->offset = offset;
1829 __entry->nents = nents;
1830 __entry->status = status;
1831 ),
1832
1833 TP_printk("cq.id=%u 0x%016llx:0x%08x nents=%u status=%d",
1834 __entry->cq_id, (unsigned long long)__entry->offset,
1835 __entry->handle, __entry->nents, __entry->status
1836 )
1837);
1838
1839TRACE_EVENT(svcrdma_rwctx_empty,
1840 TP_PROTO(
1841 const struct svcxprt_rdma *rdma,
1842 unsigned int num_sges
1843 ),
1844
1845 TP_ARGS(rdma, num_sges),
1846
1847 TP_STRUCT__entry(
1848 __field(u32, cq_id)
1849 __field(unsigned int, num_sges)
1850 ),
1851
1852 TP_fast_assign(
1853 __entry->cq_id = rdma->sc_sq_cq->res.id;
1854 __entry->num_sges = num_sges;
1855 ),
1856
1857 TP_printk("cq.id=%u num_sges=%d",
1858 __entry->cq_id, __entry->num_sges
1859 )
1860);
1861
1862TRACE_EVENT(svcrdma_page_overrun_err,
1863 TP_PROTO(
1864 const struct rpc_rdma_cid *cid,
1865 unsigned int pageno
1866 ),
1867
1868 TP_ARGS(cid, pageno),
1869
1870 TP_STRUCT__entry(
1871 __field(u32, cq_id)
1872 __field(int, completion_id)
1873 __field(unsigned int, pageno)
1874 ),
1875
1876 TP_fast_assign(
1877 __entry->cq_id = cid->ci_queue_id;
1878 __entry->completion_id = cid->ci_completion_id;
1879 __entry->pageno = pageno;
1880 ),
1881
1882 TP_printk("cq.id=%u cid=%d pageno=%u",
1883 __entry->cq_id, __entry->completion_id,
1884 __entry->pageno
1885 )
1886);
1887
1888TRACE_EVENT(svcrdma_small_wrch_err,
1889 TP_PROTO(
1890 const struct rpc_rdma_cid *cid,
1891 unsigned int remaining,
1892 unsigned int seg_no,
1893 unsigned int num_segs
1894 ),
1895
1896 TP_ARGS(cid, remaining, seg_no, num_segs),
1897
1898 TP_STRUCT__entry(
1899 __field(u32, cq_id)
1900 __field(int, completion_id)
1901 __field(unsigned int, remaining)
1902 __field(unsigned int, seg_no)
1903 __field(unsigned int, num_segs)
1904 ),
1905
1906 TP_fast_assign(
1907 __entry->cq_id = cid->ci_queue_id;
1908 __entry->completion_id = cid->ci_completion_id;
1909 __entry->remaining = remaining;
1910 __entry->seg_no = seg_no;
1911 __entry->num_segs = num_segs;
1912 ),
1913
1914 TP_printk("cq.id=%u cid=%d remaining=%u seg_no=%u num_segs=%u",
1915 __entry->cq_id, __entry->completion_id,
1916 __entry->remaining, __entry->seg_no, __entry->num_segs
1917 )
1918);
1919
1920TRACE_EVENT(svcrdma_send_pullup,
1921 TP_PROTO(
1922 const struct svc_rdma_send_ctxt *ctxt,
1923 unsigned int msglen
1924 ),
1925
1926 TP_ARGS(ctxt, msglen),
1927
1928 TP_STRUCT__entry(
1929 __field(u32, cq_id)
1930 __field(int, completion_id)
1931 __field(unsigned int, hdrlen)
1932 __field(unsigned int, msglen)
1933 ),
1934
1935 TP_fast_assign(
1936 __entry->cq_id = ctxt->sc_cid.ci_queue_id;
1937 __entry->completion_id = ctxt->sc_cid.ci_completion_id;
1938 __entry->hdrlen = ctxt->sc_hdrbuf.len,
1939 __entry->msglen = msglen;
1940 ),
1941
1942 TP_printk("cq.id=%u cid=%d hdr=%u msg=%u (total %u)",
1943 __entry->cq_id, __entry->completion_id,
1944 __entry->hdrlen, __entry->msglen,
1945 __entry->hdrlen + __entry->msglen)
1946);
1947
1948TRACE_EVENT(svcrdma_send_err,
1949 TP_PROTO(
1950 const struct svc_rqst *rqst,
1951 int status
1952 ),
1953
1954 TP_ARGS(rqst, status),
1955
1956 TP_STRUCT__entry(
1957 __field(int, status)
1958 __field(u32, xid)
1959 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1960 ),
1961
1962 TP_fast_assign(
1963 __entry->status = status;
1964 __entry->xid = __be32_to_cpu(rqst->rq_xid);
1965 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1966 ),
1967
1968 TP_printk("addr=%s xid=0x%08x status=%d", __get_str(addr),
1969 __entry->xid, __entry->status
1970 )
1971);
1972
1973TRACE_EVENT(svcrdma_post_send,
1974 TP_PROTO(
1975 const struct svc_rdma_send_ctxt *ctxt
1976 ),
1977
1978 TP_ARGS(ctxt),
1979
1980 TP_STRUCT__entry(
1981 __field(u32, cq_id)
1982 __field(int, completion_id)
1983 __field(unsigned int, num_sge)
1984 __field(u32, inv_rkey)
1985 ),
1986
1987 TP_fast_assign(
1988 const struct ib_send_wr *wr = &ctxt->sc_send_wr;
1989
1990 __entry->cq_id = ctxt->sc_cid.ci_queue_id;
1991 __entry->completion_id = ctxt->sc_cid.ci_completion_id;
1992 __entry->num_sge = wr->num_sge;
1993 __entry->inv_rkey = (wr->opcode == IB_WR_SEND_WITH_INV) ?
1994 wr->ex.invalidate_rkey : 0;
1995 ),
1996
1997 TP_printk("cq.id=%u cid=%d num_sge=%u inv_rkey=0x%08x",
1998 __entry->cq_id, __entry->completion_id,
1999 __entry->num_sge, __entry->inv_rkey
2000 )
2001);
2002
2003DEFINE_SIMPLE_CID_EVENT(svcrdma_wc_send);
2004DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_send_flush);
2005DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_send_err);
2006
2007DEFINE_SIMPLE_CID_EVENT(svcrdma_post_recv);
2008
2009DEFINE_RECEIVE_SUCCESS_EVENT(svcrdma_wc_recv);
2010DEFINE_RECEIVE_FLUSH_EVENT(svcrdma_wc_recv_flush);
2011DEFINE_RECEIVE_FLUSH_EVENT(svcrdma_wc_recv_err);
2012
2013TRACE_EVENT(svcrdma_rq_post_err,
2014 TP_PROTO(
2015 const struct svcxprt_rdma *rdma,
2016 int status
2017 ),
2018
2019 TP_ARGS(rdma, status),
2020
2021 TP_STRUCT__entry(
2022 __field(int, status)
2023 __string(addr, rdma->sc_xprt.xpt_remotebuf)
2024 ),
2025
2026 TP_fast_assign(
2027 __entry->status = status;
2028 __assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
2029 ),
2030
2031 TP_printk("addr=%s status=%d",
2032 __get_str(addr), __entry->status
2033 )
2034);
2035
2036DECLARE_EVENT_CLASS(svcrdma_post_chunk_class,
2037 TP_PROTO(
2038 const struct rpc_rdma_cid *cid,
2039 int sqecount
2040 ),
2041
2042 TP_ARGS(cid, sqecount),
2043
2044 TP_STRUCT__entry(
2045 __field(u32, cq_id)
2046 __field(int, completion_id)
2047 __field(int, sqecount)
2048 ),
2049
2050 TP_fast_assign(
2051 __entry->cq_id = cid->ci_queue_id;
2052 __entry->completion_id = cid->ci_completion_id;
2053 __entry->sqecount = sqecount;
2054 ),
2055
2056 TP_printk("cq.id=%u cid=%d sqecount=%d",
2057 __entry->cq_id, __entry->completion_id,
2058 __entry->sqecount
2059 )
2060);
2061
2062#define DEFINE_POST_CHUNK_EVENT(name) \
2063 DEFINE_EVENT(svcrdma_post_chunk_class, \
2064 svcrdma_post_##name##_chunk, \
2065 TP_PROTO( \
2066 const struct rpc_rdma_cid *cid, \
2067 int sqecount \
2068 ), \
2069 TP_ARGS(cid, sqecount))
2070
2071DEFINE_POST_CHUNK_EVENT(read);
2072DEFINE_POST_CHUNK_EVENT(write);
2073DEFINE_POST_CHUNK_EVENT(reply);
2074
2075DEFINE_EVENT(svcrdma_post_chunk_class, svcrdma_cc_release,
2076 TP_PROTO(
2077 const struct rpc_rdma_cid *cid,
2078 int sqecount
2079 ),
2080 TP_ARGS(cid, sqecount)
2081);
2082
2083TRACE_EVENT(svcrdma_wc_read,
2084 TP_PROTO(
2085 const struct ib_wc *wc,
2086 const struct rpc_rdma_cid *cid,
2087 unsigned int totalbytes,
2088 const ktime_t posttime
2089 ),
2090
2091 TP_ARGS(wc, cid, totalbytes, posttime),
2092
2093 TP_STRUCT__entry(
2094 __field(u32, cq_id)
2095 __field(int, completion_id)
2096 __field(s64, read_latency)
2097 __field(unsigned int, totalbytes)
2098 ),
2099
2100 TP_fast_assign(
2101 __entry->cq_id = cid->ci_queue_id;
2102 __entry->completion_id = cid->ci_completion_id;
2103 __entry->totalbytes = totalbytes;
2104 __entry->read_latency = ktime_us_delta(ktime_get(), posttime);
2105 ),
2106
2107 TP_printk("cq.id=%u cid=%d totalbytes=%u latency-us=%lld",
2108 __entry->cq_id, __entry->completion_id,
2109 __entry->totalbytes, __entry->read_latency
2110 )
2111);
2112
2113DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_read_flush);
2114DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_read_err);
2115DEFINE_SIMPLE_CID_EVENT(svcrdma_read_finished);
2116
2117DEFINE_SIMPLE_CID_EVENT(svcrdma_wc_write);
2118DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_write_flush);
2119DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_write_err);
2120
2121TRACE_EVENT(svcrdma_qp_error,
2122 TP_PROTO(
2123 const struct ib_event *event,
2124 const struct sockaddr *sap
2125 ),
2126
2127 TP_ARGS(event, sap),
2128
2129 TP_STRUCT__entry(
2130 __field(unsigned int, event)
2131 __string(device, event->device->name)
2132 __array(__u8, addr, INET6_ADDRSTRLEN + 10)
2133 ),
2134
2135 TP_fast_assign(
2136 __entry->event = event->event;
2137 __assign_str(device, event->device->name);
2138 snprintf(__entry->addr, sizeof(__entry->addr) - 1,
2139 "%pISpc", sap);
2140 ),
2141
2142 TP_printk("addr=%s dev=%s event=%s (%u)",
2143 __entry->addr, __get_str(device),
2144 rdma_show_ib_event(__entry->event), __entry->event
2145 )
2146);
2147
2148DECLARE_EVENT_CLASS(svcrdma_sendqueue_class,
2149 TP_PROTO(
2150 const struct svcxprt_rdma *rdma,
2151 const struct rpc_rdma_cid *cid
2152 ),
2153
2154 TP_ARGS(rdma, cid),
2155
2156 TP_STRUCT__entry(
2157 __field(u32, cq_id)
2158 __field(int, completion_id)
2159 __field(int, avail)
2160 __field(int, depth)
2161 ),
2162
2163 TP_fast_assign(
2164 __entry->cq_id = cid->ci_queue_id;
2165 __entry->completion_id = cid->ci_completion_id;
2166 __entry->avail = atomic_read(&rdma->sc_sq_avail);
2167 __entry->depth = rdma->sc_sq_depth;
2168 ),
2169
2170 TP_printk("cq.id=%u cid=%d sc_sq_avail=%d/%d",
2171 __entry->cq_id, __entry->completion_id,
2172 __entry->avail, __entry->depth
2173 )
2174);
2175
2176#define DEFINE_SQ_EVENT(name) \
2177 DEFINE_EVENT(svcrdma_sendqueue_class, name, \
2178 TP_PROTO( \
2179 const struct svcxprt_rdma *rdma, \
2180 const struct rpc_rdma_cid *cid \
2181 ), \
2182 TP_ARGS(rdma, cid) \
2183 )
2184
2185DEFINE_SQ_EVENT(svcrdma_sq_full);
2186DEFINE_SQ_EVENT(svcrdma_sq_retry);
2187
2188TRACE_EVENT(svcrdma_sq_post_err,
2189 TP_PROTO(
2190 const struct svcxprt_rdma *rdma,
2191 const struct rpc_rdma_cid *cid,
2192 int status
2193 ),
2194
2195 TP_ARGS(rdma, cid, status),
2196
2197 TP_STRUCT__entry(
2198 __field(u32, cq_id)
2199 __field(int, completion_id)
2200 __field(int, avail)
2201 __field(int, depth)
2202 __field(int, status)
2203 ),
2204
2205 TP_fast_assign(
2206 __entry->cq_id = cid->ci_queue_id;
2207 __entry->completion_id = cid->ci_completion_id;
2208 __entry->avail = atomic_read(&rdma->sc_sq_avail);
2209 __entry->depth = rdma->sc_sq_depth;
2210 __entry->status = status;
2211 ),
2212
2213 TP_printk("cq.id=%u cid=%d sc_sq_avail=%d/%d status=%d",
2214 __entry->cq_id, __entry->completion_id,
2215 __entry->avail, __entry->depth, __entry->status
2216 )
2217);
2218
2219#endif /* _TRACE_RPCRDMA_H */
2220
2221#include <trace/define_trace.h>