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
  21DECLARE_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
  57DECLARE_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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  88DECLARE_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
 138DECLARE_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
 184DECLARE_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
 219TRACE_DEFINE_ENUM(DMA_BIDIRECTIONAL);
 220TRACE_DEFINE_ENUM(DMA_TO_DEVICE);
 221TRACE_DEFINE_ENUM(DMA_FROM_DEVICE);
 222TRACE_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
 231DECLARE_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
 268DECLARE_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
 305TRACE_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
 336TRACE_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
 367DEFINE_RXPRT_EVENT(xprtrdma_conn_start);
 368DEFINE_RXPRT_EVENT(xprtrdma_conn_tout);
 369DEFINE_RXPRT_EVENT(xprtrdma_create);
 370DEFINE_RXPRT_EVENT(xprtrdma_op_destroy);
 371DEFINE_RXPRT_EVENT(xprtrdma_remove);
 372DEFINE_RXPRT_EVENT(xprtrdma_reinsert);
 373DEFINE_RXPRT_EVENT(xprtrdma_reconnect);
 374DEFINE_RXPRT_EVENT(xprtrdma_op_inject_dsc);
 375DEFINE_RXPRT_EVENT(xprtrdma_op_close);
 376DEFINE_RXPRT_EVENT(xprtrdma_op_connect);
 377
 378TRACE_EVENT(xprtrdma_op_set_cto,
 379	TP_PROTO(
 380		const struct rpcrdma_xprt *r_xprt,
 381		unsigned long connect,
 382		unsigned long reconnect
 383	),
 384
 385	TP_ARGS(r_xprt, connect, reconnect),
 386
 387	TP_STRUCT__entry(
 388		__field(const void *, r_xprt)
 389		__field(unsigned long, connect)
 390		__field(unsigned long, reconnect)
 391		__string(addr, rpcrdma_addrstr(r_xprt))
 392		__string(port, rpcrdma_portstr(r_xprt))
 393	),
 394
 395	TP_fast_assign(
 396		__entry->r_xprt = r_xprt;
 397		__entry->connect = connect;
 398		__entry->reconnect = reconnect;
 399		__assign_str(addr, rpcrdma_addrstr(r_xprt));
 400		__assign_str(port, rpcrdma_portstr(r_xprt));
 401	),
 402
 403	TP_printk("peer=[%s]:%s r_xprt=%p: connect=%lu reconnect=%lu",
 404		__get_str(addr), __get_str(port), __entry->r_xprt,
 405		__entry->connect / HZ, __entry->reconnect / HZ
 406	)
 407);
 408
 409TRACE_EVENT(xprtrdma_qp_event,
 410	TP_PROTO(
 411		const struct rpcrdma_xprt *r_xprt,
 412		const struct ib_event *event
 413	),
 414
 415	TP_ARGS(r_xprt, event),
 416
 417	TP_STRUCT__entry(
 418		__field(const void *, r_xprt)
 419		__field(unsigned int, event)
 420		__string(name, event->device->name)
 421		__string(addr, rpcrdma_addrstr(r_xprt))
 422		__string(port, rpcrdma_portstr(r_xprt))
 423	),
 424
 425	TP_fast_assign(
 426		__entry->r_xprt = r_xprt;
 427		__entry->event = event->event;
 428		__assign_str(name, event->device->name);
 429		__assign_str(addr, rpcrdma_addrstr(r_xprt));
 430		__assign_str(port, rpcrdma_portstr(r_xprt));
 431	),
 432
 433	TP_printk("peer=[%s]:%s r_xprt=%p: dev %s: %s (%u)",
 434		__get_str(addr), __get_str(port), __entry->r_xprt,
 435		__get_str(name), rdma_show_ib_event(__entry->event),
 436		__entry->event
 437	)
 438);
 439
 440/**
 441 ** Call events
 442 **/
 443
 444TRACE_EVENT(xprtrdma_createmrs,
 445	TP_PROTO(
 446		const struct rpcrdma_xprt *r_xprt,
 447		unsigned int count
 448	),
 449
 450	TP_ARGS(r_xprt, count),
 451
 452	TP_STRUCT__entry(
 453		__field(const void *, r_xprt)
 454		__string(addr, rpcrdma_addrstr(r_xprt))
 455		__string(port, rpcrdma_portstr(r_xprt))
 456		__field(unsigned int, count)
 457	),
 458
 459	TP_fast_assign(
 460		__entry->r_xprt = r_xprt;
 461		__entry->count = count;
 462		__assign_str(addr, rpcrdma_addrstr(r_xprt));
 463		__assign_str(port, rpcrdma_portstr(r_xprt));
 464	),
 465
 466	TP_printk("peer=[%s]:%s r_xprt=%p: created %u MRs",
 467		__get_str(addr), __get_str(port), __entry->r_xprt,
 468		__entry->count
 469	)
 470);
 471
 472TRACE_EVENT(xprtrdma_mr_get,
 473	TP_PROTO(
 474		const struct rpcrdma_req *req
 475	),
 476
 477	TP_ARGS(req),
 478
 479	TP_STRUCT__entry(
 480		__field(const void *, req)
 481		__field(unsigned int, task_id)
 482		__field(unsigned int, client_id)
 483		__field(u32, xid)
 484	),
 485
 486	TP_fast_assign(
 487		const struct rpc_rqst *rqst = &req->rl_slot;
 488
 489		__entry->req = req;
 490		__entry->task_id = rqst->rq_task->tk_pid;
 491		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
 492		__entry->xid = be32_to_cpu(rqst->rq_xid);
 493	),
 494
 495	TP_printk("task:%u@%u xid=0x%08x req=%p",
 496		__entry->task_id, __entry->client_id, __entry->xid,
 497		__entry->req
 498	)
 499);
 500
 501TRACE_EVENT(xprtrdma_nomrs,
 502	TP_PROTO(
 
 503		const struct rpcrdma_req *req
 504	),
 505
 506	TP_ARGS(req),
 507
 508	TP_STRUCT__entry(
 509		__field(const void *, req)
 510		__field(unsigned int, task_id)
 511		__field(unsigned int, client_id)
 512		__field(u32, xid)
 
 513	),
 514
 515	TP_fast_assign(
 516		const struct rpc_rqst *rqst = &req->rl_slot;
 517
 518		__entry->req = req;
 519		__entry->task_id = rqst->rq_task->tk_pid;
 520		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
 521		__entry->xid = be32_to_cpu(rqst->rq_xid);
 
 522	),
 523
 524	TP_printk("task:%u@%u xid=0x%08x req=%p",
 525		__entry->task_id, __entry->client_id, __entry->xid,
 526		__entry->req
 527	)
 528);
 529
 530DEFINE_RDCH_EVENT(read);
 531DEFINE_WRCH_EVENT(write);
 532DEFINE_WRCH_EVENT(reply);
 
 533
 534TRACE_DEFINE_ENUM(rpcrdma_noch);
 
 
 535TRACE_DEFINE_ENUM(rpcrdma_readch);
 536TRACE_DEFINE_ENUM(rpcrdma_areadch);
 537TRACE_DEFINE_ENUM(rpcrdma_writech);
 538TRACE_DEFINE_ENUM(rpcrdma_replych);
 539
 540#define xprtrdma_show_chunktype(x)					\
 541		__print_symbolic(x,					\
 542				{ rpcrdma_noch, "inline" },		\
 
 
 543				{ rpcrdma_readch, "read list" },	\
 544				{ rpcrdma_areadch, "*read list" },	\
 545				{ rpcrdma_writech, "write list" },	\
 546				{ rpcrdma_replych, "reply chunk" })
 547
 548TRACE_EVENT(xprtrdma_marshal,
 549	TP_PROTO(
 550		const struct rpcrdma_req *req,
 551		unsigned int rtype,
 552		unsigned int wtype
 553	),
 554
 555	TP_ARGS(req, rtype, wtype),
 556
 557	TP_STRUCT__entry(
 558		__field(unsigned int, task_id)
 559		__field(unsigned int, client_id)
 560		__field(u32, xid)
 561		__field(unsigned int, hdrlen)
 562		__field(unsigned int, headlen)
 563		__field(unsigned int, pagelen)
 564		__field(unsigned int, taillen)
 565		__field(unsigned int, rtype)
 566		__field(unsigned int, wtype)
 567	),
 568
 569	TP_fast_assign(
 570		const struct rpc_rqst *rqst = &req->rl_slot;
 571
 572		__entry->task_id = rqst->rq_task->tk_pid;
 573		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
 574		__entry->xid = be32_to_cpu(rqst->rq_xid);
 575		__entry->hdrlen = req->rl_hdrbuf.len;
 576		__entry->headlen = rqst->rq_snd_buf.head[0].iov_len;
 577		__entry->pagelen = rqst->rq_snd_buf.page_len;
 578		__entry->taillen = rqst->rq_snd_buf.tail[0].iov_len;
 579		__entry->rtype = rtype;
 580		__entry->wtype = wtype;
 581	),
 582
 583	TP_printk("task:%u@%u xid=0x%08x: hdr=%u xdr=%u/%u/%u %s/%s",
 
 584		__entry->task_id, __entry->client_id, __entry->xid,
 585		__entry->hdrlen,
 586		__entry->headlen, __entry->pagelen, __entry->taillen,
 587		xprtrdma_show_chunktype(__entry->rtype),
 588		xprtrdma_show_chunktype(__entry->wtype)
 589	)
 590);
 591
 592TRACE_EVENT(xprtrdma_marshal_failed,
 593	TP_PROTO(const struct rpc_rqst *rqst,
 594		 int ret
 595	),
 596
 597	TP_ARGS(rqst, ret),
 598
 599	TP_STRUCT__entry(
 600		__field(unsigned int, task_id)
 601		__field(unsigned int, client_id)
 602		__field(u32, xid)
 603		__field(int, ret)
 604	),
 605
 606	TP_fast_assign(
 607		__entry->task_id = rqst->rq_task->tk_pid;
 608		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
 609		__entry->xid = be32_to_cpu(rqst->rq_xid);
 610		__entry->ret = ret;
 611	),
 612
 613	TP_printk("task:%u@%u xid=0x%08x: ret=%d",
 614		__entry->task_id, __entry->client_id, __entry->xid,
 615		__entry->ret
 616	)
 617);
 618
 619TRACE_EVENT(xprtrdma_prepsend_failed,
 620	TP_PROTO(const struct rpc_rqst *rqst,
 621		 int ret
 622	),
 623
 624	TP_ARGS(rqst, ret),
 625
 626	TP_STRUCT__entry(
 627		__field(unsigned int, task_id)
 628		__field(unsigned int, client_id)
 629		__field(u32, xid)
 630		__field(int, ret)
 631	),
 632
 633	TP_fast_assign(
 634		__entry->task_id = rqst->rq_task->tk_pid;
 635		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
 636		__entry->xid = be32_to_cpu(rqst->rq_xid);
 637		__entry->ret = ret;
 638	),
 639
 640	TP_printk("task:%u@%u xid=0x%08x: ret=%d",
 641		__entry->task_id, __entry->client_id, __entry->xid,
 642		__entry->ret
 643	)
 644);
 645
 646TRACE_EVENT(xprtrdma_post_send,
 647	TP_PROTO(
 648		const struct rpcrdma_req *req,
 649		int status
 650	),
 651
 652	TP_ARGS(req, status),
 653
 654	TP_STRUCT__entry(
 655		__field(const void *, req)
 
 656		__field(unsigned int, task_id)
 657		__field(unsigned int, client_id)
 658		__field(int, num_sge)
 659		__field(int, signaled)
 660		__field(int, status)
 661	),
 662
 663	TP_fast_assign(
 664		const struct rpc_rqst *rqst = &req->rl_slot;
 
 665
 
 
 666		__entry->task_id = rqst->rq_task->tk_pid;
 667		__entry->client_id = rqst->rq_task->tk_client ?
 668				     rqst->rq_task->tk_client->cl_clid : -1;
 669		__entry->req = req;
 670		__entry->num_sge = req->rl_sendctx->sc_wr.num_sge;
 671		__entry->signaled = req->rl_sendctx->sc_wr.send_flags &
 672				    IB_SEND_SIGNALED;
 673		__entry->status = status;
 674	),
 675
 676	TP_printk("task:%u@%u req=%p (%d SGE%s) %sstatus=%d",
 677		__entry->task_id, __entry->client_id,
 678		__entry->req, __entry->num_sge,
 679		(__entry->num_sge == 1 ? "" : "s"),
 680		(__entry->signaled ? "signaled " : ""),
 681		__entry->status
 682	)
 683);
 684
 685TRACE_EVENT(xprtrdma_post_recv,
 686	TP_PROTO(
 687		const struct rpcrdma_rep *rep
 
 
 688	),
 689
 690	TP_ARGS(rep),
 691
 692	TP_STRUCT__entry(
 693		__field(const void *, rep)
 
 
 
 694	),
 695
 696	TP_fast_assign(
 697		__entry->rep = rep;
 
 
 
 
 
 
 
 698	),
 699
 700	TP_printk("rep=%p",
 701		__entry->rep
 
 702	)
 703);
 704
 
 
 705TRACE_EVENT(xprtrdma_post_recvs,
 706	TP_PROTO(
 707		const struct rpcrdma_xprt *r_xprt,
 708		unsigned int count,
 709		int status
 710	),
 711
 712	TP_ARGS(r_xprt, count, status),
 713
 714	TP_STRUCT__entry(
 715		__field(const void *, r_xprt)
 716		__field(unsigned int, count)
 717		__field(int, status)
 718		__field(int, posted)
 719		__string(addr, rpcrdma_addrstr(r_xprt))
 720		__string(port, rpcrdma_portstr(r_xprt))
 721	),
 722
 723	TP_fast_assign(
 724		__entry->r_xprt = r_xprt;
 
 
 725		__entry->count = count;
 726		__entry->status = status;
 727		__entry->posted = r_xprt->rx_ep.rep_receive_count;
 728		__assign_str(addr, rpcrdma_addrstr(r_xprt));
 729		__assign_str(port, rpcrdma_portstr(r_xprt));
 730	),
 731
 732	TP_printk("peer=[%s]:%s r_xprt=%p: %u new recvs, %d active (rc %d)",
 733		__get_str(addr), __get_str(port), __entry->r_xprt,
 734		__entry->count, __entry->posted, __entry->status
 735	)
 736);
 737
 738/**
 739 ** Completion events
 740 **/
 741
 742TRACE_EVENT(xprtrdma_wc_send,
 743	TP_PROTO(
 744		const struct rpcrdma_sendctx *sc,
 745		const struct ib_wc *wc
 746	),
 747
 748	TP_ARGS(sc, wc),
 749
 750	TP_STRUCT__entry(
 751		__field(const void *, req)
 752		__field(unsigned int, unmap_count)
 753		__field(unsigned int, status)
 754		__field(unsigned int, vendor_err)
 755	),
 756
 757	TP_fast_assign(
 758		__entry->req = sc->sc_req;
 759		__entry->unmap_count = sc->sc_unmap_count;
 760		__entry->status = wc->status;
 761		__entry->vendor_err = __entry->status ? wc->vendor_err : 0;
 
 
 762	),
 763
 764	TP_printk("req=%p, unmapped %u pages: %s (%u/0x%x)",
 765		__entry->req, __entry->unmap_count,
 766		rdma_show_wc_status(__entry->status),
 767		__entry->status, __entry->vendor_err
 768	)
 769);
 770
 771TRACE_EVENT(xprtrdma_wc_receive,
 772	TP_PROTO(
 773		const struct ib_wc *wc
 
 774	),
 775
 776	TP_ARGS(wc),
 777
 778	TP_STRUCT__entry(
 779		__field(const void *, rep)
 780		__field(u32, byte_len)
 781		__field(unsigned int, status)
 782		__field(u32, vendor_err)
 783	),
 784
 785	TP_fast_assign(
 786		__entry->rep = container_of(wc->wr_cqe, struct rpcrdma_rep,
 787					    rr_cqe);
 788		__entry->status = wc->status;
 789		if (wc->status) {
 790			__entry->byte_len = 0;
 791			__entry->vendor_err = wc->vendor_err;
 792		} else {
 793			__entry->byte_len = wc->byte_len;
 794			__entry->vendor_err = 0;
 795		}
 796	),
 797
 798	TP_printk("rep=%p %u bytes: %s (%u/0x%x)",
 799		__entry->rep, __entry->byte_len,
 800		rdma_show_wc_status(__entry->status),
 801		__entry->status, __entry->vendor_err
 802	)
 803);
 804
 805DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_fastreg);
 806DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li);
 807DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li_wake);
 808DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li_done);
 
 
 
 
 
 
 
 809
 810TRACE_EVENT(xprtrdma_frwr_alloc,
 811	TP_PROTO(
 812		const struct rpcrdma_mr *mr,
 813		int rc
 814	),
 815
 816	TP_ARGS(mr, rc),
 817
 818	TP_STRUCT__entry(
 819		__field(const void *, mr)
 820		__field(int, rc)
 821	),
 822
 823	TP_fast_assign(
 824		__entry->mr = mr;
 825		__entry->rc	= rc;
 826	),
 827
 828	TP_printk("mr=%p: rc=%d",
 829		__entry->mr, __entry->rc
 830	)
 831);
 832
 833TRACE_EVENT(xprtrdma_frwr_dereg,
 834	TP_PROTO(
 835		const struct rpcrdma_mr *mr,
 836		int rc
 837	),
 838
 839	TP_ARGS(mr, rc),
 840
 841	TP_STRUCT__entry(
 842		__field(const void *, mr)
 
 843		__field(u32, handle)
 844		__field(u32, length)
 845		__field(u64, offset)
 846		__field(u32, dir)
 847		__field(int, rc)
 848	),
 849
 850	TP_fast_assign(
 851		__entry->mr = mr;
 
 852		__entry->handle = mr->mr_handle;
 853		__entry->length = mr->mr_length;
 854		__entry->offset = mr->mr_offset;
 855		__entry->dir    = mr->mr_dir;
 856		__entry->rc	= rc;
 857	),
 858
 859	TP_printk("mr=%p %u@0x%016llx:0x%08x (%s): rc=%d",
 860		__entry->mr, __entry->length,
 861		(unsigned long long)__entry->offset, __entry->handle,
 862		xprtrdma_show_direction(__entry->dir),
 863		__entry->rc
 864	)
 865);
 866
 867TRACE_EVENT(xprtrdma_frwr_sgerr,
 868	TP_PROTO(
 869		const struct rpcrdma_mr *mr,
 870		int sg_nents
 871	),
 872
 873	TP_ARGS(mr, sg_nents),
 874
 875	TP_STRUCT__entry(
 876		__field(const void *, mr)
 877		__field(u64, addr)
 878		__field(u32, dir)
 879		__field(int, nents)
 880	),
 881
 882	TP_fast_assign(
 883		__entry->mr = mr;
 884		__entry->addr = mr->mr_sg->dma_address;
 885		__entry->dir = mr->mr_dir;
 886		__entry->nents = sg_nents;
 887	),
 888
 889	TP_printk("mr=%p dma addr=0x%llx (%s) sg_nents=%d",
 890		__entry->mr, __entry->addr,
 891		xprtrdma_show_direction(__entry->dir),
 892		__entry->nents
 893	)
 894);
 895
 896TRACE_EVENT(xprtrdma_frwr_maperr,
 897	TP_PROTO(
 898		const struct rpcrdma_mr *mr,
 899		int num_mapped
 900	),
 901
 902	TP_ARGS(mr, num_mapped),
 903
 904	TP_STRUCT__entry(
 905		__field(const void *, mr)
 906		__field(u64, addr)
 907		__field(u32, dir)
 908		__field(int, num_mapped)
 909		__field(int, nents)
 910	),
 911
 912	TP_fast_assign(
 913		__entry->mr = mr;
 914		__entry->addr = mr->mr_sg->dma_address;
 915		__entry->dir = mr->mr_dir;
 916		__entry->num_mapped = num_mapped;
 917		__entry->nents = mr->mr_nents;
 918	),
 919
 920	TP_printk("mr=%p dma addr=0x%llx (%s) nents=%d of %d",
 921		__entry->mr, __entry->addr,
 922		xprtrdma_show_direction(__entry->dir),
 923		__entry->num_mapped, __entry->nents
 924	)
 925);
 926
 
 927DEFINE_MR_EVENT(localinv);
 
 928DEFINE_MR_EVENT(map);
 929DEFINE_MR_EVENT(unmap);
 930DEFINE_MR_EVENT(remoteinv);
 931DEFINE_MR_EVENT(recycle);
 932
 933TRACE_EVENT(xprtrdma_dma_maperr,
 934	TP_PROTO(
 935		u64 addr
 936	),
 937
 938	TP_ARGS(addr),
 939
 940	TP_STRUCT__entry(
 941		__field(u64, addr)
 942	),
 943
 944	TP_fast_assign(
 945		__entry->addr = addr;
 946	),
 947
 948	TP_printk("dma addr=0x%llx\n", __entry->addr)
 949);
 950
 951/**
 952 ** Reply events
 953 **/
 954
 955TRACE_EVENT(xprtrdma_reply,
 956	TP_PROTO(
 957		const struct rpc_task *task,
 958		const struct rpcrdma_rep *rep,
 959		const struct rpcrdma_req *req,
 960		unsigned int credits
 961	),
 962
 963	TP_ARGS(task, rep, req, credits),
 964
 965	TP_STRUCT__entry(
 966		__field(unsigned int, task_id)
 967		__field(unsigned int, client_id)
 968		__field(const void *, rep)
 969		__field(const void *, req)
 970		__field(u32, xid)
 971		__field(unsigned int, credits)
 972	),
 973
 974	TP_fast_assign(
 975		__entry->task_id = task->tk_pid;
 976		__entry->client_id = task->tk_client->cl_clid;
 977		__entry->rep = rep;
 978		__entry->req = req;
 979		__entry->xid = be32_to_cpu(rep->rr_xid);
 980		__entry->credits = credits;
 981	),
 982
 983	TP_printk("task:%u@%u xid=0x%08x, %u credits, rep=%p -> req=%p",
 984		__entry->task_id, __entry->client_id, __entry->xid,
 985		__entry->credits, __entry->rep, __entry->req
 986	)
 987);
 988
 989TRACE_EVENT(xprtrdma_defer_cmp,
 
 
 
 
 
 990	TP_PROTO(
 991		const struct rpcrdma_rep *rep
 
 
 992	),
 993
 994	TP_ARGS(rep),
 995
 996	TP_STRUCT__entry(
 997		__field(unsigned int, task_id)
 998		__field(unsigned int, client_id)
 999		__field(const void *, rep)
1000		__field(u32, xid)
 
 
1001	),
1002
1003	TP_fast_assign(
1004		__entry->task_id = rep->rr_rqst->rq_task->tk_pid;
1005		__entry->client_id = rep->rr_rqst->rq_task->tk_client->cl_clid;
1006		__entry->rep = rep;
1007		__entry->xid = be32_to_cpu(rep->rr_xid);
 
1008	),
1009
1010	TP_printk("task:%u@%u xid=0x%08x rep=%p",
1011		__entry->task_id, __entry->client_id, __entry->xid,
1012		__entry->rep
1013	)
1014);
1015
1016DEFINE_REPLY_EVENT(xprtrdma_reply_vers);
1017DEFINE_REPLY_EVENT(xprtrdma_reply_rqst);
1018DEFINE_REPLY_EVENT(xprtrdma_reply_short);
1019DEFINE_REPLY_EVENT(xprtrdma_reply_hdr);
 
 
1020
1021TRACE_EVENT(xprtrdma_fixup,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1022	TP_PROTO(
1023		const struct rpc_rqst *rqst,
1024		int len,
1025		int hdrlen
1026	),
1027
1028	TP_ARGS(rqst, len, hdrlen),
1029
1030	TP_STRUCT__entry(
1031		__field(unsigned int, task_id)
1032		__field(unsigned int, client_id)
1033		__field(const void *, base)
1034		__field(int, len)
1035		__field(int, hdrlen)
1036	),
1037
1038	TP_fast_assign(
1039		__entry->task_id = rqst->rq_task->tk_pid;
1040		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
1041		__entry->base = rqst->rq_rcv_buf.head[0].iov_base;
1042		__entry->len = len;
1043		__entry->hdrlen = hdrlen;
1044	),
1045
1046	TP_printk("task:%u@%u base=%p len=%d hdrlen=%d",
1047		__entry->task_id, __entry->client_id,
1048		__entry->base, __entry->len, __entry->hdrlen
1049	)
1050);
1051
1052TRACE_EVENT(xprtrdma_fixup_pg,
1053	TP_PROTO(
1054		const struct rpc_rqst *rqst,
1055		int pageno,
1056		const void *pos,
1057		int len,
1058		int curlen
1059	),
1060
1061	TP_ARGS(rqst, pageno, pos, len, curlen),
1062
1063	TP_STRUCT__entry(
1064		__field(unsigned int, task_id)
1065		__field(unsigned int, client_id)
1066		__field(const void *, pos)
1067		__field(int, pageno)
1068		__field(int, len)
1069		__field(int, curlen)
1070	),
1071
1072	TP_fast_assign(
1073		__entry->task_id = rqst->rq_task->tk_pid;
1074		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
1075		__entry->pos = pos;
1076		__entry->pageno = pageno;
1077		__entry->len = len;
1078		__entry->curlen = curlen;
1079	),
1080
1081	TP_printk("task:%u@%u pageno=%d pos=%p len=%d curlen=%d",
1082		__entry->task_id, __entry->client_id,
1083		__entry->pageno, __entry->pos, __entry->len, __entry->curlen
1084	)
1085);
1086
1087TRACE_EVENT(xprtrdma_decode_seg,
1088	TP_PROTO(
1089		u32 handle,
1090		u32 length,
1091		u64 offset
1092	),
1093
1094	TP_ARGS(handle, length, offset),
1095
1096	TP_STRUCT__entry(
1097		__field(u32, handle)
1098		__field(u32, length)
1099		__field(u64, offset)
1100	),
1101
1102	TP_fast_assign(
1103		__entry->handle = handle;
1104		__entry->length = length;
1105		__entry->offset = offset;
1106	),
1107
1108	TP_printk("%u@0x%016llx:0x%08x",
1109		__entry->length, (unsigned long long)__entry->offset,
1110		__entry->handle
1111	)
1112);
1113
1114/**
1115 ** Allocation/release of rpcrdma_reqs and rpcrdma_reps
1116 **/
1117
1118TRACE_EVENT(xprtrdma_op_allocate,
1119	TP_PROTO(
1120		const struct rpc_task *task,
1121		const struct rpcrdma_req *req
1122	),
1123
1124	TP_ARGS(task, req),
1125
1126	TP_STRUCT__entry(
1127		__field(unsigned int, task_id)
1128		__field(unsigned int, client_id)
1129		__field(const void *, req)
1130		__field(size_t, callsize)
1131		__field(size_t, rcvsize)
1132	),
1133
1134	TP_fast_assign(
1135		__entry->task_id = task->tk_pid;
1136		__entry->client_id = task->tk_client->cl_clid;
1137		__entry->req = req;
1138		__entry->callsize = task->tk_rqstp->rq_callsize;
1139		__entry->rcvsize = task->tk_rqstp->rq_rcvsize;
1140	),
1141
1142	TP_printk("task:%u@%u req=%p (%zu, %zu)",
1143		__entry->task_id, __entry->client_id,
1144		__entry->req, __entry->callsize, __entry->rcvsize
1145	)
1146);
1147
1148TRACE_EVENT(xprtrdma_op_free,
1149	TP_PROTO(
1150		const struct rpc_task *task,
1151		const struct rpcrdma_req *req
1152	),
1153
1154	TP_ARGS(task, req),
1155
1156	TP_STRUCT__entry(
1157		__field(unsigned int, task_id)
1158		__field(unsigned int, client_id)
1159		__field(const void *, req)
1160		__field(const void *, rep)
1161	),
1162
1163	TP_fast_assign(
1164		__entry->task_id = task->tk_pid;
1165		__entry->client_id = task->tk_client->cl_clid;
1166		__entry->req = req;
1167		__entry->rep = req->rl_reply;
1168	),
1169
1170	TP_printk("task:%u@%u req=%p rep=%p",
1171		__entry->task_id, __entry->client_id,
1172		__entry->req, __entry->rep
1173	)
1174);
1175
1176/**
1177 ** Callback events
1178 **/
1179
1180TRACE_EVENT(xprtrdma_cb_setup,
1181	TP_PROTO(
1182		const struct rpcrdma_xprt *r_xprt,
1183		unsigned int reqs
1184	),
1185
1186	TP_ARGS(r_xprt, reqs),
1187
1188	TP_STRUCT__entry(
1189		__field(const void *, r_xprt)
1190		__field(unsigned int, reqs)
1191		__string(addr, rpcrdma_addrstr(r_xprt))
1192		__string(port, rpcrdma_portstr(r_xprt))
1193	),
1194
1195	TP_fast_assign(
1196		__entry->r_xprt = r_xprt;
1197		__entry->reqs = reqs;
1198		__assign_str(addr, rpcrdma_addrstr(r_xprt));
1199		__assign_str(port, rpcrdma_portstr(r_xprt));
1200	),
1201
1202	TP_printk("peer=[%s]:%s r_xprt=%p: %u reqs",
1203		__get_str(addr), __get_str(port),
1204		__entry->r_xprt, __entry->reqs
1205	)
1206);
1207
1208DEFINE_CB_EVENT(xprtrdma_cb_call);
1209DEFINE_CB_EVENT(xprtrdma_cb_reply);
1210
1211TRACE_EVENT(xprtrdma_leaked_rep,
1212	TP_PROTO(
1213		const struct rpc_rqst *rqst,
1214		const struct rpcrdma_rep *rep
1215	),
1216
1217	TP_ARGS(rqst, rep),
1218
1219	TP_STRUCT__entry(
1220		__field(unsigned int, task_id)
1221		__field(unsigned int, client_id)
1222		__field(u32, xid)
1223		__field(const void *, rep)
1224	),
1225
1226	TP_fast_assign(
1227		__entry->task_id = rqst->rq_task->tk_pid;
1228		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
1229		__entry->xid = be32_to_cpu(rqst->rq_xid);
1230		__entry->rep = rep;
1231	),
1232
1233	TP_printk("task:%u@%u xid=0x%08x rep=%p",
1234		__entry->task_id, __entry->client_id, __entry->xid,
1235		__entry->rep
1236	)
1237);
1238
1239/**
1240 ** Server-side RPC/RDMA events
1241 **/
1242
1243DECLARE_EVENT_CLASS(svcrdma_xprt_event,
1244	TP_PROTO(
1245		const struct svc_xprt *xprt
 
1246	),
1247
1248	TP_ARGS(xprt),
1249
1250	TP_STRUCT__entry(
1251		__field(const void *, xprt)
1252		__string(addr, xprt->xpt_remotebuf)
1253	),
1254
1255	TP_fast_assign(
1256		__entry->xprt = xprt;
1257		__assign_str(addr, xprt->xpt_remotebuf);
1258	),
1259
1260	TP_printk("xprt=%p addr=%s",
1261		__entry->xprt, __get_str(addr)
1262	)
1263);
1264
1265#define DEFINE_XPRT_EVENT(name)						\
1266		DEFINE_EVENT(svcrdma_xprt_event, svcrdma_xprt_##name,	\
1267				TP_PROTO(				\
1268					const struct svc_xprt *xprt	\
1269				),					\
1270				TP_ARGS(xprt))
 
1271
1272DEFINE_XPRT_EVENT(accept);
1273DEFINE_XPRT_EVENT(fail);
1274DEFINE_XPRT_EVENT(free);
 
 
1275
1276TRACE_DEFINE_ENUM(RDMA_MSG);
1277TRACE_DEFINE_ENUM(RDMA_NOMSG);
1278TRACE_DEFINE_ENUM(RDMA_MSGP);
1279TRACE_DEFINE_ENUM(RDMA_DONE);
1280TRACE_DEFINE_ENUM(RDMA_ERROR);
1281
1282#define show_rpcrdma_proc(x)						\
1283		__print_symbolic(x,					\
1284				{ RDMA_MSG, "RDMA_MSG" },		\
1285				{ RDMA_NOMSG, "RDMA_NOMSG" },		\
1286				{ RDMA_MSGP, "RDMA_MSGP" },		\
1287				{ RDMA_DONE, "RDMA_DONE" },		\
1288				{ RDMA_ERROR, "RDMA_ERROR" })
1289
1290TRACE_EVENT(svcrdma_decode_rqst,
1291	TP_PROTO(
 
1292		__be32 *p,
1293		unsigned int hdrlen
1294	),
1295
1296	TP_ARGS(p, hdrlen),
1297
1298	TP_STRUCT__entry(
 
 
1299		__field(u32, xid)
1300		__field(u32, vers)
1301		__field(u32, proc)
1302		__field(u32, credits)
1303		__field(unsigned int, hdrlen)
1304	),
1305
1306	TP_fast_assign(
 
 
1307		__entry->xid = be32_to_cpup(p++);
1308		__entry->vers = be32_to_cpup(p++);
1309		__entry->credits = be32_to_cpup(p++);
1310		__entry->proc = be32_to_cpup(p);
1311		__entry->hdrlen = hdrlen;
1312	),
1313
1314	TP_printk("xid=0x%08x vers=%u credits=%u proc=%s hdrlen=%u",
 
1315		__entry->xid, __entry->vers, __entry->credits,
1316		show_rpcrdma_proc(__entry->proc), __entry->hdrlen)
1317);
1318
1319TRACE_EVENT(svcrdma_decode_short,
1320	TP_PROTO(
 
1321		unsigned int hdrlen
1322	),
1323
1324	TP_ARGS(hdrlen),
1325
1326	TP_STRUCT__entry(
 
 
1327		__field(unsigned int, hdrlen)
1328	),
1329
1330	TP_fast_assign(
 
 
1331		__entry->hdrlen = hdrlen;
1332	),
1333
1334	TP_printk("hdrlen=%u", __entry->hdrlen)
 
 
1335);
1336
1337DECLARE_EVENT_CLASS(svcrdma_badreq_event,
1338	TP_PROTO(
 
1339		__be32 *p
1340	),
1341
1342	TP_ARGS(p),
1343
1344	TP_STRUCT__entry(
 
 
1345		__field(u32, xid)
1346		__field(u32, vers)
1347		__field(u32, proc)
1348		__field(u32, credits)
1349	),
1350
1351	TP_fast_assign(
 
 
1352		__entry->xid = be32_to_cpup(p++);
1353		__entry->vers = be32_to_cpup(p++);
1354		__entry->credits = be32_to_cpup(p++);
1355		__entry->proc = be32_to_cpup(p);
1356	),
1357
1358	TP_printk("xid=0x%08x vers=%u credits=%u proc=%u",
 
1359		__entry->xid, __entry->vers, __entry->credits, __entry->proc)
1360);
1361
1362#define DEFINE_BADREQ_EVENT(name)					\
1363		DEFINE_EVENT(svcrdma_badreq_event, svcrdma_decode_##name,\
 
1364				TP_PROTO(				\
 
1365					__be32 *p			\
1366				),					\
1367				TP_ARGS(p))
1368
1369DEFINE_BADREQ_EVENT(badvers);
1370DEFINE_BADREQ_EVENT(drop);
1371DEFINE_BADREQ_EVENT(badproc);
1372DEFINE_BADREQ_EVENT(parse);
1373
1374DECLARE_EVENT_CLASS(svcrdma_segment_event,
1375	TP_PROTO(
 
 
1376		u32 handle,
1377		u32 length,
1378		u64 offset
1379	),
1380
1381	TP_ARGS(handle, length, offset),
1382
1383	TP_STRUCT__entry(
 
 
 
1384		__field(u32, handle)
1385		__field(u32, length)
1386		__field(u64, offset)
1387	),
1388
1389	TP_fast_assign(
 
 
 
1390		__entry->handle = handle;
1391		__entry->length = length;
1392		__entry->offset = offset;
1393	),
1394
1395	TP_printk("%u@0x%016llx:0x%08x",
1396		__entry->length, (unsigned long long)__entry->offset,
1397		__entry->handle
 
1398	)
1399);
1400
1401#define DEFINE_SEGMENT_EVENT(name)					\
1402		DEFINE_EVENT(svcrdma_segment_event, svcrdma_encode_##name,\
1403				TP_PROTO(				\
1404					u32 handle,			\
1405					u32 length,			\
1406					u64 offset			\
1407				),					\
1408				TP_ARGS(handle, length, offset))
1409
1410DEFINE_SEGMENT_EVENT(rseg);
1411DEFINE_SEGMENT_EVENT(wseg);
1412
1413DECLARE_EVENT_CLASS(svcrdma_chunk_event,
1414	TP_PROTO(
1415		u32 length
 
 
1416	),
1417
1418	TP_ARGS(length),
1419
1420	TP_STRUCT__entry(
 
 
 
 
 
1421		__field(u32, length)
 
1422	),
1423
1424	TP_fast_assign(
1425		__entry->length = length;
 
 
 
 
 
 
1426	),
1427
1428	TP_printk("length=%u",
1429		__entry->length
 
 
1430	)
1431);
1432
1433#define DEFINE_CHUNK_EVENT(name)					\
1434		DEFINE_EVENT(svcrdma_chunk_event, svcrdma_encode_##name,\
1435				TP_PROTO(				\
1436					u32 length			\
1437				),					\
1438				TP_ARGS(length))
1439
1440DEFINE_CHUNK_EVENT(pzr);
1441DEFINE_CHUNK_EVENT(write);
1442DEFINE_CHUNK_EVENT(reply);
1443
1444TRACE_EVENT(svcrdma_encode_read,
1445	TP_PROTO(
1446		u32 length,
1447		u32 position
 
1448	),
1449
1450	TP_ARGS(length, position),
1451
1452	TP_STRUCT__entry(
 
 
 
 
1453		__field(u32, length)
1454		__field(u32, position)
1455	),
1456
1457	TP_fast_assign(
1458		__entry->length = length;
1459		__entry->position = position;
 
 
 
 
 
 
 
1460	),
1461
1462	TP_printk("length=%u position=%u",
1463		__entry->length, __entry->position
 
 
1464	)
1465);
1466
1467DECLARE_EVENT_CLASS(svcrdma_error_event,
1468	TP_PROTO(
1469		__be32 xid
1470	),
1471
1472	TP_ARGS(xid),
1473
1474	TP_STRUCT__entry(
1475		__field(u32, xid)
1476	),
1477
1478	TP_fast_assign(
1479		__entry->xid = be32_to_cpu(xid);
1480	),
1481
1482	TP_printk("xid=0x%08x",
1483		__entry->xid
1484	)
1485);
1486
1487#define DEFINE_ERROR_EVENT(name)					\
1488		DEFINE_EVENT(svcrdma_error_event, svcrdma_err_##name,	\
1489				TP_PROTO(				\
1490					__be32 xid			\
1491				),					\
1492				TP_ARGS(xid))
1493
1494DEFINE_ERROR_EVENT(vers);
1495DEFINE_ERROR_EVENT(chunk);
1496
1497/**
1498 ** Server-side RDMA API events
1499 **/
1500
1501TRACE_EVENT(svcrdma_dma_map_page,
1502	TP_PROTO(
1503		const struct svcxprt_rdma *rdma,
1504		const void *page
 
1505	),
1506
1507	TP_ARGS(rdma, page),
1508
1509	TP_STRUCT__entry(
1510		__field(const void *, page);
1511		__string(device, rdma->sc_cm_id->device->name)
1512		__string(addr, rdma->sc_xprt.xpt_remotebuf)
 
1513	),
1514
1515	TP_fast_assign(
1516		__entry->page = page;
1517		__assign_str(device, rdma->sc_cm_id->device->name);
1518		__assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
 
1519	),
1520
1521	TP_printk("addr=%s device=%s page=%p",
1522		__get_str(addr), __get_str(device), __entry->page
 
1523	)
1524);
1525
1526TRACE_EVENT(svcrdma_dma_map_rwctx,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1527	TP_PROTO(
1528		const struct svcxprt_rdma *rdma,
 
 
 
1529		int status
1530	),
1531
1532	TP_ARGS(rdma, status),
1533
1534	TP_STRUCT__entry(
 
 
 
 
1535		__field(int, status)
1536		__string(device, rdma->sc_cm_id->device->name)
1537		__string(addr, rdma->sc_xprt.xpt_remotebuf)
1538	),
1539
1540	TP_fast_assign(
 
 
 
 
1541		__entry->status = status;
1542		__assign_str(device, rdma->sc_cm_id->device->name);
1543		__assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
1544	),
1545
1546	TP_printk("addr=%s device=%s status=%d",
1547		__get_str(addr), __get_str(device), __entry->status
 
1548	)
1549);
1550
1551TRACE_EVENT(svcrdma_send_failed,
1552	TP_PROTO(
1553		const struct svc_rqst *rqst,
1554		int status
1555	),
1556
1557	TP_ARGS(rqst, status),
1558
1559	TP_STRUCT__entry(
1560		__field(int, status)
1561		__field(u32, xid)
1562		__field(const void *, xprt)
1563		__string(addr, rqst->rq_xprt->xpt_remotebuf)
1564	),
1565
1566	TP_fast_assign(
1567		__entry->status = status;
1568		__entry->xid = __be32_to_cpu(rqst->rq_xid);
1569		__entry->xprt = rqst->rq_xprt;
1570		__assign_str(addr, rqst->rq_xprt->xpt_remotebuf);
1571	),
1572
1573	TP_printk("xprt=%p addr=%s xid=0x%08x status=%d",
1574		__entry->xprt, __get_str(addr),
1575		__entry->xid, __entry->status
1576	)
1577);
1578
1579DECLARE_EVENT_CLASS(svcrdma_sendcomp_event,
1580	TP_PROTO(
1581		const struct ib_wc *wc
 
1582	),
1583
1584	TP_ARGS(wc),
1585
1586	TP_STRUCT__entry(
1587		__field(const void *, cqe)
1588		__field(unsigned int, status)
1589		__field(unsigned int, vendor_err)
1590	),
1591
1592	TP_fast_assign(
1593		__entry->cqe = wc->wr_cqe;
1594		__entry->status = wc->status;
1595		if (wc->status)
1596			__entry->vendor_err = wc->vendor_err;
1597		else
1598			__entry->vendor_err = 0;
1599	),
1600
1601	TP_printk("cqe=%p status=%s (%u/0x%x)",
1602		__entry->cqe, rdma_show_wc_status(__entry->status),
1603		__entry->status, __entry->vendor_err
1604	)
1605);
1606
1607#define DEFINE_SENDCOMP_EVENT(name)					\
1608		DEFINE_EVENT(svcrdma_sendcomp_event, svcrdma_wc_##name,	\
1609				TP_PROTO(				\
1610					const struct ib_wc *wc		\
1611				),					\
1612				TP_ARGS(wc))
1613
1614TRACE_EVENT(svcrdma_post_send,
1615	TP_PROTO(
1616		const struct ib_send_wr *wr,
1617		int status
 
 
1618	),
1619
1620	TP_ARGS(wr, status),
1621
1622	TP_STRUCT__entry(
1623		__field(const void *, cqe)
1624		__field(unsigned int, num_sge)
1625		__field(u32, inv_rkey)
1626		__field(int, status)
 
1627	),
1628
1629	TP_fast_assign(
1630		__entry->cqe = wr->wr_cqe;
1631		__entry->num_sge = wr->num_sge;
1632		__entry->inv_rkey = (wr->opcode == IB_WR_SEND_WITH_INV) ?
1633					wr->ex.invalidate_rkey : 0;
1634		__entry->status = status;
1635	),
1636
1637	TP_printk("cqe=%p num_sge=%u inv_rkey=0x%08x status=%d",
1638		__entry->cqe, __entry->num_sge,
1639		__entry->inv_rkey, __entry->status
1640	)
1641);
1642
1643DEFINE_SENDCOMP_EVENT(send);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1644
1645TRACE_EVENT(svcrdma_post_recv,
 
 
 
 
 
 
1646	TP_PROTO(
1647		const struct ib_recv_wr *wr,
1648		int status
1649	),
1650
1651	TP_ARGS(wr, status),
1652
1653	TP_STRUCT__entry(
1654		__field(const void *, cqe)
1655		__field(int, status)
 
 
1656	),
1657
1658	TP_fast_assign(
1659		__entry->cqe = wr->wr_cqe;
1660		__entry->status = status;
 
 
1661	),
1662
1663	TP_printk("cqe=%p status=%d",
1664		__entry->cqe, __entry->status
1665	)
1666);
1667
1668TRACE_EVENT(svcrdma_wc_receive,
1669	TP_PROTO(
1670		const struct ib_wc *wc
1671	),
1672
1673	TP_ARGS(wc),
1674
1675	TP_STRUCT__entry(
1676		__field(const void *, cqe)
1677		__field(u32, byte_len)
1678		__field(unsigned int, status)
1679		__field(u32, vendor_err)
1680	),
1681
1682	TP_fast_assign(
1683		__entry->cqe = wc->wr_cqe;
1684		__entry->status = wc->status;
1685		if (wc->status) {
1686			__entry->byte_len = 0;
1687			__entry->vendor_err = wc->vendor_err;
1688		} else {
1689			__entry->byte_len = wc->byte_len;
1690			__entry->vendor_err = 0;
1691		}
1692	),
1693
1694	TP_printk("cqe=%p byte_len=%u status=%s (%u/0x%x)",
1695		__entry->cqe, __entry->byte_len,
1696		rdma_show_wc_status(__entry->status),
1697		__entry->status, __entry->vendor_err
1698	)
1699);
1700
1701TRACE_EVENT(svcrdma_post_rw,
 
 
 
 
 
 
 
 
 
 
1702	TP_PROTO(
1703		const void *cqe,
1704		int sqecount,
1705		int status
1706	),
1707
1708	TP_ARGS(cqe, sqecount, status),
1709
1710	TP_STRUCT__entry(
1711		__field(const void *, cqe)
1712		__field(int, sqecount)
1713		__field(int, status)
 
1714	),
1715
1716	TP_fast_assign(
1717		__entry->cqe = cqe;
1718		__entry->sqecount = sqecount;
1719		__entry->status = status;
 
1720	),
1721
1722	TP_printk("cqe=%p sqecount=%d status=%d",
1723		__entry->cqe, __entry->sqecount, __entry->status
1724	)
1725);
1726
1727DEFINE_SENDCOMP_EVENT(read);
1728DEFINE_SENDCOMP_EVENT(write);
 
 
 
 
 
1729
1730TRACE_EVENT(svcrdma_cm_event,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1731	TP_PROTO(
1732		const struct rdma_cm_event *event,
1733		const struct sockaddr *sap
1734	),
 
 
1735
1736	TP_ARGS(event, sap),
 
 
 
 
 
 
 
 
1737
1738	TP_STRUCT__entry(
1739		__field(unsigned int, event)
1740		__field(int, status)
1741		__array(__u8, addr, INET6_ADDRSTRLEN + 10)
 
1742	),
1743
1744	TP_fast_assign(
1745		__entry->event = event->event;
1746		__entry->status = event->status;
1747		snprintf(__entry->addr, sizeof(__entry->addr) - 1,
1748			 "%pISpc", sap);
1749	),
1750
1751	TP_printk("addr=%s event=%s (%u/%d)",
1752		__entry->addr,
1753		rdma_show_cm_event(__entry->event),
1754		__entry->event, __entry->status
1755	)
1756);
1757
 
 
 
 
 
 
 
 
 
 
 
 
1758TRACE_EVENT(svcrdma_qp_error,
1759	TP_PROTO(
1760		const struct ib_event *event,
1761		const struct sockaddr *sap
1762	),
1763
1764	TP_ARGS(event, sap),
1765
1766	TP_STRUCT__entry(
1767		__field(unsigned int, event)
1768		__string(device, event->device->name)
1769		__array(__u8, addr, INET6_ADDRSTRLEN + 10)
1770	),
1771
1772	TP_fast_assign(
1773		__entry->event = event->event;
1774		__assign_str(device, event->device->name);
1775		snprintf(__entry->addr, sizeof(__entry->addr) - 1,
1776			 "%pISpc", sap);
1777	),
1778
1779	TP_printk("addr=%s dev=%s event=%s (%u)",
1780		__entry->addr, __get_str(device),
1781		rdma_show_ib_event(__entry->event), __entry->event
1782	)
1783);
1784
1785DECLARE_EVENT_CLASS(svcrdma_sendqueue_event,
1786	TP_PROTO(
1787		const struct svcxprt_rdma *rdma
 
1788	),
1789
1790	TP_ARGS(rdma),
1791
1792	TP_STRUCT__entry(
 
 
1793		__field(int, avail)
1794		__field(int, depth)
1795		__string(addr, rdma->sc_xprt.xpt_remotebuf)
1796	),
1797
1798	TP_fast_assign(
 
 
1799		__entry->avail = atomic_read(&rdma->sc_sq_avail);
1800		__entry->depth = rdma->sc_sq_depth;
1801		__assign_str(addr, rdma->sc_xprt.xpt_remotebuf);
1802	),
1803
1804	TP_printk("addr=%s sc_sq_avail=%d/%d",
1805		__get_str(addr), __entry->avail, __entry->depth
 
1806	)
1807);
1808
1809#define DEFINE_SQ_EVENT(name)						\
1810		DEFINE_EVENT(svcrdma_sendqueue_event, svcrdma_sq_##name,\
1811				TP_PROTO(				\
1812					const struct svcxprt_rdma *rdma \
1813				),					\
1814				TP_ARGS(rdma))
 
 
 
 
 
1815
1816DEFINE_SQ_EVENT(full);
1817DEFINE_SQ_EVENT(retry);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1818
1819#endif /* _TRACE_RPCRDMA_H */
1820
1821#include <trace/define_trace.h>