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/sunrpc/rpc_rdma_cid.h>
  15#include <linux/tracepoint.h>
  16#include <rdma/ib_cm.h>
  17
  18#include <trace/misc/rdma.h>
  19#include <trace/misc/sunrpc.h>
  20
  21/**
  22 ** Event classes
  23 **/
  24
  25DECLARE_EVENT_CLASS(rpcrdma_simple_cid_class,
  26	TP_PROTO(
 
  27		const struct rpc_rdma_cid *cid
  28	),
  29
  30	TP_ARGS(cid),
  31
  32	TP_STRUCT__entry(
  33		__field(u32, cq_id)
  34		__field(int, completion_id)
 
 
  35	),
  36
  37	TP_fast_assign(
  38		__entry->cq_id = cid->ci_queue_id;
  39		__entry->completion_id = cid->ci_completion_id;
 
 
 
 
 
  40	),
  41
  42	TP_printk("cq.id=%d cid=%d",
  43		__entry->cq_id, __entry->completion_id
 
 
  44	)
  45);
  46
  47#define DEFINE_SIMPLE_CID_EVENT(name)					\
  48		DEFINE_EVENT(rpcrdma_simple_cid_class, name,		\
  49				TP_PROTO(				\
 
  50					const struct rpc_rdma_cid *cid	\
  51				),					\
  52				TP_ARGS(cid)				\
  53		)
  54
  55DECLARE_EVENT_CLASS(rpcrdma_completion_class,
  56	TP_PROTO(
  57		const struct ib_wc *wc,
  58		const struct rpc_rdma_cid *cid
  59	),
  60
  61	TP_ARGS(wc, cid),
  62
  63	TP_STRUCT__entry(
  64		__field(u32, cq_id)
  65		__field(int, completion_id)
  66		__field(unsigned long, status)
  67		__field(unsigned int, vendor_err)
  68	),
  69
  70	TP_fast_assign(
  71		__entry->cq_id = cid->ci_queue_id;
  72		__entry->completion_id = cid->ci_completion_id;
  73		__entry->status = wc->status;
  74		if (wc->status)
  75			__entry->vendor_err = wc->vendor_err;
  76		else
  77			__entry->vendor_err = 0;
  78	),
  79
  80	TP_printk("cq.id=%u cid=%d status=%s (%lu/0x%x)",
  81		__entry->cq_id, __entry->completion_id,
  82		rdma_show_wc_status(__entry->status),
  83		__entry->status, __entry->vendor_err
  84	)
  85);
  86
  87#define DEFINE_COMPLETION_EVENT(name)					\
  88		DEFINE_EVENT(rpcrdma_completion_class, name,		\
  89				TP_PROTO(				\
  90					const struct ib_wc *wc,		\
  91					const struct rpc_rdma_cid *cid	\
  92				),					\
  93				TP_ARGS(wc, cid))
  94
  95DECLARE_EVENT_CLASS(rpcrdma_send_flush_class,
  96	TP_PROTO(
  97		const struct ib_wc *wc,
  98		const struct rpc_rdma_cid *cid
  99	),
 100
 101	TP_ARGS(wc, cid),
 102
 103	TP_STRUCT__entry(
 104		__field(u32, cq_id)
 105		__field(int, completion_id)
 106		__field(unsigned long, status)
 107		__field(unsigned int, vendor_err)
 108	),
 109
 110	TP_fast_assign(
 111		__entry->cq_id = cid->ci_queue_id;
 112		__entry->completion_id = cid->ci_completion_id;
 113		__entry->status = wc->status;
 114		__entry->vendor_err = wc->vendor_err;
 115	),
 116
 117	TP_printk("cq.id=%u cid=%d status=%s (%lu/0x%x)",
 118		__entry->cq_id, __entry->completion_id,
 119		rdma_show_wc_status(__entry->status),
 120		__entry->status, __entry->vendor_err
 121	)
 122);
 123
 124#define DEFINE_SEND_FLUSH_EVENT(name)					\
 125		DEFINE_EVENT(rpcrdma_send_flush_class, name,		\
 126				TP_PROTO(				\
 127					const struct ib_wc *wc,		\
 128					const struct rpc_rdma_cid *cid	\
 129				),					\
 130				TP_ARGS(wc, cid))
 131
 132DECLARE_EVENT_CLASS(rpcrdma_mr_completion_class,
 133	TP_PROTO(
 134		const struct ib_wc *wc,
 135		const struct rpc_rdma_cid *cid
 136	),
 137
 138	TP_ARGS(wc, cid),
 139
 140	TP_STRUCT__entry(
 141		__field(u32, cq_id)
 142		__field(int, completion_id)
 143		__field(unsigned long, status)
 144		__field(unsigned int, vendor_err)
 145	),
 146
 147	TP_fast_assign(
 148		__entry->cq_id = cid->ci_queue_id;
 149		__entry->completion_id = cid->ci_completion_id;
 150		__entry->status = wc->status;
 151		if (wc->status)
 152			__entry->vendor_err = wc->vendor_err;
 153		else
 154			__entry->vendor_err = 0;
 155	),
 156
 157	TP_printk("cq.id=%u mr.id=%d status=%s (%lu/0x%x)",
 158		__entry->cq_id, __entry->completion_id,
 159		rdma_show_wc_status(__entry->status),
 160		__entry->status, __entry->vendor_err
 161	)
 162);
 163
 164#define DEFINE_MR_COMPLETION_EVENT(name)				\
 165		DEFINE_EVENT(rpcrdma_mr_completion_class, name,		\
 166				TP_PROTO(				\
 167					const struct ib_wc *wc,		\
 168					const struct rpc_rdma_cid *cid	\
 169				),					\
 170				TP_ARGS(wc, cid))
 171
 172DECLARE_EVENT_CLASS(rpcrdma_receive_completion_class,
 173	TP_PROTO(
 174		const struct ib_wc *wc,
 175		const struct rpc_rdma_cid *cid
 176	),
 177
 178	TP_ARGS(wc, cid),
 179
 180	TP_STRUCT__entry(
 181		__field(u32, cq_id)
 182		__field(int, completion_id)
 183		__field(u32, received)
 184		__field(unsigned long, status)
 185		__field(unsigned int, vendor_err)
 186	),
 187
 188	TP_fast_assign(
 189		__entry->cq_id = cid->ci_queue_id;
 190		__entry->completion_id = cid->ci_completion_id;
 191		__entry->status = wc->status;
 192		if (wc->status) {
 193			__entry->received = 0;
 194			__entry->vendor_err = wc->vendor_err;
 195		} else {
 196			__entry->received = wc->byte_len;
 197			__entry->vendor_err = 0;
 198		}
 199	),
 200
 201	TP_printk("cq.id=%u cid=%d status=%s (%lu/0x%x) received=%u",
 202		__entry->cq_id, __entry->completion_id,
 203		rdma_show_wc_status(__entry->status),
 204		__entry->status, __entry->vendor_err,
 205		__entry->received
 206	)
 207);
 208
 209#define DEFINE_RECEIVE_COMPLETION_EVENT(name)				\
 210		DEFINE_EVENT(rpcrdma_receive_completion_class, name,	\
 211				TP_PROTO(				\
 212					const struct ib_wc *wc,		\
 213					const struct rpc_rdma_cid *cid	\
 214				),					\
 215				TP_ARGS(wc, cid))
 216
 217DECLARE_EVENT_CLASS(rpcrdma_receive_success_class,
 218	TP_PROTO(
 219		const struct ib_wc *wc,
 220		const struct rpc_rdma_cid *cid
 221	),
 222
 223	TP_ARGS(wc, cid),
 224
 225	TP_STRUCT__entry(
 226		__field(u32, cq_id)
 227		__field(int, completion_id)
 228		__field(u32, received)
 229	),
 230
 231	TP_fast_assign(
 232		__entry->cq_id = cid->ci_queue_id;
 233		__entry->completion_id = cid->ci_completion_id;
 234		__entry->received = wc->byte_len;
 235	),
 236
 237	TP_printk("cq.id=%u cid=%d received=%u",
 238		__entry->cq_id, __entry->completion_id,
 239		__entry->received
 240	)
 241);
 242
 243#define DEFINE_RECEIVE_SUCCESS_EVENT(name)				\
 244		DEFINE_EVENT(rpcrdma_receive_success_class, name,	\
 245				TP_PROTO(				\
 246					const struct ib_wc *wc,		\
 247					const struct rpc_rdma_cid *cid	\
 248				),					\
 249				TP_ARGS(wc, cid))
 250
 251DECLARE_EVENT_CLASS(rpcrdma_receive_flush_class,
 252	TP_PROTO(
 253		const struct ib_wc *wc,
 254		const struct rpc_rdma_cid *cid
 255	),
 256
 257	TP_ARGS(wc, cid),
 258
 259	TP_STRUCT__entry(
 260		__field(u32, cq_id)
 261		__field(int, completion_id)
 262		__field(unsigned long, status)
 263		__field(unsigned int, vendor_err)
 264	),
 265
 266	TP_fast_assign(
 267		__entry->cq_id = cid->ci_queue_id;
 268		__entry->completion_id = cid->ci_completion_id;
 269		__entry->status = wc->status;
 270		__entry->vendor_err = wc->vendor_err;
 271	),
 272
 273	TP_printk("cq.id=%u cid=%d status=%s (%lu/0x%x)",
 274		__entry->cq_id, __entry->completion_id,
 275		rdma_show_wc_status(__entry->status),
 276		__entry->status, __entry->vendor_err
 277	)
 278);
 279
 280#define DEFINE_RECEIVE_FLUSH_EVENT(name)				\
 281		DEFINE_EVENT(rpcrdma_receive_flush_class, name,		\
 282				TP_PROTO(				\
 283					const struct ib_wc *wc,		\
 284					const struct rpc_rdma_cid *cid	\
 285				),					\
 286				TP_ARGS(wc, cid))
 287
 288DECLARE_EVENT_CLASS(xprtrdma_reply_class,
 289	TP_PROTO(
 290		const struct rpcrdma_rep *rep
 291	),
 292
 293	TP_ARGS(rep),
 294
 295	TP_STRUCT__entry(
 296		__field(u32, xid)
 297		__field(u32, version)
 298		__field(u32, proc)
 299		__string(addr, rpcrdma_addrstr(rep->rr_rxprt))
 300		__string(port, rpcrdma_portstr(rep->rr_rxprt))
 301	),
 302
 303	TP_fast_assign(
 304		__entry->xid = be32_to_cpu(rep->rr_xid);
 305		__entry->version = be32_to_cpu(rep->rr_vers);
 306		__entry->proc = be32_to_cpu(rep->rr_proc);
 307		__assign_str(addr);
 308		__assign_str(port);
 309	),
 310
 311	TP_printk("peer=[%s]:%s xid=0x%08x version=%u proc=%u",
 312		__get_str(addr), __get_str(port),
 313		__entry->xid, __entry->version, __entry->proc
 314	)
 315);
 316
 317#define DEFINE_REPLY_EVENT(name)					\
 318		DEFINE_EVENT(xprtrdma_reply_class,			\
 319				xprtrdma_reply_##name##_err,		\
 320				TP_PROTO(				\
 321					const struct rpcrdma_rep *rep	\
 322				),					\
 323				TP_ARGS(rep))
 324
 325DECLARE_EVENT_CLASS(xprtrdma_rxprt,
 326	TP_PROTO(
 327		const struct rpcrdma_xprt *r_xprt
 328	),
 329
 330	TP_ARGS(r_xprt),
 331
 332	TP_STRUCT__entry(
 333		__string(addr, rpcrdma_addrstr(r_xprt))
 334		__string(port, rpcrdma_portstr(r_xprt))
 335	),
 336
 337	TP_fast_assign(
 338		__assign_str(addr);
 339		__assign_str(port);
 340	),
 341
 342	TP_printk("peer=[%s]:%s",
 343		__get_str(addr), __get_str(port)
 344	)
 345);
 346
 347#define DEFINE_RXPRT_EVENT(name)					\
 348		DEFINE_EVENT(xprtrdma_rxprt, name,			\
 349				TP_PROTO(				\
 350					const struct rpcrdma_xprt *r_xprt \
 351				),					\
 352				TP_ARGS(r_xprt))
 353
 354DECLARE_EVENT_CLASS(xprtrdma_connect_class,
 355	TP_PROTO(
 356		const struct rpcrdma_xprt *r_xprt,
 357		int rc
 358	),
 359
 360	TP_ARGS(r_xprt, rc),
 361
 362	TP_STRUCT__entry(
 363		__field(int, rc)
 364		__field(int, connect_status)
 365		__string(addr, rpcrdma_addrstr(r_xprt))
 366		__string(port, rpcrdma_portstr(r_xprt))
 367	),
 368
 369	TP_fast_assign(
 370		__entry->rc = rc;
 371		__entry->connect_status = r_xprt->rx_ep->re_connect_status;
 372		__assign_str(addr);
 373		__assign_str(port);
 374	),
 375
 376	TP_printk("peer=[%s]:%s rc=%d connection status=%d",
 377		__get_str(addr), __get_str(port),
 378		__entry->rc, __entry->connect_status
 379	)
 380);
 381
 382#define DEFINE_CONN_EVENT(name)						\
 383		DEFINE_EVENT(xprtrdma_connect_class, xprtrdma_##name,	\
 384				TP_PROTO(				\
 385					const struct rpcrdma_xprt *r_xprt, \
 386					int rc				\
 387				),					\
 388				TP_ARGS(r_xprt, rc))
 389
 390DECLARE_EVENT_CLASS(xprtrdma_rdch_event,
 391	TP_PROTO(
 392		const struct rpc_task *task,
 393		unsigned int pos,
 394		struct rpcrdma_mr *mr,
 395		int nsegs
 396	),
 397
 398	TP_ARGS(task, pos, mr, nsegs),
 399
 400	TP_STRUCT__entry(
 401		__field(unsigned int, task_id)
 402		__field(unsigned int, client_id)
 403		__field(unsigned int, pos)
 404		__field(int, nents)
 405		__field(u32, handle)
 406		__field(u32, length)
 407		__field(u64, offset)
 408		__field(int, nsegs)
 409	),
 410
 411	TP_fast_assign(
 412		__entry->task_id = task->tk_pid;
 413		__entry->client_id = task->tk_client->cl_clid;
 414		__entry->pos = pos;
 415		__entry->nents = mr->mr_nents;
 416		__entry->handle = mr->mr_handle;
 417		__entry->length = mr->mr_length;
 418		__entry->offset = mr->mr_offset;
 419		__entry->nsegs = nsegs;
 420	),
 421
 422	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 423		  " pos=%u %u@0x%016llx:0x%08x (%s)",
 424		__entry->task_id, __entry->client_id,
 425		__entry->pos, __entry->length,
 426		(unsigned long long)__entry->offset, __entry->handle,
 427		__entry->nents < __entry->nsegs ? "more" : "last"
 428	)
 429);
 430
 431#define DEFINE_RDCH_EVENT(name)						\
 432		DEFINE_EVENT(xprtrdma_rdch_event, xprtrdma_chunk_##name,\
 433				TP_PROTO(				\
 434					const struct rpc_task *task,	\
 435					unsigned int pos,		\
 436					struct rpcrdma_mr *mr,		\
 437					int nsegs			\
 438				),					\
 439				TP_ARGS(task, pos, mr, nsegs))
 440
 441DECLARE_EVENT_CLASS(xprtrdma_wrch_event,
 442	TP_PROTO(
 443		const struct rpc_task *task,
 444		struct rpcrdma_mr *mr,
 445		int nsegs
 446	),
 447
 448	TP_ARGS(task, mr, nsegs),
 449
 450	TP_STRUCT__entry(
 451		__field(unsigned int, task_id)
 452		__field(unsigned int, client_id)
 453		__field(int, nents)
 454		__field(u32, handle)
 455		__field(u32, length)
 456		__field(u64, offset)
 457		__field(int, nsegs)
 458	),
 459
 460	TP_fast_assign(
 461		__entry->task_id = task->tk_pid;
 462		__entry->client_id = task->tk_client->cl_clid;
 463		__entry->nents = mr->mr_nents;
 464		__entry->handle = mr->mr_handle;
 465		__entry->length = mr->mr_length;
 466		__entry->offset = mr->mr_offset;
 467		__entry->nsegs = nsegs;
 468	),
 469
 470	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 471		  " %u@0x%016llx:0x%08x (%s)",
 472		__entry->task_id, __entry->client_id,
 473		__entry->length, (unsigned long long)__entry->offset,
 474		__entry->handle,
 475		__entry->nents < __entry->nsegs ? "more" : "last"
 476	)
 477);
 478
 479#define DEFINE_WRCH_EVENT(name)						\
 480		DEFINE_EVENT(xprtrdma_wrch_event, xprtrdma_chunk_##name,\
 481				TP_PROTO(				\
 482					const struct rpc_task *task,	\
 483					struct rpcrdma_mr *mr,		\
 484					int nsegs			\
 485				),					\
 486				TP_ARGS(task, mr, nsegs))
 487
 488TRACE_DEFINE_ENUM(DMA_BIDIRECTIONAL);
 489TRACE_DEFINE_ENUM(DMA_TO_DEVICE);
 490TRACE_DEFINE_ENUM(DMA_FROM_DEVICE);
 491TRACE_DEFINE_ENUM(DMA_NONE);
 492
 493#define xprtrdma_show_direction(x)					\
 494		__print_symbolic(x,					\
 495				{ DMA_BIDIRECTIONAL, "BIDIR" },		\
 496				{ DMA_TO_DEVICE, "TO_DEVICE" },		\
 497				{ DMA_FROM_DEVICE, "FROM_DEVICE" },	\
 498				{ DMA_NONE, "NONE" })
 499
 500DECLARE_EVENT_CLASS(xprtrdma_mr_class,
 501	TP_PROTO(
 502		const struct rpcrdma_mr *mr
 503	),
 504
 505	TP_ARGS(mr),
 506
 507	TP_STRUCT__entry(
 508		__field(unsigned int, task_id)
 509		__field(unsigned int, client_id)
 510		__field(u32, mr_id)
 511		__field(int, nents)
 512		__field(u32, handle)
 513		__field(u32, length)
 514		__field(u64, offset)
 515		__field(u32, dir)
 516	),
 517
 518	TP_fast_assign(
 519		const struct rpcrdma_req *req = mr->mr_req;
 520
 521		if (req) {
 522			const struct rpc_task *task = req->rl_slot.rq_task;
 523
 524			__entry->task_id = task->tk_pid;
 525			__entry->client_id = task->tk_client->cl_clid;
 526		} else {
 527			__entry->task_id = 0;
 528			__entry->client_id = -1;
 529		}
 530		__entry->mr_id  = mr->mr_ibmr->res.id;
 531		__entry->nents  = mr->mr_nents;
 532		__entry->handle = mr->mr_handle;
 533		__entry->length = mr->mr_length;
 534		__entry->offset = mr->mr_offset;
 535		__entry->dir    = mr->mr_dir;
 536	),
 537
 538	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 539		  " mr.id=%u nents=%d %u@0x%016llx:0x%08x (%s)",
 540		__entry->task_id, __entry->client_id,
 541		__entry->mr_id, __entry->nents, __entry->length,
 542		(unsigned long long)__entry->offset, __entry->handle,
 543		xprtrdma_show_direction(__entry->dir)
 544	)
 545);
 546
 547#define DEFINE_MR_EVENT(name)						\
 548		DEFINE_EVENT(xprtrdma_mr_class,				\
 549				xprtrdma_mr_##name,			\
 550				TP_PROTO(				\
 551					const struct rpcrdma_mr *mr	\
 552				),					\
 553				TP_ARGS(mr))
 554
 555DECLARE_EVENT_CLASS(xprtrdma_anonymous_mr_class,
 556	TP_PROTO(
 557		const struct rpcrdma_mr *mr
 558	),
 559
 560	TP_ARGS(mr),
 561
 562	TP_STRUCT__entry(
 563		__field(u32, mr_id)
 564		__field(int, nents)
 565		__field(u32, handle)
 566		__field(u32, length)
 567		__field(u64, offset)
 568		__field(u32, dir)
 569	),
 570
 571	TP_fast_assign(
 572		__entry->mr_id  = mr->mr_ibmr->res.id;
 573		__entry->nents  = mr->mr_nents;
 574		__entry->handle = mr->mr_handle;
 575		__entry->length = mr->mr_length;
 576		__entry->offset = mr->mr_offset;
 577		__entry->dir    = mr->mr_dir;
 578	),
 579
 580	TP_printk("mr.id=%u nents=%d %u@0x%016llx:0x%08x (%s)",
 581		__entry->mr_id, __entry->nents, __entry->length,
 582		(unsigned long long)__entry->offset, __entry->handle,
 583		xprtrdma_show_direction(__entry->dir)
 584	)
 585);
 586
 587#define DEFINE_ANON_MR_EVENT(name)					\
 588		DEFINE_EVENT(xprtrdma_anonymous_mr_class,		\
 589				xprtrdma_mr_##name,			\
 590				TP_PROTO(				\
 591					const struct rpcrdma_mr *mr	\
 592				),					\
 593				TP_ARGS(mr))
 594
 595DECLARE_EVENT_CLASS(xprtrdma_callback_class,
 596	TP_PROTO(
 597		const struct rpcrdma_xprt *r_xprt,
 598		const struct rpc_rqst *rqst
 599	),
 600
 601	TP_ARGS(r_xprt, rqst),
 602
 603	TP_STRUCT__entry(
 604		__field(u32, xid)
 605		__string(addr, rpcrdma_addrstr(r_xprt))
 606		__string(port, rpcrdma_portstr(r_xprt))
 607	),
 608
 609	TP_fast_assign(
 610		__entry->xid = be32_to_cpu(rqst->rq_xid);
 611		__assign_str(addr);
 612		__assign_str(port);
 613	),
 614
 615	TP_printk("peer=[%s]:%s xid=0x%08x",
 616		__get_str(addr), __get_str(port), __entry->xid
 617	)
 618);
 619
 620#define DEFINE_CALLBACK_EVENT(name)					\
 621		DEFINE_EVENT(xprtrdma_callback_class,			\
 622				xprtrdma_cb_##name,			\
 623				TP_PROTO(				\
 624					const struct rpcrdma_xprt *r_xprt, \
 625					const struct rpc_rqst *rqst	\
 626				),					\
 627				TP_ARGS(r_xprt, rqst))
 628
 629/**
 630 ** Connection events
 631 **/
 632
 633TRACE_EVENT(xprtrdma_inline_thresh,
 634	TP_PROTO(
 635		const struct rpcrdma_ep *ep
 636	),
 637
 638	TP_ARGS(ep),
 639
 640	TP_STRUCT__entry(
 641		__field(unsigned int, inline_send)
 642		__field(unsigned int, inline_recv)
 643		__field(unsigned int, max_send)
 644		__field(unsigned int, max_recv)
 645		__array(unsigned char, srcaddr, sizeof(struct sockaddr_in6))
 646		__array(unsigned char, dstaddr, sizeof(struct sockaddr_in6))
 647	),
 648
 649	TP_fast_assign(
 650		const struct rdma_cm_id *id = ep->re_id;
 651
 652		__entry->inline_send = ep->re_inline_send;
 653		__entry->inline_recv = ep->re_inline_recv;
 654		__entry->max_send = ep->re_max_inline_send;
 655		__entry->max_recv = ep->re_max_inline_recv;
 656		memcpy(__entry->srcaddr, &id->route.addr.src_addr,
 657		       sizeof(struct sockaddr_in6));
 658		memcpy(__entry->dstaddr, &id->route.addr.dst_addr,
 659		       sizeof(struct sockaddr_in6));
 660	),
 661
 662	TP_printk("%pISpc -> %pISpc neg send/recv=%u/%u, calc send/recv=%u/%u",
 663		__entry->srcaddr, __entry->dstaddr,
 664		__entry->inline_send, __entry->inline_recv,
 665		__entry->max_send, __entry->max_recv
 666	)
 667);
 668
 669DEFINE_CONN_EVENT(connect);
 670DEFINE_CONN_EVENT(disconnect);
 671
 672TRACE_EVENT(xprtrdma_device_removal,
 673	TP_PROTO(
 674		const struct rdma_cm_id *id
 675	),
 676
 677	TP_ARGS(id),
 678
 679	TP_STRUCT__entry(
 680		__string(name, id->device->name)
 681		__array(unsigned char, addr, sizeof(struct sockaddr_in6))
 682	),
 683
 684	TP_fast_assign(
 685		__assign_str(name);
 686		memcpy(__entry->addr, &id->route.addr.dst_addr,
 687		       sizeof(struct sockaddr_in6));
 688	),
 689
 690	TP_printk("device %s to be removed, disconnecting %pISpc\n",
 691		__get_str(name), __entry->addr
 692	)
 693);
 694
 695DEFINE_RXPRT_EVENT(xprtrdma_op_inject_dsc);
 696
 697TRACE_EVENT(xprtrdma_op_connect,
 698	TP_PROTO(
 699		const struct rpcrdma_xprt *r_xprt,
 700		unsigned long delay
 701	),
 702
 703	TP_ARGS(r_xprt, delay),
 704
 705	TP_STRUCT__entry(
 706		__field(unsigned long, delay)
 707		__string(addr, rpcrdma_addrstr(r_xprt))
 708		__string(port, rpcrdma_portstr(r_xprt))
 709	),
 710
 711	TP_fast_assign(
 712		__entry->delay = delay;
 713		__assign_str(addr);
 714		__assign_str(port);
 715	),
 716
 717	TP_printk("peer=[%s]:%s delay=%lu",
 718		__get_str(addr), __get_str(port), __entry->delay
 719	)
 720);
 721
 722
 723TRACE_EVENT(xprtrdma_op_set_cto,
 724	TP_PROTO(
 725		const struct rpcrdma_xprt *r_xprt,
 726		unsigned long connect,
 727		unsigned long reconnect
 728	),
 729
 730	TP_ARGS(r_xprt, connect, reconnect),
 731
 732	TP_STRUCT__entry(
 733		__field(unsigned long, connect)
 734		__field(unsigned long, reconnect)
 735		__string(addr, rpcrdma_addrstr(r_xprt))
 736		__string(port, rpcrdma_portstr(r_xprt))
 737	),
 738
 739	TP_fast_assign(
 740		__entry->connect = connect;
 741		__entry->reconnect = reconnect;
 742		__assign_str(addr);
 743		__assign_str(port);
 744	),
 745
 746	TP_printk("peer=[%s]:%s connect=%lu reconnect=%lu",
 747		__get_str(addr), __get_str(port),
 748		__entry->connect / HZ, __entry->reconnect / HZ
 749	)
 750);
 751
 752/**
 753 ** Call events
 754 **/
 755
 756TRACE_EVENT(xprtrdma_createmrs,
 757	TP_PROTO(
 758		const struct rpcrdma_xprt *r_xprt,
 759		unsigned int count
 760	),
 761
 762	TP_ARGS(r_xprt, count),
 763
 764	TP_STRUCT__entry(
 765		__string(addr, rpcrdma_addrstr(r_xprt))
 766		__string(port, rpcrdma_portstr(r_xprt))
 767		__field(unsigned int, count)
 768	),
 769
 770	TP_fast_assign(
 771		__entry->count = count;
 772		__assign_str(addr);
 773		__assign_str(port);
 774	),
 775
 776	TP_printk("peer=[%s]:%s created %u MRs",
 777		__get_str(addr), __get_str(port), __entry->count
 778	)
 779);
 780
 781TRACE_EVENT(xprtrdma_nomrs_err,
 782	TP_PROTO(
 783		const struct rpcrdma_xprt *r_xprt,
 784		const struct rpcrdma_req *req
 785	),
 786
 787	TP_ARGS(r_xprt, req),
 788
 789	TP_STRUCT__entry(
 790		__field(unsigned int, task_id)
 791		__field(unsigned int, client_id)
 792		__string(addr, rpcrdma_addrstr(r_xprt))
 793		__string(port, rpcrdma_portstr(r_xprt))
 794	),
 795
 796	TP_fast_assign(
 797		const struct rpc_rqst *rqst = &req->rl_slot;
 798
 799		__entry->task_id = rqst->rq_task->tk_pid;
 800		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
 801		__assign_str(addr);
 802		__assign_str(port);
 803	),
 804
 805	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " peer=[%s]:%s",
 806		__entry->task_id, __entry->client_id,
 807		__get_str(addr), __get_str(port)
 808	)
 809);
 810
 811DEFINE_RDCH_EVENT(read);
 812DEFINE_WRCH_EVENT(write);
 813DEFINE_WRCH_EVENT(reply);
 814DEFINE_WRCH_EVENT(wp);
 815
 816TRACE_DEFINE_ENUM(rpcrdma_noch);
 817TRACE_DEFINE_ENUM(rpcrdma_noch_pullup);
 818TRACE_DEFINE_ENUM(rpcrdma_noch_mapped);
 819TRACE_DEFINE_ENUM(rpcrdma_readch);
 820TRACE_DEFINE_ENUM(rpcrdma_areadch);
 821TRACE_DEFINE_ENUM(rpcrdma_writech);
 822TRACE_DEFINE_ENUM(rpcrdma_replych);
 823
 824#define xprtrdma_show_chunktype(x)					\
 825		__print_symbolic(x,					\
 826				{ rpcrdma_noch, "inline" },		\
 827				{ rpcrdma_noch_pullup, "pullup" },	\
 828				{ rpcrdma_noch_mapped, "mapped" },	\
 829				{ rpcrdma_readch, "read list" },	\
 830				{ rpcrdma_areadch, "*read list" },	\
 831				{ rpcrdma_writech, "write list" },	\
 832				{ rpcrdma_replych, "reply chunk" })
 833
 834TRACE_EVENT(xprtrdma_marshal,
 835	TP_PROTO(
 836		const struct rpcrdma_req *req,
 837		unsigned int rtype,
 838		unsigned int wtype
 839	),
 840
 841	TP_ARGS(req, rtype, wtype),
 842
 843	TP_STRUCT__entry(
 844		__field(unsigned int, task_id)
 845		__field(unsigned int, client_id)
 846		__field(u32, xid)
 847		__field(unsigned int, hdrlen)
 848		__field(unsigned int, headlen)
 849		__field(unsigned int, pagelen)
 850		__field(unsigned int, taillen)
 851		__field(unsigned int, rtype)
 852		__field(unsigned int, wtype)
 853	),
 854
 855	TP_fast_assign(
 856		const struct rpc_rqst *rqst = &req->rl_slot;
 857
 858		__entry->task_id = rqst->rq_task->tk_pid;
 859		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
 860		__entry->xid = be32_to_cpu(rqst->rq_xid);
 861		__entry->hdrlen = req->rl_hdrbuf.len;
 862		__entry->headlen = rqst->rq_snd_buf.head[0].iov_len;
 863		__entry->pagelen = rqst->rq_snd_buf.page_len;
 864		__entry->taillen = rqst->rq_snd_buf.tail[0].iov_len;
 865		__entry->rtype = rtype;
 866		__entry->wtype = wtype;
 867	),
 868
 869	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER
 870		  " xid=0x%08x hdr=%u xdr=%u/%u/%u %s/%s",
 871		__entry->task_id, __entry->client_id, __entry->xid,
 872		__entry->hdrlen,
 873		__entry->headlen, __entry->pagelen, __entry->taillen,
 874		xprtrdma_show_chunktype(__entry->rtype),
 875		xprtrdma_show_chunktype(__entry->wtype)
 876	)
 877);
 878
 879TRACE_EVENT(xprtrdma_marshal_failed,
 880	TP_PROTO(const struct rpc_rqst *rqst,
 881		 int ret
 882	),
 883
 884	TP_ARGS(rqst, ret),
 885
 886	TP_STRUCT__entry(
 887		__field(unsigned int, task_id)
 888		__field(unsigned int, client_id)
 889		__field(u32, xid)
 890		__field(int, ret)
 891	),
 892
 893	TP_fast_assign(
 894		__entry->task_id = rqst->rq_task->tk_pid;
 895		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
 896		__entry->xid = be32_to_cpu(rqst->rq_xid);
 897		__entry->ret = ret;
 898	),
 899
 900	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x ret=%d",
 901		__entry->task_id, __entry->client_id, __entry->xid,
 902		__entry->ret
 903	)
 904);
 905
 906TRACE_EVENT(xprtrdma_prepsend_failed,
 907	TP_PROTO(const struct rpc_rqst *rqst,
 908		 int ret
 909	),
 910
 911	TP_ARGS(rqst, ret),
 912
 913	TP_STRUCT__entry(
 914		__field(unsigned int, task_id)
 915		__field(unsigned int, client_id)
 916		__field(u32, xid)
 917		__field(int, ret)
 918	),
 919
 920	TP_fast_assign(
 921		__entry->task_id = rqst->rq_task->tk_pid;
 922		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
 923		__entry->xid = be32_to_cpu(rqst->rq_xid);
 924		__entry->ret = ret;
 925	),
 926
 927	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x ret=%d",
 928		__entry->task_id, __entry->client_id, __entry->xid,
 929		__entry->ret
 930	)
 931);
 932
 933TRACE_EVENT(xprtrdma_post_send,
 934	TP_PROTO(
 935		const struct rpcrdma_req *req
 936	),
 937
 938	TP_ARGS(req),
 939
 940	TP_STRUCT__entry(
 941		__field(u32, cq_id)
 942		__field(int, completion_id)
 943		__field(unsigned int, task_id)
 944		__field(unsigned int, client_id)
 945		__field(int, num_sge)
 946		__field(int, signaled)
 947	),
 948
 949	TP_fast_assign(
 950		const struct rpc_rqst *rqst = &req->rl_slot;
 951		const struct rpcrdma_sendctx *sc = req->rl_sendctx;
 952
 953		__entry->cq_id = sc->sc_cid.ci_queue_id;
 954		__entry->completion_id = sc->sc_cid.ci_completion_id;
 955		__entry->task_id = rqst->rq_task->tk_pid;
 956		__entry->client_id = rqst->rq_task->tk_client ?
 957				     rqst->rq_task->tk_client->cl_clid : -1;
 958		__entry->num_sge = req->rl_wr.num_sge;
 959		__entry->signaled = req->rl_wr.send_flags & IB_SEND_SIGNALED;
 960	),
 961
 962	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " cq.id=%u cid=%d (%d SGE%s) %s",
 963		__entry->task_id, __entry->client_id,
 964		__entry->cq_id, __entry->completion_id,
 965		__entry->num_sge, (__entry->num_sge == 1 ? "" : "s"),
 966		(__entry->signaled ? "signaled" : "")
 967	)
 968);
 969
 970TRACE_EVENT(xprtrdma_post_send_err,
 971	TP_PROTO(
 972		const struct rpcrdma_xprt *r_xprt,
 973		const struct rpcrdma_req *req,
 974		int rc
 975	),
 976
 977	TP_ARGS(r_xprt, req, rc),
 978
 979	TP_STRUCT__entry(
 980		__field(u32, cq_id)
 981		__field(unsigned int, task_id)
 982		__field(unsigned int, client_id)
 983		__field(int, rc)
 984	),
 985
 986	TP_fast_assign(
 987		const struct rpc_rqst *rqst = &req->rl_slot;
 988		const struct rpcrdma_ep *ep = r_xprt->rx_ep;
 989
 990		__entry->cq_id = ep ? ep->re_attr.recv_cq->res.id : 0;
 991		__entry->task_id = rqst->rq_task->tk_pid;
 992		__entry->client_id = rqst->rq_task->tk_client ?
 993				     rqst->rq_task->tk_client->cl_clid : -1;
 994		__entry->rc = rc;
 995	),
 996
 997	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " cq.id=%u rc=%d",
 998		__entry->task_id, __entry->client_id,
 999		__entry->cq_id, __entry->rc
1000	)
1001);
1002
1003DEFINE_SIMPLE_CID_EVENT(xprtrdma_post_recv);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1004
1005TRACE_EVENT(xprtrdma_post_recvs,
1006	TP_PROTO(
1007		const struct rpcrdma_xprt *r_xprt,
1008		unsigned int count
1009	),
1010
1011	TP_ARGS(r_xprt, count),
1012
1013	TP_STRUCT__entry(
1014		__field(u32, cq_id)
1015		__field(unsigned int, count)
1016		__field(int, posted)
1017		__string(addr, rpcrdma_addrstr(r_xprt))
1018		__string(port, rpcrdma_portstr(r_xprt))
1019	),
1020
1021	TP_fast_assign(
1022		const struct rpcrdma_ep *ep = r_xprt->rx_ep;
1023
1024		__entry->cq_id = ep->re_attr.recv_cq->res.id;
1025		__entry->count = count;
1026		__entry->posted = ep->re_receive_count;
1027		__assign_str(addr);
1028		__assign_str(port);
1029	),
1030
1031	TP_printk("peer=[%s]:%s cq.id=%d %u new recvs, %d active",
1032		__get_str(addr), __get_str(port), __entry->cq_id,
1033		__entry->count, __entry->posted
1034	)
1035);
1036
1037TRACE_EVENT(xprtrdma_post_recvs_err,
1038	TP_PROTO(
1039		const struct rpcrdma_xprt *r_xprt,
1040		int status
1041	),
1042
1043	TP_ARGS(r_xprt, status),
1044
1045	TP_STRUCT__entry(
1046		__field(u32, cq_id)
1047		__field(int, status)
1048		__string(addr, rpcrdma_addrstr(r_xprt))
1049		__string(port, rpcrdma_portstr(r_xprt))
1050	),
1051
1052	TP_fast_assign(
1053		const struct rpcrdma_ep *ep = r_xprt->rx_ep;
1054
1055		__entry->cq_id = ep->re_attr.recv_cq->res.id;
1056		__entry->status = status;
1057		__assign_str(addr);
1058		__assign_str(port);
1059	),
1060
1061	TP_printk("peer=[%s]:%s cq.id=%d rc=%d",
1062		__get_str(addr), __get_str(port), __entry->cq_id,
1063		__entry->status
1064	)
1065);
1066
1067TRACE_EVENT(xprtrdma_post_linv_err,
1068	TP_PROTO(
1069		const struct rpcrdma_req *req,
1070		int status
1071	),
1072
1073	TP_ARGS(req, status),
1074
1075	TP_STRUCT__entry(
1076		__field(unsigned int, task_id)
1077		__field(unsigned int, client_id)
1078		__field(int, status)
1079	),
1080
1081	TP_fast_assign(
1082		const struct rpc_task *task = req->rl_slot.rq_task;
1083
1084		__entry->task_id = task->tk_pid;
1085		__entry->client_id = task->tk_client->cl_clid;
1086		__entry->status = status;
1087	),
1088
1089	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " status=%d",
1090		__entry->task_id, __entry->client_id, __entry->status
1091	)
1092);
1093
1094/**
1095 ** Completion events
1096 **/
1097
1098DEFINE_RECEIVE_COMPLETION_EVENT(xprtrdma_wc_receive);
1099
1100DEFINE_COMPLETION_EVENT(xprtrdma_wc_send);
1101DEFINE_MR_COMPLETION_EVENT(xprtrdma_wc_fastreg);
1102DEFINE_MR_COMPLETION_EVENT(xprtrdma_wc_li);
1103DEFINE_MR_COMPLETION_EVENT(xprtrdma_wc_li_wake);
1104DEFINE_MR_COMPLETION_EVENT(xprtrdma_wc_li_done);
1105
1106TRACE_EVENT(xprtrdma_frwr_alloc,
1107	TP_PROTO(
1108		const struct rpcrdma_mr *mr,
1109		int rc
1110	),
1111
1112	TP_ARGS(mr, rc),
1113
1114	TP_STRUCT__entry(
1115		__field(u32, mr_id)
1116		__field(int, rc)
1117	),
1118
1119	TP_fast_assign(
1120		__entry->mr_id = mr->mr_ibmr->res.id;
1121		__entry->rc = rc;
1122	),
1123
1124	TP_printk("mr.id=%u: rc=%d",
1125		__entry->mr_id, __entry->rc
1126	)
1127);
1128
1129TRACE_EVENT(xprtrdma_frwr_dereg,
1130	TP_PROTO(
1131		const struct rpcrdma_mr *mr,
1132		int rc
1133	),
1134
1135	TP_ARGS(mr, rc),
1136
1137	TP_STRUCT__entry(
1138		__field(u32, mr_id)
1139		__field(int, nents)
1140		__field(u32, handle)
1141		__field(u32, length)
1142		__field(u64, offset)
1143		__field(u32, dir)
1144		__field(int, rc)
1145	),
1146
1147	TP_fast_assign(
1148		__entry->mr_id  = mr->mr_ibmr->res.id;
1149		__entry->nents  = mr->mr_nents;
1150		__entry->handle = mr->mr_handle;
1151		__entry->length = mr->mr_length;
1152		__entry->offset = mr->mr_offset;
1153		__entry->dir    = mr->mr_dir;
1154		__entry->rc	= rc;
1155	),
1156
1157	TP_printk("mr.id=%u nents=%d %u@0x%016llx:0x%08x (%s): rc=%d",
1158		__entry->mr_id, __entry->nents, __entry->length,
1159		(unsigned long long)__entry->offset, __entry->handle,
1160		xprtrdma_show_direction(__entry->dir),
1161		__entry->rc
1162	)
1163);
1164
1165TRACE_EVENT(xprtrdma_frwr_sgerr,
1166	TP_PROTO(
1167		const struct rpcrdma_mr *mr,
1168		int sg_nents
1169	),
1170
1171	TP_ARGS(mr, sg_nents),
1172
1173	TP_STRUCT__entry(
1174		__field(u32, mr_id)
1175		__field(u64, addr)
1176		__field(u32, dir)
1177		__field(int, nents)
1178	),
1179
1180	TP_fast_assign(
1181		__entry->mr_id = mr->mr_ibmr->res.id;
1182		__entry->addr = mr->mr_sg->dma_address;
1183		__entry->dir = mr->mr_dir;
1184		__entry->nents = sg_nents;
1185	),
1186
1187	TP_printk("mr.id=%u DMA addr=0x%llx (%s) sg_nents=%d",
1188		__entry->mr_id, __entry->addr,
1189		xprtrdma_show_direction(__entry->dir),
1190		__entry->nents
1191	)
1192);
1193
1194TRACE_EVENT(xprtrdma_frwr_maperr,
1195	TP_PROTO(
1196		const struct rpcrdma_mr *mr,
1197		int num_mapped
1198	),
1199
1200	TP_ARGS(mr, num_mapped),
1201
1202	TP_STRUCT__entry(
1203		__field(u32, mr_id)
1204		__field(u64, addr)
1205		__field(u32, dir)
1206		__field(int, num_mapped)
1207		__field(int, nents)
1208	),
1209
1210	TP_fast_assign(
1211		__entry->mr_id = mr->mr_ibmr->res.id;
1212		__entry->addr = mr->mr_sg->dma_address;
1213		__entry->dir = mr->mr_dir;
1214		__entry->num_mapped = num_mapped;
1215		__entry->nents = mr->mr_nents;
1216	),
1217
1218	TP_printk("mr.id=%u DMA addr=0x%llx (%s) nents=%d of %d",
1219		__entry->mr_id, __entry->addr,
1220		xprtrdma_show_direction(__entry->dir),
1221		__entry->num_mapped, __entry->nents
1222	)
1223);
1224
1225DEFINE_MR_EVENT(fastreg);
1226DEFINE_MR_EVENT(localinv);
1227DEFINE_MR_EVENT(reminv);
1228DEFINE_MR_EVENT(map);
1229
1230DEFINE_ANON_MR_EVENT(unmap);
1231
1232TRACE_EVENT(xprtrdma_dma_maperr,
1233	TP_PROTO(
1234		u64 addr
1235	),
1236
1237	TP_ARGS(addr),
1238
1239	TP_STRUCT__entry(
1240		__field(u64, addr)
1241	),
1242
1243	TP_fast_assign(
1244		__entry->addr = addr;
1245	),
1246
1247	TP_printk("dma addr=0x%llx\n", __entry->addr)
1248);
1249
1250/**
1251 ** Reply events
1252 **/
1253
1254TRACE_EVENT(xprtrdma_reply,
1255	TP_PROTO(
1256		const struct rpc_task *task,
1257		const struct rpcrdma_rep *rep,
1258		unsigned int credits
1259	),
1260
1261	TP_ARGS(task, rep, credits),
1262
1263	TP_STRUCT__entry(
1264		__field(unsigned int, task_id)
1265		__field(unsigned int, client_id)
1266		__field(u32, xid)
1267		__field(unsigned int, credits)
1268	),
1269
1270	TP_fast_assign(
1271		__entry->task_id = task->tk_pid;
1272		__entry->client_id = task->tk_client->cl_clid;
1273		__entry->xid = be32_to_cpu(rep->rr_xid);
1274		__entry->credits = credits;
1275	),
1276
1277	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x credits=%u",
1278		__entry->task_id, __entry->client_id, __entry->xid,
1279		__entry->credits
1280	)
1281);
1282
1283DEFINE_REPLY_EVENT(vers);
1284DEFINE_REPLY_EVENT(rqst);
1285DEFINE_REPLY_EVENT(short);
1286DEFINE_REPLY_EVENT(hdr);
1287
1288TRACE_EVENT(xprtrdma_err_vers,
1289	TP_PROTO(
1290		const struct rpc_rqst *rqst,
1291		__be32 *min,
1292		__be32 *max
1293	),
1294
1295	TP_ARGS(rqst, min, max),
1296
1297	TP_STRUCT__entry(
1298		__field(unsigned int, task_id)
1299		__field(unsigned int, client_id)
1300		__field(u32, xid)
1301		__field(u32, min)
1302		__field(u32, max)
1303	),
1304
1305	TP_fast_assign(
1306		__entry->task_id = rqst->rq_task->tk_pid;
1307		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
1308		__entry->xid = be32_to_cpu(rqst->rq_xid);
1309		__entry->min = be32_to_cpup(min);
1310		__entry->max = be32_to_cpup(max);
1311	),
1312
1313	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x versions=[%u, %u]",
1314		__entry->task_id, __entry->client_id, __entry->xid,
1315		__entry->min, __entry->max
1316	)
1317);
1318
1319TRACE_EVENT(xprtrdma_err_chunk,
1320	TP_PROTO(
1321		const struct rpc_rqst *rqst
1322	),
1323
1324	TP_ARGS(rqst),
1325
1326	TP_STRUCT__entry(
1327		__field(unsigned int, task_id)
1328		__field(unsigned int, client_id)
1329		__field(u32, xid)
1330	),
1331
1332	TP_fast_assign(
1333		__entry->task_id = rqst->rq_task->tk_pid;
1334		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
1335		__entry->xid = be32_to_cpu(rqst->rq_xid);
1336	),
1337
1338	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x",
1339		__entry->task_id, __entry->client_id, __entry->xid
1340	)
1341);
1342
1343TRACE_EVENT(xprtrdma_err_unrecognized,
1344	TP_PROTO(
1345		const struct rpc_rqst *rqst,
1346		__be32 *procedure
1347	),
1348
1349	TP_ARGS(rqst, procedure),
1350
1351	TP_STRUCT__entry(
1352		__field(unsigned int, task_id)
1353		__field(unsigned int, client_id)
1354		__field(u32, xid)
1355		__field(u32, procedure)
1356	),
1357
1358	TP_fast_assign(
1359		__entry->task_id = rqst->rq_task->tk_pid;
1360		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
1361		__entry->procedure = be32_to_cpup(procedure);
1362	),
1363
1364	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " xid=0x%08x procedure=%u",
1365		__entry->task_id, __entry->client_id, __entry->xid,
1366		__entry->procedure
1367	)
1368);
1369
1370TRACE_EVENT(xprtrdma_fixup,
1371	TP_PROTO(
1372		const struct rpc_rqst *rqst,
1373		unsigned long fixup
1374	),
1375
1376	TP_ARGS(rqst, fixup),
1377
1378	TP_STRUCT__entry(
1379		__field(unsigned int, task_id)
1380		__field(unsigned int, client_id)
1381		__field(unsigned long, fixup)
1382		__field(size_t, headlen)
1383		__field(unsigned int, pagelen)
1384		__field(size_t, taillen)
1385	),
1386
1387	TP_fast_assign(
1388		__entry->task_id = rqst->rq_task->tk_pid;
1389		__entry->client_id = rqst->rq_task->tk_client->cl_clid;
1390		__entry->fixup = fixup;
1391		__entry->headlen = rqst->rq_rcv_buf.head[0].iov_len;
1392		__entry->pagelen = rqst->rq_rcv_buf.page_len;
1393		__entry->taillen = rqst->rq_rcv_buf.tail[0].iov_len;
1394	),
1395
1396	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER " fixup=%lu xdr=%zu/%u/%zu",
1397		__entry->task_id, __entry->client_id, __entry->fixup,
1398		__entry->headlen, __entry->pagelen, __entry->taillen
1399	)
1400);
1401
1402TRACE_EVENT(xprtrdma_decode_seg,
1403	TP_PROTO(
1404		u32 handle,
1405		u32 length,
1406		u64 offset
1407	),
1408
1409	TP_ARGS(handle, length, offset),
1410
1411	TP_STRUCT__entry(
1412		__field(u32, handle)
1413		__field(u32, length)
1414		__field(u64, offset)
1415	),
1416
1417	TP_fast_assign(
1418		__entry->handle = handle;
1419		__entry->length = length;
1420		__entry->offset = offset;
1421	),
1422
1423	TP_printk("%u@0x%016llx:0x%08x",
1424		__entry->length, (unsigned long long)__entry->offset,
1425		__entry->handle
1426	)
1427);
1428
1429TRACE_EVENT(xprtrdma_mrs_zap,
1430	TP_PROTO(
1431		const struct rpc_task *task
1432	),
1433
1434	TP_ARGS(task),
1435
1436	TP_STRUCT__entry(
1437		__field(unsigned int, task_id)
1438		__field(unsigned int, client_id)
1439	),
1440
1441	TP_fast_assign(
1442		__entry->task_id = task->tk_pid;
1443		__entry->client_id = task->tk_client->cl_clid;
1444	),
1445
1446	TP_printk(SUNRPC_TRACE_TASK_SPECIFIER,
1447		__entry->task_id, __entry->client_id
1448	)
1449);
1450
1451/**
1452 ** Callback events
1453 **/
1454
1455TRACE_EVENT(xprtrdma_cb_setup,
1456	TP_PROTO(
1457		const struct rpcrdma_xprt *r_xprt,
1458		unsigned int reqs
1459	),
1460
1461	TP_ARGS(r_xprt, reqs),
1462
1463	TP_STRUCT__entry(
1464		__field(unsigned int, reqs)
1465		__string(addr, rpcrdma_addrstr(r_xprt))
1466		__string(port, rpcrdma_portstr(r_xprt))
1467	),
1468
1469	TP_fast_assign(
1470		__entry->reqs = reqs;
1471		__assign_str(addr);
1472		__assign_str(port);
1473	),
1474
1475	TP_printk("peer=[%s]:%s %u reqs",
1476		__get_str(addr), __get_str(port), __entry->reqs
1477	)
1478);
1479
1480DEFINE_CALLBACK_EVENT(call);
1481DEFINE_CALLBACK_EVENT(reply);
1482
1483/**
1484 ** Server-side RPC/RDMA events
1485 **/
1486
1487DECLARE_EVENT_CLASS(svcrdma_accept_class,
1488	TP_PROTO(
1489		const struct svcxprt_rdma *rdma,
1490		long status
1491	),
1492
1493	TP_ARGS(rdma, status),
1494
1495	TP_STRUCT__entry(
1496		__field(long, status)
1497		__string(addr, rdma->sc_xprt.xpt_remotebuf)
1498	),
1499
1500	TP_fast_assign(
1501		__entry->status = status;
1502		__assign_str(addr);
1503	),
1504
1505	TP_printk("addr=%s status=%ld",
1506		__get_str(addr), __entry->status
1507	)
1508);
1509
1510#define DEFINE_ACCEPT_EVENT(name) \
1511		DEFINE_EVENT(svcrdma_accept_class, svcrdma_##name##_err, \
1512				TP_PROTO( \
1513					const struct svcxprt_rdma *rdma, \
1514					long status \
1515				), \
1516				TP_ARGS(rdma, status))
1517
1518DEFINE_ACCEPT_EVENT(pd);
1519DEFINE_ACCEPT_EVENT(qp);
1520DEFINE_ACCEPT_EVENT(fabric);
1521DEFINE_ACCEPT_EVENT(initdepth);
1522DEFINE_ACCEPT_EVENT(accept);
1523
1524TRACE_DEFINE_ENUM(RDMA_MSG);
1525TRACE_DEFINE_ENUM(RDMA_NOMSG);
1526TRACE_DEFINE_ENUM(RDMA_MSGP);
1527TRACE_DEFINE_ENUM(RDMA_DONE);
1528TRACE_DEFINE_ENUM(RDMA_ERROR);
1529
1530#define show_rpcrdma_proc(x)						\
1531		__print_symbolic(x,					\
1532				{ RDMA_MSG, "RDMA_MSG" },		\
1533				{ RDMA_NOMSG, "RDMA_NOMSG" },		\
1534				{ RDMA_MSGP, "RDMA_MSGP" },		\
1535				{ RDMA_DONE, "RDMA_DONE" },		\
1536				{ RDMA_ERROR, "RDMA_ERROR" })
1537
1538TRACE_EVENT(svcrdma_decode_rqst,
1539	TP_PROTO(
1540		const struct svc_rdma_recv_ctxt *ctxt,
1541		__be32 *p,
1542		unsigned int hdrlen
1543	),
1544
1545	TP_ARGS(ctxt, p, hdrlen),
1546
1547	TP_STRUCT__entry(
1548		__field(u32, cq_id)
1549		__field(int, completion_id)
1550		__field(u32, xid)
1551		__field(u32, vers)
1552		__field(u32, proc)
1553		__field(u32, credits)
1554		__field(unsigned int, hdrlen)
1555	),
1556
1557	TP_fast_assign(
1558		__entry->cq_id = ctxt->rc_cid.ci_queue_id;
1559		__entry->completion_id = ctxt->rc_cid.ci_completion_id;
1560		__entry->xid = be32_to_cpup(p++);
1561		__entry->vers = be32_to_cpup(p++);
1562		__entry->credits = be32_to_cpup(p++);
1563		__entry->proc = be32_to_cpup(p);
1564		__entry->hdrlen = hdrlen;
1565	),
1566
1567	TP_printk("cq.id=%u cid=%d xid=0x%08x vers=%u credits=%u proc=%s hdrlen=%u",
1568		__entry->cq_id, __entry->completion_id,
1569		__entry->xid, __entry->vers, __entry->credits,
1570		show_rpcrdma_proc(__entry->proc), __entry->hdrlen)
1571);
1572
1573TRACE_EVENT(svcrdma_decode_short_err,
1574	TP_PROTO(
1575		const struct svc_rdma_recv_ctxt *ctxt,
1576		unsigned int hdrlen
1577	),
1578
1579	TP_ARGS(ctxt, hdrlen),
1580
1581	TP_STRUCT__entry(
1582		__field(u32, cq_id)
1583		__field(int, completion_id)
1584		__field(unsigned int, hdrlen)
1585	),
1586
1587	TP_fast_assign(
1588		__entry->cq_id = ctxt->rc_cid.ci_queue_id;
1589		__entry->completion_id = ctxt->rc_cid.ci_completion_id;
1590		__entry->hdrlen = hdrlen;
1591	),
1592
1593	TP_printk("cq.id=%u cid=%d hdrlen=%u",
1594		__entry->cq_id, __entry->completion_id,
1595		__entry->hdrlen)
1596);
1597
1598DECLARE_EVENT_CLASS(svcrdma_badreq_event,
1599	TP_PROTO(
1600		const struct svc_rdma_recv_ctxt *ctxt,
1601		__be32 *p
1602	),
1603
1604	TP_ARGS(ctxt, p),
1605
1606	TP_STRUCT__entry(
1607		__field(u32, cq_id)
1608		__field(int, completion_id)
1609		__field(u32, xid)
1610		__field(u32, vers)
1611		__field(u32, proc)
1612		__field(u32, credits)
1613	),
1614
1615	TP_fast_assign(
1616		__entry->cq_id = ctxt->rc_cid.ci_queue_id;
1617		__entry->completion_id = ctxt->rc_cid.ci_completion_id;
1618		__entry->xid = be32_to_cpup(p++);
1619		__entry->vers = be32_to_cpup(p++);
1620		__entry->credits = be32_to_cpup(p++);
1621		__entry->proc = be32_to_cpup(p);
1622	),
1623
1624	TP_printk("cq.id=%u cid=%d xid=0x%08x vers=%u credits=%u proc=%u",
1625		__entry->cq_id, __entry->completion_id,
1626		__entry->xid, __entry->vers, __entry->credits, __entry->proc)
1627);
1628
1629#define DEFINE_BADREQ_EVENT(name)					\
1630		DEFINE_EVENT(svcrdma_badreq_event,			\
1631			     svcrdma_decode_##name##_err,		\
1632				TP_PROTO(				\
1633					const struct svc_rdma_recv_ctxt *ctxt,	\
1634					__be32 *p			\
1635				),					\
1636				TP_ARGS(ctxt, p))
1637
1638DEFINE_BADREQ_EVENT(badvers);
1639DEFINE_BADREQ_EVENT(drop);
1640DEFINE_BADREQ_EVENT(badproc);
1641DEFINE_BADREQ_EVENT(parse);
1642
1643TRACE_EVENT(svcrdma_encode_wseg,
1644	TP_PROTO(
1645		const struct svc_rdma_send_ctxt *ctxt,
1646		u32 segno,
1647		u32 handle,
1648		u32 length,
1649		u64 offset
1650	),
1651
1652	TP_ARGS(ctxt, segno, handle, length, offset),
1653
1654	TP_STRUCT__entry(
1655		__field(u32, cq_id)
1656		__field(int, completion_id)
1657		__field(u32, segno)
1658		__field(u32, handle)
1659		__field(u32, length)
1660		__field(u64, offset)
1661	),
1662
1663	TP_fast_assign(
1664		__entry->cq_id = ctxt->sc_cid.ci_queue_id;
1665		__entry->completion_id = ctxt->sc_cid.ci_completion_id;
1666		__entry->segno = segno;
1667		__entry->handle = handle;
1668		__entry->length = length;
1669		__entry->offset = offset;
1670	),
1671
1672	TP_printk("cq.id=%u cid=%d segno=%u %u@0x%016llx:0x%08x",
1673		__entry->cq_id, __entry->completion_id,
1674		__entry->segno, __entry->length,
1675		(unsigned long long)__entry->offset, __entry->handle
1676	)
1677);
1678
1679TRACE_EVENT(svcrdma_decode_rseg,
1680	TP_PROTO(
1681		const struct rpc_rdma_cid *cid,
1682		const struct svc_rdma_chunk *chunk,
1683		const struct svc_rdma_segment *segment
1684	),
1685
1686	TP_ARGS(cid, chunk, segment),
1687
1688	TP_STRUCT__entry(
1689		__field(u32, cq_id)
1690		__field(int, completion_id)
1691		__field(u32, segno)
1692		__field(u32, position)
1693		__field(u32, handle)
1694		__field(u32, length)
1695		__field(u64, offset)
1696	),
1697
1698	TP_fast_assign(
1699		__entry->cq_id = cid->ci_queue_id;
1700		__entry->completion_id = cid->ci_completion_id;
1701		__entry->segno = chunk->ch_segcount;
1702		__entry->position = chunk->ch_position;
1703		__entry->handle = segment->rs_handle;
1704		__entry->length = segment->rs_length;
1705		__entry->offset = segment->rs_offset;
1706	),
1707
1708	TP_printk("cq.id=%u cid=%d segno=%u position=%u %u@0x%016llx:0x%08x",
1709		__entry->cq_id, __entry->completion_id,
1710		__entry->segno, __entry->position, __entry->length,
1711		(unsigned long long)__entry->offset, __entry->handle
1712	)
1713);
1714
1715TRACE_EVENT(svcrdma_decode_wseg,
1716	TP_PROTO(
1717		const struct rpc_rdma_cid *cid,
1718		const struct svc_rdma_chunk *chunk,
1719		u32 segno
1720	),
1721
1722	TP_ARGS(cid, chunk, segno),
1723
1724	TP_STRUCT__entry(
1725		__field(u32, cq_id)
1726		__field(int, completion_id)
1727		__field(u32, segno)
1728		__field(u32, handle)
1729		__field(u32, length)
1730		__field(u64, offset)
1731	),
1732
1733	TP_fast_assign(
1734		const struct svc_rdma_segment *segment =
1735			&chunk->ch_segments[segno];
1736
1737		__entry->cq_id = cid->ci_queue_id;
1738		__entry->completion_id = cid->ci_completion_id;
1739		__entry->segno = segno;
1740		__entry->handle = segment->rs_handle;
1741		__entry->length = segment->rs_length;
1742		__entry->offset = segment->rs_offset;
1743	),
1744
1745	TP_printk("cq.id=%u cid=%d segno=%u %u@0x%016llx:0x%08x",
1746		__entry->cq_id, __entry->completion_id,
1747		__entry->segno, __entry->length,
1748		(unsigned long long)__entry->offset, __entry->handle
1749	)
1750);
1751
1752DECLARE_EVENT_CLASS(svcrdma_error_event,
1753	TP_PROTO(
1754		__be32 xid
1755	),
1756
1757	TP_ARGS(xid),
1758
1759	TP_STRUCT__entry(
1760		__field(u32, xid)
1761	),
1762
1763	TP_fast_assign(
1764		__entry->xid = be32_to_cpu(xid);
1765	),
1766
1767	TP_printk("xid=0x%08x",
1768		__entry->xid
1769	)
1770);
1771
1772#define DEFINE_ERROR_EVENT(name)					\
1773		DEFINE_EVENT(svcrdma_error_event, svcrdma_err_##name,	\
1774				TP_PROTO(				\
1775					__be32 xid			\
1776				),					\
1777				TP_ARGS(xid))
1778
1779DEFINE_ERROR_EVENT(vers);
1780DEFINE_ERROR_EVENT(chunk);
1781
1782/**
1783 ** Server-side RDMA API events
1784 **/
1785
1786DECLARE_EVENT_CLASS(svcrdma_dma_map_class,
1787	TP_PROTO(
1788		const struct rpc_rdma_cid *cid,
1789		u64 dma_addr,
1790		u32 length
1791	),
1792
1793	TP_ARGS(cid, dma_addr, length),
1794
1795	TP_STRUCT__entry(
1796		__field(u32, cq_id)
1797		__field(int, completion_id)
1798		__field(u64, dma_addr)
1799		__field(u32, length)
 
 
1800	),
1801
1802	TP_fast_assign(
1803		__entry->cq_id = cid->ci_queue_id;
1804		__entry->completion_id = cid->ci_completion_id;
1805		__entry->dma_addr = dma_addr;
1806		__entry->length = length;
 
 
1807	),
1808
1809	TP_printk("cq.id=%u cid=%d dma_addr=%llu length=%u",
1810		__entry->cq_id, __entry->completion_id,
1811		__entry->dma_addr, __entry->length
1812	)
1813);
1814
1815#define DEFINE_SVC_DMA_EVENT(name)					\
1816		DEFINE_EVENT(svcrdma_dma_map_class, svcrdma_##name,	\
1817				TP_PROTO(				\
1818					const struct rpc_rdma_cid *cid, \
1819					u64 dma_addr,			\
1820					u32 length			\
1821				),					\
1822				TP_ARGS(cid, dma_addr, length)		\
1823		)
1824
1825DEFINE_SVC_DMA_EVENT(dma_map_page);
1826DEFINE_SVC_DMA_EVENT(dma_map_err);
1827DEFINE_SVC_DMA_EVENT(dma_unmap_page);
1828
1829TRACE_EVENT(svcrdma_dma_map_rw_err,
1830	TP_PROTO(
1831		const struct svcxprt_rdma *rdma,
1832		u64 offset,
1833		u32 handle,
1834		unsigned int nents,
1835		int status
1836	),
1837
1838	TP_ARGS(rdma, offset, handle, nents, status),
1839
1840	TP_STRUCT__entry(
1841		__field(u32, cq_id)
1842		__field(u32, handle)
1843		__field(u64, offset)
1844		__field(unsigned int, nents)
1845		__field(int, status)
 
 
 
1846	),
1847
1848	TP_fast_assign(
1849		__entry->cq_id = rdma->sc_sq_cq->res.id;
1850		__entry->handle = handle;
1851		__entry->offset = offset;
1852		__entry->nents = nents;
1853		__entry->status = status;
 
 
 
1854	),
1855
1856	TP_printk("cq.id=%u 0x%016llx:0x%08x nents=%u status=%d",
1857		__entry->cq_id, (unsigned long long)__entry->offset,
1858		__entry->handle, __entry->nents, __entry->status
1859	)
1860);
1861
1862TRACE_EVENT(svcrdma_rwctx_empty,
1863	TP_PROTO(
1864		const struct svcxprt_rdma *rdma,
1865		unsigned int num_sges
1866	),
1867
1868	TP_ARGS(rdma, num_sges),
1869
1870	TP_STRUCT__entry(
1871		__field(u32, cq_id)
1872		__field(unsigned int, num_sges)
 
 
1873	),
1874
1875	TP_fast_assign(
1876		__entry->cq_id = rdma->sc_sq_cq->res.id;
1877		__entry->num_sges = num_sges;
 
 
1878	),
1879
1880	TP_printk("cq.id=%u num_sges=%d",
1881		__entry->cq_id, __entry->num_sges
1882	)
1883);
1884
1885TRACE_EVENT(svcrdma_page_overrun_err,
1886	TP_PROTO(
1887		const struct rpc_rdma_cid *cid,
 
1888		unsigned int pageno
1889	),
1890
1891	TP_ARGS(cid, pageno),
1892
1893	TP_STRUCT__entry(
1894		__field(u32, cq_id)
1895		__field(int, completion_id)
1896		__field(unsigned int, pageno)
 
 
 
1897	),
1898
1899	TP_fast_assign(
1900		__entry->cq_id = cid->ci_queue_id;
1901		__entry->completion_id = cid->ci_completion_id;
1902		__entry->pageno = pageno;
 
 
 
1903	),
1904
1905	TP_printk("cq.id=%u cid=%d pageno=%u",
1906		__entry->cq_id, __entry->completion_id,
1907		__entry->pageno
1908	)
1909);
1910
1911TRACE_EVENT(svcrdma_small_wrch_err,
1912	TP_PROTO(
1913		const struct rpc_rdma_cid *cid,
1914		unsigned int remaining,
1915		unsigned int seg_no,
1916		unsigned int num_segs
1917	),
1918
1919	TP_ARGS(cid, remaining, seg_no, num_segs),
1920
1921	TP_STRUCT__entry(
1922		__field(u32, cq_id)
1923		__field(int, completion_id)
1924		__field(unsigned int, remaining)
1925		__field(unsigned int, seg_no)
1926		__field(unsigned int, num_segs)
 
 
1927	),
1928
1929	TP_fast_assign(
1930		__entry->cq_id = cid->ci_queue_id;
1931		__entry->completion_id = cid->ci_completion_id;
1932		__entry->remaining = remaining;
1933		__entry->seg_no = seg_no;
1934		__entry->num_segs = num_segs;
 
 
1935	),
1936
1937	TP_printk("cq.id=%u cid=%d remaining=%u seg_no=%u num_segs=%u",
1938		__entry->cq_id, __entry->completion_id,
1939		__entry->remaining, __entry->seg_no, __entry->num_segs
1940	)
1941);
1942
1943TRACE_EVENT(svcrdma_send_pullup,
1944	TP_PROTO(
1945		const struct svc_rdma_send_ctxt *ctxt,
1946		unsigned int msglen
1947	),
1948
1949	TP_ARGS(ctxt, msglen),
1950
1951	TP_STRUCT__entry(
1952		__field(u32, cq_id)
1953		__field(int, completion_id)
1954		__field(unsigned int, hdrlen)
1955		__field(unsigned int, msglen)
1956	),
1957
1958	TP_fast_assign(
1959		__entry->cq_id = ctxt->sc_cid.ci_queue_id;
1960		__entry->completion_id = ctxt->sc_cid.ci_completion_id;
1961		__entry->hdrlen = ctxt->sc_hdrbuf.len,
1962		__entry->msglen = msglen;
1963	),
1964
1965	TP_printk("cq.id=%u cid=%d hdr=%u msg=%u (total %u)",
1966		__entry->cq_id, __entry->completion_id,
1967		__entry->hdrlen, __entry->msglen,
1968		__entry->hdrlen + __entry->msglen)
1969);
1970
1971TRACE_EVENT(svcrdma_send_err,
1972	TP_PROTO(
1973		const struct svc_rqst *rqst,
1974		int status
1975	),
1976
1977	TP_ARGS(rqst, status),
1978
1979	TP_STRUCT__entry(
1980		__field(int, status)
1981		__field(u32, xid)
1982		__string(addr, rqst->rq_xprt->xpt_remotebuf)
1983	),
1984
1985	TP_fast_assign(
1986		__entry->status = status;
1987		__entry->xid = __be32_to_cpu(rqst->rq_xid);
1988		__assign_str(addr);
1989	),
1990
1991	TP_printk("addr=%s xid=0x%08x status=%d", __get_str(addr),
1992		__entry->xid, __entry->status
1993	)
1994);
1995
1996TRACE_EVENT(svcrdma_post_send,
1997	TP_PROTO(
1998		const struct svc_rdma_send_ctxt *ctxt
1999	),
2000
2001	TP_ARGS(ctxt),
2002
2003	TP_STRUCT__entry(
2004		__field(u32, cq_id)
2005		__field(int, completion_id)
2006		__field(unsigned int, num_sge)
2007		__field(u32, inv_rkey)
2008	),
2009
2010	TP_fast_assign(
2011		const struct ib_send_wr *wr = &ctxt->sc_send_wr;
2012
2013		__entry->cq_id = ctxt->sc_cid.ci_queue_id;
2014		__entry->completion_id = ctxt->sc_cid.ci_completion_id;
2015		__entry->num_sge = wr->num_sge;
2016		__entry->inv_rkey = (wr->opcode == IB_WR_SEND_WITH_INV) ?
2017					wr->ex.invalidate_rkey : 0;
2018	),
2019
2020	TP_printk("cq.id=%u cid=%d num_sge=%u inv_rkey=0x%08x",
2021		__entry->cq_id, __entry->completion_id,
2022		__entry->num_sge, __entry->inv_rkey
2023	)
2024);
2025
2026DEFINE_SIMPLE_CID_EVENT(svcrdma_wc_send);
2027DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_send_flush);
2028DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_send_err);
2029
2030DEFINE_SIMPLE_CID_EVENT(svcrdma_post_recv);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2031
2032DEFINE_RECEIVE_SUCCESS_EVENT(svcrdma_wc_recv);
2033DEFINE_RECEIVE_FLUSH_EVENT(svcrdma_wc_recv_flush);
2034DEFINE_RECEIVE_FLUSH_EVENT(svcrdma_wc_recv_err);
2035
2036TRACE_EVENT(svcrdma_rq_post_err,
2037	TP_PROTO(
2038		const struct svcxprt_rdma *rdma,
2039		int status
2040	),
2041
2042	TP_ARGS(rdma, status),
2043
2044	TP_STRUCT__entry(
2045		__field(int, status)
2046		__string(addr, rdma->sc_xprt.xpt_remotebuf)
2047	),
2048
2049	TP_fast_assign(
2050		__entry->status = status;
2051		__assign_str(addr);
2052	),
2053
2054	TP_printk("addr=%s status=%d",
2055		__get_str(addr), __entry->status
2056	)
2057);
2058
2059DECLARE_EVENT_CLASS(svcrdma_post_chunk_class,
2060	TP_PROTO(
2061		const struct rpc_rdma_cid *cid,
2062		int sqecount
2063	),
2064
2065	TP_ARGS(cid, sqecount),
2066
2067	TP_STRUCT__entry(
2068		__field(u32, cq_id)
2069		__field(int, completion_id)
2070		__field(int, sqecount)
2071	),
2072
2073	TP_fast_assign(
2074		__entry->cq_id = cid->ci_queue_id;
2075		__entry->completion_id = cid->ci_completion_id;
2076		__entry->sqecount = sqecount;
2077	),
2078
2079	TP_printk("cq.id=%u cid=%d sqecount=%d",
2080		__entry->cq_id, __entry->completion_id,
2081		__entry->sqecount
2082	)
2083);
2084
2085#define DEFINE_POST_CHUNK_EVENT(name)					\
2086		DEFINE_EVENT(svcrdma_post_chunk_class,			\
2087				svcrdma_post_##name##_chunk,		\
2088				TP_PROTO(				\
2089					const struct rpc_rdma_cid *cid,	\
2090					int sqecount			\
2091				),					\
2092				TP_ARGS(cid, sqecount))
2093
2094DEFINE_POST_CHUNK_EVENT(read);
2095DEFINE_POST_CHUNK_EVENT(write);
2096DEFINE_POST_CHUNK_EVENT(reply);
2097
2098DEFINE_EVENT(svcrdma_post_chunk_class, svcrdma_cc_release,
2099	TP_PROTO(
2100		const struct rpc_rdma_cid *cid,
2101		int sqecount
2102	),
2103	TP_ARGS(cid, sqecount)
2104);
2105
2106TRACE_EVENT(svcrdma_wc_read,
2107	TP_PROTO(
2108		const struct ib_wc *wc,
2109		const struct rpc_rdma_cid *cid,
2110		unsigned int totalbytes,
2111		const ktime_t posttime
2112	),
2113
2114	TP_ARGS(wc, cid, totalbytes, posttime),
2115
2116	TP_STRUCT__entry(
2117		__field(u32, cq_id)
2118		__field(int, completion_id)
2119		__field(s64, read_latency)
2120		__field(unsigned int, totalbytes)
2121	),
2122
2123	TP_fast_assign(
2124		__entry->cq_id = cid->ci_queue_id;
2125		__entry->completion_id = cid->ci_completion_id;
2126		__entry->totalbytes = totalbytes;
2127		__entry->read_latency = ktime_us_delta(ktime_get(), posttime);
2128	),
2129
2130	TP_printk("cq.id=%u cid=%d totalbytes=%u latency-us=%lld",
2131		__entry->cq_id, __entry->completion_id,
2132		__entry->totalbytes, __entry->read_latency
2133	)
2134);
2135
2136DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_read_flush);
2137DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_read_err);
2138DEFINE_SIMPLE_CID_EVENT(svcrdma_read_finished);
2139
2140DEFINE_SIMPLE_CID_EVENT(svcrdma_wc_write);
2141DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_write_flush);
2142DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_write_err);
2143
2144DEFINE_SIMPLE_CID_EVENT(svcrdma_wc_reply);
2145DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_reply_flush);
2146DEFINE_SEND_FLUSH_EVENT(svcrdma_wc_reply_err);
2147
2148TRACE_EVENT(svcrdma_qp_error,
2149	TP_PROTO(
2150		const struct ib_event *event,
2151		const struct sockaddr *sap
2152	),
2153
2154	TP_ARGS(event, sap),
2155
2156	TP_STRUCT__entry(
2157		__field(unsigned int, event)
2158		__string(device, event->device->name)
2159		__array(__u8, addr, INET6_ADDRSTRLEN + 10)
2160	),
2161
2162	TP_fast_assign(
2163		__entry->event = event->event;
2164		__assign_str(device);
2165		snprintf(__entry->addr, sizeof(__entry->addr) - 1,
2166			 "%pISpc", sap);
2167	),
2168
2169	TP_printk("addr=%s dev=%s event=%s (%u)",
2170		__entry->addr, __get_str(device),
2171		rdma_show_ib_event(__entry->event), __entry->event
2172	)
2173);
2174
2175TRACE_EVENT(svcrdma_device_removal,
2176	TP_PROTO(
2177		const struct rdma_cm_id *id
2178	),
2179
2180	TP_ARGS(id),
2181
2182	TP_STRUCT__entry(
2183		__string(name, id->device->name)
2184		__array(unsigned char, addr, sizeof(struct sockaddr_in6))
2185	),
2186
2187	TP_fast_assign(
2188		__assign_str(name);
2189		memcpy(__entry->addr, &id->route.addr.dst_addr,
2190		       sizeof(struct sockaddr_in6));
2191	),
2192
2193	TP_printk("device %s to be removed, disconnecting %pISpc\n",
2194		__get_str(name), __entry->addr
2195	)
2196);
2197
2198DECLARE_EVENT_CLASS(svcrdma_sendqueue_class,
2199	TP_PROTO(
2200		const struct svcxprt_rdma *rdma,
2201		const struct rpc_rdma_cid *cid
2202	),
2203
2204	TP_ARGS(rdma, cid),
2205
2206	TP_STRUCT__entry(
2207		__field(u32, cq_id)
2208		__field(int, completion_id)
2209		__field(int, avail)
2210		__field(int, depth)
 
2211	),
2212
2213	TP_fast_assign(
2214		__entry->cq_id = cid->ci_queue_id;
2215		__entry->completion_id = cid->ci_completion_id;
2216		__entry->avail = atomic_read(&rdma->sc_sq_avail);
2217		__entry->depth = rdma->sc_sq_depth;
 
2218	),
2219
2220	TP_printk("cq.id=%u cid=%d sc_sq_avail=%d/%d",
2221		__entry->cq_id, __entry->completion_id,
2222		__entry->avail, __entry->depth
2223	)
2224);
2225
2226#define DEFINE_SQ_EVENT(name)						\
2227		DEFINE_EVENT(svcrdma_sendqueue_class, name,		\
2228			TP_PROTO(					\
2229				const struct svcxprt_rdma *rdma,	\
2230				const struct rpc_rdma_cid *cid		\
2231			),						\
2232			TP_ARGS(rdma, cid)				\
2233		)
2234
2235DEFINE_SQ_EVENT(svcrdma_sq_full);
2236DEFINE_SQ_EVENT(svcrdma_sq_retry);
2237
2238TRACE_EVENT(svcrdma_sq_post_err,
2239	TP_PROTO(
2240		const struct svcxprt_rdma *rdma,
2241		const struct rpc_rdma_cid *cid,
2242		int status
2243	),
2244
2245	TP_ARGS(rdma, cid, status),
2246
2247	TP_STRUCT__entry(
2248		__field(u32, cq_id)
2249		__field(int, completion_id)
2250		__field(int, avail)
2251		__field(int, depth)
2252		__field(int, status)
 
2253	),
2254
2255	TP_fast_assign(
2256		__entry->cq_id = cid->ci_queue_id;
2257		__entry->completion_id = cid->ci_completion_id;
2258		__entry->avail = atomic_read(&rdma->sc_sq_avail);
2259		__entry->depth = rdma->sc_sq_depth;
2260		__entry->status = status;
 
2261	),
2262
2263	TP_printk("cq.id=%u cid=%d sc_sq_avail=%d/%d status=%d",
2264		__entry->cq_id, __entry->completion_id,
2265		__entry->avail, __entry->depth, __entry->status
2266	)
2267);
2268
2269DECLARE_EVENT_CLASS(rpcrdma_client_device_class,
2270	TP_PROTO(
2271		const struct ib_device *device
2272	),
2273
2274	TP_ARGS(device),
2275
2276	TP_STRUCT__entry(
2277		__string(name, device->name)
2278	),
2279
2280	TP_fast_assign(
2281		__assign_str(name);
2282	),
2283
2284	TP_printk("device=%s",
2285		__get_str(name)
2286	)
2287);
2288
2289#define DEFINE_CLIENT_DEVICE_EVENT(name)				\
2290	DEFINE_EVENT(rpcrdma_client_device_class, name,			\
2291		TP_PROTO(						\
2292			const struct ib_device *device			\
2293		),							\
2294		TP_ARGS(device)						\
2295	)
2296
2297DEFINE_CLIENT_DEVICE_EVENT(rpcrdma_client_completion);
2298DEFINE_CLIENT_DEVICE_EVENT(rpcrdma_client_add_one);
2299DEFINE_CLIENT_DEVICE_EVENT(rpcrdma_client_remove_one);
2300DEFINE_CLIENT_DEVICE_EVENT(rpcrdma_client_wait_on);
2301DEFINE_CLIENT_DEVICE_EVENT(rpcrdma_client_remove_one_done);
2302
2303DECLARE_EVENT_CLASS(rpcrdma_client_register_class,
2304	TP_PROTO(
2305		const struct ib_device *device,
2306		const struct rpcrdma_notification *rn
2307	),
2308
2309	TP_ARGS(device, rn),
2310
2311	TP_STRUCT__entry(
2312		__string(name, device->name)
2313		__field(void *, callback)
2314		__field(u32, index)
2315	),
2316
2317	TP_fast_assign(
2318		__assign_str(name);
2319		__entry->callback = rn->rn_done;
2320		__entry->index = rn->rn_index;
2321	),
2322
2323	TP_printk("device=%s index=%u done callback=%pS\n",
2324		__get_str(name), __entry->index, __entry->callback
2325	)
2326);
2327
2328#define DEFINE_CLIENT_REGISTER_EVENT(name)				\
2329	DEFINE_EVENT(rpcrdma_client_register_class, name,		\
2330	TP_PROTO(							\
2331		const struct ib_device *device,				\
2332		const struct rpcrdma_notification *rn			\
2333	),								\
2334	TP_ARGS(device, rn))
2335
2336DEFINE_CLIENT_REGISTER_EVENT(rpcrdma_client_register);
2337DEFINE_CLIENT_REGISTER_EVENT(rpcrdma_client_unregister);
2338
2339#endif /* _TRACE_RPCRDMA_H */
2340
2341#include <trace/define_trace.h>