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