include/trace/events/rpcrdma.h

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