1e48f083eSChuck Lever /* SPDX-License-Identifier: GPL-2.0 */ 2e48f083eSChuck Lever /* 398895edbSChuck Lever * Copyright (c) 2017, 2018 Oracle. All rights reserved. 498895edbSChuck Lever * 598895edbSChuck Lever * Trace point definitions for the "rpcrdma" subsystem. 6e48f083eSChuck Lever */ 7e48f083eSChuck Lever #undef TRACE_SYSTEM 8e48f083eSChuck Lever #define TRACE_SYSTEM rpcrdma 9e48f083eSChuck Lever 10e48f083eSChuck Lever #if !defined(_TRACE_RPCRDMA_H) || defined(TRACE_HEADER_MULTI_READ) 11e48f083eSChuck Lever #define _TRACE_RPCRDMA_H 12e48f083eSChuck Lever 1353b2c1cbSChuck Lever #include <linux/scatterlist.h> 14e48f083eSChuck Lever #include <linux/tracepoint.h> 15e48f083eSChuck Lever #include <trace/events/rdma.h> 16e48f083eSChuck Lever 17ab03eff5SChuck Lever /** 18b4a7f91cSChuck Lever ** Event classes 19b4a7f91cSChuck Lever **/ 20b4a7f91cSChuck Lever 21b4a7f91cSChuck Lever DECLARE_EVENT_CLASS(xprtrdma_reply_event, 22b4a7f91cSChuck Lever TP_PROTO( 23b4a7f91cSChuck Lever const struct rpcrdma_rep *rep 24b4a7f91cSChuck Lever ), 25b4a7f91cSChuck Lever 26b4a7f91cSChuck Lever TP_ARGS(rep), 27b4a7f91cSChuck Lever 28b4a7f91cSChuck Lever TP_STRUCT__entry( 29b4a7f91cSChuck Lever __field(const void *, rep) 30b4a7f91cSChuck Lever __field(const void *, r_xprt) 31b4a7f91cSChuck Lever __field(u32, xid) 32b4a7f91cSChuck Lever __field(u32, version) 33b4a7f91cSChuck Lever __field(u32, proc) 34b4a7f91cSChuck Lever ), 35b4a7f91cSChuck Lever 36b4a7f91cSChuck Lever TP_fast_assign( 37b4a7f91cSChuck Lever __entry->rep = rep; 38b4a7f91cSChuck Lever __entry->r_xprt = rep->rr_rxprt; 39b4a7f91cSChuck Lever __entry->xid = be32_to_cpu(rep->rr_xid); 40b4a7f91cSChuck Lever __entry->version = be32_to_cpu(rep->rr_vers); 41b4a7f91cSChuck Lever __entry->proc = be32_to_cpu(rep->rr_proc); 42b4a7f91cSChuck Lever ), 43b4a7f91cSChuck Lever 44b4a7f91cSChuck Lever TP_printk("rxprt %p xid=0x%08x rep=%p: version %u proc %u", 45b4a7f91cSChuck Lever __entry->r_xprt, __entry->xid, __entry->rep, 46b4a7f91cSChuck Lever __entry->version, __entry->proc 47b4a7f91cSChuck Lever ) 48b4a7f91cSChuck Lever ); 49b4a7f91cSChuck Lever 50b4a7f91cSChuck Lever #define DEFINE_REPLY_EVENT(name) \ 51b4a7f91cSChuck Lever DEFINE_EVENT(xprtrdma_reply_event, name, \ 52b4a7f91cSChuck Lever TP_PROTO( \ 53b4a7f91cSChuck Lever const struct rpcrdma_rep *rep \ 54b4a7f91cSChuck Lever ), \ 55b4a7f91cSChuck Lever TP_ARGS(rep)) 56b4a7f91cSChuck Lever 571c443effSChuck Lever DECLARE_EVENT_CLASS(xprtrdma_rxprt, 581c443effSChuck Lever TP_PROTO( 591c443effSChuck Lever const struct rpcrdma_xprt *r_xprt 601c443effSChuck Lever ), 611c443effSChuck Lever 621c443effSChuck Lever TP_ARGS(r_xprt), 631c443effSChuck Lever 641c443effSChuck Lever TP_STRUCT__entry( 651c443effSChuck Lever __field(const void *, r_xprt) 661c443effSChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 671c443effSChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 681c443effSChuck Lever ), 691c443effSChuck Lever 701c443effSChuck Lever TP_fast_assign( 711c443effSChuck Lever __entry->r_xprt = r_xprt; 721c443effSChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 731c443effSChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 741c443effSChuck Lever ), 751c443effSChuck Lever 761c443effSChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p", 771c443effSChuck Lever __get_str(addr), __get_str(port), __entry->r_xprt 781c443effSChuck Lever ) 791c443effSChuck Lever ); 801c443effSChuck Lever 811c443effSChuck Lever #define DEFINE_RXPRT_EVENT(name) \ 821c443effSChuck Lever DEFINE_EVENT(xprtrdma_rxprt, name, \ 831c443effSChuck Lever TP_PROTO( \ 841c443effSChuck Lever const struct rpcrdma_xprt *r_xprt \ 851c443effSChuck Lever ), \ 861c443effSChuck Lever TP_ARGS(r_xprt)) 871c443effSChuck Lever 8858f10ad4SChuck Lever DECLARE_EVENT_CLASS(xprtrdma_rdch_event, 8958f10ad4SChuck Lever TP_PROTO( 9058f10ad4SChuck Lever const struct rpc_task *task, 9158f10ad4SChuck Lever unsigned int pos, 9258f10ad4SChuck Lever struct rpcrdma_mr *mr, 9358f10ad4SChuck Lever int nsegs 9458f10ad4SChuck Lever ), 9558f10ad4SChuck Lever 9658f10ad4SChuck Lever TP_ARGS(task, pos, mr, nsegs), 9758f10ad4SChuck Lever 9858f10ad4SChuck Lever TP_STRUCT__entry( 9958f10ad4SChuck Lever __field(unsigned int, task_id) 10058f10ad4SChuck Lever __field(unsigned int, client_id) 10158f10ad4SChuck Lever __field(unsigned int, pos) 10258f10ad4SChuck Lever __field(int, nents) 10358f10ad4SChuck Lever __field(u32, handle) 10458f10ad4SChuck Lever __field(u32, length) 10558f10ad4SChuck Lever __field(u64, offset) 10658f10ad4SChuck Lever __field(int, nsegs) 10758f10ad4SChuck Lever ), 10858f10ad4SChuck Lever 10958f10ad4SChuck Lever TP_fast_assign( 11058f10ad4SChuck Lever __entry->task_id = task->tk_pid; 11158f10ad4SChuck Lever __entry->client_id = task->tk_client->cl_clid; 11258f10ad4SChuck Lever __entry->pos = pos; 11358f10ad4SChuck Lever __entry->nents = mr->mr_nents; 11458f10ad4SChuck Lever __entry->handle = mr->mr_handle; 11558f10ad4SChuck Lever __entry->length = mr->mr_length; 11658f10ad4SChuck Lever __entry->offset = mr->mr_offset; 11758f10ad4SChuck Lever __entry->nsegs = nsegs; 11858f10ad4SChuck Lever ), 11958f10ad4SChuck Lever 120aba11831SChuck Lever TP_printk("task:%u@%u pos=%u %u@0x%016llx:0x%08x (%s)", 121aba11831SChuck Lever __entry->task_id, __entry->client_id, 12258f10ad4SChuck Lever __entry->pos, __entry->length, 12358f10ad4SChuck Lever (unsigned long long)__entry->offset, __entry->handle, 12458f10ad4SChuck Lever __entry->nents < __entry->nsegs ? "more" : "last" 12558f10ad4SChuck Lever ) 12658f10ad4SChuck Lever ); 12758f10ad4SChuck Lever 12858f10ad4SChuck Lever #define DEFINE_RDCH_EVENT(name) \ 129aba11831SChuck Lever DEFINE_EVENT(xprtrdma_rdch_event, xprtrdma_chunk_##name,\ 13058f10ad4SChuck Lever TP_PROTO( \ 13158f10ad4SChuck Lever const struct rpc_task *task, \ 13258f10ad4SChuck Lever unsigned int pos, \ 13358f10ad4SChuck Lever struct rpcrdma_mr *mr, \ 13458f10ad4SChuck Lever int nsegs \ 13558f10ad4SChuck Lever ), \ 13658f10ad4SChuck Lever TP_ARGS(task, pos, mr, nsegs)) 13758f10ad4SChuck Lever 13858f10ad4SChuck Lever DECLARE_EVENT_CLASS(xprtrdma_wrch_event, 13958f10ad4SChuck Lever TP_PROTO( 14058f10ad4SChuck Lever const struct rpc_task *task, 14158f10ad4SChuck Lever struct rpcrdma_mr *mr, 14258f10ad4SChuck Lever int nsegs 14358f10ad4SChuck Lever ), 14458f10ad4SChuck Lever 14558f10ad4SChuck Lever TP_ARGS(task, mr, nsegs), 14658f10ad4SChuck Lever 14758f10ad4SChuck Lever TP_STRUCT__entry( 14858f10ad4SChuck Lever __field(unsigned int, task_id) 14958f10ad4SChuck Lever __field(unsigned int, client_id) 15058f10ad4SChuck Lever __field(int, nents) 15158f10ad4SChuck Lever __field(u32, handle) 15258f10ad4SChuck Lever __field(u32, length) 15358f10ad4SChuck Lever __field(u64, offset) 15458f10ad4SChuck Lever __field(int, nsegs) 15558f10ad4SChuck Lever ), 15658f10ad4SChuck Lever 15758f10ad4SChuck Lever TP_fast_assign( 15858f10ad4SChuck Lever __entry->task_id = task->tk_pid; 15958f10ad4SChuck Lever __entry->client_id = task->tk_client->cl_clid; 16058f10ad4SChuck Lever __entry->nents = mr->mr_nents; 16158f10ad4SChuck Lever __entry->handle = mr->mr_handle; 16258f10ad4SChuck Lever __entry->length = mr->mr_length; 16358f10ad4SChuck Lever __entry->offset = mr->mr_offset; 16458f10ad4SChuck Lever __entry->nsegs = nsegs; 16558f10ad4SChuck Lever ), 16658f10ad4SChuck Lever 167aba11831SChuck Lever TP_printk("task:%u@%u %u@0x%016llx:0x%08x (%s)", 168aba11831SChuck Lever __entry->task_id, __entry->client_id, 16958f10ad4SChuck Lever __entry->length, (unsigned long long)__entry->offset, 17058f10ad4SChuck Lever __entry->handle, 17158f10ad4SChuck Lever __entry->nents < __entry->nsegs ? "more" : "last" 17258f10ad4SChuck Lever ) 17358f10ad4SChuck Lever ); 17458f10ad4SChuck Lever 17558f10ad4SChuck Lever #define DEFINE_WRCH_EVENT(name) \ 176aba11831SChuck Lever DEFINE_EVENT(xprtrdma_wrch_event, xprtrdma_chunk_##name,\ 17758f10ad4SChuck Lever TP_PROTO( \ 17858f10ad4SChuck Lever const struct rpc_task *task, \ 17958f10ad4SChuck Lever struct rpcrdma_mr *mr, \ 18058f10ad4SChuck Lever int nsegs \ 18158f10ad4SChuck Lever ), \ 18258f10ad4SChuck Lever TP_ARGS(task, mr, nsegs)) 18358f10ad4SChuck Lever 18458f10ad4SChuck Lever TRACE_DEFINE_ENUM(FRWR_IS_INVALID); 18558f10ad4SChuck Lever TRACE_DEFINE_ENUM(FRWR_IS_VALID); 18658f10ad4SChuck Lever TRACE_DEFINE_ENUM(FRWR_FLUSHED_FR); 18758f10ad4SChuck Lever TRACE_DEFINE_ENUM(FRWR_FLUSHED_LI); 18858f10ad4SChuck Lever 18958f10ad4SChuck Lever #define xprtrdma_show_frwr_state(x) \ 19058f10ad4SChuck Lever __print_symbolic(x, \ 19158f10ad4SChuck Lever { FRWR_IS_INVALID, "INVALID" }, \ 19258f10ad4SChuck Lever { FRWR_IS_VALID, "VALID" }, \ 19358f10ad4SChuck Lever { FRWR_FLUSHED_FR, "FLUSHED_FR" }, \ 19458f10ad4SChuck Lever { FRWR_FLUSHED_LI, "FLUSHED_LI" }) 19558f10ad4SChuck Lever 19658f10ad4SChuck Lever DECLARE_EVENT_CLASS(xprtrdma_frwr_done, 19758f10ad4SChuck Lever TP_PROTO( 19858f10ad4SChuck Lever const struct ib_wc *wc, 19958f10ad4SChuck Lever const struct rpcrdma_frwr *frwr 20058f10ad4SChuck Lever ), 20158f10ad4SChuck Lever 20258f10ad4SChuck Lever TP_ARGS(wc, frwr), 20358f10ad4SChuck Lever 20458f10ad4SChuck Lever TP_STRUCT__entry( 20558f10ad4SChuck Lever __field(const void *, mr) 20658f10ad4SChuck Lever __field(unsigned int, state) 20758f10ad4SChuck Lever __field(unsigned int, status) 20858f10ad4SChuck Lever __field(unsigned int, vendor_err) 20958f10ad4SChuck Lever ), 21058f10ad4SChuck Lever 21158f10ad4SChuck Lever TP_fast_assign( 21258f10ad4SChuck Lever __entry->mr = container_of(frwr, struct rpcrdma_mr, frwr); 21358f10ad4SChuck Lever __entry->state = frwr->fr_state; 21458f10ad4SChuck Lever __entry->status = wc->status; 21558f10ad4SChuck Lever __entry->vendor_err = __entry->status ? wc->vendor_err : 0; 21658f10ad4SChuck Lever ), 21758f10ad4SChuck Lever 21858f10ad4SChuck Lever TP_printk( 21958f10ad4SChuck Lever "mr=%p state=%s: %s (%u/0x%x)", 22058f10ad4SChuck Lever __entry->mr, xprtrdma_show_frwr_state(__entry->state), 22158f10ad4SChuck Lever rdma_show_wc_status(__entry->status), 22258f10ad4SChuck Lever __entry->status, __entry->vendor_err 22358f10ad4SChuck Lever ) 22458f10ad4SChuck Lever ); 22558f10ad4SChuck Lever 22658f10ad4SChuck Lever #define DEFINE_FRWR_DONE_EVENT(name) \ 22758f10ad4SChuck Lever DEFINE_EVENT(xprtrdma_frwr_done, name, \ 22858f10ad4SChuck Lever TP_PROTO( \ 22958f10ad4SChuck Lever const struct ib_wc *wc, \ 23058f10ad4SChuck Lever const struct rpcrdma_frwr *frwr \ 23158f10ad4SChuck Lever ), \ 23258f10ad4SChuck Lever TP_ARGS(wc, frwr)) 23358f10ad4SChuck Lever 234aba11831SChuck Lever TRACE_DEFINE_ENUM(DMA_BIDIRECTIONAL); 235aba11831SChuck Lever TRACE_DEFINE_ENUM(DMA_TO_DEVICE); 236aba11831SChuck Lever TRACE_DEFINE_ENUM(DMA_FROM_DEVICE); 237aba11831SChuck Lever TRACE_DEFINE_ENUM(DMA_NONE); 238aba11831SChuck Lever 239aba11831SChuck Lever #define xprtrdma_show_direction(x) \ 240aba11831SChuck Lever __print_symbolic(x, \ 241aba11831SChuck Lever { DMA_BIDIRECTIONAL, "BIDIR" }, \ 242aba11831SChuck Lever { DMA_TO_DEVICE, "TO_DEVICE" }, \ 243aba11831SChuck Lever { DMA_FROM_DEVICE, "FROM_DEVICE" }, \ 244aba11831SChuck Lever { DMA_NONE, "NONE" }) 245aba11831SChuck Lever 2462937fedeSChuck Lever DECLARE_EVENT_CLASS(xprtrdma_mr, 2472937fedeSChuck Lever TP_PROTO( 2482937fedeSChuck Lever const struct rpcrdma_mr *mr 2492937fedeSChuck Lever ), 2502937fedeSChuck Lever 2512937fedeSChuck Lever TP_ARGS(mr), 2522937fedeSChuck Lever 2532937fedeSChuck Lever TP_STRUCT__entry( 2542937fedeSChuck Lever __field(const void *, mr) 2552937fedeSChuck Lever __field(u32, handle) 2562937fedeSChuck Lever __field(u32, length) 2572937fedeSChuck Lever __field(u64, offset) 258aba11831SChuck Lever __field(u32, dir) 2592937fedeSChuck Lever ), 2602937fedeSChuck Lever 2612937fedeSChuck Lever TP_fast_assign( 2622937fedeSChuck Lever __entry->mr = mr; 2632937fedeSChuck Lever __entry->handle = mr->mr_handle; 2642937fedeSChuck Lever __entry->length = mr->mr_length; 2652937fedeSChuck Lever __entry->offset = mr->mr_offset; 266aba11831SChuck Lever __entry->dir = mr->mr_dir; 2672937fedeSChuck Lever ), 2682937fedeSChuck Lever 269aba11831SChuck Lever TP_printk("mr=%p %u@0x%016llx:0x%08x (%s)", 2702937fedeSChuck Lever __entry->mr, __entry->length, 271aba11831SChuck Lever (unsigned long long)__entry->offset, __entry->handle, 272aba11831SChuck Lever xprtrdma_show_direction(__entry->dir) 2732937fedeSChuck Lever ) 2742937fedeSChuck Lever ); 2752937fedeSChuck Lever 2762937fedeSChuck Lever #define DEFINE_MR_EVENT(name) \ 277d379eaa8SChuck Lever DEFINE_EVENT(xprtrdma_mr, xprtrdma_mr_##name, \ 2782937fedeSChuck Lever TP_PROTO( \ 2792937fedeSChuck Lever const struct rpcrdma_mr *mr \ 2802937fedeSChuck Lever ), \ 2812937fedeSChuck Lever TP_ARGS(mr)) 2822937fedeSChuck Lever 283fc1eb807SChuck Lever DECLARE_EVENT_CLASS(xprtrdma_cb_event, 284fc1eb807SChuck Lever TP_PROTO( 285fc1eb807SChuck Lever const struct rpc_rqst *rqst 286fc1eb807SChuck Lever ), 287fc1eb807SChuck Lever 288fc1eb807SChuck Lever TP_ARGS(rqst), 289fc1eb807SChuck Lever 290fc1eb807SChuck Lever TP_STRUCT__entry( 291fc1eb807SChuck Lever __field(const void *, rqst) 292fc1eb807SChuck Lever __field(const void *, rep) 293fc1eb807SChuck Lever __field(const void *, req) 294fc1eb807SChuck Lever __field(u32, xid) 295fc1eb807SChuck Lever ), 296fc1eb807SChuck Lever 297fc1eb807SChuck Lever TP_fast_assign( 298fc1eb807SChuck Lever __entry->rqst = rqst; 299fc1eb807SChuck Lever __entry->req = rpcr_to_rdmar(rqst); 300fc1eb807SChuck Lever __entry->rep = rpcr_to_rdmar(rqst)->rl_reply; 301fc1eb807SChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 302fc1eb807SChuck Lever ), 303fc1eb807SChuck Lever 304fc1eb807SChuck Lever TP_printk("xid=0x%08x, rqst=%p req=%p rep=%p", 305fc1eb807SChuck Lever __entry->xid, __entry->rqst, __entry->req, __entry->rep 306fc1eb807SChuck Lever ) 307fc1eb807SChuck Lever ); 308fc1eb807SChuck Lever 309fc1eb807SChuck Lever #define DEFINE_CB_EVENT(name) \ 310fc1eb807SChuck Lever DEFINE_EVENT(xprtrdma_cb_event, name, \ 311fc1eb807SChuck Lever TP_PROTO( \ 312fc1eb807SChuck Lever const struct rpc_rqst *rqst \ 313fc1eb807SChuck Lever ), \ 314fc1eb807SChuck Lever TP_ARGS(rqst)) 315fc1eb807SChuck Lever 316b4a7f91cSChuck Lever /** 317b4744e00SChuck Lever ** Connection events 318b4744e00SChuck Lever **/ 319b4744e00SChuck Lever 320ae38288eSChuck Lever TRACE_EVENT(xprtrdma_cm_event, 321b4744e00SChuck Lever TP_PROTO( 322b4744e00SChuck Lever const struct rpcrdma_xprt *r_xprt, 323b4744e00SChuck Lever struct rdma_cm_event *event 324b4744e00SChuck Lever ), 325b4744e00SChuck Lever 326b4744e00SChuck Lever TP_ARGS(r_xprt, event), 327b4744e00SChuck Lever 328b4744e00SChuck Lever TP_STRUCT__entry( 329b4744e00SChuck Lever __field(const void *, r_xprt) 330b4744e00SChuck Lever __field(unsigned int, event) 331b4744e00SChuck Lever __field(int, status) 332b4744e00SChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 333b4744e00SChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 334b4744e00SChuck Lever ), 335b4744e00SChuck Lever 336b4744e00SChuck Lever TP_fast_assign( 337b4744e00SChuck Lever __entry->r_xprt = r_xprt; 338b4744e00SChuck Lever __entry->event = event->event; 339b4744e00SChuck Lever __entry->status = event->status; 340b4744e00SChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 341b4744e00SChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 342b4744e00SChuck Lever ), 343b4744e00SChuck Lever 344b4744e00SChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: %s (%u/%d)", 345b4744e00SChuck Lever __get_str(addr), __get_str(port), 346b4744e00SChuck Lever __entry->r_xprt, rdma_show_cm_event(__entry->event), 347b4744e00SChuck Lever __entry->event, __entry->status 348b4744e00SChuck Lever ) 349b4744e00SChuck Lever ); 350b4744e00SChuck Lever 351b4744e00SChuck Lever TRACE_EVENT(xprtrdma_disconnect, 352b4744e00SChuck Lever TP_PROTO( 353b4744e00SChuck Lever const struct rpcrdma_xprt *r_xprt, 354b4744e00SChuck Lever int status 355b4744e00SChuck Lever ), 356b4744e00SChuck Lever 357b4744e00SChuck Lever TP_ARGS(r_xprt, status), 358b4744e00SChuck Lever 359b4744e00SChuck Lever TP_STRUCT__entry( 360b4744e00SChuck Lever __field(const void *, r_xprt) 361b4744e00SChuck Lever __field(int, status) 362b4744e00SChuck Lever __field(int, connected) 363b4744e00SChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 364b4744e00SChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 365b4744e00SChuck Lever ), 366b4744e00SChuck Lever 367b4744e00SChuck Lever TP_fast_assign( 368b4744e00SChuck Lever __entry->r_xprt = r_xprt; 369b4744e00SChuck Lever __entry->status = status; 370b4744e00SChuck Lever __entry->connected = r_xprt->rx_ep.rep_connected; 371b4744e00SChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 372b4744e00SChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 373b4744e00SChuck Lever ), 374b4744e00SChuck Lever 375b4744e00SChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: status=%d %sconnected", 376b4744e00SChuck Lever __get_str(addr), __get_str(port), 377b4744e00SChuck Lever __entry->r_xprt, __entry->status, 378b4744e00SChuck Lever __entry->connected == 1 ? "still " : "dis" 379b4744e00SChuck Lever ) 380b4744e00SChuck Lever ); 381b4744e00SChuck Lever 382b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_conn_start); 383b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_conn_tout); 384b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_create); 385395069fcSChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_op_destroy); 386b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_remove); 387b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_reinsert); 388b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_reconnect); 389395069fcSChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_op_inject_dsc); 390395069fcSChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_op_close); 391395069fcSChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_op_connect); 392b4744e00SChuck Lever 393f9521d53SChuck Lever TRACE_EVENT(xprtrdma_qp_event, 394643cf323SChuck Lever TP_PROTO( 395643cf323SChuck Lever const struct rpcrdma_xprt *r_xprt, 396643cf323SChuck Lever const struct ib_event *event 397643cf323SChuck Lever ), 398643cf323SChuck Lever 399643cf323SChuck Lever TP_ARGS(r_xprt, event), 400643cf323SChuck Lever 401643cf323SChuck Lever TP_STRUCT__entry( 402643cf323SChuck Lever __field(const void *, r_xprt) 403643cf323SChuck Lever __field(unsigned int, event) 404643cf323SChuck Lever __string(name, event->device->name) 405643cf323SChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 406643cf323SChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 407643cf323SChuck Lever ), 408643cf323SChuck Lever 409643cf323SChuck Lever TP_fast_assign( 410643cf323SChuck Lever __entry->r_xprt = r_xprt; 411643cf323SChuck Lever __entry->event = event->event; 412643cf323SChuck Lever __assign_str(name, event->device->name); 413643cf323SChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 414643cf323SChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 415643cf323SChuck Lever ), 416643cf323SChuck Lever 417643cf323SChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: dev %s: %s (%u)", 418643cf323SChuck Lever __get_str(addr), __get_str(port), __entry->r_xprt, 419643cf323SChuck Lever __get_str(name), rdma_show_ib_event(__entry->event), 420643cf323SChuck Lever __entry->event 421643cf323SChuck Lever ) 422643cf323SChuck Lever ); 423643cf323SChuck Lever 424b4744e00SChuck Lever /** 425ab03eff5SChuck Lever ** Call events 426ab03eff5SChuck Lever **/ 427ab03eff5SChuck Lever 4281c443effSChuck Lever TRACE_EVENT(xprtrdma_createmrs, 4291c443effSChuck Lever TP_PROTO( 4301c443effSChuck Lever const struct rpcrdma_xprt *r_xprt, 4311c443effSChuck Lever unsigned int count 4321c443effSChuck Lever ), 4331c443effSChuck Lever 4341c443effSChuck Lever TP_ARGS(r_xprt, count), 4351c443effSChuck Lever 4361c443effSChuck Lever TP_STRUCT__entry( 4371c443effSChuck Lever __field(const void *, r_xprt) 4381c443effSChuck Lever __field(unsigned int, count) 4391c443effSChuck Lever ), 4401c443effSChuck Lever 4411c443effSChuck Lever TP_fast_assign( 4421c443effSChuck Lever __entry->r_xprt = r_xprt; 4431c443effSChuck Lever __entry->count = count; 4441c443effSChuck Lever ), 4451c443effSChuck Lever 4461c443effSChuck Lever TP_printk("r_xprt=%p: created %u MRs", 4471c443effSChuck Lever __entry->r_xprt, __entry->count 4481c443effSChuck Lever ) 4491c443effSChuck Lever ); 4501c443effSChuck Lever 4511c443effSChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_nomrs); 4521c443effSChuck Lever 453aba11831SChuck Lever DEFINE_RDCH_EVENT(read); 454aba11831SChuck Lever DEFINE_WRCH_EVENT(write); 455aba11831SChuck Lever DEFINE_WRCH_EVENT(reply); 45658f10ad4SChuck Lever 457ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_noch); 458ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_readch); 459ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_areadch); 460ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_writech); 461ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_replych); 462ab03eff5SChuck Lever 463ab03eff5SChuck Lever #define xprtrdma_show_chunktype(x) \ 464ab03eff5SChuck Lever __print_symbolic(x, \ 465ab03eff5SChuck Lever { rpcrdma_noch, "inline" }, \ 466ab03eff5SChuck Lever { rpcrdma_readch, "read list" }, \ 467ab03eff5SChuck Lever { rpcrdma_areadch, "*read list" }, \ 468ab03eff5SChuck Lever { rpcrdma_writech, "write list" }, \ 469ab03eff5SChuck Lever { rpcrdma_replych, "reply chunk" }) 470ab03eff5SChuck Lever 471ab03eff5SChuck Lever TRACE_EVENT(xprtrdma_marshal, 472ab03eff5SChuck Lever TP_PROTO( 4731310051cSChuck Lever const struct rpcrdma_req *req, 474ab03eff5SChuck Lever unsigned int rtype, 475ab03eff5SChuck Lever unsigned int wtype 476ab03eff5SChuck Lever ), 477ab03eff5SChuck Lever 4781310051cSChuck Lever TP_ARGS(req, rtype, wtype), 479ab03eff5SChuck Lever 480ab03eff5SChuck Lever TP_STRUCT__entry( 481ab03eff5SChuck Lever __field(unsigned int, task_id) 482ab03eff5SChuck Lever __field(unsigned int, client_id) 483ab03eff5SChuck Lever __field(u32, xid) 484ab03eff5SChuck Lever __field(unsigned int, hdrlen) 485ab03eff5SChuck Lever __field(unsigned int, headlen) 486ab03eff5SChuck Lever __field(unsigned int, pagelen) 487ab03eff5SChuck Lever __field(unsigned int, taillen) 488ab03eff5SChuck Lever __field(unsigned int, rtype) 489ab03eff5SChuck Lever __field(unsigned int, wtype) 490ab03eff5SChuck Lever ), 491ab03eff5SChuck Lever 492ab03eff5SChuck Lever TP_fast_assign( 4931310051cSChuck Lever const struct rpc_rqst *rqst = &req->rl_slot; 4941310051cSChuck Lever 495ab03eff5SChuck Lever __entry->task_id = rqst->rq_task->tk_pid; 496ab03eff5SChuck Lever __entry->client_id = rqst->rq_task->tk_client->cl_clid; 497ab03eff5SChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 4981310051cSChuck Lever __entry->hdrlen = req->rl_hdrbuf.len; 499ab03eff5SChuck Lever __entry->headlen = rqst->rq_snd_buf.head[0].iov_len; 500ab03eff5SChuck Lever __entry->pagelen = rqst->rq_snd_buf.page_len; 501ab03eff5SChuck Lever __entry->taillen = rqst->rq_snd_buf.tail[0].iov_len; 502ab03eff5SChuck Lever __entry->rtype = rtype; 503ab03eff5SChuck Lever __entry->wtype = wtype; 504ab03eff5SChuck Lever ), 505ab03eff5SChuck Lever 506ab03eff5SChuck Lever TP_printk("task:%u@%u xid=0x%08x: hdr=%u xdr=%u/%u/%u %s/%s", 507ab03eff5SChuck Lever __entry->task_id, __entry->client_id, __entry->xid, 508ab03eff5SChuck Lever __entry->hdrlen, 509ab03eff5SChuck Lever __entry->headlen, __entry->pagelen, __entry->taillen, 510ab03eff5SChuck Lever xprtrdma_show_chunktype(__entry->rtype), 511ab03eff5SChuck Lever xprtrdma_show_chunktype(__entry->wtype) 512ab03eff5SChuck Lever ) 513ab03eff5SChuck Lever ); 514ab03eff5SChuck Lever 51517e4c443SChuck Lever TRACE_EVENT(xprtrdma_marshal_failed, 51617e4c443SChuck Lever TP_PROTO(const struct rpc_rqst *rqst, 51717e4c443SChuck Lever int ret 51817e4c443SChuck Lever ), 51917e4c443SChuck Lever 52017e4c443SChuck Lever TP_ARGS(rqst, ret), 52117e4c443SChuck Lever 52217e4c443SChuck Lever TP_STRUCT__entry( 52317e4c443SChuck Lever __field(unsigned int, task_id) 52417e4c443SChuck Lever __field(unsigned int, client_id) 52517e4c443SChuck Lever __field(u32, xid) 52617e4c443SChuck Lever __field(int, ret) 52717e4c443SChuck Lever ), 52817e4c443SChuck Lever 52917e4c443SChuck Lever TP_fast_assign( 53017e4c443SChuck Lever __entry->task_id = rqst->rq_task->tk_pid; 53117e4c443SChuck Lever __entry->client_id = rqst->rq_task->tk_client->cl_clid; 53217e4c443SChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 53317e4c443SChuck Lever __entry->ret = ret; 53417e4c443SChuck Lever ), 53517e4c443SChuck Lever 53617e4c443SChuck Lever TP_printk("task:%u@%u xid=0x%08x: ret=%d", 53717e4c443SChuck Lever __entry->task_id, __entry->client_id, __entry->xid, 53817e4c443SChuck Lever __entry->ret 53917e4c443SChuck Lever ) 54017e4c443SChuck Lever ); 54117e4c443SChuck Lever 542ab03eff5SChuck Lever TRACE_EVENT(xprtrdma_post_send, 543ab03eff5SChuck Lever TP_PROTO( 544ab03eff5SChuck Lever const struct rpcrdma_req *req, 545ab03eff5SChuck Lever int status 546ab03eff5SChuck Lever ), 547ab03eff5SChuck Lever 548ab03eff5SChuck Lever TP_ARGS(req, status), 549ab03eff5SChuck Lever 550ab03eff5SChuck Lever TP_STRUCT__entry( 551ab03eff5SChuck Lever __field(const void *, req) 5520c77668dSChuck Lever __field(unsigned int, task_id) 5530c77668dSChuck Lever __field(unsigned int, client_id) 554ab03eff5SChuck Lever __field(int, num_sge) 555470443e0SChuck Lever __field(int, signaled) 556ab03eff5SChuck Lever __field(int, status) 557ab03eff5SChuck Lever ), 558ab03eff5SChuck Lever 559ab03eff5SChuck Lever TP_fast_assign( 5600c77668dSChuck Lever const struct rpc_rqst *rqst = &req->rl_slot; 5610c77668dSChuck Lever 5620c77668dSChuck Lever __entry->task_id = rqst->rq_task->tk_pid; 56310694ac9SChuck Lever __entry->client_id = rqst->rq_task->tk_client ? 56410694ac9SChuck Lever rqst->rq_task->tk_client->cl_clid : -1; 565ab03eff5SChuck Lever __entry->req = req; 566ab03eff5SChuck Lever __entry->num_sge = req->rl_sendctx->sc_wr.num_sge; 567ab03eff5SChuck Lever __entry->signaled = req->rl_sendctx->sc_wr.send_flags & 568ab03eff5SChuck Lever IB_SEND_SIGNALED; 569ab03eff5SChuck Lever __entry->status = status; 570ab03eff5SChuck Lever ), 571ab03eff5SChuck Lever 5720c77668dSChuck Lever TP_printk("task:%u@%u req=%p (%d SGE%s) %sstatus=%d", 5730c77668dSChuck Lever __entry->task_id, __entry->client_id, 574ab03eff5SChuck Lever __entry->req, __entry->num_sge, 5750c77668dSChuck Lever (__entry->num_sge == 1 ? "" : "s"), 5760c77668dSChuck Lever (__entry->signaled ? "signaled " : ""), 577ab03eff5SChuck Lever __entry->status 578ab03eff5SChuck Lever ) 579ab03eff5SChuck Lever ); 580ab03eff5SChuck Lever 581b4a7f91cSChuck Lever TRACE_EVENT(xprtrdma_post_recv, 582b4a7f91cSChuck Lever TP_PROTO( 5830e0b854cSChuck Lever const struct ib_cqe *cqe 584b4a7f91cSChuck Lever ), 585b4a7f91cSChuck Lever 5860e0b854cSChuck Lever TP_ARGS(cqe), 587b4a7f91cSChuck Lever 588b4a7f91cSChuck Lever TP_STRUCT__entry( 5890e0b854cSChuck Lever __field(const void *, cqe) 590b4a7f91cSChuck Lever ), 591b4a7f91cSChuck Lever 592b4a7f91cSChuck Lever TP_fast_assign( 5930e0b854cSChuck Lever __entry->cqe = cqe; 594b4a7f91cSChuck Lever ), 595b4a7f91cSChuck Lever 5960e0b854cSChuck Lever TP_printk("cqe=%p", 5970e0b854cSChuck Lever __entry->cqe 598b4a7f91cSChuck Lever ) 599b4a7f91cSChuck Lever ); 600b4a7f91cSChuck Lever 6017c8d9e7cSChuck Lever TRACE_EVENT(xprtrdma_post_recvs, 6027c8d9e7cSChuck Lever TP_PROTO( 6037c8d9e7cSChuck Lever const struct rpcrdma_xprt *r_xprt, 6047c8d9e7cSChuck Lever unsigned int count, 6057c8d9e7cSChuck Lever int status 6067c8d9e7cSChuck Lever ), 6077c8d9e7cSChuck Lever 6087c8d9e7cSChuck Lever TP_ARGS(r_xprt, count, status), 6097c8d9e7cSChuck Lever 6107c8d9e7cSChuck Lever TP_STRUCT__entry( 6117c8d9e7cSChuck Lever __field(const void *, r_xprt) 6127c8d9e7cSChuck Lever __field(unsigned int, count) 6137c8d9e7cSChuck Lever __field(int, status) 6147c8d9e7cSChuck Lever __field(int, posted) 6157c8d9e7cSChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 6167c8d9e7cSChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 6177c8d9e7cSChuck Lever ), 6187c8d9e7cSChuck Lever 6197c8d9e7cSChuck Lever TP_fast_assign( 6207c8d9e7cSChuck Lever __entry->r_xprt = r_xprt; 6217c8d9e7cSChuck Lever __entry->count = count; 6227c8d9e7cSChuck Lever __entry->status = status; 6236ceea368SChuck Lever __entry->posted = r_xprt->rx_ep.rep_receive_count; 6247c8d9e7cSChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 6257c8d9e7cSChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 6267c8d9e7cSChuck Lever ), 6277c8d9e7cSChuck Lever 6287c8d9e7cSChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: %u new recvs, %d active (rc %d)", 6297c8d9e7cSChuck Lever __get_str(addr), __get_str(port), __entry->r_xprt, 6307c8d9e7cSChuck Lever __entry->count, __entry->posted, __entry->status 631ab03eff5SChuck Lever ) 632ab03eff5SChuck Lever ); 633ab03eff5SChuck Lever 634ab03eff5SChuck Lever /** 635ab03eff5SChuck Lever ** Completion events 636ab03eff5SChuck Lever **/ 637ab03eff5SChuck Lever 638ab03eff5SChuck Lever TRACE_EVENT(xprtrdma_wc_send, 639ab03eff5SChuck Lever TP_PROTO( 640ab03eff5SChuck Lever const struct rpcrdma_sendctx *sc, 641ab03eff5SChuck Lever const struct ib_wc *wc 642ab03eff5SChuck Lever ), 643ab03eff5SChuck Lever 644ab03eff5SChuck Lever TP_ARGS(sc, wc), 645ab03eff5SChuck Lever 646ab03eff5SChuck Lever TP_STRUCT__entry( 647ab03eff5SChuck Lever __field(const void *, req) 648ab03eff5SChuck Lever __field(unsigned int, unmap_count) 649ab03eff5SChuck Lever __field(unsigned int, status) 650ab03eff5SChuck Lever __field(unsigned int, vendor_err) 651ab03eff5SChuck Lever ), 652ab03eff5SChuck Lever 653ab03eff5SChuck Lever TP_fast_assign( 654ab03eff5SChuck Lever __entry->req = sc->sc_req; 655ab03eff5SChuck Lever __entry->unmap_count = sc->sc_unmap_count; 656ab03eff5SChuck Lever __entry->status = wc->status; 657ab03eff5SChuck Lever __entry->vendor_err = __entry->status ? wc->vendor_err : 0; 658ab03eff5SChuck Lever ), 659ab03eff5SChuck Lever 660ab03eff5SChuck Lever TP_printk("req=%p, unmapped %u pages: %s (%u/0x%x)", 661ab03eff5SChuck Lever __entry->req, __entry->unmap_count, 662ab03eff5SChuck Lever rdma_show_wc_status(__entry->status), 663ab03eff5SChuck Lever __entry->status, __entry->vendor_err 664ab03eff5SChuck Lever ) 665ab03eff5SChuck Lever ); 666ab03eff5SChuck Lever 667b4a7f91cSChuck Lever TRACE_EVENT(xprtrdma_wc_receive, 668b4a7f91cSChuck Lever TP_PROTO( 669b4a7f91cSChuck Lever const struct ib_wc *wc 670b4a7f91cSChuck Lever ), 671b4a7f91cSChuck Lever 6720e0b854cSChuck Lever TP_ARGS(wc), 673b4a7f91cSChuck Lever 674b4a7f91cSChuck Lever TP_STRUCT__entry( 6750e0b854cSChuck Lever __field(const void *, cqe) 6760e0b854cSChuck Lever __field(u32, byte_len) 677b4a7f91cSChuck Lever __field(unsigned int, status) 6780e0b854cSChuck Lever __field(u32, vendor_err) 679b4a7f91cSChuck Lever ), 680b4a7f91cSChuck Lever 681b4a7f91cSChuck Lever TP_fast_assign( 6820e0b854cSChuck Lever __entry->cqe = wc->wr_cqe; 683b4a7f91cSChuck Lever __entry->status = wc->status; 6840e0b854cSChuck Lever if (wc->status) { 6850e0b854cSChuck Lever __entry->byte_len = 0; 6860e0b854cSChuck Lever __entry->vendor_err = wc->vendor_err; 6870e0b854cSChuck Lever } else { 6880e0b854cSChuck Lever __entry->byte_len = wc->byte_len; 6890e0b854cSChuck Lever __entry->vendor_err = 0; 6900e0b854cSChuck Lever } 691b4a7f91cSChuck Lever ), 692b4a7f91cSChuck Lever 6930e0b854cSChuck Lever TP_printk("cqe=%p %u bytes: %s (%u/0x%x)", 6940e0b854cSChuck Lever __entry->cqe, __entry->byte_len, 695b4a7f91cSChuck Lever rdma_show_wc_status(__entry->status), 696b4a7f91cSChuck Lever __entry->status, __entry->vendor_err 697b4a7f91cSChuck Lever ) 698b4a7f91cSChuck Lever ); 699b4a7f91cSChuck Lever 70058f10ad4SChuck Lever DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_fastreg); 7012937fedeSChuck Lever DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li); 7022937fedeSChuck Lever DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li_wake); 7032937fedeSChuck Lever 70453b2c1cbSChuck Lever TRACE_EVENT(xprtrdma_frwr_alloc, 70553b2c1cbSChuck Lever TP_PROTO( 70653b2c1cbSChuck Lever const struct rpcrdma_mr *mr, 70753b2c1cbSChuck Lever int rc 70853b2c1cbSChuck Lever ), 70953b2c1cbSChuck Lever 71053b2c1cbSChuck Lever TP_ARGS(mr, rc), 71153b2c1cbSChuck Lever 71253b2c1cbSChuck Lever TP_STRUCT__entry( 71353b2c1cbSChuck Lever __field(const void *, mr) 71453b2c1cbSChuck Lever __field(int, rc) 71553b2c1cbSChuck Lever ), 71653b2c1cbSChuck Lever 71753b2c1cbSChuck Lever TP_fast_assign( 71853b2c1cbSChuck Lever __entry->mr = mr; 71953b2c1cbSChuck Lever __entry->rc = rc; 72053b2c1cbSChuck Lever ), 72153b2c1cbSChuck Lever 72253b2c1cbSChuck Lever TP_printk("mr=%p: rc=%d", 72353b2c1cbSChuck Lever __entry->mr, __entry->rc 72453b2c1cbSChuck Lever ) 72553b2c1cbSChuck Lever ); 72653b2c1cbSChuck Lever 72753b2c1cbSChuck Lever TRACE_EVENT(xprtrdma_frwr_dereg, 72853b2c1cbSChuck Lever TP_PROTO( 72953b2c1cbSChuck Lever const struct rpcrdma_mr *mr, 73053b2c1cbSChuck Lever int rc 73153b2c1cbSChuck Lever ), 73253b2c1cbSChuck Lever 73353b2c1cbSChuck Lever TP_ARGS(mr, rc), 73453b2c1cbSChuck Lever 73553b2c1cbSChuck Lever TP_STRUCT__entry( 73653b2c1cbSChuck Lever __field(const void *, mr) 73753b2c1cbSChuck Lever __field(u32, handle) 73853b2c1cbSChuck Lever __field(u32, length) 73953b2c1cbSChuck Lever __field(u64, offset) 74053b2c1cbSChuck Lever __field(u32, dir) 74153b2c1cbSChuck Lever __field(int, rc) 74253b2c1cbSChuck Lever ), 74353b2c1cbSChuck Lever 74453b2c1cbSChuck Lever TP_fast_assign( 74553b2c1cbSChuck Lever __entry->mr = mr; 74653b2c1cbSChuck Lever __entry->handle = mr->mr_handle; 74753b2c1cbSChuck Lever __entry->length = mr->mr_length; 74853b2c1cbSChuck Lever __entry->offset = mr->mr_offset; 74953b2c1cbSChuck Lever __entry->dir = mr->mr_dir; 75053b2c1cbSChuck Lever __entry->rc = rc; 75153b2c1cbSChuck Lever ), 75253b2c1cbSChuck Lever 75353b2c1cbSChuck Lever TP_printk("mr=%p %u@0x%016llx:0x%08x (%s): rc=%d", 75453b2c1cbSChuck Lever __entry->mr, __entry->length, 75553b2c1cbSChuck Lever (unsigned long long)__entry->offset, __entry->handle, 75653b2c1cbSChuck Lever xprtrdma_show_direction(__entry->dir), 75753b2c1cbSChuck Lever __entry->rc 75853b2c1cbSChuck Lever ) 75953b2c1cbSChuck Lever ); 76053b2c1cbSChuck Lever 76153b2c1cbSChuck Lever TRACE_EVENT(xprtrdma_frwr_sgerr, 76253b2c1cbSChuck Lever TP_PROTO( 76353b2c1cbSChuck Lever const struct rpcrdma_mr *mr, 76453b2c1cbSChuck Lever int sg_nents 76553b2c1cbSChuck Lever ), 76653b2c1cbSChuck Lever 76753b2c1cbSChuck Lever TP_ARGS(mr, sg_nents), 76853b2c1cbSChuck Lever 76953b2c1cbSChuck Lever TP_STRUCT__entry( 77053b2c1cbSChuck Lever __field(const void *, mr) 77153b2c1cbSChuck Lever __field(u64, addr) 77253b2c1cbSChuck Lever __field(u32, dir) 77353b2c1cbSChuck Lever __field(int, nents) 77453b2c1cbSChuck Lever ), 77553b2c1cbSChuck Lever 77653b2c1cbSChuck Lever TP_fast_assign( 77753b2c1cbSChuck Lever __entry->mr = mr; 77853b2c1cbSChuck Lever __entry->addr = mr->mr_sg->dma_address; 77953b2c1cbSChuck Lever __entry->dir = mr->mr_dir; 78053b2c1cbSChuck Lever __entry->nents = sg_nents; 78153b2c1cbSChuck Lever ), 78253b2c1cbSChuck Lever 78353b2c1cbSChuck Lever TP_printk("mr=%p dma addr=0x%llx (%s) sg_nents=%d", 78453b2c1cbSChuck Lever __entry->mr, __entry->addr, 78553b2c1cbSChuck Lever xprtrdma_show_direction(__entry->dir), 78653b2c1cbSChuck Lever __entry->nents 78753b2c1cbSChuck Lever ) 78853b2c1cbSChuck Lever ); 78953b2c1cbSChuck Lever 79053b2c1cbSChuck Lever TRACE_EVENT(xprtrdma_frwr_maperr, 79153b2c1cbSChuck Lever TP_PROTO( 79253b2c1cbSChuck Lever const struct rpcrdma_mr *mr, 79353b2c1cbSChuck Lever int num_mapped 79453b2c1cbSChuck Lever ), 79553b2c1cbSChuck Lever 79653b2c1cbSChuck Lever TP_ARGS(mr, num_mapped), 79753b2c1cbSChuck Lever 79853b2c1cbSChuck Lever TP_STRUCT__entry( 79953b2c1cbSChuck Lever __field(const void *, mr) 80053b2c1cbSChuck Lever __field(u64, addr) 80153b2c1cbSChuck Lever __field(u32, dir) 80253b2c1cbSChuck Lever __field(int, num_mapped) 80353b2c1cbSChuck Lever __field(int, nents) 80453b2c1cbSChuck Lever ), 80553b2c1cbSChuck Lever 80653b2c1cbSChuck Lever TP_fast_assign( 80753b2c1cbSChuck Lever __entry->mr = mr; 80853b2c1cbSChuck Lever __entry->addr = mr->mr_sg->dma_address; 80953b2c1cbSChuck Lever __entry->dir = mr->mr_dir; 81053b2c1cbSChuck Lever __entry->num_mapped = num_mapped; 81153b2c1cbSChuck Lever __entry->nents = mr->mr_nents; 81253b2c1cbSChuck Lever ), 81353b2c1cbSChuck Lever 81453b2c1cbSChuck Lever TP_printk("mr=%p dma addr=0x%llx (%s) nents=%d of %d", 81553b2c1cbSChuck Lever __entry->mr, __entry->addr, 81653b2c1cbSChuck Lever xprtrdma_show_direction(__entry->dir), 81753b2c1cbSChuck Lever __entry->num_mapped, __entry->nents 81853b2c1cbSChuck Lever ) 81953b2c1cbSChuck Lever ); 82053b2c1cbSChuck Lever 821d379eaa8SChuck Lever DEFINE_MR_EVENT(localinv); 822d379eaa8SChuck Lever DEFINE_MR_EVENT(map); 823d379eaa8SChuck Lever DEFINE_MR_EVENT(unmap); 824d379eaa8SChuck Lever DEFINE_MR_EVENT(remoteinv); 825d379eaa8SChuck Lever DEFINE_MR_EVENT(recycle); 82658f10ad4SChuck Lever 82753b2c1cbSChuck Lever TRACE_EVENT(xprtrdma_dma_maperr, 82853b2c1cbSChuck Lever TP_PROTO( 82953b2c1cbSChuck Lever u64 addr 83053b2c1cbSChuck Lever ), 83153b2c1cbSChuck Lever 83253b2c1cbSChuck Lever TP_ARGS(addr), 83353b2c1cbSChuck Lever 83453b2c1cbSChuck Lever TP_STRUCT__entry( 83553b2c1cbSChuck Lever __field(u64, addr) 83653b2c1cbSChuck Lever ), 83753b2c1cbSChuck Lever 83853b2c1cbSChuck Lever TP_fast_assign( 83953b2c1cbSChuck Lever __entry->addr = addr; 84053b2c1cbSChuck Lever ), 84153b2c1cbSChuck Lever 84253b2c1cbSChuck Lever TP_printk("dma addr=0x%llx\n", __entry->addr) 84353b2c1cbSChuck Lever ); 84453b2c1cbSChuck Lever 845b4a7f91cSChuck Lever /** 846b4a7f91cSChuck Lever ** Reply events 847b4a7f91cSChuck Lever **/ 848b4a7f91cSChuck Lever 849b4a7f91cSChuck Lever TRACE_EVENT(xprtrdma_reply, 850b4a7f91cSChuck Lever TP_PROTO( 851b4a7f91cSChuck Lever const struct rpc_task *task, 852b4a7f91cSChuck Lever const struct rpcrdma_rep *rep, 853b4a7f91cSChuck Lever const struct rpcrdma_req *req, 854b4a7f91cSChuck Lever unsigned int credits 855b4a7f91cSChuck Lever ), 856b4a7f91cSChuck Lever 857b4a7f91cSChuck Lever TP_ARGS(task, rep, req, credits), 858b4a7f91cSChuck Lever 859b4a7f91cSChuck Lever TP_STRUCT__entry( 860b4a7f91cSChuck Lever __field(unsigned int, task_id) 861b4a7f91cSChuck Lever __field(unsigned int, client_id) 862b4a7f91cSChuck Lever __field(const void *, rep) 863b4a7f91cSChuck Lever __field(const void *, req) 864b4a7f91cSChuck Lever __field(u32, xid) 865b4a7f91cSChuck Lever __field(unsigned int, credits) 866b4a7f91cSChuck Lever ), 867b4a7f91cSChuck Lever 868b4a7f91cSChuck Lever TP_fast_assign( 869b4a7f91cSChuck Lever __entry->task_id = task->tk_pid; 870b4a7f91cSChuck Lever __entry->client_id = task->tk_client->cl_clid; 871b4a7f91cSChuck Lever __entry->rep = rep; 872b4a7f91cSChuck Lever __entry->req = req; 873b4a7f91cSChuck Lever __entry->xid = be32_to_cpu(rep->rr_xid); 874b4a7f91cSChuck Lever __entry->credits = credits; 875b4a7f91cSChuck Lever ), 876b4a7f91cSChuck Lever 877b4a7f91cSChuck Lever TP_printk("task:%u@%u xid=0x%08x, %u credits, rep=%p -> req=%p", 878b4a7f91cSChuck Lever __entry->task_id, __entry->client_id, __entry->xid, 879b4a7f91cSChuck Lever __entry->credits, __entry->rep, __entry->req 880b4a7f91cSChuck Lever ) 881b4a7f91cSChuck Lever ); 882b4a7f91cSChuck Lever 883b4a7f91cSChuck Lever TRACE_EVENT(xprtrdma_defer_cmp, 884b4a7f91cSChuck Lever TP_PROTO( 885b4a7f91cSChuck Lever const struct rpcrdma_rep *rep 886b4a7f91cSChuck Lever ), 887b4a7f91cSChuck Lever 888b4a7f91cSChuck Lever TP_ARGS(rep), 889b4a7f91cSChuck Lever 890b4a7f91cSChuck Lever TP_STRUCT__entry( 891b4a7f91cSChuck Lever __field(unsigned int, task_id) 892b4a7f91cSChuck Lever __field(unsigned int, client_id) 893b4a7f91cSChuck Lever __field(const void *, rep) 894b4a7f91cSChuck Lever __field(u32, xid) 895b4a7f91cSChuck Lever ), 896b4a7f91cSChuck Lever 897b4a7f91cSChuck Lever TP_fast_assign( 898b4a7f91cSChuck Lever __entry->task_id = rep->rr_rqst->rq_task->tk_pid; 899b4a7f91cSChuck Lever __entry->client_id = rep->rr_rqst->rq_task->tk_client->cl_clid; 900b4a7f91cSChuck Lever __entry->rep = rep; 901b4a7f91cSChuck Lever __entry->xid = be32_to_cpu(rep->rr_xid); 902b4a7f91cSChuck Lever ), 903b4a7f91cSChuck Lever 904b4a7f91cSChuck Lever TP_printk("task:%u@%u xid=0x%08x rep=%p", 905b4a7f91cSChuck Lever __entry->task_id, __entry->client_id, __entry->xid, 906b4a7f91cSChuck Lever __entry->rep 907b4a7f91cSChuck Lever ) 908b4a7f91cSChuck Lever ); 909b4a7f91cSChuck Lever 910b4a7f91cSChuck Lever DEFINE_REPLY_EVENT(xprtrdma_reply_vers); 911b4a7f91cSChuck Lever DEFINE_REPLY_EVENT(xprtrdma_reply_rqst); 912b4a7f91cSChuck Lever DEFINE_REPLY_EVENT(xprtrdma_reply_short); 913b4a7f91cSChuck Lever DEFINE_REPLY_EVENT(xprtrdma_reply_hdr); 914b4a7f91cSChuck Lever 915e11b7c96SChuck Lever TRACE_EVENT(xprtrdma_fixup, 916e11b7c96SChuck Lever TP_PROTO( 917e11b7c96SChuck Lever const struct rpc_rqst *rqst, 918e11b7c96SChuck Lever int len, 919e11b7c96SChuck Lever int hdrlen 920e11b7c96SChuck Lever ), 921e11b7c96SChuck Lever 922e11b7c96SChuck Lever TP_ARGS(rqst, len, hdrlen), 923e11b7c96SChuck Lever 924e11b7c96SChuck Lever TP_STRUCT__entry( 925e11b7c96SChuck Lever __field(unsigned int, task_id) 926e11b7c96SChuck Lever __field(unsigned int, client_id) 927e11b7c96SChuck Lever __field(const void *, base) 928e11b7c96SChuck Lever __field(int, len) 929e11b7c96SChuck Lever __field(int, hdrlen) 930e11b7c96SChuck Lever ), 931e11b7c96SChuck Lever 932e11b7c96SChuck Lever TP_fast_assign( 933e11b7c96SChuck Lever __entry->task_id = rqst->rq_task->tk_pid; 934e11b7c96SChuck Lever __entry->client_id = rqst->rq_task->tk_client->cl_clid; 935e11b7c96SChuck Lever __entry->base = rqst->rq_rcv_buf.head[0].iov_base; 936e11b7c96SChuck Lever __entry->len = len; 937e11b7c96SChuck Lever __entry->hdrlen = hdrlen; 938e11b7c96SChuck Lever ), 939e11b7c96SChuck Lever 940e11b7c96SChuck Lever TP_printk("task:%u@%u base=%p len=%d hdrlen=%d", 941e11b7c96SChuck Lever __entry->task_id, __entry->client_id, 942e11b7c96SChuck Lever __entry->base, __entry->len, __entry->hdrlen 943e11b7c96SChuck Lever ) 944e11b7c96SChuck Lever ); 945e11b7c96SChuck Lever 946e11b7c96SChuck Lever TRACE_EVENT(xprtrdma_fixup_pg, 947e11b7c96SChuck Lever TP_PROTO( 948e11b7c96SChuck Lever const struct rpc_rqst *rqst, 949e11b7c96SChuck Lever int pageno, 950e11b7c96SChuck Lever const void *pos, 951e11b7c96SChuck Lever int len, 952e11b7c96SChuck Lever int curlen 953e11b7c96SChuck Lever ), 954e11b7c96SChuck Lever 955e11b7c96SChuck Lever TP_ARGS(rqst, pageno, pos, len, curlen), 956e11b7c96SChuck Lever 957e11b7c96SChuck Lever TP_STRUCT__entry( 958e11b7c96SChuck Lever __field(unsigned int, task_id) 959e11b7c96SChuck Lever __field(unsigned int, client_id) 960e11b7c96SChuck Lever __field(const void *, pos) 961e11b7c96SChuck Lever __field(int, pageno) 962e11b7c96SChuck Lever __field(int, len) 963e11b7c96SChuck Lever __field(int, curlen) 964e11b7c96SChuck Lever ), 965e11b7c96SChuck Lever 966e11b7c96SChuck Lever TP_fast_assign( 967e11b7c96SChuck Lever __entry->task_id = rqst->rq_task->tk_pid; 968e11b7c96SChuck Lever __entry->client_id = rqst->rq_task->tk_client->cl_clid; 969e11b7c96SChuck Lever __entry->pos = pos; 970e11b7c96SChuck Lever __entry->pageno = pageno; 971e11b7c96SChuck Lever __entry->len = len; 972e11b7c96SChuck Lever __entry->curlen = curlen; 973e11b7c96SChuck Lever ), 974e11b7c96SChuck Lever 975e11b7c96SChuck Lever TP_printk("task:%u@%u pageno=%d pos=%p len=%d curlen=%d", 976e11b7c96SChuck Lever __entry->task_id, __entry->client_id, 977e11b7c96SChuck Lever __entry->pageno, __entry->pos, __entry->len, __entry->curlen 978e11b7c96SChuck Lever ) 979e11b7c96SChuck Lever ); 980e11b7c96SChuck Lever 981e11b7c96SChuck Lever TRACE_EVENT(xprtrdma_decode_seg, 982e11b7c96SChuck Lever TP_PROTO( 983e11b7c96SChuck Lever u32 handle, 984e11b7c96SChuck Lever u32 length, 985e11b7c96SChuck Lever u64 offset 986e11b7c96SChuck Lever ), 987e11b7c96SChuck Lever 988e11b7c96SChuck Lever TP_ARGS(handle, length, offset), 989e11b7c96SChuck Lever 990e11b7c96SChuck Lever TP_STRUCT__entry( 991e11b7c96SChuck Lever __field(u32, handle) 992e11b7c96SChuck Lever __field(u32, length) 993e11b7c96SChuck Lever __field(u64, offset) 994e11b7c96SChuck Lever ), 995e11b7c96SChuck Lever 996e11b7c96SChuck Lever TP_fast_assign( 997e11b7c96SChuck Lever __entry->handle = handle; 998e11b7c96SChuck Lever __entry->length = length; 999e11b7c96SChuck Lever __entry->offset = offset; 1000e11b7c96SChuck Lever ), 1001e11b7c96SChuck Lever 1002e11b7c96SChuck Lever TP_printk("%u@0x%016llx:0x%08x", 1003e11b7c96SChuck Lever __entry->length, (unsigned long long)__entry->offset, 1004e11b7c96SChuck Lever __entry->handle 1005e11b7c96SChuck Lever ) 1006e11b7c96SChuck Lever ); 1007e11b7c96SChuck Lever 1008fc1eb807SChuck Lever /** 1009ae724676SChuck Lever ** Allocation/release of rpcrdma_reqs and rpcrdma_reps 1010ae724676SChuck Lever **/ 1011ae724676SChuck Lever 1012395069fcSChuck Lever TRACE_EVENT(xprtrdma_op_allocate, 1013ae724676SChuck Lever TP_PROTO( 1014ae724676SChuck Lever const struct rpc_task *task, 1015ae724676SChuck Lever const struct rpcrdma_req *req 1016ae724676SChuck Lever ), 1017ae724676SChuck Lever 1018ae724676SChuck Lever TP_ARGS(task, req), 1019ae724676SChuck Lever 1020ae724676SChuck Lever TP_STRUCT__entry( 1021ae724676SChuck Lever __field(unsigned int, task_id) 1022ae724676SChuck Lever __field(unsigned int, client_id) 1023ae724676SChuck Lever __field(const void *, req) 1024ae724676SChuck Lever __field(size_t, callsize) 1025ae724676SChuck Lever __field(size_t, rcvsize) 1026ae724676SChuck Lever ), 1027ae724676SChuck Lever 1028ae724676SChuck Lever TP_fast_assign( 1029ae724676SChuck Lever __entry->task_id = task->tk_pid; 1030ae724676SChuck Lever __entry->client_id = task->tk_client->cl_clid; 1031ae724676SChuck Lever __entry->req = req; 1032ae724676SChuck Lever __entry->callsize = task->tk_rqstp->rq_callsize; 1033ae724676SChuck Lever __entry->rcvsize = task->tk_rqstp->rq_rcvsize; 1034ae724676SChuck Lever ), 1035ae724676SChuck Lever 10367c8d9e7cSChuck Lever TP_printk("task:%u@%u req=%p (%zu, %zu)", 1037ae724676SChuck Lever __entry->task_id, __entry->client_id, 10387c8d9e7cSChuck Lever __entry->req, __entry->callsize, __entry->rcvsize 1039ae724676SChuck Lever ) 1040ae724676SChuck Lever ); 1041ae724676SChuck Lever 1042395069fcSChuck Lever TRACE_EVENT(xprtrdma_op_free, 1043ae724676SChuck Lever TP_PROTO( 1044ae724676SChuck Lever const struct rpc_task *task, 1045ae724676SChuck Lever const struct rpcrdma_req *req 1046ae724676SChuck Lever ), 1047ae724676SChuck Lever 1048ae724676SChuck Lever TP_ARGS(task, req), 1049ae724676SChuck Lever 1050ae724676SChuck Lever TP_STRUCT__entry( 1051ae724676SChuck Lever __field(unsigned int, task_id) 1052ae724676SChuck Lever __field(unsigned int, client_id) 1053ae724676SChuck Lever __field(const void *, req) 1054ae724676SChuck Lever __field(const void *, rep) 1055ae724676SChuck Lever ), 1056ae724676SChuck Lever 1057ae724676SChuck Lever TP_fast_assign( 1058ae724676SChuck Lever __entry->task_id = task->tk_pid; 1059ae724676SChuck Lever __entry->client_id = task->tk_client->cl_clid; 1060ae724676SChuck Lever __entry->req = req; 1061ae724676SChuck Lever __entry->rep = req->rl_reply; 1062ae724676SChuck Lever ), 1063ae724676SChuck Lever 1064ae724676SChuck Lever TP_printk("task:%u@%u req=%p rep=%p", 1065ae724676SChuck Lever __entry->task_id, __entry->client_id, 1066ae724676SChuck Lever __entry->req, __entry->rep 1067ae724676SChuck Lever ) 1068ae724676SChuck Lever ); 1069ae724676SChuck Lever 1070ae724676SChuck Lever /** 1071fc1eb807SChuck Lever ** Callback events 1072fc1eb807SChuck Lever **/ 1073fc1eb807SChuck Lever 1074fc1eb807SChuck Lever TRACE_EVENT(xprtrdma_cb_setup, 1075fc1eb807SChuck Lever TP_PROTO( 1076fc1eb807SChuck Lever const struct rpcrdma_xprt *r_xprt, 1077fc1eb807SChuck Lever unsigned int reqs 1078fc1eb807SChuck Lever ), 1079fc1eb807SChuck Lever 1080fc1eb807SChuck Lever TP_ARGS(r_xprt, reqs), 1081fc1eb807SChuck Lever 1082fc1eb807SChuck Lever TP_STRUCT__entry( 1083fc1eb807SChuck Lever __field(const void *, r_xprt) 1084fc1eb807SChuck Lever __field(unsigned int, reqs) 1085fc1eb807SChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 1086fc1eb807SChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 1087fc1eb807SChuck Lever ), 1088fc1eb807SChuck Lever 1089fc1eb807SChuck Lever TP_fast_assign( 1090fc1eb807SChuck Lever __entry->r_xprt = r_xprt; 1091fc1eb807SChuck Lever __entry->reqs = reqs; 1092fc1eb807SChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 1093fc1eb807SChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 1094fc1eb807SChuck Lever ), 1095fc1eb807SChuck Lever 1096fc1eb807SChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: %u reqs", 1097fc1eb807SChuck Lever __get_str(addr), __get_str(port), 1098fc1eb807SChuck Lever __entry->r_xprt, __entry->reqs 1099fc1eb807SChuck Lever ) 1100fc1eb807SChuck Lever ); 1101fc1eb807SChuck Lever 1102fc1eb807SChuck Lever DEFINE_CB_EVENT(xprtrdma_cb_call); 1103fc1eb807SChuck Lever DEFINE_CB_EVENT(xprtrdma_cb_reply); 1104fc1eb807SChuck Lever 110507e10308SChuck Lever TRACE_EVENT(xprtrdma_leaked_rep, 110607e10308SChuck Lever TP_PROTO( 110707e10308SChuck Lever const struct rpc_rqst *rqst, 110807e10308SChuck Lever const struct rpcrdma_rep *rep 110907e10308SChuck Lever ), 111007e10308SChuck Lever 111107e10308SChuck Lever TP_ARGS(rqst, rep), 111207e10308SChuck Lever 111307e10308SChuck Lever TP_STRUCT__entry( 111407e10308SChuck Lever __field(unsigned int, task_id) 111507e10308SChuck Lever __field(unsigned int, client_id) 111607e10308SChuck Lever __field(u32, xid) 111707e10308SChuck Lever __field(const void *, rep) 111807e10308SChuck Lever ), 111907e10308SChuck Lever 112007e10308SChuck Lever TP_fast_assign( 112107e10308SChuck Lever __entry->task_id = rqst->rq_task->tk_pid; 112207e10308SChuck Lever __entry->client_id = rqst->rq_task->tk_client->cl_clid; 112307e10308SChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 112407e10308SChuck Lever __entry->rep = rep; 112507e10308SChuck Lever ), 112607e10308SChuck Lever 112707e10308SChuck Lever TP_printk("task:%u@%u xid=0x%08x rep=%p", 112807e10308SChuck Lever __entry->task_id, __entry->client_id, __entry->xid, 112907e10308SChuck Lever __entry->rep 113007e10308SChuck Lever ) 113107e10308SChuck Lever ); 113207e10308SChuck Lever 113398895edbSChuck Lever /** 113498895edbSChuck Lever ** Server-side RPC/RDMA events 113598895edbSChuck Lever **/ 113698895edbSChuck Lever 113798895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_xprt_event, 113898895edbSChuck Lever TP_PROTO( 113998895edbSChuck Lever const struct svc_xprt *xprt 114098895edbSChuck Lever ), 114198895edbSChuck Lever 114298895edbSChuck Lever TP_ARGS(xprt), 114398895edbSChuck Lever 114498895edbSChuck Lever TP_STRUCT__entry( 114598895edbSChuck Lever __field(const void *, xprt) 114698895edbSChuck Lever __string(addr, xprt->xpt_remotebuf) 114798895edbSChuck Lever ), 114898895edbSChuck Lever 114998895edbSChuck Lever TP_fast_assign( 115098895edbSChuck Lever __entry->xprt = xprt; 115198895edbSChuck Lever __assign_str(addr, xprt->xpt_remotebuf); 115298895edbSChuck Lever ), 115398895edbSChuck Lever 115498895edbSChuck Lever TP_printk("xprt=%p addr=%s", 115598895edbSChuck Lever __entry->xprt, __get_str(addr) 115698895edbSChuck Lever ) 115798895edbSChuck Lever ); 115898895edbSChuck Lever 115998895edbSChuck Lever #define DEFINE_XPRT_EVENT(name) \ 116098895edbSChuck Lever DEFINE_EVENT(svcrdma_xprt_event, svcrdma_xprt_##name, \ 116198895edbSChuck Lever TP_PROTO( \ 116298895edbSChuck Lever const struct svc_xprt *xprt \ 116398895edbSChuck Lever ), \ 116498895edbSChuck Lever TP_ARGS(xprt)) 116598895edbSChuck Lever 116698895edbSChuck Lever DEFINE_XPRT_EVENT(accept); 116798895edbSChuck Lever DEFINE_XPRT_EVENT(fail); 116898895edbSChuck Lever DEFINE_XPRT_EVENT(free); 116998895edbSChuck Lever 117098895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_MSG); 117198895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_NOMSG); 117298895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_MSGP); 117398895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_DONE); 117498895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_ERROR); 117598895edbSChuck Lever 117698895edbSChuck Lever #define show_rpcrdma_proc(x) \ 117798895edbSChuck Lever __print_symbolic(x, \ 117898895edbSChuck Lever { RDMA_MSG, "RDMA_MSG" }, \ 117998895edbSChuck Lever { RDMA_NOMSG, "RDMA_NOMSG" }, \ 118098895edbSChuck Lever { RDMA_MSGP, "RDMA_MSGP" }, \ 118198895edbSChuck Lever { RDMA_DONE, "RDMA_DONE" }, \ 118298895edbSChuck Lever { RDMA_ERROR, "RDMA_ERROR" }) 118398895edbSChuck Lever 118498895edbSChuck Lever TRACE_EVENT(svcrdma_decode_rqst, 118598895edbSChuck Lever TP_PROTO( 118698895edbSChuck Lever __be32 *p, 118798895edbSChuck Lever unsigned int hdrlen 118898895edbSChuck Lever ), 118998895edbSChuck Lever 119098895edbSChuck Lever TP_ARGS(p, hdrlen), 119198895edbSChuck Lever 119298895edbSChuck Lever TP_STRUCT__entry( 119398895edbSChuck Lever __field(u32, xid) 119498895edbSChuck Lever __field(u32, vers) 119598895edbSChuck Lever __field(u32, proc) 119698895edbSChuck Lever __field(u32, credits) 119798895edbSChuck Lever __field(unsigned int, hdrlen) 119898895edbSChuck Lever ), 119998895edbSChuck Lever 120098895edbSChuck Lever TP_fast_assign( 120198895edbSChuck Lever __entry->xid = be32_to_cpup(p++); 120298895edbSChuck Lever __entry->vers = be32_to_cpup(p++); 120398895edbSChuck Lever __entry->credits = be32_to_cpup(p++); 120498895edbSChuck Lever __entry->proc = be32_to_cpup(p); 120598895edbSChuck Lever __entry->hdrlen = hdrlen; 120698895edbSChuck Lever ), 120798895edbSChuck Lever 120898895edbSChuck Lever TP_printk("xid=0x%08x vers=%u credits=%u proc=%s hdrlen=%u", 120998895edbSChuck Lever __entry->xid, __entry->vers, __entry->credits, 121098895edbSChuck Lever show_rpcrdma_proc(__entry->proc), __entry->hdrlen) 121198895edbSChuck Lever ); 121298895edbSChuck Lever 121398895edbSChuck Lever TRACE_EVENT(svcrdma_decode_short, 121498895edbSChuck Lever TP_PROTO( 121598895edbSChuck Lever unsigned int hdrlen 121698895edbSChuck Lever ), 121798895edbSChuck Lever 121898895edbSChuck Lever TP_ARGS(hdrlen), 121998895edbSChuck Lever 122098895edbSChuck Lever TP_STRUCT__entry( 122198895edbSChuck Lever __field(unsigned int, hdrlen) 122298895edbSChuck Lever ), 122398895edbSChuck Lever 122498895edbSChuck Lever TP_fast_assign( 122598895edbSChuck Lever __entry->hdrlen = hdrlen; 122698895edbSChuck Lever ), 122798895edbSChuck Lever 122898895edbSChuck Lever TP_printk("hdrlen=%u", __entry->hdrlen) 122998895edbSChuck Lever ); 123098895edbSChuck Lever 123198895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_badreq_event, 123298895edbSChuck Lever TP_PROTO( 123398895edbSChuck Lever __be32 *p 123498895edbSChuck Lever ), 123598895edbSChuck Lever 123698895edbSChuck Lever TP_ARGS(p), 123798895edbSChuck Lever 123898895edbSChuck Lever TP_STRUCT__entry( 123998895edbSChuck Lever __field(u32, xid) 124098895edbSChuck Lever __field(u32, vers) 124198895edbSChuck Lever __field(u32, proc) 124298895edbSChuck Lever __field(u32, credits) 124398895edbSChuck Lever ), 124498895edbSChuck Lever 124598895edbSChuck Lever TP_fast_assign( 124698895edbSChuck Lever __entry->xid = be32_to_cpup(p++); 124798895edbSChuck Lever __entry->vers = be32_to_cpup(p++); 124898895edbSChuck Lever __entry->credits = be32_to_cpup(p++); 124998895edbSChuck Lever __entry->proc = be32_to_cpup(p); 125098895edbSChuck Lever ), 125198895edbSChuck Lever 125298895edbSChuck Lever TP_printk("xid=0x%08x vers=%u credits=%u proc=%u", 125398895edbSChuck Lever __entry->xid, __entry->vers, __entry->credits, __entry->proc) 125498895edbSChuck Lever ); 125598895edbSChuck Lever 125698895edbSChuck Lever #define DEFINE_BADREQ_EVENT(name) \ 125798895edbSChuck Lever DEFINE_EVENT(svcrdma_badreq_event, svcrdma_decode_##name,\ 125898895edbSChuck Lever TP_PROTO( \ 125998895edbSChuck Lever __be32 *p \ 126098895edbSChuck Lever ), \ 126198895edbSChuck Lever TP_ARGS(p)) 126298895edbSChuck Lever 126398895edbSChuck Lever DEFINE_BADREQ_EVENT(badvers); 126498895edbSChuck Lever DEFINE_BADREQ_EVENT(drop); 126598895edbSChuck Lever DEFINE_BADREQ_EVENT(badproc); 126698895edbSChuck Lever DEFINE_BADREQ_EVENT(parse); 126798895edbSChuck Lever 126898895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_segment_event, 126998895edbSChuck Lever TP_PROTO( 127098895edbSChuck Lever u32 handle, 127198895edbSChuck Lever u32 length, 127298895edbSChuck Lever u64 offset 127398895edbSChuck Lever ), 127498895edbSChuck Lever 127598895edbSChuck Lever TP_ARGS(handle, length, offset), 127698895edbSChuck Lever 127798895edbSChuck Lever TP_STRUCT__entry( 127898895edbSChuck Lever __field(u32, handle) 127998895edbSChuck Lever __field(u32, length) 128098895edbSChuck Lever __field(u64, offset) 128198895edbSChuck Lever ), 128298895edbSChuck Lever 128398895edbSChuck Lever TP_fast_assign( 128498895edbSChuck Lever __entry->handle = handle; 128598895edbSChuck Lever __entry->length = length; 128698895edbSChuck Lever __entry->offset = offset; 128798895edbSChuck Lever ), 128898895edbSChuck Lever 128998895edbSChuck Lever TP_printk("%u@0x%016llx:0x%08x", 129098895edbSChuck Lever __entry->length, (unsigned long long)__entry->offset, 129198895edbSChuck Lever __entry->handle 129298895edbSChuck Lever ) 129398895edbSChuck Lever ); 129498895edbSChuck Lever 129598895edbSChuck Lever #define DEFINE_SEGMENT_EVENT(name) \ 129698895edbSChuck Lever DEFINE_EVENT(svcrdma_segment_event, svcrdma_encode_##name,\ 129798895edbSChuck Lever TP_PROTO( \ 129898895edbSChuck Lever u32 handle, \ 129998895edbSChuck Lever u32 length, \ 130098895edbSChuck Lever u64 offset \ 130198895edbSChuck Lever ), \ 130298895edbSChuck Lever TP_ARGS(handle, length, offset)) 130398895edbSChuck Lever 130498895edbSChuck Lever DEFINE_SEGMENT_EVENT(rseg); 130598895edbSChuck Lever DEFINE_SEGMENT_EVENT(wseg); 130698895edbSChuck Lever 130798895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_chunk_event, 130898895edbSChuck Lever TP_PROTO( 130998895edbSChuck Lever u32 length 131098895edbSChuck Lever ), 131198895edbSChuck Lever 131298895edbSChuck Lever TP_ARGS(length), 131398895edbSChuck Lever 131498895edbSChuck Lever TP_STRUCT__entry( 131598895edbSChuck Lever __field(u32, length) 131698895edbSChuck Lever ), 131798895edbSChuck Lever 131898895edbSChuck Lever TP_fast_assign( 131998895edbSChuck Lever __entry->length = length; 132098895edbSChuck Lever ), 132198895edbSChuck Lever 132298895edbSChuck Lever TP_printk("length=%u", 132398895edbSChuck Lever __entry->length 132498895edbSChuck Lever ) 132598895edbSChuck Lever ); 132698895edbSChuck Lever 132798895edbSChuck Lever #define DEFINE_CHUNK_EVENT(name) \ 132898895edbSChuck Lever DEFINE_EVENT(svcrdma_chunk_event, svcrdma_encode_##name,\ 132998895edbSChuck Lever TP_PROTO( \ 133098895edbSChuck Lever u32 length \ 133198895edbSChuck Lever ), \ 133298895edbSChuck Lever TP_ARGS(length)) 133398895edbSChuck Lever 133498895edbSChuck Lever DEFINE_CHUNK_EVENT(pzr); 133598895edbSChuck Lever DEFINE_CHUNK_EVENT(write); 133698895edbSChuck Lever DEFINE_CHUNK_EVENT(reply); 133798895edbSChuck Lever 133898895edbSChuck Lever TRACE_EVENT(svcrdma_encode_read, 133998895edbSChuck Lever TP_PROTO( 134098895edbSChuck Lever u32 length, 134198895edbSChuck Lever u32 position 134298895edbSChuck Lever ), 134398895edbSChuck Lever 134498895edbSChuck Lever TP_ARGS(length, position), 134598895edbSChuck Lever 134698895edbSChuck Lever TP_STRUCT__entry( 134798895edbSChuck Lever __field(u32, length) 134898895edbSChuck Lever __field(u32, position) 134998895edbSChuck Lever ), 135098895edbSChuck Lever 135198895edbSChuck Lever TP_fast_assign( 135298895edbSChuck Lever __entry->length = length; 135398895edbSChuck Lever __entry->position = position; 135498895edbSChuck Lever ), 135598895edbSChuck Lever 135698895edbSChuck Lever TP_printk("length=%u position=%u", 135798895edbSChuck Lever __entry->length, __entry->position 135898895edbSChuck Lever ) 135998895edbSChuck Lever ); 136098895edbSChuck Lever 136198895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_error_event, 136298895edbSChuck Lever TP_PROTO( 136398895edbSChuck Lever __be32 xid 136498895edbSChuck Lever ), 136598895edbSChuck Lever 136698895edbSChuck Lever TP_ARGS(xid), 136798895edbSChuck Lever 136898895edbSChuck Lever TP_STRUCT__entry( 136998895edbSChuck Lever __field(u32, xid) 137098895edbSChuck Lever ), 137198895edbSChuck Lever 137298895edbSChuck Lever TP_fast_assign( 137398895edbSChuck Lever __entry->xid = be32_to_cpu(xid); 137498895edbSChuck Lever ), 137598895edbSChuck Lever 137698895edbSChuck Lever TP_printk("xid=0x%08x", 137798895edbSChuck Lever __entry->xid 137898895edbSChuck Lever ) 137998895edbSChuck Lever ); 138098895edbSChuck Lever 138198895edbSChuck Lever #define DEFINE_ERROR_EVENT(name) \ 138298895edbSChuck Lever DEFINE_EVENT(svcrdma_error_event, svcrdma_err_##name, \ 138398895edbSChuck Lever TP_PROTO( \ 138498895edbSChuck Lever __be32 xid \ 138598895edbSChuck Lever ), \ 138698895edbSChuck Lever TP_ARGS(xid)) 138798895edbSChuck Lever 138898895edbSChuck Lever DEFINE_ERROR_EVENT(vers); 138998895edbSChuck Lever DEFINE_ERROR_EVENT(chunk); 139098895edbSChuck Lever 1391bd2abef3SChuck Lever /** 1392bd2abef3SChuck Lever ** Server-side RDMA API events 1393bd2abef3SChuck Lever **/ 1394bd2abef3SChuck Lever 1395bd2abef3SChuck Lever TRACE_EVENT(svcrdma_dma_map_page, 1396bd2abef3SChuck Lever TP_PROTO( 1397bd2abef3SChuck Lever const struct svcxprt_rdma *rdma, 1398bd2abef3SChuck Lever const void *page 1399bd2abef3SChuck Lever ), 1400bd2abef3SChuck Lever 1401bd2abef3SChuck Lever TP_ARGS(rdma, page), 1402bd2abef3SChuck Lever 1403bd2abef3SChuck Lever TP_STRUCT__entry( 1404bd2abef3SChuck Lever __field(const void *, page); 1405bd2abef3SChuck Lever __string(device, rdma->sc_cm_id->device->name) 1406bd2abef3SChuck Lever __string(addr, rdma->sc_xprt.xpt_remotebuf) 1407bd2abef3SChuck Lever ), 1408bd2abef3SChuck Lever 1409bd2abef3SChuck Lever TP_fast_assign( 1410bd2abef3SChuck Lever __entry->page = page; 1411bd2abef3SChuck Lever __assign_str(device, rdma->sc_cm_id->device->name); 1412bd2abef3SChuck Lever __assign_str(addr, rdma->sc_xprt.xpt_remotebuf); 1413bd2abef3SChuck Lever ), 1414bd2abef3SChuck Lever 1415bd2abef3SChuck Lever TP_printk("addr=%s device=%s page=%p", 1416bd2abef3SChuck Lever __get_str(addr), __get_str(device), __entry->page 1417bd2abef3SChuck Lever ) 1418bd2abef3SChuck Lever ); 1419bd2abef3SChuck Lever 1420bd2abef3SChuck Lever TRACE_EVENT(svcrdma_dma_map_rwctx, 1421bd2abef3SChuck Lever TP_PROTO( 1422bd2abef3SChuck Lever const struct svcxprt_rdma *rdma, 1423bd2abef3SChuck Lever int status 1424bd2abef3SChuck Lever ), 1425bd2abef3SChuck Lever 1426bd2abef3SChuck Lever TP_ARGS(rdma, status), 1427bd2abef3SChuck Lever 1428bd2abef3SChuck Lever TP_STRUCT__entry( 1429bd2abef3SChuck Lever __field(int, status) 1430bd2abef3SChuck Lever __string(device, rdma->sc_cm_id->device->name) 1431bd2abef3SChuck Lever __string(addr, rdma->sc_xprt.xpt_remotebuf) 1432bd2abef3SChuck Lever ), 1433bd2abef3SChuck Lever 1434bd2abef3SChuck Lever TP_fast_assign( 1435bd2abef3SChuck Lever __entry->status = status; 1436bd2abef3SChuck Lever __assign_str(device, rdma->sc_cm_id->device->name); 1437bd2abef3SChuck Lever __assign_str(addr, rdma->sc_xprt.xpt_remotebuf); 1438bd2abef3SChuck Lever ), 1439bd2abef3SChuck Lever 1440bd2abef3SChuck Lever TP_printk("addr=%s device=%s status=%d", 1441bd2abef3SChuck Lever __get_str(addr), __get_str(device), __entry->status 1442bd2abef3SChuck Lever ) 1443bd2abef3SChuck Lever ); 1444bd2abef3SChuck Lever 1445bd2abef3SChuck Lever TRACE_EVENT(svcrdma_send_failed, 1446bd2abef3SChuck Lever TP_PROTO( 1447bd2abef3SChuck Lever const struct svc_rqst *rqst, 1448bd2abef3SChuck Lever int status 1449bd2abef3SChuck Lever ), 1450bd2abef3SChuck Lever 1451bd2abef3SChuck Lever TP_ARGS(rqst, status), 1452bd2abef3SChuck Lever 1453bd2abef3SChuck Lever TP_STRUCT__entry( 1454bd2abef3SChuck Lever __field(int, status) 1455bd2abef3SChuck Lever __field(u32, xid) 1456bd2abef3SChuck Lever __field(const void *, xprt) 1457bd2abef3SChuck Lever __string(addr, rqst->rq_xprt->xpt_remotebuf) 1458bd2abef3SChuck Lever ), 1459bd2abef3SChuck Lever 1460bd2abef3SChuck Lever TP_fast_assign( 1461bd2abef3SChuck Lever __entry->status = status; 1462bd2abef3SChuck Lever __entry->xid = __be32_to_cpu(rqst->rq_xid); 1463bd2abef3SChuck Lever __entry->xprt = rqst->rq_xprt; 1464bd2abef3SChuck Lever __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1465bd2abef3SChuck Lever ), 1466bd2abef3SChuck Lever 1467bd2abef3SChuck Lever TP_printk("xprt=%p addr=%s xid=0x%08x status=%d", 1468bd2abef3SChuck Lever __entry->xprt, __get_str(addr), 1469bd2abef3SChuck Lever __entry->xid, __entry->status 1470bd2abef3SChuck Lever ) 1471bd2abef3SChuck Lever ); 1472bd2abef3SChuck Lever 1473bd2abef3SChuck Lever DECLARE_EVENT_CLASS(svcrdma_sendcomp_event, 1474bd2abef3SChuck Lever TP_PROTO( 1475bd2abef3SChuck Lever const struct ib_wc *wc 1476bd2abef3SChuck Lever ), 1477bd2abef3SChuck Lever 1478bd2abef3SChuck Lever TP_ARGS(wc), 1479bd2abef3SChuck Lever 1480bd2abef3SChuck Lever TP_STRUCT__entry( 1481bd2abef3SChuck Lever __field(const void *, cqe) 1482bd2abef3SChuck Lever __field(unsigned int, status) 1483bd2abef3SChuck Lever __field(unsigned int, vendor_err) 1484bd2abef3SChuck Lever ), 1485bd2abef3SChuck Lever 1486bd2abef3SChuck Lever TP_fast_assign( 1487bd2abef3SChuck Lever __entry->cqe = wc->wr_cqe; 1488bd2abef3SChuck Lever __entry->status = wc->status; 1489bd2abef3SChuck Lever if (wc->status) 1490bd2abef3SChuck Lever __entry->vendor_err = wc->vendor_err; 1491bd2abef3SChuck Lever else 1492bd2abef3SChuck Lever __entry->vendor_err = 0; 1493bd2abef3SChuck Lever ), 1494bd2abef3SChuck Lever 1495bd2abef3SChuck Lever TP_printk("cqe=%p status=%s (%u/0x%x)", 1496bd2abef3SChuck Lever __entry->cqe, rdma_show_wc_status(__entry->status), 1497bd2abef3SChuck Lever __entry->status, __entry->vendor_err 1498bd2abef3SChuck Lever ) 1499bd2abef3SChuck Lever ); 1500bd2abef3SChuck Lever 1501bd2abef3SChuck Lever #define DEFINE_SENDCOMP_EVENT(name) \ 1502bd2abef3SChuck Lever DEFINE_EVENT(svcrdma_sendcomp_event, svcrdma_wc_##name, \ 1503bd2abef3SChuck Lever TP_PROTO( \ 1504bd2abef3SChuck Lever const struct ib_wc *wc \ 1505bd2abef3SChuck Lever ), \ 1506bd2abef3SChuck Lever TP_ARGS(wc)) 1507bd2abef3SChuck Lever 1508bd2abef3SChuck Lever TRACE_EVENT(svcrdma_post_send, 1509bd2abef3SChuck Lever TP_PROTO( 1510bd2abef3SChuck Lever const struct ib_send_wr *wr, 1511bd2abef3SChuck Lever int status 1512bd2abef3SChuck Lever ), 1513bd2abef3SChuck Lever 1514bd2abef3SChuck Lever TP_ARGS(wr, status), 1515bd2abef3SChuck Lever 1516bd2abef3SChuck Lever TP_STRUCT__entry( 1517bd2abef3SChuck Lever __field(const void *, cqe) 1518bd2abef3SChuck Lever __field(unsigned int, num_sge) 1519bd2abef3SChuck Lever __field(u32, inv_rkey) 1520bd2abef3SChuck Lever __field(int, status) 1521bd2abef3SChuck Lever ), 1522bd2abef3SChuck Lever 1523bd2abef3SChuck Lever TP_fast_assign( 1524bd2abef3SChuck Lever __entry->cqe = wr->wr_cqe; 1525bd2abef3SChuck Lever __entry->num_sge = wr->num_sge; 1526bd2abef3SChuck Lever __entry->inv_rkey = (wr->opcode == IB_WR_SEND_WITH_INV) ? 1527bd2abef3SChuck Lever wr->ex.invalidate_rkey : 0; 1528bd2abef3SChuck Lever __entry->status = status; 1529bd2abef3SChuck Lever ), 1530bd2abef3SChuck Lever 1531bd2abef3SChuck Lever TP_printk("cqe=%p num_sge=%u inv_rkey=0x%08x status=%d", 1532bd2abef3SChuck Lever __entry->cqe, __entry->num_sge, 1533bd2abef3SChuck Lever __entry->inv_rkey, __entry->status 1534bd2abef3SChuck Lever ) 1535bd2abef3SChuck Lever ); 1536bd2abef3SChuck Lever 1537bd2abef3SChuck Lever DEFINE_SENDCOMP_EVENT(send); 1538bd2abef3SChuck Lever 1539bd2abef3SChuck Lever TRACE_EVENT(svcrdma_post_recv, 1540bd2abef3SChuck Lever TP_PROTO( 1541bd2abef3SChuck Lever const struct ib_recv_wr *wr, 1542bd2abef3SChuck Lever int status 1543bd2abef3SChuck Lever ), 1544bd2abef3SChuck Lever 1545bd2abef3SChuck Lever TP_ARGS(wr, status), 1546bd2abef3SChuck Lever 1547bd2abef3SChuck Lever TP_STRUCT__entry( 1548bd2abef3SChuck Lever __field(const void *, cqe) 1549bd2abef3SChuck Lever __field(int, status) 1550bd2abef3SChuck Lever ), 1551bd2abef3SChuck Lever 1552bd2abef3SChuck Lever TP_fast_assign( 1553bd2abef3SChuck Lever __entry->cqe = wr->wr_cqe; 1554bd2abef3SChuck Lever __entry->status = status; 1555bd2abef3SChuck Lever ), 1556bd2abef3SChuck Lever 1557bd2abef3SChuck Lever TP_printk("cqe=%p status=%d", 1558bd2abef3SChuck Lever __entry->cqe, __entry->status 1559bd2abef3SChuck Lever ) 1560bd2abef3SChuck Lever ); 1561bd2abef3SChuck Lever 1562bd2abef3SChuck Lever TRACE_EVENT(svcrdma_wc_receive, 1563bd2abef3SChuck Lever TP_PROTO( 1564bd2abef3SChuck Lever const struct ib_wc *wc 1565bd2abef3SChuck Lever ), 1566bd2abef3SChuck Lever 1567bd2abef3SChuck Lever TP_ARGS(wc), 1568bd2abef3SChuck Lever 1569bd2abef3SChuck Lever TP_STRUCT__entry( 1570bd2abef3SChuck Lever __field(const void *, cqe) 1571bd2abef3SChuck Lever __field(u32, byte_len) 1572bd2abef3SChuck Lever __field(unsigned int, status) 1573bd2abef3SChuck Lever __field(u32, vendor_err) 1574bd2abef3SChuck Lever ), 1575bd2abef3SChuck Lever 1576bd2abef3SChuck Lever TP_fast_assign( 1577bd2abef3SChuck Lever __entry->cqe = wc->wr_cqe; 1578bd2abef3SChuck Lever __entry->status = wc->status; 1579bd2abef3SChuck Lever if (wc->status) { 1580bd2abef3SChuck Lever __entry->byte_len = 0; 1581bd2abef3SChuck Lever __entry->vendor_err = wc->vendor_err; 1582bd2abef3SChuck Lever } else { 1583bd2abef3SChuck Lever __entry->byte_len = wc->byte_len; 1584bd2abef3SChuck Lever __entry->vendor_err = 0; 1585bd2abef3SChuck Lever } 1586bd2abef3SChuck Lever ), 1587bd2abef3SChuck Lever 1588bd2abef3SChuck Lever TP_printk("cqe=%p byte_len=%u status=%s (%u/0x%x)", 1589bd2abef3SChuck Lever __entry->cqe, __entry->byte_len, 1590bd2abef3SChuck Lever rdma_show_wc_status(__entry->status), 1591bd2abef3SChuck Lever __entry->status, __entry->vendor_err 1592bd2abef3SChuck Lever ) 1593bd2abef3SChuck Lever ); 1594bd2abef3SChuck Lever 1595bd2abef3SChuck Lever TRACE_EVENT(svcrdma_post_rw, 1596bd2abef3SChuck Lever TP_PROTO( 1597bd2abef3SChuck Lever const void *cqe, 1598bd2abef3SChuck Lever int sqecount, 1599bd2abef3SChuck Lever int status 1600bd2abef3SChuck Lever ), 1601bd2abef3SChuck Lever 1602bd2abef3SChuck Lever TP_ARGS(cqe, sqecount, status), 1603bd2abef3SChuck Lever 1604bd2abef3SChuck Lever TP_STRUCT__entry( 1605bd2abef3SChuck Lever __field(const void *, cqe) 1606bd2abef3SChuck Lever __field(int, sqecount) 1607bd2abef3SChuck Lever __field(int, status) 1608bd2abef3SChuck Lever ), 1609bd2abef3SChuck Lever 1610bd2abef3SChuck Lever TP_fast_assign( 1611bd2abef3SChuck Lever __entry->cqe = cqe; 1612bd2abef3SChuck Lever __entry->sqecount = sqecount; 1613bd2abef3SChuck Lever __entry->status = status; 1614bd2abef3SChuck Lever ), 1615bd2abef3SChuck Lever 1616bd2abef3SChuck Lever TP_printk("cqe=%p sqecount=%d status=%d", 1617bd2abef3SChuck Lever __entry->cqe, __entry->sqecount, __entry->status 1618bd2abef3SChuck Lever ) 1619bd2abef3SChuck Lever ); 1620bd2abef3SChuck Lever 1621bd2abef3SChuck Lever DEFINE_SENDCOMP_EVENT(read); 1622bd2abef3SChuck Lever DEFINE_SENDCOMP_EVENT(write); 1623bd2abef3SChuck Lever 1624bd2abef3SChuck Lever TRACE_EVENT(svcrdma_cm_event, 1625bd2abef3SChuck Lever TP_PROTO( 1626bd2abef3SChuck Lever const struct rdma_cm_event *event, 1627bd2abef3SChuck Lever const struct sockaddr *sap 1628bd2abef3SChuck Lever ), 1629bd2abef3SChuck Lever 1630bd2abef3SChuck Lever TP_ARGS(event, sap), 1631bd2abef3SChuck Lever 1632bd2abef3SChuck Lever TP_STRUCT__entry( 1633bd2abef3SChuck Lever __field(unsigned int, event) 1634bd2abef3SChuck Lever __field(int, status) 1635bd2abef3SChuck Lever __array(__u8, addr, INET6_ADDRSTRLEN + 10) 1636bd2abef3SChuck Lever ), 1637bd2abef3SChuck Lever 1638bd2abef3SChuck Lever TP_fast_assign( 1639bd2abef3SChuck Lever __entry->event = event->event; 1640bd2abef3SChuck Lever __entry->status = event->status; 1641bd2abef3SChuck Lever snprintf(__entry->addr, sizeof(__entry->addr) - 1, 1642bd2abef3SChuck Lever "%pISpc", sap); 1643bd2abef3SChuck Lever ), 1644bd2abef3SChuck Lever 1645bd2abef3SChuck Lever TP_printk("addr=%s event=%s (%u/%d)", 1646bd2abef3SChuck Lever __entry->addr, 1647bd2abef3SChuck Lever rdma_show_cm_event(__entry->event), 1648bd2abef3SChuck Lever __entry->event, __entry->status 1649bd2abef3SChuck Lever ) 1650bd2abef3SChuck Lever ); 1651bd2abef3SChuck Lever 1652bd2abef3SChuck Lever TRACE_EVENT(svcrdma_qp_error, 1653bd2abef3SChuck Lever TP_PROTO( 1654bd2abef3SChuck Lever const struct ib_event *event, 1655bd2abef3SChuck Lever const struct sockaddr *sap 1656bd2abef3SChuck Lever ), 1657bd2abef3SChuck Lever 1658bd2abef3SChuck Lever TP_ARGS(event, sap), 1659bd2abef3SChuck Lever 1660bd2abef3SChuck Lever TP_STRUCT__entry( 1661bd2abef3SChuck Lever __field(unsigned int, event) 1662bd2abef3SChuck Lever __string(device, event->device->name) 1663bd2abef3SChuck Lever __array(__u8, addr, INET6_ADDRSTRLEN + 10) 1664bd2abef3SChuck Lever ), 1665bd2abef3SChuck Lever 1666bd2abef3SChuck Lever TP_fast_assign( 1667bd2abef3SChuck Lever __entry->event = event->event; 1668bd2abef3SChuck Lever __assign_str(device, event->device->name); 1669bd2abef3SChuck Lever snprintf(__entry->addr, sizeof(__entry->addr) - 1, 1670bd2abef3SChuck Lever "%pISpc", sap); 1671bd2abef3SChuck Lever ), 1672bd2abef3SChuck Lever 1673bd2abef3SChuck Lever TP_printk("addr=%s dev=%s event=%s (%u)", 1674bd2abef3SChuck Lever __entry->addr, __get_str(device), 1675bd2abef3SChuck Lever rdma_show_ib_event(__entry->event), __entry->event 1676bd2abef3SChuck Lever ) 1677bd2abef3SChuck Lever ); 1678bd2abef3SChuck Lever 1679bd2abef3SChuck Lever DECLARE_EVENT_CLASS(svcrdma_sendqueue_event, 1680bd2abef3SChuck Lever TP_PROTO( 1681bd2abef3SChuck Lever const struct svcxprt_rdma *rdma 1682bd2abef3SChuck Lever ), 1683bd2abef3SChuck Lever 1684bd2abef3SChuck Lever TP_ARGS(rdma), 1685bd2abef3SChuck Lever 1686bd2abef3SChuck Lever TP_STRUCT__entry( 1687bd2abef3SChuck Lever __field(int, avail) 1688bd2abef3SChuck Lever __field(int, depth) 1689bd2abef3SChuck Lever __string(addr, rdma->sc_xprt.xpt_remotebuf) 1690bd2abef3SChuck Lever ), 1691bd2abef3SChuck Lever 1692bd2abef3SChuck Lever TP_fast_assign( 1693bd2abef3SChuck Lever __entry->avail = atomic_read(&rdma->sc_sq_avail); 1694bd2abef3SChuck Lever __entry->depth = rdma->sc_sq_depth; 1695bd2abef3SChuck Lever __assign_str(addr, rdma->sc_xprt.xpt_remotebuf); 1696bd2abef3SChuck Lever ), 1697bd2abef3SChuck Lever 1698bd2abef3SChuck Lever TP_printk("addr=%s sc_sq_avail=%d/%d", 1699bd2abef3SChuck Lever __get_str(addr), __entry->avail, __entry->depth 1700bd2abef3SChuck Lever ) 1701bd2abef3SChuck Lever ); 1702bd2abef3SChuck Lever 1703bd2abef3SChuck Lever #define DEFINE_SQ_EVENT(name) \ 1704bd2abef3SChuck Lever DEFINE_EVENT(svcrdma_sendqueue_event, svcrdma_sq_##name,\ 1705bd2abef3SChuck Lever TP_PROTO( \ 1706bd2abef3SChuck Lever const struct svcxprt_rdma *rdma \ 1707bd2abef3SChuck Lever ), \ 1708bd2abef3SChuck Lever TP_ARGS(rdma)) 1709bd2abef3SChuck Lever 1710bd2abef3SChuck Lever DEFINE_SQ_EVENT(full); 1711bd2abef3SChuck Lever DEFINE_SQ_EVENT(retry); 1712bd2abef3SChuck Lever 1713e48f083eSChuck Lever #endif /* _TRACE_RPCRDMA_H */ 1714e48f083eSChuck Lever 1715e48f083eSChuck Lever #include <trace/define_trace.h> 1716