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/tracepoint.h>
  14 #include <trace/events/rdma.h>
  15
  16 /**
  17  ** Event classes
  18  **/
  19
  20 DECLARE_EVENT_CLASS(xprtrdma_reply_event,
  21         TP_PROTO(
  22                 const struct rpcrdma_rep *rep
  23         ),
  24
  25         TP_ARGS(rep),
  26
  27         TP_STRUCT__entry(
  28                 __field(const void *, rep)
  29                 __field(const void *, r_xprt)
  30                 __field(u32, xid)
  31                 __field(u32, version)
  32                 __field(u32, proc)
  33         ),
  34
  35         TP_fast_assign(
  36                 __entry->rep = rep;
  37                 __entry->r_xprt = rep->rr_rxprt;
  38                 __entry->xid = be32_to_cpu(rep->rr_xid);
  39                 __entry->version = be32_to_cpu(rep->rr_vers);
  40                 __entry->proc = be32_to_cpu(rep->rr_proc);
  41         ),
  42
  43         TP_printk("rxprt %p xid=0x%08x rep=%p: version %u proc %u",
  44                 __entry->r_xprt, __entry->xid, __entry->rep,
  45                 __entry->version, __entry->proc
  46         )
  47 );
  48
  49 #define DEFINE_REPLY_EVENT(name)                                        \
  50                 DEFINE_EVENT(xprtrdma_reply_event, name,                \
  51                                 TP_PROTO(                               \
  52                                         const struct rpcrdma_rep *rep   \
  53                                 ),                                      \
  54                                 TP_ARGS(rep))
  55
  56 DECLARE_EVENT_CLASS(xprtrdma_rxprt,
  57         TP_PROTO(
  58                 const struct rpcrdma_xprt *r_xprt
  59         ),
  60
  61         TP_ARGS(r_xprt),
  62
  63         TP_STRUCT__entry(
  64                 __field(const void *, r_xprt)
  65                 __string(addr, rpcrdma_addrstr(r_xprt))
  66                 __string(port, rpcrdma_portstr(r_xprt))
  67         ),
  68
  69         TP_fast_assign(
  70                 __entry->r_xprt = r_xprt;
  71                 __assign_str(addr, rpcrdma_addrstr(r_xprt));
  72                 __assign_str(port, rpcrdma_portstr(r_xprt));
  73         ),
  74
  75         TP_printk("peer=[%s]:%s r_xprt=%p",
  76                 __get_str(addr), __get_str(port), __entry->r_xprt
  77         )
  78 );
  79
  80 #define DEFINE_RXPRT_EVENT(name)                                        \
  81                 DEFINE_EVENT(xprtrdma_rxprt, name,                      \
  82                                 TP_PROTO(                               \
  83                                         const struct rpcrdma_xprt *r_xprt \
  84                                 ),                                      \
  85                                 TP_ARGS(r_xprt))
  86
  87 DECLARE_EVENT_CLASS(xprtrdma_rdch_event,
  88         TP_PROTO(
  89                 const struct rpc_task *task,
  90                 unsigned int pos,
  91                 struct rpcrdma_mr *mr,
  92                 int nsegs
  93         ),
  94
  95         TP_ARGS(task, pos, mr, nsegs),
  96
  97         TP_STRUCT__entry(
  98                 __field(unsigned int, task_id)
  99                 __field(unsigned int, client_id)
 100                 __field(unsigned int, pos)
 101                 __field(int, nents)
 102                 __field(u32, handle)
 103                 __field(u32, length)
 104                 __field(u64, offset)
 105                 __field(int, nsegs)
 106         ),
 107
 108         TP_fast_assign(
 109                 __entry->task_id = task->tk_pid;
 110                 __entry->client_id = task->tk_client->cl_clid;
 111                 __entry->pos = pos;
 112                 __entry->nents = mr->mr_nents;
 113                 __entry->handle = mr->mr_handle;
 114                 __entry->length = mr->mr_length;
 115                 __entry->offset = mr->mr_offset;
 116                 __entry->nsegs = nsegs;
 117         ),
 118
 119         TP_printk("task:%u@%u pos=%u %u@0x%016llx:0x%08x (%s)",
 120                 __entry->task_id, __entry->client_id,
 121                 __entry->pos, __entry->length,
 122                 (unsigned long long)__entry->offset, __entry->handle,
 123                 __entry->nents < __entry->nsegs ? "more" : "last"
 124         )
 125 );
 126
 127 #define DEFINE_RDCH_EVENT(name)                                         \
 128                 DEFINE_EVENT(xprtrdma_rdch_event, xprtrdma_chunk_##name,\
 129                                 TP_PROTO(                               \
 130                                         const struct rpc_task *task,    \
 131                                         unsigned int pos,               \
 132                                         struct rpcrdma_mr *mr,          \
 133                                         int nsegs                       \
 134                                 ),                                      \
 135                                 TP_ARGS(task, pos, mr, nsegs))
 136
 137 DECLARE_EVENT_CLASS(xprtrdma_wrch_event,
 138         TP_PROTO(
 139                 const struct rpc_task *task,
 140                 struct rpcrdma_mr *mr,
 141                 int nsegs
 142         ),
 143
 144         TP_ARGS(task, mr, nsegs),
 145
 146         TP_STRUCT__entry(
 147                 __field(unsigned int, task_id)
 148                 __field(unsigned int, client_id)
 149                 __field(int, nents)
 150                 __field(u32, handle)
 151                 __field(u32, length)
 152                 __field(u64, offset)
 153                 __field(int, nsegs)
 154         ),
 155
 156         TP_fast_assign(
 157                 __entry->task_id = task->tk_pid;
 158                 __entry->client_id = task->tk_client->cl_clid;
 159                 __entry->nents = mr->mr_nents;
 160                 __entry->handle = mr->mr_handle;
 161                 __entry->length = mr->mr_length;
 162                 __entry->offset = mr->mr_offset;
 163                 __entry->nsegs = nsegs;
 164         ),
 165
 166         TP_printk("task:%u@%u %u@0x%016llx:0x%08x (%s)",
 167                 __entry->task_id, __entry->client_id,
 168                 __entry->length, (unsigned long long)__entry->offset,
 169                 __entry->handle,
 170                 __entry->nents < __entry->nsegs ? "more" : "last"
 171         )
 172 );
 173
 174 #define DEFINE_WRCH_EVENT(name)                                         \
 175                 DEFINE_EVENT(xprtrdma_wrch_event, xprtrdma_chunk_##name,\
 176                                 TP_PROTO(                               \
 177                                         const struct rpc_task *task,    \
 178                                         struct rpcrdma_mr *mr,          \
 179                                         int nsegs                       \
 180                                 ),                                      \
 181                                 TP_ARGS(task, mr, nsegs))
 182
 183 TRACE_DEFINE_ENUM(FRWR_IS_INVALID);
 184 TRACE_DEFINE_ENUM(FRWR_IS_VALID);
 185 TRACE_DEFINE_ENUM(FRWR_FLUSHED_FR);
 186 TRACE_DEFINE_ENUM(FRWR_FLUSHED_LI);
 187
 188 #define xprtrdma_show_frwr_state(x)                                     \
 189                 __print_symbolic(x,                                     \
 190                                 { FRWR_IS_INVALID, "INVALID" },         \
 191                                 { FRWR_IS_VALID, "VALID" },             \
 192                                 { FRWR_FLUSHED_FR, "FLUSHED_FR" },      \
 193                                 { FRWR_FLUSHED_LI, "FLUSHED_LI" })
 194
 195 DECLARE_EVENT_CLASS(xprtrdma_frwr_done,
 196         TP_PROTO(
 197                 const struct ib_wc *wc,
 198                 const struct rpcrdma_frwr *frwr
 199         ),
 200
 201         TP_ARGS(wc, frwr),
 202
 203         TP_STRUCT__entry(
 204                 __field(const void *, mr)
 205                 __field(unsigned int, state)
 206                 __field(unsigned int, status)
 207                 __field(unsigned int, vendor_err)
 208         ),
 209
 210         TP_fast_assign(
 211                 __entry->mr = container_of(frwr, struct rpcrdma_mr, frwr);
 212                 __entry->state = frwr->fr_state;
 213                 __entry->status = wc->status;
 214                 __entry->vendor_err = __entry->status ? wc->vendor_err : 0;
 215         ),
 216
 217         TP_printk(
 218                 "mr=%p state=%s: %s (%u/0x%x)",
 219                 __entry->mr, xprtrdma_show_frwr_state(__entry->state),
 220                 rdma_show_wc_status(__entry->status),
 221                 __entry->status, __entry->vendor_err
 222         )
 223 );
 224
 225 #define DEFINE_FRWR_DONE_EVENT(name)                                    \
 226                 DEFINE_EVENT(xprtrdma_frwr_done, name,                  \
 227                                 TP_PROTO(                               \
 228                                         const struct ib_wc *wc,         \
 229                                         const struct rpcrdma_frwr *frwr \
 230                                 ),                                      \
 231                                 TP_ARGS(wc, frwr))
 232
 233 TRACE_DEFINE_ENUM(DMA_BIDIRECTIONAL);
 234 TRACE_DEFINE_ENUM(DMA_TO_DEVICE);
 235 TRACE_DEFINE_ENUM(DMA_FROM_DEVICE);
 236 TRACE_DEFINE_ENUM(DMA_NONE);
 237
 238 #define xprtrdma_show_direction(x)                                      \
 239                 __print_symbolic(x,                                     \
 240                                 { DMA_BIDIRECTIONAL, "BIDIR" },         \
 241                                 { DMA_TO_DEVICE, "TO_DEVICE" },         \
 242                                 { DMA_FROM_DEVICE, "FROM_DEVICE" },     \
 243                                 { DMA_NONE, "NONE" })
 244
 245 DECLARE_EVENT_CLASS(xprtrdma_mr,
 246         TP_PROTO(
 247                 const struct rpcrdma_mr *mr
 248         ),
 249
 250         TP_ARGS(mr),
 251
 252         TP_STRUCT__entry(
 253                 __field(const void *, mr)
 254                 __field(u32, handle)
 255                 __field(u32, length)
 256                 __field(u64, offset)
 257                 __field(u32, dir)
 258         ),
 259
 260         TP_fast_assign(
 261                 __entry->mr = mr;
 262                 __entry->handle = mr->mr_handle;
 263                 __entry->length = mr->mr_length;
 264                 __entry->offset = mr->mr_offset;
 265                 __entry->dir    = mr->mr_dir;
 266         ),
 267
 268         TP_printk("mr=%p %u@0x%016llx:0x%08x (%s)",
 269                 __entry->mr, __entry->length,
 270                 (unsigned long long)__entry->offset, __entry->handle,
 271                 xprtrdma_show_direction(__entry->dir)
 272         )
 273 );
 274
 275 #define DEFINE_MR_EVENT(name) \
 276                 DEFINE_EVENT(xprtrdma_mr, xprtrdma_mr_##name, \
 277                                 TP_PROTO( \
 278                                         const struct rpcrdma_mr *mr \
 279                                 ), \
 280                                 TP_ARGS(mr))
 281
 282 DECLARE_EVENT_CLASS(xprtrdma_cb_event,
 283         TP_PROTO(
 284                 const struct rpc_rqst *rqst
 285         ),
 286
 287         TP_ARGS(rqst),
 288
 289         TP_STRUCT__entry(
 290                 __field(const void *, rqst)
 291                 __field(const void *, rep)
 292                 __field(const void *, req)
 293                 __field(u32, xid)
 294         ),
 295
 296         TP_fast_assign(
 297                 __entry->rqst = rqst;
 298                 __entry->req = rpcr_to_rdmar(rqst);
 299                 __entry->rep = rpcr_to_rdmar(rqst)->rl_reply;
 300                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 301         ),
 302
 303         TP_printk("xid=0x%08x, rqst=%p req=%p rep=%p",
 304                 __entry->xid, __entry->rqst, __entry->req, __entry->rep
 305         )
 306 );
 307
 308 #define DEFINE_CB_EVENT(name)                                           \
 309                 DEFINE_EVENT(xprtrdma_cb_event, name,                   \
 310                                 TP_PROTO(                               \
 311                                         const struct rpc_rqst *rqst     \
 312                                 ),                                      \
 313                                 TP_ARGS(rqst))
 314
 315 /**
 316  ** Connection events
 317  **/
 318
 319 TRACE_EVENT(xprtrdma_cm_event,
 320         TP_PROTO(
 321                 const struct rpcrdma_xprt *r_xprt,
 322                 struct rdma_cm_event *event
 323         ),
 324
 325         TP_ARGS(r_xprt, event),
 326
 327         TP_STRUCT__entry(
 328                 __field(const void *, r_xprt)
 329                 __field(unsigned int, event)
 330                 __field(int, status)
 331                 __string(addr, rpcrdma_addrstr(r_xprt))
 332                 __string(port, rpcrdma_portstr(r_xprt))
 333         ),
 334
 335         TP_fast_assign(
 336                 __entry->r_xprt = r_xprt;
 337                 __entry->event = event->event;
 338                 __entry->status = event->status;
 339                 __assign_str(addr, rpcrdma_addrstr(r_xprt));
 340                 __assign_str(port, rpcrdma_portstr(r_xprt));
 341         ),
 342
 343         TP_printk("peer=[%s]:%s r_xprt=%p: %s (%u/%d)",
 344                 __get_str(addr), __get_str(port),
 345                 __entry->r_xprt, rdma_show_cm_event(__entry->event),
 346                 __entry->event, __entry->status
 347         )
 348 );
 349
 350 TRACE_EVENT(xprtrdma_disconnect,
 351         TP_PROTO(
 352                 const struct rpcrdma_xprt *r_xprt,
 353                 int status
 354         ),
 355
 356         TP_ARGS(r_xprt, status),
 357
 358         TP_STRUCT__entry(
 359                 __field(const void *, r_xprt)
 360                 __field(int, status)
 361                 __field(int, connected)
 362                 __string(addr, rpcrdma_addrstr(r_xprt))
 363                 __string(port, rpcrdma_portstr(r_xprt))
 364         ),
 365
 366         TP_fast_assign(
 367                 __entry->r_xprt = r_xprt;
 368                 __entry->status = status;
 369                 __entry->connected = r_xprt->rx_ep.rep_connected;
 370                 __assign_str(addr, rpcrdma_addrstr(r_xprt));
 371                 __assign_str(port, rpcrdma_portstr(r_xprt));
 372         ),
 373
 374         TP_printk("peer=[%s]:%s r_xprt=%p: status=%d %sconnected",
 375                 __get_str(addr), __get_str(port),
 376                 __entry->r_xprt, __entry->status,
 377                 __entry->connected == 1 ? "still " : "dis"
 378         )
 379 );
 380
 381 DEFINE_RXPRT_EVENT(xprtrdma_conn_start);
 382 DEFINE_RXPRT_EVENT(xprtrdma_conn_tout);
 383 DEFINE_RXPRT_EVENT(xprtrdma_create);
 384 DEFINE_RXPRT_EVENT(xprtrdma_op_destroy);
 385 DEFINE_RXPRT_EVENT(xprtrdma_remove);
 386 DEFINE_RXPRT_EVENT(xprtrdma_reinsert);
 387 DEFINE_RXPRT_EVENT(xprtrdma_reconnect);
 388 DEFINE_RXPRT_EVENT(xprtrdma_op_inject_dsc);
 389 DEFINE_RXPRT_EVENT(xprtrdma_op_close);
 390 DEFINE_RXPRT_EVENT(xprtrdma_op_connect);
 391
 392 TRACE_EVENT(xprtrdma_qp_event,
 393         TP_PROTO(
 394                 const struct rpcrdma_xprt *r_xprt,
 395                 const struct ib_event *event
 396         ),
 397
 398         TP_ARGS(r_xprt, event),
 399
 400         TP_STRUCT__entry(
 401                 __field(const void *, r_xprt)
 402                 __field(unsigned int, event)
 403                 __string(name, event->device->name)
 404                 __string(addr, rpcrdma_addrstr(r_xprt))
 405                 __string(port, rpcrdma_portstr(r_xprt))
 406         ),
 407
 408         TP_fast_assign(
 409                 __entry->r_xprt = r_xprt;
 410                 __entry->event = event->event;
 411                 __assign_str(name, event->device->name);
 412                 __assign_str(addr, rpcrdma_addrstr(r_xprt));
 413                 __assign_str(port, rpcrdma_portstr(r_xprt));
 414         ),
 415
 416         TP_printk("peer=[%s]:%s r_xprt=%p: dev %s: %s (%u)",
 417                 __get_str(addr), __get_str(port), __entry->r_xprt,
 418                 __get_str(name), rdma_show_ib_event(__entry->event),
 419                 __entry->event
 420         )
 421 );
 422
 423 /**
 424  ** Call events
 425  **/
 426
 427 TRACE_EVENT(xprtrdma_createmrs,
 428         TP_PROTO(
 429                 const struct rpcrdma_xprt *r_xprt,
 430                 unsigned int count
 431         ),
 432
 433         TP_ARGS(r_xprt, count),
 434
 435         TP_STRUCT__entry(
 436                 __field(const void *, r_xprt)
 437                 __field(unsigned int, count)
 438         ),
 439
 440         TP_fast_assign(
 441                 __entry->r_xprt = r_xprt;
 442                 __entry->count = count;
 443         ),
 444
 445         TP_printk("r_xprt=%p: created %u MRs",
 446                 __entry->r_xprt, __entry->count
 447         )
 448 );
 449
 450 DEFINE_RXPRT_EVENT(xprtrdma_nomrs);
 451
 452 DEFINE_RDCH_EVENT(read);
 453 DEFINE_WRCH_EVENT(write);
 454 DEFINE_WRCH_EVENT(reply);
 455
 456 TRACE_DEFINE_ENUM(rpcrdma_noch);
 457 TRACE_DEFINE_ENUM(rpcrdma_readch);
 458 TRACE_DEFINE_ENUM(rpcrdma_areadch);
 459 TRACE_DEFINE_ENUM(rpcrdma_writech);
 460 TRACE_DEFINE_ENUM(rpcrdma_replych);
 461
 462 #define xprtrdma_show_chunktype(x)                                      \
 463                 __print_symbolic(x,                                     \
 464                                 { rpcrdma_noch, "inline" },             \
 465                                 { rpcrdma_readch, "read list" },        \
 466                                 { rpcrdma_areadch, "*read list" },      \
 467                                 { rpcrdma_writech, "write list" },      \
 468                                 { rpcrdma_replych, "reply chunk" })
 469
 470 TRACE_EVENT(xprtrdma_marshal,
 471         TP_PROTO(
 472                 const struct rpc_rqst *rqst,
 473                 unsigned int hdrlen,
 474                 unsigned int rtype,
 475                 unsigned int wtype
 476         ),
 477
 478         TP_ARGS(rqst, hdrlen, rtype, wtype),
 479
 480         TP_STRUCT__entry(
 481                 __field(unsigned int, task_id)
 482                 __field(unsigned int, client_id)
 483                 __field(u32, xid)
 484                 __field(unsigned int, hdrlen)
 485                 __field(unsigned int, headlen)
 486                 __field(unsigned int, pagelen)
 487                 __field(unsigned int, taillen)
 488                 __field(unsigned int, rtype)
 489                 __field(unsigned int, wtype)
 490         ),
 491
 492         TP_fast_assign(
 493                 __entry->task_id = rqst->rq_task->tk_pid;
 494                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
 495                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 496                 __entry->hdrlen = hdrlen;
 497                 __entry->headlen = rqst->rq_snd_buf.head[0].iov_len;
 498                 __entry->pagelen = rqst->rq_snd_buf.page_len;
 499                 __entry->taillen = rqst->rq_snd_buf.tail[0].iov_len;
 500                 __entry->rtype = rtype;
 501                 __entry->wtype = wtype;
 502         ),
 503
 504         TP_printk("task:%u@%u xid=0x%08x: hdr=%u xdr=%u/%u/%u %s/%s",
 505                 __entry->task_id, __entry->client_id, __entry->xid,
 506                 __entry->hdrlen,
 507                 __entry->headlen, __entry->pagelen, __entry->taillen,
 508                 xprtrdma_show_chunktype(__entry->rtype),
 509                 xprtrdma_show_chunktype(__entry->wtype)
 510         )
 511 );
 512
 513 TRACE_EVENT(xprtrdma_post_send,
 514         TP_PROTO(
 515                 const struct rpcrdma_req *req,
 516                 int status
 517         ),
 518
 519         TP_ARGS(req, status),
 520
 521         TP_STRUCT__entry(
 522                 __field(const void *, req)
 523                 __field(int, num_sge)
 524                 __field(int, signaled)
 525                 __field(int, status)
 526         ),
 527
 528         TP_fast_assign(
 529                 __entry->req = req;
 530                 __entry->num_sge = req->rl_sendctx->sc_wr.num_sge;
 531                 __entry->signaled = req->rl_sendctx->sc_wr.send_flags &
 532                                     IB_SEND_SIGNALED;
 533                 __entry->status = status;
 534         ),
 535
 536         TP_printk("req=%p, %d SGEs%s, status=%d",
 537                 __entry->req, __entry->num_sge,
 538                 (__entry->signaled ? ", signaled" : ""),
 539                 __entry->status
 540         )
 541 );
 542
 543 TRACE_EVENT(xprtrdma_post_recv,
 544         TP_PROTO(
 545                 const struct ib_cqe *cqe
 546         ),
 547
 548         TP_ARGS(cqe),
 549
 550         TP_STRUCT__entry(
 551                 __field(const void *, cqe)
 552         ),
 553
 554         TP_fast_assign(
 555                 __entry->cqe = cqe;
 556         ),
 557
 558         TP_printk("cqe=%p",
 559                 __entry->cqe
 560         )
 561 );
 562
 563 TRACE_EVENT(xprtrdma_post_recvs,
 564         TP_PROTO(
 565                 const struct rpcrdma_xprt *r_xprt,
 566                 unsigned int count,
 567                 int status
 568         ),
 569
 570         TP_ARGS(r_xprt, count, status),
 571
 572         TP_STRUCT__entry(
 573                 __field(const void *, r_xprt)
 574                 __field(unsigned int, count)
 575                 __field(int, status)
 576                 __field(int, posted)
 577                 __string(addr, rpcrdma_addrstr(r_xprt))
 578                 __string(port, rpcrdma_portstr(r_xprt))
 579         ),
 580
 581         TP_fast_assign(
 582                 __entry->r_xprt = r_xprt;
 583                 __entry->count = count;
 584                 __entry->status = status;
 585                 __entry->posted = r_xprt->rx_ep.rep_receive_count;
 586                 __assign_str(addr, rpcrdma_addrstr(r_xprt));
 587                 __assign_str(port, rpcrdma_portstr(r_xprt));
 588         ),
 589
 590         TP_printk("peer=[%s]:%s r_xprt=%p: %u new recvs, %d active (rc %d)",
 591                 __get_str(addr), __get_str(port), __entry->r_xprt,
 592                 __entry->count, __entry->posted, __entry->status
 593         )
 594 );
 595
 596 /**
 597  ** Completion events
 598  **/
 599
 600 TRACE_EVENT(xprtrdma_wc_send,
 601         TP_PROTO(
 602                 const struct rpcrdma_sendctx *sc,
 603                 const struct ib_wc *wc
 604         ),
 605
 606         TP_ARGS(sc, wc),
 607
 608         TP_STRUCT__entry(
 609                 __field(const void *, req)
 610                 __field(unsigned int, unmap_count)
 611                 __field(unsigned int, status)
 612                 __field(unsigned int, vendor_err)
 613         ),
 614
 615         TP_fast_assign(
 616                 __entry->req = sc->sc_req;
 617                 __entry->unmap_count = sc->sc_unmap_count;
 618                 __entry->status = wc->status;
 619                 __entry->vendor_err = __entry->status ? wc->vendor_err : 0;
 620         ),
 621
 622         TP_printk("req=%p, unmapped %u pages: %s (%u/0x%x)",
 623                 __entry->req, __entry->unmap_count,
 624                 rdma_show_wc_status(__entry->status),
 625                 __entry->status, __entry->vendor_err
 626         )
 627 );
 628
 629 TRACE_EVENT(xprtrdma_wc_receive,
 630         TP_PROTO(
 631                 const struct ib_wc *wc
 632         ),
 633
 634         TP_ARGS(wc),
 635
 636         TP_STRUCT__entry(
 637                 __field(const void *, cqe)
 638                 __field(u32, byte_len)
 639                 __field(unsigned int, status)
 640                 __field(u32, vendor_err)
 641         ),
 642
 643         TP_fast_assign(
 644                 __entry->cqe = wc->wr_cqe;
 645                 __entry->status = wc->status;
 646                 if (wc->status) {
 647                         __entry->byte_len = 0;
 648                         __entry->vendor_err = wc->vendor_err;
 649                 } else {
 650                         __entry->byte_len = wc->byte_len;
 651                         __entry->vendor_err = 0;
 652                 }
 653         ),
 654
 655         TP_printk("cqe=%p %u bytes: %s (%u/0x%x)",
 656                 __entry->cqe, __entry->byte_len,
 657                 rdma_show_wc_status(__entry->status),
 658                 __entry->status, __entry->vendor_err
 659         )
 660 );
 661
 662 DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_fastreg);
 663 DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li);
 664 DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li_wake);
 665
 666 DEFINE_MR_EVENT(localinv);
 667 DEFINE_MR_EVENT(map);
 668 DEFINE_MR_EVENT(unmap);
 669 DEFINE_MR_EVENT(remoteinv);
 670 DEFINE_MR_EVENT(recycle);
 671
 672 /**
 673  ** Reply events
 674  **/
 675
 676 TRACE_EVENT(xprtrdma_reply,
 677         TP_PROTO(
 678                 const struct rpc_task *task,
 679                 const struct rpcrdma_rep *rep,
 680                 const struct rpcrdma_req *req,
 681                 unsigned int credits
 682         ),
 683
 684         TP_ARGS(task, rep, req, credits),
 685
 686         TP_STRUCT__entry(
 687                 __field(unsigned int, task_id)
 688                 __field(unsigned int, client_id)
 689                 __field(const void *, rep)
 690                 __field(const void *, req)
 691                 __field(u32, xid)
 692                 __field(unsigned int, credits)
 693         ),
 694
 695         TP_fast_assign(
 696                 __entry->task_id = task->tk_pid;
 697                 __entry->client_id = task->tk_client->cl_clid;
 698                 __entry->rep = rep;
 699                 __entry->req = req;
 700                 __entry->xid = be32_to_cpu(rep->rr_xid);
 701                 __entry->credits = credits;
 702         ),
 703
 704         TP_printk("task:%u@%u xid=0x%08x, %u credits, rep=%p -> req=%p",
 705                 __entry->task_id, __entry->client_id, __entry->xid,
 706                 __entry->credits, __entry->rep, __entry->req
 707         )
 708 );
 709
 710 TRACE_EVENT(xprtrdma_defer_cmp,
 711         TP_PROTO(
 712                 const struct rpcrdma_rep *rep
 713         ),
 714
 715         TP_ARGS(rep),
 716
 717         TP_STRUCT__entry(
 718                 __field(unsigned int, task_id)
 719                 __field(unsigned int, client_id)
 720                 __field(const void *, rep)
 721                 __field(u32, xid)
 722         ),
 723
 724         TP_fast_assign(
 725                 __entry->task_id = rep->rr_rqst->rq_task->tk_pid;
 726                 __entry->client_id = rep->rr_rqst->rq_task->tk_client->cl_clid;
 727                 __entry->rep = rep;
 728                 __entry->xid = be32_to_cpu(rep->rr_xid);
 729         ),
 730
 731         TP_printk("task:%u@%u xid=0x%08x rep=%p",
 732                 __entry->task_id, __entry->client_id, __entry->xid,
 733                 __entry->rep
 734         )
 735 );
 736
 737 DEFINE_REPLY_EVENT(xprtrdma_reply_vers);
 738 DEFINE_REPLY_EVENT(xprtrdma_reply_rqst);
 739 DEFINE_REPLY_EVENT(xprtrdma_reply_short);
 740 DEFINE_REPLY_EVENT(xprtrdma_reply_hdr);
 741
 742 TRACE_EVENT(xprtrdma_fixup,
 743         TP_PROTO(
 744                 const struct rpc_rqst *rqst,
 745                 int len,
 746                 int hdrlen
 747         ),
 748
 749         TP_ARGS(rqst, len, hdrlen),
 750
 751         TP_STRUCT__entry(
 752                 __field(unsigned int, task_id)
 753                 __field(unsigned int, client_id)
 754                 __field(const void *, base)
 755                 __field(int, len)
 756                 __field(int, hdrlen)
 757         ),
 758
 759         TP_fast_assign(
 760                 __entry->task_id = rqst->rq_task->tk_pid;
 761                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
 762                 __entry->base = rqst->rq_rcv_buf.head[0].iov_base;
 763                 __entry->len = len;
 764                 __entry->hdrlen = hdrlen;
 765         ),
 766
 767         TP_printk("task:%u@%u base=%p len=%d hdrlen=%d",
 768                 __entry->task_id, __entry->client_id,
 769                 __entry->base, __entry->len, __entry->hdrlen
 770         )
 771 );
 772
 773 TRACE_EVENT(xprtrdma_fixup_pg,
 774         TP_PROTO(
 775                 const struct rpc_rqst *rqst,
 776                 int pageno,
 777                 const void *pos,
 778                 int len,
 779                 int curlen
 780         ),
 781
 782         TP_ARGS(rqst, pageno, pos, len, curlen),
 783
 784         TP_STRUCT__entry(
 785                 __field(unsigned int, task_id)
 786                 __field(unsigned int, client_id)
 787                 __field(const void *, pos)
 788                 __field(int, pageno)
 789                 __field(int, len)
 790                 __field(int, curlen)
 791         ),
 792
 793         TP_fast_assign(
 794                 __entry->task_id = rqst->rq_task->tk_pid;
 795                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
 796                 __entry->pos = pos;
 797                 __entry->pageno = pageno;
 798                 __entry->len = len;
 799                 __entry->curlen = curlen;
 800         ),
 801
 802         TP_printk("task:%u@%u pageno=%d pos=%p len=%d curlen=%d",
 803                 __entry->task_id, __entry->client_id,
 804                 __entry->pageno, __entry->pos, __entry->len, __entry->curlen
 805         )
 806 );
 807
 808 TRACE_EVENT(xprtrdma_decode_seg,
 809         TP_PROTO(
 810                 u32 handle,
 811                 u32 length,
 812                 u64 offset
 813         ),
 814
 815         TP_ARGS(handle, length, offset),
 816
 817         TP_STRUCT__entry(
 818                 __field(u32, handle)
 819                 __field(u32, length)
 820                 __field(u64, offset)
 821         ),
 822
 823         TP_fast_assign(
 824                 __entry->handle = handle;
 825                 __entry->length = length;
 826                 __entry->offset = offset;
 827         ),
 828
 829         TP_printk("%u@0x%016llx:0x%08x",
 830                 __entry->length, (unsigned long long)__entry->offset,
 831                 __entry->handle
 832         )
 833 );
 834
 835 /**
 836  ** Allocation/release of rpcrdma_reqs and rpcrdma_reps
 837  **/
 838
 839 TRACE_EVENT(xprtrdma_op_allocate,
 840         TP_PROTO(
 841                 const struct rpc_task *task,
 842                 const struct rpcrdma_req *req
 843         ),
 844
 845         TP_ARGS(task, req),
 846
 847         TP_STRUCT__entry(
 848                 __field(unsigned int, task_id)
 849                 __field(unsigned int, client_id)
 850                 __field(const void *, req)
 851                 __field(size_t, callsize)
 852                 __field(size_t, rcvsize)
 853         ),
 854
 855         TP_fast_assign(
 856                 __entry->task_id = task->tk_pid;
 857                 __entry->client_id = task->tk_client->cl_clid;
 858                 __entry->req = req;
 859                 __entry->callsize = task->tk_rqstp->rq_callsize;
 860                 __entry->rcvsize = task->tk_rqstp->rq_rcvsize;
 861         ),
 862
 863         TP_printk("task:%u@%u req=%p (%zu, %zu)",
 864                 __entry->task_id, __entry->client_id,
 865                 __entry->req, __entry->callsize, __entry->rcvsize
 866         )
 867 );
 868
 869 TRACE_EVENT(xprtrdma_op_free,
 870         TP_PROTO(
 871                 const struct rpc_task *task,
 872                 const struct rpcrdma_req *req
 873         ),
 874
 875         TP_ARGS(task, req),
 876
 877         TP_STRUCT__entry(
 878                 __field(unsigned int, task_id)
 879                 __field(unsigned int, client_id)
 880                 __field(const void *, req)
 881                 __field(const void *, rep)
 882         ),
 883
 884         TP_fast_assign(
 885                 __entry->task_id = task->tk_pid;
 886                 __entry->client_id = task->tk_client->cl_clid;
 887                 __entry->req = req;
 888                 __entry->rep = req->rl_reply;
 889         ),
 890
 891         TP_printk("task:%u@%u req=%p rep=%p",
 892                 __entry->task_id, __entry->client_id,
 893                 __entry->req, __entry->rep
 894         )
 895 );
 896
 897 /**
 898  ** Callback events
 899  **/
 900
 901 TRACE_EVENT(xprtrdma_cb_setup,
 902         TP_PROTO(
 903                 const struct rpcrdma_xprt *r_xprt,
 904                 unsigned int reqs
 905         ),
 906
 907         TP_ARGS(r_xprt, reqs),
 908
 909         TP_STRUCT__entry(
 910                 __field(const void *, r_xprt)
 911                 __field(unsigned int, reqs)
 912                 __string(addr, rpcrdma_addrstr(r_xprt))
 913                 __string(port, rpcrdma_portstr(r_xprt))
 914         ),
 915
 916         TP_fast_assign(
 917                 __entry->r_xprt = r_xprt;
 918                 __entry->reqs = reqs;
 919                 __assign_str(addr, rpcrdma_addrstr(r_xprt));
 920                 __assign_str(port, rpcrdma_portstr(r_xprt));
 921         ),
 922
 923         TP_printk("peer=[%s]:%s r_xprt=%p: %u reqs",
 924                 __get_str(addr), __get_str(port),
 925                 __entry->r_xprt, __entry->reqs
 926         )
 927 );
 928
 929 DEFINE_CB_EVENT(xprtrdma_cb_call);
 930 DEFINE_CB_EVENT(xprtrdma_cb_reply);
 931
 932 /**
 933  ** Server-side RPC/RDMA events
 934  **/
 935
 936 DECLARE_EVENT_CLASS(svcrdma_xprt_event,
 937         TP_PROTO(
 938                 const struct svc_xprt *xprt
 939         ),
 940
 941         TP_ARGS(xprt),
 942
 943         TP_STRUCT__entry(
 944                 __field(const void *, xprt)
 945                 __string(addr, xprt->xpt_remotebuf)
 946         ),
 947
 948         TP_fast_assign(
 949                 __entry->xprt = xprt;
 950                 __assign_str(addr, xprt->xpt_remotebuf);
 951         ),
 952
 953         TP_printk("xprt=%p addr=%s",
 954                 __entry->xprt, __get_str(addr)
 955         )
 956 );
 957
 958 #define DEFINE_XPRT_EVENT(name)                                         \
 959                 DEFINE_EVENT(svcrdma_xprt_event, svcrdma_xprt_##name,   \
 960                                 TP_PROTO(                               \
 961                                         const struct svc_xprt *xprt     \
 962                                 ),                                      \
 963                                 TP_ARGS(xprt))
 964
 965 DEFINE_XPRT_EVENT(accept);
 966 DEFINE_XPRT_EVENT(fail);
 967 DEFINE_XPRT_EVENT(free);
 968
 969 TRACE_DEFINE_ENUM(RDMA_MSG);
 970 TRACE_DEFINE_ENUM(RDMA_NOMSG);
 971 TRACE_DEFINE_ENUM(RDMA_MSGP);
 972 TRACE_DEFINE_ENUM(RDMA_DONE);
 973 TRACE_DEFINE_ENUM(RDMA_ERROR);
 974
 975 #define show_rpcrdma_proc(x)                                            \
 976                 __print_symbolic(x,                                     \
 977                                 { RDMA_MSG, "RDMA_MSG" },               \
 978                                 { RDMA_NOMSG, "RDMA_NOMSG" },           \
 979                                 { RDMA_MSGP, "RDMA_MSGP" },             \
 980                                 { RDMA_DONE, "RDMA_DONE" },             \
 981                                 { RDMA_ERROR, "RDMA_ERROR" })
 982
 983 TRACE_EVENT(svcrdma_decode_rqst,
 984         TP_PROTO(
 985                 __be32 *p,
 986                 unsigned int hdrlen
 987         ),
 988
 989         TP_ARGS(p, hdrlen),
 990
 991         TP_STRUCT__entry(
 992                 __field(u32, xid)
 993                 __field(u32, vers)
 994                 __field(u32, proc)
 995                 __field(u32, credits)
 996                 __field(unsigned int, hdrlen)
 997         ),
 998
 999         TP_fast_assign(
1000                 __entry->xid = be32_to_cpup(p++);
1001                 __entry->vers = be32_to_cpup(p++);
1002                 __entry->credits = be32_to_cpup(p++);
1003                 __entry->proc = be32_to_cpup(p);
1004                 __entry->hdrlen = hdrlen;
1005         ),
1006
1007         TP_printk("xid=0x%08x vers=%u credits=%u proc=%s hdrlen=%u",
1008                 __entry->xid, __entry->vers, __entry->credits,
1009                 show_rpcrdma_proc(__entry->proc), __entry->hdrlen)
1010 );
1011
1012 TRACE_EVENT(svcrdma_decode_short,
1013         TP_PROTO(
1014                 unsigned int hdrlen
1015         ),
1016
1017         TP_ARGS(hdrlen),
1018
1019         TP_STRUCT__entry(
1020                 __field(unsigned int, hdrlen)
1021         ),
1022
1023         TP_fast_assign(
1024                 __entry->hdrlen = hdrlen;
1025         ),
1026
1027         TP_printk("hdrlen=%u", __entry->hdrlen)
1028 );
1029
1030 DECLARE_EVENT_CLASS(svcrdma_badreq_event,
1031         TP_PROTO(
1032                 __be32 *p
1033         ),
1034
1035         TP_ARGS(p),
1036
1037         TP_STRUCT__entry(
1038                 __field(u32, xid)
1039                 __field(u32, vers)
1040                 __field(u32, proc)
1041                 __field(u32, credits)
1042         ),
1043
1044         TP_fast_assign(
1045                 __entry->xid = be32_to_cpup(p++);
1046                 __entry->vers = be32_to_cpup(p++);
1047                 __entry->credits = be32_to_cpup(p++);
1048                 __entry->proc = be32_to_cpup(p);
1049         ),
1050
1051         TP_printk("xid=0x%08x vers=%u credits=%u proc=%u",
1052                 __entry->xid, __entry->vers, __entry->credits, __entry->proc)
1053 );
1054
1055 #define DEFINE_BADREQ_EVENT(name)                                       \
1056                 DEFINE_EVENT(svcrdma_badreq_event, svcrdma_decode_##name,\
1057                                 TP_PROTO(                               \
1058                                         __be32 *p                       \
1059                                 ),                                      \
1060                                 TP_ARGS(p))
1061
1062 DEFINE_BADREQ_EVENT(badvers);
1063 DEFINE_BADREQ_EVENT(drop);
1064 DEFINE_BADREQ_EVENT(badproc);
1065 DEFINE_BADREQ_EVENT(parse);
1066
1067 DECLARE_EVENT_CLASS(svcrdma_segment_event,
1068         TP_PROTO(
1069                 u32 handle,
1070                 u32 length,
1071                 u64 offset
1072         ),
1073
1074         TP_ARGS(handle, length, offset),
1075
1076         TP_STRUCT__entry(
1077                 __field(u32, handle)
1078                 __field(u32, length)
1079                 __field(u64, offset)
1080         ),
1081
1082         TP_fast_assign(
1083                 __entry->handle = handle;
1084                 __entry->length = length;
1085                 __entry->offset = offset;
1086         ),
1087
1088         TP_printk("%u@0x%016llx:0x%08x",
1089                 __entry->length, (unsigned long long)__entry->offset,
1090                 __entry->handle
1091         )
1092 );
1093
1094 #define DEFINE_SEGMENT_EVENT(name)                                      \
1095                 DEFINE_EVENT(svcrdma_segment_event, svcrdma_encode_##name,\
1096                                 TP_PROTO(                               \
1097                                         u32 handle,                     \
1098                                         u32 length,                     \
1099                                         u64 offset                      \
1100                                 ),                                      \
1101                                 TP_ARGS(handle, length, offset))
1102
1103 DEFINE_SEGMENT_EVENT(rseg);
1104 DEFINE_SEGMENT_EVENT(wseg);
1105
1106 DECLARE_EVENT_CLASS(svcrdma_chunk_event,
1107         TP_PROTO(
1108                 u32 length
1109         ),
1110
1111         TP_ARGS(length),
1112
1113         TP_STRUCT__entry(
1114                 __field(u32, length)
1115         ),
1116
1117         TP_fast_assign(
1118                 __entry->length = length;
1119         ),
1120
1121         TP_printk("length=%u",
1122                 __entry->length
1123         )
1124 );
1125
1126 #define DEFINE_CHUNK_EVENT(name)                                        \
1127                 DEFINE_EVENT(svcrdma_chunk_event, svcrdma_encode_##name,\
1128                                 TP_PROTO(                               \
1129                                         u32 length                      \
1130                                 ),                                      \
1131                                 TP_ARGS(length))
1132
1133 DEFINE_CHUNK_EVENT(pzr);
1134 DEFINE_CHUNK_EVENT(write);
1135 DEFINE_CHUNK_EVENT(reply);
1136
1137 TRACE_EVENT(svcrdma_encode_read,
1138         TP_PROTO(
1139                 u32 length,
1140                 u32 position
1141         ),
1142
1143         TP_ARGS(length, position),
1144
1145         TP_STRUCT__entry(
1146                 __field(u32, length)
1147                 __field(u32, position)
1148         ),
1149
1150         TP_fast_assign(
1151                 __entry->length = length;
1152                 __entry->position = position;
1153         ),
1154
1155         TP_printk("length=%u position=%u",
1156                 __entry->length, __entry->position
1157         )
1158 );
1159
1160 DECLARE_EVENT_CLASS(svcrdma_error_event,
1161         TP_PROTO(
1162                 __be32 xid
1163         ),
1164
1165         TP_ARGS(xid),
1166
1167         TP_STRUCT__entry(
1168                 __field(u32, xid)
1169         ),
1170
1171         TP_fast_assign(
1172                 __entry->xid = be32_to_cpu(xid);
1173         ),
1174
1175         TP_printk("xid=0x%08x",
1176                 __entry->xid
1177         )
1178 );
1179
1180 #define DEFINE_ERROR_EVENT(name)                                        \
1181                 DEFINE_EVENT(svcrdma_error_event, svcrdma_err_##name,   \
1182                                 TP_PROTO(                               \
1183                                         __be32 xid                      \
1184                                 ),                                      \
1185                                 TP_ARGS(xid))
1186
1187 DEFINE_ERROR_EVENT(vers);
1188 DEFINE_ERROR_EVENT(chunk);
1189
1190 /**
1191  ** Server-side RDMA API events
1192  **/
1193
1194 TRACE_EVENT(svcrdma_dma_map_page,
1195         TP_PROTO(
1196                 const struct svcxprt_rdma *rdma,
1197                 const void *page
1198         ),
1199
1200         TP_ARGS(rdma, page),
1201
1202         TP_STRUCT__entry(
1203                 __field(const void *, page);
1204                 __string(device, rdma->sc_cm_id->device->name)
1205                 __string(addr, rdma->sc_xprt.xpt_remotebuf)
1206         ),
1207
1208         TP_fast_assign(
1209                 __entry->page = page;
1210                 __assign_str(device, rdma->sc_cm_id->device->name);
1211                 __assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
1212         ),
1213
1214         TP_printk("addr=%s device=%s page=%p",
1215                 __get_str(addr), __get_str(device), __entry->page
1216         )
1217 );
1218
1219 TRACE_EVENT(svcrdma_dma_map_rwctx,
1220         TP_PROTO(
1221                 const struct svcxprt_rdma *rdma,
1222                 int status
1223         ),
1224
1225         TP_ARGS(rdma, status),
1226
1227         TP_STRUCT__entry(
1228                 __field(int, status)
1229                 __string(device, rdma->sc_cm_id->device->name)
1230                 __string(addr, rdma->sc_xprt.xpt_remotebuf)
1231         ),
1232
1233         TP_fast_assign(
1234                 __entry->status = status;
1235                 __assign_str(device, rdma->sc_cm_id->device->name);
1236                 __assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
1237         ),
1238
1239         TP_printk("addr=%s device=%s status=%d",
1240                 __get_str(addr), __get_str(device), __entry->status
1241         )
1242 );
1243
1244 TRACE_EVENT(svcrdma_send_failed,
1245         TP_PROTO(
1246                 const struct svc_rqst *rqst,
1247                 int status
1248         ),
1249
1250         TP_ARGS(rqst, status),
1251
1252         TP_STRUCT__entry(
1253                 __field(int, status)
1254                 __field(u32, xid)
1255                 __field(const void *, xprt)
1256                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1257         ),
1258
1259         TP_fast_assign(
1260                 __entry->status = status;
1261                 __entry->xid = __be32_to_cpu(rqst->rq_xid);
1262                 __entry->xprt = rqst->rq_xprt;
1263                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1264         ),
1265
1266         TP_printk("xprt=%p addr=%s xid=0x%08x status=%d",
1267                 __entry->xprt, __get_str(addr),
1268                 __entry->xid, __entry->status
1269         )
1270 );
1271
1272 DECLARE_EVENT_CLASS(svcrdma_sendcomp_event,
1273         TP_PROTO(
1274                 const struct ib_wc *wc
1275         ),
1276
1277         TP_ARGS(wc),
1278
1279         TP_STRUCT__entry(
1280                 __field(const void *, cqe)
1281                 __field(unsigned int, status)
1282                 __field(unsigned int, vendor_err)
1283         ),
1284
1285         TP_fast_assign(
1286                 __entry->cqe = wc->wr_cqe;
1287                 __entry->status = wc->status;
1288                 if (wc->status)
1289                         __entry->vendor_err = wc->vendor_err;
1290                 else
1291                         __entry->vendor_err = 0;
1292         ),
1293
1294         TP_printk("cqe=%p status=%s (%u/0x%x)",
1295                 __entry->cqe, rdma_show_wc_status(__entry->status),
1296                 __entry->status, __entry->vendor_err
1297         )
1298 );
1299
1300 #define DEFINE_SENDCOMP_EVENT(name)                                     \
1301                 DEFINE_EVENT(svcrdma_sendcomp_event, svcrdma_wc_##name, \
1302                                 TP_PROTO(                               \
1303                                         const struct ib_wc *wc          \
1304                                 ),                                      \
1305                                 TP_ARGS(wc))
1306
1307 TRACE_EVENT(svcrdma_post_send,
1308         TP_PROTO(
1309                 const struct ib_send_wr *wr,
1310                 int status
1311         ),
1312
1313         TP_ARGS(wr, status),
1314
1315         TP_STRUCT__entry(
1316                 __field(const void *, cqe)
1317                 __field(unsigned int, num_sge)
1318                 __field(u32, inv_rkey)
1319                 __field(int, status)
1320         ),
1321
1322         TP_fast_assign(
1323                 __entry->cqe = wr->wr_cqe;
1324                 __entry->num_sge = wr->num_sge;
1325                 __entry->inv_rkey = (wr->opcode == IB_WR_SEND_WITH_INV) ?
1326                                         wr->ex.invalidate_rkey : 0;
1327                 __entry->status = status;
1328         ),
1329
1330         TP_printk("cqe=%p num_sge=%u inv_rkey=0x%08x status=%d",
1331                 __entry->cqe, __entry->num_sge,
1332                 __entry->inv_rkey, __entry->status
1333         )
1334 );
1335
1336 DEFINE_SENDCOMP_EVENT(send);
1337
1338 TRACE_EVENT(svcrdma_post_recv,
1339         TP_PROTO(
1340                 const struct ib_recv_wr *wr,
1341                 int status
1342         ),
1343
1344         TP_ARGS(wr, status),
1345
1346         TP_STRUCT__entry(
1347                 __field(const void *, cqe)
1348                 __field(int, status)
1349         ),
1350
1351         TP_fast_assign(
1352                 __entry->cqe = wr->wr_cqe;
1353                 __entry->status = status;
1354         ),
1355
1356         TP_printk("cqe=%p status=%d",
1357                 __entry->cqe, __entry->status
1358         )
1359 );
1360
1361 TRACE_EVENT(svcrdma_wc_receive,
1362         TP_PROTO(
1363                 const struct ib_wc *wc
1364         ),
1365
1366         TP_ARGS(wc),
1367
1368         TP_STRUCT__entry(
1369                 __field(const void *, cqe)
1370                 __field(u32, byte_len)
1371                 __field(unsigned int, status)
1372                 __field(u32, vendor_err)
1373         ),
1374
1375         TP_fast_assign(
1376                 __entry->cqe = wc->wr_cqe;
1377                 __entry->status = wc->status;
1378                 if (wc->status) {
1379                         __entry->byte_len = 0;
1380                         __entry->vendor_err = wc->vendor_err;
1381                 } else {
1382                         __entry->byte_len = wc->byte_len;
1383                         __entry->vendor_err = 0;
1384                 }
1385         ),
1386
1387         TP_printk("cqe=%p byte_len=%u status=%s (%u/0x%x)",
1388                 __entry->cqe, __entry->byte_len,
1389                 rdma_show_wc_status(__entry->status),
1390                 __entry->status, __entry->vendor_err
1391         )
1392 );
1393
1394 TRACE_EVENT(svcrdma_post_rw,
1395         TP_PROTO(
1396                 const void *cqe,
1397                 int sqecount,
1398                 int status
1399         ),
1400
1401         TP_ARGS(cqe, sqecount, status),
1402
1403         TP_STRUCT__entry(
1404                 __field(const void *, cqe)
1405                 __field(int, sqecount)
1406                 __field(int, status)
1407         ),
1408
1409         TP_fast_assign(
1410                 __entry->cqe = cqe;
1411                 __entry->sqecount = sqecount;
1412                 __entry->status = status;
1413         ),
1414
1415         TP_printk("cqe=%p sqecount=%d status=%d",
1416                 __entry->cqe, __entry->sqecount, __entry->status
1417         )
1418 );
1419
1420 DEFINE_SENDCOMP_EVENT(read);
1421 DEFINE_SENDCOMP_EVENT(write);
1422
1423 TRACE_EVENT(svcrdma_cm_event,
1424         TP_PROTO(
1425                 const struct rdma_cm_event *event,
1426                 const struct sockaddr *sap
1427         ),
1428
1429         TP_ARGS(event, sap),
1430
1431         TP_STRUCT__entry(
1432                 __field(unsigned int, event)
1433                 __field(int, status)
1434                 __array(__u8, addr, INET6_ADDRSTRLEN + 10)
1435         ),
1436
1437         TP_fast_assign(
1438                 __entry->event = event->event;
1439                 __entry->status = event->status;
1440                 snprintf(__entry->addr, sizeof(__entry->addr) - 1,
1441                          "%pISpc", sap);
1442         ),
1443
1444         TP_printk("addr=%s event=%s (%u/%d)",
1445                 __entry->addr,
1446                 rdma_show_cm_event(__entry->event),
1447                 __entry->event, __entry->status
1448         )
1449 );
1450
1451 TRACE_EVENT(svcrdma_qp_error,
1452         TP_PROTO(
1453                 const struct ib_event *event,
1454                 const struct sockaddr *sap
1455         ),
1456
1457         TP_ARGS(event, sap),
1458
1459         TP_STRUCT__entry(
1460                 __field(unsigned int, event)
1461                 __string(device, event->device->name)
1462                 __array(__u8, addr, INET6_ADDRSTRLEN + 10)
1463         ),
1464
1465         TP_fast_assign(
1466                 __entry->event = event->event;
1467                 __assign_str(device, event->device->name);
1468                 snprintf(__entry->addr, sizeof(__entry->addr) - 1,
1469                          "%pISpc", sap);
1470         ),
1471
1472         TP_printk("addr=%s dev=%s event=%s (%u)",
1473                 __entry->addr, __get_str(device),
1474                 rdma_show_ib_event(__entry->event), __entry->event
1475         )
1476 );
1477
1478 DECLARE_EVENT_CLASS(svcrdma_sendqueue_event,
1479         TP_PROTO(
1480                 const struct svcxprt_rdma *rdma
1481         ),
1482
1483         TP_ARGS(rdma),
1484
1485         TP_STRUCT__entry(
1486                 __field(int, avail)
1487                 __field(int, depth)
1488                 __string(addr, rdma->sc_xprt.xpt_remotebuf)
1489         ),
1490
1491         TP_fast_assign(
1492                 __entry->avail = atomic_read(&rdma->sc_sq_avail);
1493                 __entry->depth = rdma->sc_sq_depth;
1494                 __assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
1495         ),
1496
1497         TP_printk("addr=%s sc_sq_avail=%d/%d",
1498                 __get_str(addr), __entry->avail, __entry->depth
1499         )
1500 );
1501
1502 #define DEFINE_SQ_EVENT(name)                                           \
1503                 DEFINE_EVENT(svcrdma_sendqueue_event, svcrdma_sq_##name,\
1504                                 TP_PROTO(                               \
1505                                         const struct svcxprt_rdma *rdma \
1506                                 ),                                      \
1507                                 TP_ARGS(rdma))
1508
1509 DEFINE_SQ_EVENT(full);
1510 DEFINE_SQ_EVENT(retry);
1511
1512 #endif /* _TRACE_RPCRDMA_H */
1513
1514 #include <trace/define_trace.h>