include/trace/events/rpcrdma.h

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