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_destroy);
 385 DEFINE_RXPRT_EVENT(xprtrdma_remove);
 386 DEFINE_RXPRT_EVENT(xprtrdma_reinsert);
 387 DEFINE_RXPRT_EVENT(xprtrdma_reconnect);
 388 DEFINE_RXPRT_EVENT(xprtrdma_inject_dsc);
 389
 390 TRACE_EVENT(xprtrdma_qp_event,
 391         TP_PROTO(
 392                 const struct rpcrdma_xprt *r_xprt,
 393                 const struct ib_event *event
 394         ),
 395
 396         TP_ARGS(r_xprt, event),
 397
 398         TP_STRUCT__entry(
 399                 __field(const void *, r_xprt)
 400                 __field(unsigned int, event)
 401                 __string(name, event->device->name)
 402                 __string(addr, rpcrdma_addrstr(r_xprt))
 403                 __string(port, rpcrdma_portstr(r_xprt))
 404         ),
 405
 406         TP_fast_assign(
 407                 __entry->r_xprt = r_xprt;
 408                 __entry->event = event->event;
 409                 __assign_str(name, event->device->name);
 410                 __assign_str(addr, rpcrdma_addrstr(r_xprt));
 411                 __assign_str(port, rpcrdma_portstr(r_xprt));
 412         ),
 413
 414         TP_printk("peer=[%s]:%s r_xprt=%p: dev %s: %s (%u)",
 415                 __get_str(addr), __get_str(port), __entry->r_xprt,
 416                 __get_str(name), rdma_show_ib_event(__entry->event),
 417                 __entry->event
 418         )
 419 );
 420
 421 /**
 422  ** Call events
 423  **/
 424
 425 TRACE_EVENT(xprtrdma_createmrs,
 426         TP_PROTO(
 427                 const struct rpcrdma_xprt *r_xprt,
 428                 unsigned int count
 429         ),
 430
 431         TP_ARGS(r_xprt, count),
 432
 433         TP_STRUCT__entry(
 434                 __field(const void *, r_xprt)
 435                 __field(unsigned int, count)
 436         ),
 437
 438         TP_fast_assign(
 439                 __entry->r_xprt = r_xprt;
 440                 __entry->count = count;
 441         ),
 442
 443         TP_printk("r_xprt=%p: created %u MRs",
 444                 __entry->r_xprt, __entry->count
 445         )
 446 );
 447
 448 DEFINE_RXPRT_EVENT(xprtrdma_nomrs);
 449
 450 DEFINE_RDCH_EVENT(read);
 451 DEFINE_WRCH_EVENT(write);
 452 DEFINE_WRCH_EVENT(reply);
 453
 454 TRACE_DEFINE_ENUM(rpcrdma_noch);
 455 TRACE_DEFINE_ENUM(rpcrdma_readch);
 456 TRACE_DEFINE_ENUM(rpcrdma_areadch);
 457 TRACE_DEFINE_ENUM(rpcrdma_writech);
 458 TRACE_DEFINE_ENUM(rpcrdma_replych);
 459
 460 #define xprtrdma_show_chunktype(x)                                      \
 461                 __print_symbolic(x,                                     \
 462                                 { rpcrdma_noch, "inline" },             \
 463                                 { rpcrdma_readch, "read list" },        \
 464                                 { rpcrdma_areadch, "*read list" },      \
 465                                 { rpcrdma_writech, "write list" },      \
 466                                 { rpcrdma_replych, "reply chunk" })
 467
 468 TRACE_EVENT(xprtrdma_marshal,
 469         TP_PROTO(
 470                 const struct rpc_rqst *rqst,
 471                 unsigned int hdrlen,
 472                 unsigned int rtype,
 473                 unsigned int wtype
 474         ),
 475
 476         TP_ARGS(rqst, hdrlen, rtype, wtype),
 477
 478         TP_STRUCT__entry(
 479                 __field(unsigned int, task_id)
 480                 __field(unsigned int, client_id)
 481                 __field(u32, xid)
 482                 __field(unsigned int, hdrlen)
 483                 __field(unsigned int, headlen)
 484                 __field(unsigned int, pagelen)
 485                 __field(unsigned int, taillen)
 486                 __field(unsigned int, rtype)
 487                 __field(unsigned int, wtype)
 488         ),
 489
 490         TP_fast_assign(
 491                 __entry->task_id = rqst->rq_task->tk_pid;
 492                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
 493                 __entry->xid = be32_to_cpu(rqst->rq_xid);
 494                 __entry->hdrlen = hdrlen;
 495                 __entry->headlen = rqst->rq_snd_buf.head[0].iov_len;
 496                 __entry->pagelen = rqst->rq_snd_buf.page_len;
 497                 __entry->taillen = rqst->rq_snd_buf.tail[0].iov_len;
 498                 __entry->rtype = rtype;
 499                 __entry->wtype = wtype;
 500         ),
 501
 502         TP_printk("task:%u@%u xid=0x%08x: hdr=%u xdr=%u/%u/%u %s/%s",
 503                 __entry->task_id, __entry->client_id, __entry->xid,
 504                 __entry->hdrlen,
 505                 __entry->headlen, __entry->pagelen, __entry->taillen,
 506                 xprtrdma_show_chunktype(__entry->rtype),
 507                 xprtrdma_show_chunktype(__entry->wtype)
 508         )
 509 );
 510
 511 TRACE_EVENT(xprtrdma_post_send,
 512         TP_PROTO(
 513                 const struct rpcrdma_req *req,
 514                 int status
 515         ),
 516
 517         TP_ARGS(req, status),
 518
 519         TP_STRUCT__entry(
 520                 __field(const void *, req)
 521                 __field(int, num_sge)
 522                 __field(int, signaled)
 523                 __field(int, status)
 524         ),
 525
 526         TP_fast_assign(
 527                 __entry->req = req;
 528                 __entry->num_sge = req->rl_sendctx->sc_wr.num_sge;
 529                 __entry->signaled = req->rl_sendctx->sc_wr.send_flags &
 530                                     IB_SEND_SIGNALED;
 531                 __entry->status = status;
 532         ),
 533
 534         TP_printk("req=%p, %d SGEs%s, status=%d",
 535                 __entry->req, __entry->num_sge,
 536                 (__entry->signaled ? ", signaled" : ""),
 537                 __entry->status
 538         )
 539 );
 540
 541 TRACE_EVENT(xprtrdma_post_recv,
 542         TP_PROTO(
 543                 const struct ib_cqe *cqe
 544         ),
 545
 546         TP_ARGS(cqe),
 547
 548         TP_STRUCT__entry(
 549                 __field(const void *, cqe)
 550         ),
 551
 552         TP_fast_assign(
 553                 __entry->cqe = cqe;
 554         ),
 555
 556         TP_printk("cqe=%p",
 557                 __entry->cqe
 558         )
 559 );
 560
 561 TRACE_EVENT(xprtrdma_post_recvs,
 562         TP_PROTO(
 563                 const struct rpcrdma_xprt *r_xprt,
 564                 unsigned int count,
 565                 int status
 566         ),
 567
 568         TP_ARGS(r_xprt, count, status),
 569
 570         TP_STRUCT__entry(
 571                 __field(const void *, r_xprt)
 572                 __field(unsigned int, count)
 573                 __field(int, status)
 574                 __field(int, posted)
 575                 __string(addr, rpcrdma_addrstr(r_xprt))
 576                 __string(port, rpcrdma_portstr(r_xprt))
 577         ),
 578
 579         TP_fast_assign(
 580                 __entry->r_xprt = r_xprt;
 581                 __entry->count = count;
 582                 __entry->status = status;
 583                 __entry->posted = r_xprt->rx_ep.rep_receive_count;
 584                 __assign_str(addr, rpcrdma_addrstr(r_xprt));
 585                 __assign_str(port, rpcrdma_portstr(r_xprt));
 586         ),
 587
 588         TP_printk("peer=[%s]:%s r_xprt=%p: %u new recvs, %d active (rc %d)",
 589                 __get_str(addr), __get_str(port), __entry->r_xprt,
 590                 __entry->count, __entry->posted, __entry->status
 591         )
 592 );
 593
 594 /**
 595  ** Completion events
 596  **/
 597
 598 TRACE_EVENT(xprtrdma_wc_send,
 599         TP_PROTO(
 600                 const struct rpcrdma_sendctx *sc,
 601                 const struct ib_wc *wc
 602         ),
 603
 604         TP_ARGS(sc, wc),
 605
 606         TP_STRUCT__entry(
 607                 __field(const void *, req)
 608                 __field(unsigned int, unmap_count)
 609                 __field(unsigned int, status)
 610                 __field(unsigned int, vendor_err)
 611         ),
 612
 613         TP_fast_assign(
 614                 __entry->req = sc->sc_req;
 615                 __entry->unmap_count = sc->sc_unmap_count;
 616                 __entry->status = wc->status;
 617                 __entry->vendor_err = __entry->status ? wc->vendor_err : 0;
 618         ),
 619
 620         TP_printk("req=%p, unmapped %u pages: %s (%u/0x%x)",
 621                 __entry->req, __entry->unmap_count,
 622                 rdma_show_wc_status(__entry->status),
 623                 __entry->status, __entry->vendor_err
 624         )
 625 );
 626
 627 TRACE_EVENT(xprtrdma_wc_receive,
 628         TP_PROTO(
 629                 const struct ib_wc *wc
 630         ),
 631
 632         TP_ARGS(wc),
 633
 634         TP_STRUCT__entry(
 635                 __field(const void *, cqe)
 636                 __field(u32, byte_len)
 637                 __field(unsigned int, status)
 638                 __field(u32, vendor_err)
 639         ),
 640
 641         TP_fast_assign(
 642                 __entry->cqe = wc->wr_cqe;
 643                 __entry->status = wc->status;
 644                 if (wc->status) {
 645                         __entry->byte_len = 0;
 646                         __entry->vendor_err = wc->vendor_err;
 647                 } else {
 648                         __entry->byte_len = wc->byte_len;
 649                         __entry->vendor_err = 0;
 650                 }
 651         ),
 652
 653         TP_printk("cqe=%p %u bytes: %s (%u/0x%x)",
 654                 __entry->cqe, __entry->byte_len,
 655                 rdma_show_wc_status(__entry->status),
 656                 __entry->status, __entry->vendor_err
 657         )
 658 );
 659
 660 DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_fastreg);
 661 DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li);
 662 DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li_wake);
 663
 664 DEFINE_MR_EVENT(localinv);
 665 DEFINE_MR_EVENT(map);
 666 DEFINE_MR_EVENT(unmap);
 667 DEFINE_MR_EVENT(remoteinv);
 668 DEFINE_MR_EVENT(recycle);
 669
 670 /**
 671  ** Reply events
 672  **/
 673
 674 TRACE_EVENT(xprtrdma_reply,
 675         TP_PROTO(
 676                 const struct rpc_task *task,
 677                 const struct rpcrdma_rep *rep,
 678                 const struct rpcrdma_req *req,
 679                 unsigned int credits
 680         ),
 681
 682         TP_ARGS(task, rep, req, credits),
 683
 684         TP_STRUCT__entry(
 685                 __field(unsigned int, task_id)
 686                 __field(unsigned int, client_id)
 687                 __field(const void *, rep)
 688                 __field(const void *, req)
 689                 __field(u32, xid)
 690                 __field(unsigned int, credits)
 691         ),
 692
 693         TP_fast_assign(
 694                 __entry->task_id = task->tk_pid;
 695                 __entry->client_id = task->tk_client->cl_clid;
 696                 __entry->rep = rep;
 697                 __entry->req = req;
 698                 __entry->xid = be32_to_cpu(rep->rr_xid);
 699                 __entry->credits = credits;
 700         ),
 701
 702         TP_printk("task:%u@%u xid=0x%08x, %u credits, rep=%p -> req=%p",
 703                 __entry->task_id, __entry->client_id, __entry->xid,
 704                 __entry->credits, __entry->rep, __entry->req
 705         )
 706 );
 707
 708 TRACE_EVENT(xprtrdma_defer_cmp,
 709         TP_PROTO(
 710                 const struct rpcrdma_rep *rep
 711         ),
 712
 713         TP_ARGS(rep),
 714
 715         TP_STRUCT__entry(
 716                 __field(unsigned int, task_id)
 717                 __field(unsigned int, client_id)
 718                 __field(const void *, rep)
 719                 __field(u32, xid)
 720         ),
 721
 722         TP_fast_assign(
 723                 __entry->task_id = rep->rr_rqst->rq_task->tk_pid;
 724                 __entry->client_id = rep->rr_rqst->rq_task->tk_client->cl_clid;
 725                 __entry->rep = rep;
 726                 __entry->xid = be32_to_cpu(rep->rr_xid);
 727         ),
 728
 729         TP_printk("task:%u@%u xid=0x%08x rep=%p",
 730                 __entry->task_id, __entry->client_id, __entry->xid,
 731                 __entry->rep
 732         )
 733 );
 734
 735 DEFINE_REPLY_EVENT(xprtrdma_reply_vers);
 736 DEFINE_REPLY_EVENT(xprtrdma_reply_rqst);
 737 DEFINE_REPLY_EVENT(xprtrdma_reply_short);
 738 DEFINE_REPLY_EVENT(xprtrdma_reply_hdr);
 739
 740 TRACE_EVENT(xprtrdma_fixup,
 741         TP_PROTO(
 742                 const struct rpc_rqst *rqst,
 743                 int len,
 744                 int hdrlen
 745         ),
 746
 747         TP_ARGS(rqst, len, hdrlen),
 748
 749         TP_STRUCT__entry(
 750                 __field(unsigned int, task_id)
 751                 __field(unsigned int, client_id)
 752                 __field(const void *, base)
 753                 __field(int, len)
 754                 __field(int, hdrlen)
 755         ),
 756
 757         TP_fast_assign(
 758                 __entry->task_id = rqst->rq_task->tk_pid;
 759                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
 760                 __entry->base = rqst->rq_rcv_buf.head[0].iov_base;
 761                 __entry->len = len;
 762                 __entry->hdrlen = hdrlen;
 763         ),
 764
 765         TP_printk("task:%u@%u base=%p len=%d hdrlen=%d",
 766                 __entry->task_id, __entry->client_id,
 767                 __entry->base, __entry->len, __entry->hdrlen
 768         )
 769 );
 770
 771 TRACE_EVENT(xprtrdma_fixup_pg,
 772         TP_PROTO(
 773                 const struct rpc_rqst *rqst,
 774                 int pageno,
 775                 const void *pos,
 776                 int len,
 777                 int curlen
 778         ),
 779
 780         TP_ARGS(rqst, pageno, pos, len, curlen),
 781
 782         TP_STRUCT__entry(
 783                 __field(unsigned int, task_id)
 784                 __field(unsigned int, client_id)
 785                 __field(const void *, pos)
 786                 __field(int, pageno)
 787                 __field(int, len)
 788                 __field(int, curlen)
 789         ),
 790
 791         TP_fast_assign(
 792                 __entry->task_id = rqst->rq_task->tk_pid;
 793                 __entry->client_id = rqst->rq_task->tk_client->cl_clid;
 794                 __entry->pos = pos;
 795                 __entry->pageno = pageno;
 796                 __entry->len = len;
 797                 __entry->curlen = curlen;
 798         ),
 799
 800         TP_printk("task:%u@%u pageno=%d pos=%p len=%d curlen=%d",
 801                 __entry->task_id, __entry->client_id,
 802                 __entry->pageno, __entry->pos, __entry->len, __entry->curlen
 803         )
 804 );
 805
 806 TRACE_EVENT(xprtrdma_decode_seg,
 807         TP_PROTO(
 808                 u32 handle,
 809                 u32 length,
 810                 u64 offset
 811         ),
 812
 813         TP_ARGS(handle, length, offset),
 814
 815         TP_STRUCT__entry(
 816                 __field(u32, handle)
 817                 __field(u32, length)
 818                 __field(u64, offset)
 819         ),
 820
 821         TP_fast_assign(
 822                 __entry->handle = handle;
 823                 __entry->length = length;
 824                 __entry->offset = offset;
 825         ),
 826
 827         TP_printk("%u@0x%016llx:0x%08x",
 828                 __entry->length, (unsigned long long)__entry->offset,
 829                 __entry->handle
 830         )
 831 );
 832
 833 /**
 834  ** Allocation/release of rpcrdma_reqs and rpcrdma_reps
 835  **/
 836
 837 TRACE_EVENT(xprtrdma_allocate,
 838         TP_PROTO(
 839                 const struct rpc_task *task,
 840                 const struct rpcrdma_req *req
 841         ),
 842
 843         TP_ARGS(task, req),
 844
 845         TP_STRUCT__entry(
 846                 __field(unsigned int, task_id)
 847                 __field(unsigned int, client_id)
 848                 __field(const void *, req)
 849                 __field(size_t, callsize)
 850                 __field(size_t, rcvsize)
 851         ),
 852
 853         TP_fast_assign(
 854                 __entry->task_id = task->tk_pid;
 855                 __entry->client_id = task->tk_client->cl_clid;
 856                 __entry->req = req;
 857                 __entry->callsize = task->tk_rqstp->rq_callsize;
 858                 __entry->rcvsize = task->tk_rqstp->rq_rcvsize;
 859         ),
 860
 861         TP_printk("task:%u@%u req=%p (%zu, %zu)",
 862                 __entry->task_id, __entry->client_id,
 863                 __entry->req, __entry->callsize, __entry->rcvsize
 864         )
 865 );
 866
 867 TRACE_EVENT(xprtrdma_rpc_done,
 868         TP_PROTO(
 869                 const struct rpc_task *task,
 870                 const struct rpcrdma_req *req
 871         ),
 872
 873         TP_ARGS(task, req),
 874
 875         TP_STRUCT__entry(
 876                 __field(unsigned int, task_id)
 877                 __field(unsigned int, client_id)
 878                 __field(const void *, req)
 879                 __field(const void *, rep)
 880         ),
 881
 882         TP_fast_assign(
 883                 __entry->task_id = task->tk_pid;
 884                 __entry->client_id = task->tk_client->cl_clid;
 885                 __entry->req = req;
 886                 __entry->rep = req->rl_reply;
 887         ),
 888
 889         TP_printk("task:%u@%u req=%p rep=%p",
 890                 __entry->task_id, __entry->client_id,
 891                 __entry->req, __entry->rep
 892         )
 893 );
 894
 895 /**
 896  ** Callback events
 897  **/
 898
 899 TRACE_EVENT(xprtrdma_cb_setup,
 900         TP_PROTO(
 901                 const struct rpcrdma_xprt *r_xprt,
 902                 unsigned int reqs
 903         ),
 904
 905         TP_ARGS(r_xprt, reqs),
 906
 907         TP_STRUCT__entry(
 908                 __field(const void *, r_xprt)
 909                 __field(unsigned int, reqs)
 910                 __string(addr, rpcrdma_addrstr(r_xprt))
 911                 __string(port, rpcrdma_portstr(r_xprt))
 912         ),
 913
 914         TP_fast_assign(
 915                 __entry->r_xprt = r_xprt;
 916                 __entry->reqs = reqs;
 917                 __assign_str(addr, rpcrdma_addrstr(r_xprt));
 918                 __assign_str(port, rpcrdma_portstr(r_xprt));
 919         ),
 920
 921         TP_printk("peer=[%s]:%s r_xprt=%p: %u reqs",
 922                 __get_str(addr), __get_str(port),
 923                 __entry->r_xprt, __entry->reqs
 924         )
 925 );
 926
 927 DEFINE_CB_EVENT(xprtrdma_cb_call);
 928 DEFINE_CB_EVENT(xprtrdma_cb_reply);
 929
 930 /**
 931  ** Server-side RPC/RDMA events
 932  **/
 933
 934 DECLARE_EVENT_CLASS(svcrdma_xprt_event,
 935         TP_PROTO(
 936                 const struct svc_xprt *xprt
 937         ),
 938
 939         TP_ARGS(xprt),
 940
 941         TP_STRUCT__entry(
 942                 __field(const void *, xprt)
 943                 __string(addr, xprt->xpt_remotebuf)
 944         ),
 945
 946         TP_fast_assign(
 947                 __entry->xprt = xprt;
 948                 __assign_str(addr, xprt->xpt_remotebuf);
 949         ),
 950
 951         TP_printk("xprt=%p addr=%s",
 952                 __entry->xprt, __get_str(addr)
 953         )
 954 );
 955
 956 #define DEFINE_XPRT_EVENT(name)                                         \
 957                 DEFINE_EVENT(svcrdma_xprt_event, svcrdma_xprt_##name,   \
 958                                 TP_PROTO(                               \
 959                                         const struct svc_xprt *xprt     \
 960                                 ),                                      \
 961                                 TP_ARGS(xprt))
 962
 963 DEFINE_XPRT_EVENT(accept);
 964 DEFINE_XPRT_EVENT(fail);
 965 DEFINE_XPRT_EVENT(free);
 966
 967 TRACE_DEFINE_ENUM(RDMA_MSG);
 968 TRACE_DEFINE_ENUM(RDMA_NOMSG);
 969 TRACE_DEFINE_ENUM(RDMA_MSGP);
 970 TRACE_DEFINE_ENUM(RDMA_DONE);
 971 TRACE_DEFINE_ENUM(RDMA_ERROR);
 972
 973 #define show_rpcrdma_proc(x)                                            \
 974                 __print_symbolic(x,                                     \
 975                                 { RDMA_MSG, "RDMA_MSG" },               \
 976                                 { RDMA_NOMSG, "RDMA_NOMSG" },           \
 977                                 { RDMA_MSGP, "RDMA_MSGP" },             \
 978                                 { RDMA_DONE, "RDMA_DONE" },             \
 979                                 { RDMA_ERROR, "RDMA_ERROR" })
 980
 981 TRACE_EVENT(svcrdma_decode_rqst,
 982         TP_PROTO(
 983                 __be32 *p,
 984                 unsigned int hdrlen
 985         ),
 986
 987         TP_ARGS(p, hdrlen),
 988
 989         TP_STRUCT__entry(
 990                 __field(u32, xid)
 991                 __field(u32, vers)
 992                 __field(u32, proc)
 993                 __field(u32, credits)
 994                 __field(unsigned int, hdrlen)
 995         ),
 996
 997         TP_fast_assign(
 998                 __entry->xid = be32_to_cpup(p++);
 999                 __entry->vers = be32_to_cpup(p++);
1000                 __entry->credits = be32_to_cpup(p++);
1001                 __entry->proc = be32_to_cpup(p);
1002                 __entry->hdrlen = hdrlen;
1003         ),
1004
1005         TP_printk("xid=0x%08x vers=%u credits=%u proc=%s hdrlen=%u",
1006                 __entry->xid, __entry->vers, __entry->credits,
1007                 show_rpcrdma_proc(__entry->proc), __entry->hdrlen)
1008 );
1009
1010 TRACE_EVENT(svcrdma_decode_short,
1011         TP_PROTO(
1012                 unsigned int hdrlen
1013         ),
1014
1015         TP_ARGS(hdrlen),
1016
1017         TP_STRUCT__entry(
1018                 __field(unsigned int, hdrlen)
1019         ),
1020
1021         TP_fast_assign(
1022                 __entry->hdrlen = hdrlen;
1023         ),
1024
1025         TP_printk("hdrlen=%u", __entry->hdrlen)
1026 );
1027
1028 DECLARE_EVENT_CLASS(svcrdma_badreq_event,
1029         TP_PROTO(
1030                 __be32 *p
1031         ),
1032
1033         TP_ARGS(p),
1034
1035         TP_STRUCT__entry(
1036                 __field(u32, xid)
1037                 __field(u32, vers)
1038                 __field(u32, proc)
1039                 __field(u32, credits)
1040         ),
1041
1042         TP_fast_assign(
1043                 __entry->xid = be32_to_cpup(p++);
1044                 __entry->vers = be32_to_cpup(p++);
1045                 __entry->credits = be32_to_cpup(p++);
1046                 __entry->proc = be32_to_cpup(p);
1047         ),
1048
1049         TP_printk("xid=0x%08x vers=%u credits=%u proc=%u",
1050                 __entry->xid, __entry->vers, __entry->credits, __entry->proc)
1051 );
1052
1053 #define DEFINE_BADREQ_EVENT(name)                                       \
1054                 DEFINE_EVENT(svcrdma_badreq_event, svcrdma_decode_##name,\
1055                                 TP_PROTO(                               \
1056                                         __be32 *p                       \
1057                                 ),                                      \
1058                                 TP_ARGS(p))
1059
1060 DEFINE_BADREQ_EVENT(badvers);
1061 DEFINE_BADREQ_EVENT(drop);
1062 DEFINE_BADREQ_EVENT(badproc);
1063 DEFINE_BADREQ_EVENT(parse);
1064
1065 DECLARE_EVENT_CLASS(svcrdma_segment_event,
1066         TP_PROTO(
1067                 u32 handle,
1068                 u32 length,
1069                 u64 offset
1070         ),
1071
1072         TP_ARGS(handle, length, offset),
1073
1074         TP_STRUCT__entry(
1075                 __field(u32, handle)
1076                 __field(u32, length)
1077                 __field(u64, offset)
1078         ),
1079
1080         TP_fast_assign(
1081                 __entry->handle = handle;
1082                 __entry->length = length;
1083                 __entry->offset = offset;
1084         ),
1085
1086         TP_printk("%u@0x%016llx:0x%08x",
1087                 __entry->length, (unsigned long long)__entry->offset,
1088                 __entry->handle
1089         )
1090 );
1091
1092 #define DEFINE_SEGMENT_EVENT(name)                                      \
1093                 DEFINE_EVENT(svcrdma_segment_event, svcrdma_encode_##name,\
1094                                 TP_PROTO(                               \
1095                                         u32 handle,                     \
1096                                         u32 length,                     \
1097                                         u64 offset                      \
1098                                 ),                                      \
1099                                 TP_ARGS(handle, length, offset))
1100
1101 DEFINE_SEGMENT_EVENT(rseg);
1102 DEFINE_SEGMENT_EVENT(wseg);
1103
1104 DECLARE_EVENT_CLASS(svcrdma_chunk_event,
1105         TP_PROTO(
1106                 u32 length
1107         ),
1108
1109         TP_ARGS(length),
1110
1111         TP_STRUCT__entry(
1112                 __field(u32, length)
1113         ),
1114
1115         TP_fast_assign(
1116                 __entry->length = length;
1117         ),
1118
1119         TP_printk("length=%u",
1120                 __entry->length
1121         )
1122 );
1123
1124 #define DEFINE_CHUNK_EVENT(name)                                        \
1125                 DEFINE_EVENT(svcrdma_chunk_event, svcrdma_encode_##name,\
1126                                 TP_PROTO(                               \
1127                                         u32 length                      \
1128                                 ),                                      \
1129                                 TP_ARGS(length))
1130
1131 DEFINE_CHUNK_EVENT(pzr);
1132 DEFINE_CHUNK_EVENT(write);
1133 DEFINE_CHUNK_EVENT(reply);
1134
1135 TRACE_EVENT(svcrdma_encode_read,
1136         TP_PROTO(
1137                 u32 length,
1138                 u32 position
1139         ),
1140
1141         TP_ARGS(length, position),
1142
1143         TP_STRUCT__entry(
1144                 __field(u32, length)
1145                 __field(u32, position)
1146         ),
1147
1148         TP_fast_assign(
1149                 __entry->length = length;
1150                 __entry->position = position;
1151         ),
1152
1153         TP_printk("length=%u position=%u",
1154                 __entry->length, __entry->position
1155         )
1156 );
1157
1158 DECLARE_EVENT_CLASS(svcrdma_error_event,
1159         TP_PROTO(
1160                 __be32 xid
1161         ),
1162
1163         TP_ARGS(xid),
1164
1165         TP_STRUCT__entry(
1166                 __field(u32, xid)
1167         ),
1168
1169         TP_fast_assign(
1170                 __entry->xid = be32_to_cpu(xid);
1171         ),
1172
1173         TP_printk("xid=0x%08x",
1174                 __entry->xid
1175         )
1176 );
1177
1178 #define DEFINE_ERROR_EVENT(name)                                        \
1179                 DEFINE_EVENT(svcrdma_error_event, svcrdma_err_##name,   \
1180                                 TP_PROTO(                               \
1181                                         __be32 xid                      \
1182                                 ),                                      \
1183                                 TP_ARGS(xid))
1184
1185 DEFINE_ERROR_EVENT(vers);
1186 DEFINE_ERROR_EVENT(chunk);
1187
1188 /**
1189  ** Server-side RDMA API events
1190  **/
1191
1192 TRACE_EVENT(svcrdma_dma_map_page,
1193         TP_PROTO(
1194                 const struct svcxprt_rdma *rdma,
1195                 const void *page
1196         ),
1197
1198         TP_ARGS(rdma, page),
1199
1200         TP_STRUCT__entry(
1201                 __field(const void *, page);
1202                 __string(device, rdma->sc_cm_id->device->name)
1203                 __string(addr, rdma->sc_xprt.xpt_remotebuf)
1204         ),
1205
1206         TP_fast_assign(
1207                 __entry->page = page;
1208                 __assign_str(device, rdma->sc_cm_id->device->name);
1209                 __assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
1210         ),
1211
1212         TP_printk("addr=%s device=%s page=%p",
1213                 __get_str(addr), __get_str(device), __entry->page
1214         )
1215 );
1216
1217 TRACE_EVENT(svcrdma_dma_map_rwctx,
1218         TP_PROTO(
1219                 const struct svcxprt_rdma *rdma,
1220                 int status
1221         ),
1222
1223         TP_ARGS(rdma, status),
1224
1225         TP_STRUCT__entry(
1226                 __field(int, status)
1227                 __string(device, rdma->sc_cm_id->device->name)
1228                 __string(addr, rdma->sc_xprt.xpt_remotebuf)
1229         ),
1230
1231         TP_fast_assign(
1232                 __entry->status = status;
1233                 __assign_str(device, rdma->sc_cm_id->device->name);
1234                 __assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
1235         ),
1236
1237         TP_printk("addr=%s device=%s status=%d",
1238                 __get_str(addr), __get_str(device), __entry->status
1239         )
1240 );
1241
1242 TRACE_EVENT(svcrdma_send_failed,
1243         TP_PROTO(
1244                 const struct svc_rqst *rqst,
1245                 int status
1246         ),
1247
1248         TP_ARGS(rqst, status),
1249
1250         TP_STRUCT__entry(
1251                 __field(int, status)
1252                 __field(u32, xid)
1253                 __field(const void *, xprt)
1254                 __string(addr, rqst->rq_xprt->xpt_remotebuf)
1255         ),
1256
1257         TP_fast_assign(
1258                 __entry->status = status;
1259                 __entry->xid = __be32_to_cpu(rqst->rq_xid);
1260                 __entry->xprt = rqst->rq_xprt;
1261                 __assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1262         ),
1263
1264         TP_printk("xprt=%p addr=%s xid=0x%08x status=%d",
1265                 __entry->xprt, __get_str(addr),
1266                 __entry->xid, __entry->status
1267         )
1268 );
1269
1270 DECLARE_EVENT_CLASS(svcrdma_sendcomp_event,
1271         TP_PROTO(
1272                 const struct ib_wc *wc
1273         ),
1274
1275         TP_ARGS(wc),
1276
1277         TP_STRUCT__entry(
1278                 __field(const void *, cqe)
1279                 __field(unsigned int, status)
1280                 __field(unsigned int, vendor_err)
1281         ),
1282
1283         TP_fast_assign(
1284                 __entry->cqe = wc->wr_cqe;
1285                 __entry->status = wc->status;
1286                 if (wc->status)
1287                         __entry->vendor_err = wc->vendor_err;
1288                 else
1289                         __entry->vendor_err = 0;
1290         ),
1291
1292         TP_printk("cqe=%p status=%s (%u/0x%x)",
1293                 __entry->cqe, rdma_show_wc_status(__entry->status),
1294                 __entry->status, __entry->vendor_err
1295         )
1296 );
1297
1298 #define DEFINE_SENDCOMP_EVENT(name)                                     \
1299                 DEFINE_EVENT(svcrdma_sendcomp_event, svcrdma_wc_##name, \
1300                                 TP_PROTO(                               \
1301                                         const struct ib_wc *wc          \
1302                                 ),                                      \
1303                                 TP_ARGS(wc))
1304
1305 TRACE_EVENT(svcrdma_post_send,
1306         TP_PROTO(
1307                 const struct ib_send_wr *wr,
1308                 int status
1309         ),
1310
1311         TP_ARGS(wr, status),
1312
1313         TP_STRUCT__entry(
1314                 __field(const void *, cqe)
1315                 __field(unsigned int, num_sge)
1316                 __field(u32, inv_rkey)
1317                 __field(int, status)
1318         ),
1319
1320         TP_fast_assign(
1321                 __entry->cqe = wr->wr_cqe;
1322                 __entry->num_sge = wr->num_sge;
1323                 __entry->inv_rkey = (wr->opcode == IB_WR_SEND_WITH_INV) ?
1324                                         wr->ex.invalidate_rkey : 0;
1325                 __entry->status = status;
1326         ),
1327
1328         TP_printk("cqe=%p num_sge=%u inv_rkey=0x%08x status=%d",
1329                 __entry->cqe, __entry->num_sge,
1330                 __entry->inv_rkey, __entry->status
1331         )
1332 );
1333
1334 DEFINE_SENDCOMP_EVENT(send);
1335
1336 TRACE_EVENT(svcrdma_post_recv,
1337         TP_PROTO(
1338                 const struct ib_recv_wr *wr,
1339                 int status
1340         ),
1341
1342         TP_ARGS(wr, status),
1343
1344         TP_STRUCT__entry(
1345                 __field(const void *, cqe)
1346                 __field(int, status)
1347         ),
1348
1349         TP_fast_assign(
1350                 __entry->cqe = wr->wr_cqe;
1351                 __entry->status = status;
1352         ),
1353
1354         TP_printk("cqe=%p status=%d",
1355                 __entry->cqe, __entry->status
1356         )
1357 );
1358
1359 TRACE_EVENT(svcrdma_wc_receive,
1360         TP_PROTO(
1361                 const struct ib_wc *wc
1362         ),
1363
1364         TP_ARGS(wc),
1365
1366         TP_STRUCT__entry(
1367                 __field(const void *, cqe)
1368                 __field(u32, byte_len)
1369                 __field(unsigned int, status)
1370                 __field(u32, vendor_err)
1371         ),
1372
1373         TP_fast_assign(
1374                 __entry->cqe = wc->wr_cqe;
1375                 __entry->status = wc->status;
1376                 if (wc->status) {
1377                         __entry->byte_len = 0;
1378                         __entry->vendor_err = wc->vendor_err;
1379                 } else {
1380                         __entry->byte_len = wc->byte_len;
1381                         __entry->vendor_err = 0;
1382                 }
1383         ),
1384
1385         TP_printk("cqe=%p byte_len=%u status=%s (%u/0x%x)",
1386                 __entry->cqe, __entry->byte_len,
1387                 rdma_show_wc_status(__entry->status),
1388                 __entry->status, __entry->vendor_err
1389         )
1390 );
1391
1392 TRACE_EVENT(svcrdma_post_rw,
1393         TP_PROTO(
1394                 const void *cqe,
1395                 int sqecount,
1396                 int status
1397         ),
1398
1399         TP_ARGS(cqe, sqecount, status),
1400
1401         TP_STRUCT__entry(
1402                 __field(const void *, cqe)
1403                 __field(int, sqecount)
1404                 __field(int, status)
1405         ),
1406
1407         TP_fast_assign(
1408                 __entry->cqe = cqe;
1409                 __entry->sqecount = sqecount;
1410                 __entry->status = status;
1411         ),
1412
1413         TP_printk("cqe=%p sqecount=%d status=%d",
1414                 __entry->cqe, __entry->sqecount, __entry->status
1415         )
1416 );
1417
1418 DEFINE_SENDCOMP_EVENT(read);
1419 DEFINE_SENDCOMP_EVENT(write);
1420
1421 TRACE_EVENT(svcrdma_cm_event,
1422         TP_PROTO(
1423                 const struct rdma_cm_event *event,
1424                 const struct sockaddr *sap
1425         ),
1426
1427         TP_ARGS(event, sap),
1428
1429         TP_STRUCT__entry(
1430                 __field(unsigned int, event)
1431                 __field(int, status)
1432                 __array(__u8, addr, INET6_ADDRSTRLEN + 10)
1433         ),
1434
1435         TP_fast_assign(
1436                 __entry->event = event->event;
1437                 __entry->status = event->status;
1438                 snprintf(__entry->addr, sizeof(__entry->addr) - 1,
1439                          "%pISpc", sap);
1440         ),
1441
1442         TP_printk("addr=%s event=%s (%u/%d)",
1443                 __entry->addr,
1444                 rdma_show_cm_event(__entry->event),
1445                 __entry->event, __entry->status
1446         )
1447 );
1448
1449 TRACE_EVENT(svcrdma_qp_error,
1450         TP_PROTO(
1451                 const struct ib_event *event,
1452                 const struct sockaddr *sap
1453         ),
1454
1455         TP_ARGS(event, sap),
1456
1457         TP_STRUCT__entry(
1458                 __field(unsigned int, event)
1459                 __string(device, event->device->name)
1460                 __array(__u8, addr, INET6_ADDRSTRLEN + 10)
1461         ),
1462
1463         TP_fast_assign(
1464                 __entry->event = event->event;
1465                 __assign_str(device, event->device->name);
1466                 snprintf(__entry->addr, sizeof(__entry->addr) - 1,
1467                          "%pISpc", sap);
1468         ),
1469
1470         TP_printk("addr=%s dev=%s event=%s (%u)",
1471                 __entry->addr, __get_str(device),
1472                 rdma_show_ib_event(__entry->event), __entry->event
1473         )
1474 );
1475
1476 DECLARE_EVENT_CLASS(svcrdma_sendqueue_event,
1477         TP_PROTO(
1478                 const struct svcxprt_rdma *rdma
1479         ),
1480
1481         TP_ARGS(rdma),
1482
1483         TP_STRUCT__entry(
1484                 __field(int, avail)
1485                 __field(int, depth)
1486                 __string(addr, rdma->sc_xprt.xpt_remotebuf)
1487         ),
1488
1489         TP_fast_assign(
1490                 __entry->avail = atomic_read(&rdma->sc_sq_avail);
1491                 __entry->depth = rdma->sc_sq_depth;
1492                 __assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
1493         ),
1494
1495         TP_printk("addr=%s sc_sq_avail=%d/%d",
1496                 __get_str(addr), __entry->avail, __entry->depth
1497         )
1498 );
1499
1500 #define DEFINE_SQ_EVENT(name)                                           \
1501                 DEFINE_EVENT(svcrdma_sendqueue_event, svcrdma_sq_##name,\
1502                                 TP_PROTO(                               \
1503                                         const struct svcxprt_rdma *rdma \
1504                                 ),                                      \
1505                                 TP_ARGS(rdma))
1506
1507 DEFINE_SQ_EVENT(full);
1508 DEFINE_SQ_EVENT(retry);
1509
1510 #endif /* _TRACE_RPCRDMA_H */
1511
1512 #include <trace/define_trace.h>