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