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 13e48f083eSChuck Lever #include <linux/tracepoint.h> 14e48f083eSChuck Lever #include <trace/events/rdma.h> 15e48f083eSChuck Lever 16ab03eff5SChuck Lever /** 17b4a7f91cSChuck Lever ** Event classes 18b4a7f91cSChuck Lever **/ 19b4a7f91cSChuck Lever 20b4a7f91cSChuck Lever DECLARE_EVENT_CLASS(xprtrdma_reply_event, 21b4a7f91cSChuck Lever TP_PROTO( 22b4a7f91cSChuck Lever const struct rpcrdma_rep *rep 23b4a7f91cSChuck Lever ), 24b4a7f91cSChuck Lever 25b4a7f91cSChuck Lever TP_ARGS(rep), 26b4a7f91cSChuck Lever 27b4a7f91cSChuck Lever TP_STRUCT__entry( 28b4a7f91cSChuck Lever __field(const void *, rep) 29b4a7f91cSChuck Lever __field(const void *, r_xprt) 30b4a7f91cSChuck Lever __field(u32, xid) 31b4a7f91cSChuck Lever __field(u32, version) 32b4a7f91cSChuck Lever __field(u32, proc) 33b4a7f91cSChuck Lever ), 34b4a7f91cSChuck Lever 35b4a7f91cSChuck Lever TP_fast_assign( 36b4a7f91cSChuck Lever __entry->rep = rep; 37b4a7f91cSChuck Lever __entry->r_xprt = rep->rr_rxprt; 38b4a7f91cSChuck Lever __entry->xid = be32_to_cpu(rep->rr_xid); 39b4a7f91cSChuck Lever __entry->version = be32_to_cpu(rep->rr_vers); 40b4a7f91cSChuck Lever __entry->proc = be32_to_cpu(rep->rr_proc); 41b4a7f91cSChuck Lever ), 42b4a7f91cSChuck Lever 43b4a7f91cSChuck Lever TP_printk("rxprt %p xid=0x%08x rep=%p: version %u proc %u", 44b4a7f91cSChuck Lever __entry->r_xprt, __entry->xid, __entry->rep, 45b4a7f91cSChuck Lever __entry->version, __entry->proc 46b4a7f91cSChuck Lever ) 47b4a7f91cSChuck Lever ); 48b4a7f91cSChuck Lever 49b4a7f91cSChuck Lever #define DEFINE_REPLY_EVENT(name) \ 50b4a7f91cSChuck Lever DEFINE_EVENT(xprtrdma_reply_event, name, \ 51b4a7f91cSChuck Lever TP_PROTO( \ 52b4a7f91cSChuck Lever const struct rpcrdma_rep *rep \ 53b4a7f91cSChuck Lever ), \ 54b4a7f91cSChuck Lever TP_ARGS(rep)) 55b4a7f91cSChuck Lever 561c443effSChuck Lever DECLARE_EVENT_CLASS(xprtrdma_rxprt, 571c443effSChuck Lever TP_PROTO( 581c443effSChuck Lever const struct rpcrdma_xprt *r_xprt 591c443effSChuck Lever ), 601c443effSChuck Lever 611c443effSChuck Lever TP_ARGS(r_xprt), 621c443effSChuck Lever 631c443effSChuck Lever TP_STRUCT__entry( 641c443effSChuck Lever __field(const void *, r_xprt) 651c443effSChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 661c443effSChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 671c443effSChuck Lever ), 681c443effSChuck Lever 691c443effSChuck Lever TP_fast_assign( 701c443effSChuck Lever __entry->r_xprt = r_xprt; 711c443effSChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 721c443effSChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 731c443effSChuck Lever ), 741c443effSChuck Lever 751c443effSChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p", 761c443effSChuck Lever __get_str(addr), __get_str(port), __entry->r_xprt 771c443effSChuck Lever ) 781c443effSChuck Lever ); 791c443effSChuck Lever 801c443effSChuck Lever #define DEFINE_RXPRT_EVENT(name) \ 811c443effSChuck Lever DEFINE_EVENT(xprtrdma_rxprt, name, \ 821c443effSChuck Lever TP_PROTO( \ 831c443effSChuck Lever const struct rpcrdma_xprt *r_xprt \ 841c443effSChuck Lever ), \ 851c443effSChuck Lever TP_ARGS(r_xprt)) 861c443effSChuck Lever 8758f10ad4SChuck Lever DECLARE_EVENT_CLASS(xprtrdma_rdch_event, 8858f10ad4SChuck Lever TP_PROTO( 8958f10ad4SChuck Lever const struct rpc_task *task, 9058f10ad4SChuck Lever unsigned int pos, 9158f10ad4SChuck Lever struct rpcrdma_mr *mr, 9258f10ad4SChuck Lever int nsegs 9358f10ad4SChuck Lever ), 9458f10ad4SChuck Lever 9558f10ad4SChuck Lever TP_ARGS(task, pos, mr, nsegs), 9658f10ad4SChuck Lever 9758f10ad4SChuck Lever TP_STRUCT__entry( 9858f10ad4SChuck Lever __field(unsigned int, task_id) 9958f10ad4SChuck Lever __field(unsigned int, client_id) 10058f10ad4SChuck Lever __field(const void *, mr) 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->mr = mr; 11358f10ad4SChuck Lever __entry->pos = pos; 11458f10ad4SChuck Lever __entry->nents = mr->mr_nents; 11558f10ad4SChuck Lever __entry->handle = mr->mr_handle; 11658f10ad4SChuck Lever __entry->length = mr->mr_length; 11758f10ad4SChuck Lever __entry->offset = mr->mr_offset; 11858f10ad4SChuck Lever __entry->nsegs = nsegs; 11958f10ad4SChuck Lever ), 12058f10ad4SChuck Lever 12158f10ad4SChuck Lever TP_printk("task:%u@%u mr=%p pos=%u %u@0x%016llx:0x%08x (%s)", 12258f10ad4SChuck Lever __entry->task_id, __entry->client_id, __entry->mr, 12358f10ad4SChuck Lever __entry->pos, __entry->length, 12458f10ad4SChuck Lever (unsigned long long)__entry->offset, __entry->handle, 12558f10ad4SChuck Lever __entry->nents < __entry->nsegs ? "more" : "last" 12658f10ad4SChuck Lever ) 12758f10ad4SChuck Lever ); 12858f10ad4SChuck Lever 12958f10ad4SChuck Lever #define DEFINE_RDCH_EVENT(name) \ 13058f10ad4SChuck Lever DEFINE_EVENT(xprtrdma_rdch_event, name, \ 13158f10ad4SChuck Lever TP_PROTO( \ 13258f10ad4SChuck Lever const struct rpc_task *task, \ 13358f10ad4SChuck Lever unsigned int pos, \ 13458f10ad4SChuck Lever struct rpcrdma_mr *mr, \ 13558f10ad4SChuck Lever int nsegs \ 13658f10ad4SChuck Lever ), \ 13758f10ad4SChuck Lever TP_ARGS(task, pos, mr, nsegs)) 13858f10ad4SChuck Lever 13958f10ad4SChuck Lever DECLARE_EVENT_CLASS(xprtrdma_wrch_event, 14058f10ad4SChuck Lever TP_PROTO( 14158f10ad4SChuck Lever const struct rpc_task *task, 14258f10ad4SChuck Lever struct rpcrdma_mr *mr, 14358f10ad4SChuck Lever int nsegs 14458f10ad4SChuck Lever ), 14558f10ad4SChuck Lever 14658f10ad4SChuck Lever TP_ARGS(task, mr, nsegs), 14758f10ad4SChuck Lever 14858f10ad4SChuck Lever TP_STRUCT__entry( 14958f10ad4SChuck Lever __field(unsigned int, task_id) 15058f10ad4SChuck Lever __field(unsigned int, client_id) 15158f10ad4SChuck Lever __field(const void *, mr) 15258f10ad4SChuck Lever __field(int, nents) 15358f10ad4SChuck Lever __field(u32, handle) 15458f10ad4SChuck Lever __field(u32, length) 15558f10ad4SChuck Lever __field(u64, offset) 15658f10ad4SChuck Lever __field(int, nsegs) 15758f10ad4SChuck Lever ), 15858f10ad4SChuck Lever 15958f10ad4SChuck Lever TP_fast_assign( 16058f10ad4SChuck Lever __entry->task_id = task->tk_pid; 16158f10ad4SChuck Lever __entry->client_id = task->tk_client->cl_clid; 16258f10ad4SChuck Lever __entry->mr = mr; 16358f10ad4SChuck Lever __entry->nents = mr->mr_nents; 16458f10ad4SChuck Lever __entry->handle = mr->mr_handle; 16558f10ad4SChuck Lever __entry->length = mr->mr_length; 16658f10ad4SChuck Lever __entry->offset = mr->mr_offset; 16758f10ad4SChuck Lever __entry->nsegs = nsegs; 16858f10ad4SChuck Lever ), 16958f10ad4SChuck Lever 17058f10ad4SChuck Lever TP_printk("task:%u@%u mr=%p %u@0x%016llx:0x%08x (%s)", 17158f10ad4SChuck Lever __entry->task_id, __entry->client_id, __entry->mr, 17258f10ad4SChuck Lever __entry->length, (unsigned long long)__entry->offset, 17358f10ad4SChuck Lever __entry->handle, 17458f10ad4SChuck Lever __entry->nents < __entry->nsegs ? "more" : "last" 17558f10ad4SChuck Lever ) 17658f10ad4SChuck Lever ); 17758f10ad4SChuck Lever 17858f10ad4SChuck Lever #define DEFINE_WRCH_EVENT(name) \ 17958f10ad4SChuck Lever DEFINE_EVENT(xprtrdma_wrch_event, name, \ 18058f10ad4SChuck Lever TP_PROTO( \ 18158f10ad4SChuck Lever const struct rpc_task *task, \ 18258f10ad4SChuck Lever struct rpcrdma_mr *mr, \ 18358f10ad4SChuck Lever int nsegs \ 18458f10ad4SChuck Lever ), \ 18558f10ad4SChuck Lever TP_ARGS(task, mr, nsegs)) 18658f10ad4SChuck Lever 18758f10ad4SChuck Lever TRACE_DEFINE_ENUM(FRWR_IS_INVALID); 18858f10ad4SChuck Lever TRACE_DEFINE_ENUM(FRWR_IS_VALID); 18958f10ad4SChuck Lever TRACE_DEFINE_ENUM(FRWR_FLUSHED_FR); 19058f10ad4SChuck Lever TRACE_DEFINE_ENUM(FRWR_FLUSHED_LI); 19158f10ad4SChuck Lever 19258f10ad4SChuck Lever #define xprtrdma_show_frwr_state(x) \ 19358f10ad4SChuck Lever __print_symbolic(x, \ 19458f10ad4SChuck Lever { FRWR_IS_INVALID, "INVALID" }, \ 19558f10ad4SChuck Lever { FRWR_IS_VALID, "VALID" }, \ 19658f10ad4SChuck Lever { FRWR_FLUSHED_FR, "FLUSHED_FR" }, \ 19758f10ad4SChuck Lever { FRWR_FLUSHED_LI, "FLUSHED_LI" }) 19858f10ad4SChuck Lever 19958f10ad4SChuck Lever DECLARE_EVENT_CLASS(xprtrdma_frwr_done, 20058f10ad4SChuck Lever TP_PROTO( 20158f10ad4SChuck Lever const struct ib_wc *wc, 20258f10ad4SChuck Lever const struct rpcrdma_frwr *frwr 20358f10ad4SChuck Lever ), 20458f10ad4SChuck Lever 20558f10ad4SChuck Lever TP_ARGS(wc, frwr), 20658f10ad4SChuck Lever 20758f10ad4SChuck Lever TP_STRUCT__entry( 20858f10ad4SChuck Lever __field(const void *, mr) 20958f10ad4SChuck Lever __field(unsigned int, state) 21058f10ad4SChuck Lever __field(unsigned int, status) 21158f10ad4SChuck Lever __field(unsigned int, vendor_err) 21258f10ad4SChuck Lever ), 21358f10ad4SChuck Lever 21458f10ad4SChuck Lever TP_fast_assign( 21558f10ad4SChuck Lever __entry->mr = container_of(frwr, struct rpcrdma_mr, frwr); 21658f10ad4SChuck Lever __entry->state = frwr->fr_state; 21758f10ad4SChuck Lever __entry->status = wc->status; 21858f10ad4SChuck Lever __entry->vendor_err = __entry->status ? wc->vendor_err : 0; 21958f10ad4SChuck Lever ), 22058f10ad4SChuck Lever 22158f10ad4SChuck Lever TP_printk( 22258f10ad4SChuck Lever "mr=%p state=%s: %s (%u/0x%x)", 22358f10ad4SChuck Lever __entry->mr, xprtrdma_show_frwr_state(__entry->state), 22458f10ad4SChuck Lever rdma_show_wc_status(__entry->status), 22558f10ad4SChuck Lever __entry->status, __entry->vendor_err 22658f10ad4SChuck Lever ) 22758f10ad4SChuck Lever ); 22858f10ad4SChuck Lever 22958f10ad4SChuck Lever #define DEFINE_FRWR_DONE_EVENT(name) \ 23058f10ad4SChuck Lever DEFINE_EVENT(xprtrdma_frwr_done, name, \ 23158f10ad4SChuck Lever TP_PROTO( \ 23258f10ad4SChuck Lever const struct ib_wc *wc, \ 23358f10ad4SChuck Lever const struct rpcrdma_frwr *frwr \ 23458f10ad4SChuck Lever ), \ 23558f10ad4SChuck Lever TP_ARGS(wc, frwr)) 23658f10ad4SChuck Lever 2372937fedeSChuck Lever DECLARE_EVENT_CLASS(xprtrdma_mr, 2382937fedeSChuck Lever TP_PROTO( 2392937fedeSChuck Lever const struct rpcrdma_mr *mr 2402937fedeSChuck Lever ), 2412937fedeSChuck Lever 2422937fedeSChuck Lever TP_ARGS(mr), 2432937fedeSChuck Lever 2442937fedeSChuck Lever TP_STRUCT__entry( 2452937fedeSChuck Lever __field(const void *, mr) 2462937fedeSChuck Lever __field(u32, handle) 2472937fedeSChuck Lever __field(u32, length) 2482937fedeSChuck Lever __field(u64, offset) 2492937fedeSChuck Lever ), 2502937fedeSChuck Lever 2512937fedeSChuck Lever TP_fast_assign( 2522937fedeSChuck Lever __entry->mr = mr; 2532937fedeSChuck Lever __entry->handle = mr->mr_handle; 2542937fedeSChuck Lever __entry->length = mr->mr_length; 2552937fedeSChuck Lever __entry->offset = mr->mr_offset; 2562937fedeSChuck Lever ), 2572937fedeSChuck Lever 2582937fedeSChuck Lever TP_printk("mr=%p %u@0x%016llx:0x%08x", 2592937fedeSChuck Lever __entry->mr, __entry->length, 2602937fedeSChuck Lever (unsigned long long)__entry->offset, 2612937fedeSChuck Lever __entry->handle 2622937fedeSChuck Lever ) 2632937fedeSChuck Lever ); 2642937fedeSChuck Lever 2652937fedeSChuck Lever #define DEFINE_MR_EVENT(name) \ 266d379eaa8SChuck Lever DEFINE_EVENT(xprtrdma_mr, xprtrdma_mr_##name, \ 2672937fedeSChuck Lever TP_PROTO( \ 2682937fedeSChuck Lever const struct rpcrdma_mr *mr \ 2692937fedeSChuck Lever ), \ 2702937fedeSChuck Lever TP_ARGS(mr)) 2712937fedeSChuck Lever 272fc1eb807SChuck Lever DECLARE_EVENT_CLASS(xprtrdma_cb_event, 273fc1eb807SChuck Lever TP_PROTO( 274fc1eb807SChuck Lever const struct rpc_rqst *rqst 275fc1eb807SChuck Lever ), 276fc1eb807SChuck Lever 277fc1eb807SChuck Lever TP_ARGS(rqst), 278fc1eb807SChuck Lever 279fc1eb807SChuck Lever TP_STRUCT__entry( 280fc1eb807SChuck Lever __field(const void *, rqst) 281fc1eb807SChuck Lever __field(const void *, rep) 282fc1eb807SChuck Lever __field(const void *, req) 283fc1eb807SChuck Lever __field(u32, xid) 284fc1eb807SChuck Lever ), 285fc1eb807SChuck Lever 286fc1eb807SChuck Lever TP_fast_assign( 287fc1eb807SChuck Lever __entry->rqst = rqst; 288fc1eb807SChuck Lever __entry->req = rpcr_to_rdmar(rqst); 289fc1eb807SChuck Lever __entry->rep = rpcr_to_rdmar(rqst)->rl_reply; 290fc1eb807SChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 291fc1eb807SChuck Lever ), 292fc1eb807SChuck Lever 293fc1eb807SChuck Lever TP_printk("xid=0x%08x, rqst=%p req=%p rep=%p", 294fc1eb807SChuck Lever __entry->xid, __entry->rqst, __entry->req, __entry->rep 295fc1eb807SChuck Lever ) 296fc1eb807SChuck Lever ); 297fc1eb807SChuck Lever 298fc1eb807SChuck Lever #define DEFINE_CB_EVENT(name) \ 299fc1eb807SChuck Lever DEFINE_EVENT(xprtrdma_cb_event, name, \ 300fc1eb807SChuck Lever TP_PROTO( \ 301fc1eb807SChuck Lever const struct rpc_rqst *rqst \ 302fc1eb807SChuck Lever ), \ 303fc1eb807SChuck Lever TP_ARGS(rqst)) 304fc1eb807SChuck Lever 305b4a7f91cSChuck Lever /** 306b4744e00SChuck Lever ** Connection events 307b4744e00SChuck Lever **/ 308b4744e00SChuck Lever 309b4744e00SChuck Lever TRACE_EVENT(xprtrdma_conn_upcall, 310b4744e00SChuck Lever TP_PROTO( 311b4744e00SChuck Lever const struct rpcrdma_xprt *r_xprt, 312b4744e00SChuck Lever struct rdma_cm_event *event 313b4744e00SChuck Lever ), 314b4744e00SChuck Lever 315b4744e00SChuck Lever TP_ARGS(r_xprt, event), 316b4744e00SChuck Lever 317b4744e00SChuck Lever TP_STRUCT__entry( 318b4744e00SChuck Lever __field(const void *, r_xprt) 319b4744e00SChuck Lever __field(unsigned int, event) 320b4744e00SChuck Lever __field(int, status) 321b4744e00SChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 322b4744e00SChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 323b4744e00SChuck Lever ), 324b4744e00SChuck Lever 325b4744e00SChuck Lever TP_fast_assign( 326b4744e00SChuck Lever __entry->r_xprt = r_xprt; 327b4744e00SChuck Lever __entry->event = event->event; 328b4744e00SChuck Lever __entry->status = event->status; 329b4744e00SChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 330b4744e00SChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 331b4744e00SChuck Lever ), 332b4744e00SChuck Lever 333b4744e00SChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: %s (%u/%d)", 334b4744e00SChuck Lever __get_str(addr), __get_str(port), 335b4744e00SChuck Lever __entry->r_xprt, rdma_show_cm_event(__entry->event), 336b4744e00SChuck Lever __entry->event, __entry->status 337b4744e00SChuck Lever ) 338b4744e00SChuck Lever ); 339b4744e00SChuck Lever 340b4744e00SChuck Lever TRACE_EVENT(xprtrdma_disconnect, 341b4744e00SChuck Lever TP_PROTO( 342b4744e00SChuck Lever const struct rpcrdma_xprt *r_xprt, 343b4744e00SChuck Lever int status 344b4744e00SChuck Lever ), 345b4744e00SChuck Lever 346b4744e00SChuck Lever TP_ARGS(r_xprt, status), 347b4744e00SChuck Lever 348b4744e00SChuck Lever TP_STRUCT__entry( 349b4744e00SChuck Lever __field(const void *, r_xprt) 350b4744e00SChuck Lever __field(int, status) 351b4744e00SChuck Lever __field(int, connected) 352b4744e00SChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 353b4744e00SChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 354b4744e00SChuck Lever ), 355b4744e00SChuck Lever 356b4744e00SChuck Lever TP_fast_assign( 357b4744e00SChuck Lever __entry->r_xprt = r_xprt; 358b4744e00SChuck Lever __entry->status = status; 359b4744e00SChuck Lever __entry->connected = r_xprt->rx_ep.rep_connected; 360b4744e00SChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 361b4744e00SChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 362b4744e00SChuck Lever ), 363b4744e00SChuck Lever 364b4744e00SChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: status=%d %sconnected", 365b4744e00SChuck Lever __get_str(addr), __get_str(port), 366b4744e00SChuck Lever __entry->r_xprt, __entry->status, 367b4744e00SChuck Lever __entry->connected == 1 ? "still " : "dis" 368b4744e00SChuck Lever ) 369b4744e00SChuck Lever ); 370b4744e00SChuck Lever 371b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_conn_start); 372b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_conn_tout); 373b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_create); 374b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_destroy); 375b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_remove); 376b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_reinsert); 377b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_reconnect); 378b4744e00SChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_inject_dsc); 379b4744e00SChuck Lever 380643cf323SChuck Lever TRACE_EVENT(xprtrdma_qp_error, 381643cf323SChuck Lever TP_PROTO( 382643cf323SChuck Lever const struct rpcrdma_xprt *r_xprt, 383643cf323SChuck Lever const struct ib_event *event 384643cf323SChuck Lever ), 385643cf323SChuck Lever 386643cf323SChuck Lever TP_ARGS(r_xprt, event), 387643cf323SChuck Lever 388643cf323SChuck Lever TP_STRUCT__entry( 389643cf323SChuck Lever __field(const void *, r_xprt) 390643cf323SChuck Lever __field(unsigned int, event) 391643cf323SChuck Lever __string(name, event->device->name) 392643cf323SChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 393643cf323SChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 394643cf323SChuck Lever ), 395643cf323SChuck Lever 396643cf323SChuck Lever TP_fast_assign( 397643cf323SChuck Lever __entry->r_xprt = r_xprt; 398643cf323SChuck Lever __entry->event = event->event; 399643cf323SChuck Lever __assign_str(name, event->device->name); 400643cf323SChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 401643cf323SChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 402643cf323SChuck Lever ), 403643cf323SChuck Lever 404643cf323SChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: dev %s: %s (%u)", 405643cf323SChuck Lever __get_str(addr), __get_str(port), __entry->r_xprt, 406643cf323SChuck Lever __get_str(name), rdma_show_ib_event(__entry->event), 407643cf323SChuck Lever __entry->event 408643cf323SChuck Lever ) 409643cf323SChuck Lever ); 410643cf323SChuck Lever 411b4744e00SChuck Lever /** 412ab03eff5SChuck Lever ** Call events 413ab03eff5SChuck Lever **/ 414ab03eff5SChuck Lever 4151c443effSChuck Lever TRACE_EVENT(xprtrdma_createmrs, 4161c443effSChuck Lever TP_PROTO( 4171c443effSChuck Lever const struct rpcrdma_xprt *r_xprt, 4181c443effSChuck Lever unsigned int count 4191c443effSChuck Lever ), 4201c443effSChuck Lever 4211c443effSChuck Lever TP_ARGS(r_xprt, count), 4221c443effSChuck Lever 4231c443effSChuck Lever TP_STRUCT__entry( 4241c443effSChuck Lever __field(const void *, r_xprt) 4251c443effSChuck Lever __field(unsigned int, count) 4261c443effSChuck Lever ), 4271c443effSChuck Lever 4281c443effSChuck Lever TP_fast_assign( 4291c443effSChuck Lever __entry->r_xprt = r_xprt; 4301c443effSChuck Lever __entry->count = count; 4311c443effSChuck Lever ), 4321c443effSChuck Lever 4331c443effSChuck Lever TP_printk("r_xprt=%p: created %u MRs", 4341c443effSChuck Lever __entry->r_xprt, __entry->count 4351c443effSChuck Lever ) 4361c443effSChuck Lever ); 4371c443effSChuck Lever 4381c443effSChuck Lever DEFINE_RXPRT_EVENT(xprtrdma_nomrs); 4391c443effSChuck Lever 44058f10ad4SChuck Lever DEFINE_RDCH_EVENT(xprtrdma_read_chunk); 44158f10ad4SChuck Lever DEFINE_WRCH_EVENT(xprtrdma_write_chunk); 44258f10ad4SChuck Lever DEFINE_WRCH_EVENT(xprtrdma_reply_chunk); 44358f10ad4SChuck Lever 444ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_noch); 445ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_readch); 446ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_areadch); 447ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_writech); 448ab03eff5SChuck Lever TRACE_DEFINE_ENUM(rpcrdma_replych); 449ab03eff5SChuck Lever 450ab03eff5SChuck Lever #define xprtrdma_show_chunktype(x) \ 451ab03eff5SChuck Lever __print_symbolic(x, \ 452ab03eff5SChuck Lever { rpcrdma_noch, "inline" }, \ 453ab03eff5SChuck Lever { rpcrdma_readch, "read list" }, \ 454ab03eff5SChuck Lever { rpcrdma_areadch, "*read list" }, \ 455ab03eff5SChuck Lever { rpcrdma_writech, "write list" }, \ 456ab03eff5SChuck Lever { rpcrdma_replych, "reply chunk" }) 457ab03eff5SChuck Lever 458ab03eff5SChuck Lever TRACE_EVENT(xprtrdma_marshal, 459ab03eff5SChuck Lever TP_PROTO( 460ab03eff5SChuck Lever const struct rpc_rqst *rqst, 461ab03eff5SChuck Lever unsigned int hdrlen, 462ab03eff5SChuck Lever unsigned int rtype, 463ab03eff5SChuck Lever unsigned int wtype 464ab03eff5SChuck Lever ), 465ab03eff5SChuck Lever 466ab03eff5SChuck Lever TP_ARGS(rqst, hdrlen, rtype, wtype), 467ab03eff5SChuck Lever 468ab03eff5SChuck Lever TP_STRUCT__entry( 469ab03eff5SChuck Lever __field(unsigned int, task_id) 470ab03eff5SChuck Lever __field(unsigned int, client_id) 471ab03eff5SChuck Lever __field(u32, xid) 472ab03eff5SChuck Lever __field(unsigned int, hdrlen) 473ab03eff5SChuck Lever __field(unsigned int, headlen) 474ab03eff5SChuck Lever __field(unsigned int, pagelen) 475ab03eff5SChuck Lever __field(unsigned int, taillen) 476ab03eff5SChuck Lever __field(unsigned int, rtype) 477ab03eff5SChuck Lever __field(unsigned int, wtype) 478ab03eff5SChuck Lever ), 479ab03eff5SChuck Lever 480ab03eff5SChuck Lever TP_fast_assign( 481ab03eff5SChuck Lever __entry->task_id = rqst->rq_task->tk_pid; 482ab03eff5SChuck Lever __entry->client_id = rqst->rq_task->tk_client->cl_clid; 483ab03eff5SChuck Lever __entry->xid = be32_to_cpu(rqst->rq_xid); 484ab03eff5SChuck Lever __entry->hdrlen = hdrlen; 485ab03eff5SChuck Lever __entry->headlen = rqst->rq_snd_buf.head[0].iov_len; 486ab03eff5SChuck Lever __entry->pagelen = rqst->rq_snd_buf.page_len; 487ab03eff5SChuck Lever __entry->taillen = rqst->rq_snd_buf.tail[0].iov_len; 488ab03eff5SChuck Lever __entry->rtype = rtype; 489ab03eff5SChuck Lever __entry->wtype = wtype; 490ab03eff5SChuck Lever ), 491ab03eff5SChuck Lever 492ab03eff5SChuck Lever TP_printk("task:%u@%u xid=0x%08x: hdr=%u xdr=%u/%u/%u %s/%s", 493ab03eff5SChuck Lever __entry->task_id, __entry->client_id, __entry->xid, 494ab03eff5SChuck Lever __entry->hdrlen, 495ab03eff5SChuck Lever __entry->headlen, __entry->pagelen, __entry->taillen, 496ab03eff5SChuck Lever xprtrdma_show_chunktype(__entry->rtype), 497ab03eff5SChuck Lever xprtrdma_show_chunktype(__entry->wtype) 498ab03eff5SChuck Lever ) 499ab03eff5SChuck Lever ); 500ab03eff5SChuck Lever 501ab03eff5SChuck Lever TRACE_EVENT(xprtrdma_post_send, 502ab03eff5SChuck Lever TP_PROTO( 503ab03eff5SChuck Lever const struct rpcrdma_req *req, 504ab03eff5SChuck Lever int status 505ab03eff5SChuck Lever ), 506ab03eff5SChuck Lever 507ab03eff5SChuck Lever TP_ARGS(req, status), 508ab03eff5SChuck Lever 509ab03eff5SChuck Lever TP_STRUCT__entry( 510ab03eff5SChuck Lever __field(const void *, req) 511ab03eff5SChuck Lever __field(int, num_sge) 512ab03eff5SChuck Lever __field(bool, signaled) 513ab03eff5SChuck Lever __field(int, status) 514ab03eff5SChuck Lever ), 515ab03eff5SChuck Lever 516ab03eff5SChuck Lever TP_fast_assign( 517ab03eff5SChuck Lever __entry->req = req; 518ab03eff5SChuck Lever __entry->num_sge = req->rl_sendctx->sc_wr.num_sge; 519ab03eff5SChuck Lever __entry->signaled = req->rl_sendctx->sc_wr.send_flags & 520ab03eff5SChuck Lever IB_SEND_SIGNALED; 521ab03eff5SChuck Lever __entry->status = status; 522ab03eff5SChuck Lever ), 523ab03eff5SChuck Lever 524ab03eff5SChuck Lever TP_printk("req=%p, %d SGEs%s, status=%d", 525ab03eff5SChuck Lever __entry->req, __entry->num_sge, 526ab03eff5SChuck Lever (__entry->signaled ? ", signaled" : ""), 527ab03eff5SChuck Lever __entry->status 528ab03eff5SChuck Lever ) 529ab03eff5SChuck Lever ); 530ab03eff5SChuck Lever 531b4a7f91cSChuck Lever TRACE_EVENT(xprtrdma_post_recv, 532b4a7f91cSChuck Lever TP_PROTO( 5330e0b854cSChuck Lever const struct ib_cqe *cqe 534b4a7f91cSChuck Lever ), 535b4a7f91cSChuck Lever 5360e0b854cSChuck Lever TP_ARGS(cqe), 537b4a7f91cSChuck Lever 538b4a7f91cSChuck Lever TP_STRUCT__entry( 5390e0b854cSChuck Lever __field(const void *, cqe) 540b4a7f91cSChuck Lever ), 541b4a7f91cSChuck Lever 542b4a7f91cSChuck Lever TP_fast_assign( 5430e0b854cSChuck Lever __entry->cqe = cqe; 544b4a7f91cSChuck Lever ), 545b4a7f91cSChuck Lever 5460e0b854cSChuck Lever TP_printk("cqe=%p", 5470e0b854cSChuck Lever __entry->cqe 548b4a7f91cSChuck Lever ) 549b4a7f91cSChuck Lever ); 550b4a7f91cSChuck Lever 5517c8d9e7cSChuck Lever TRACE_EVENT(xprtrdma_post_recvs, 5527c8d9e7cSChuck Lever TP_PROTO( 5537c8d9e7cSChuck Lever const struct rpcrdma_xprt *r_xprt, 5547c8d9e7cSChuck Lever unsigned int count, 5557c8d9e7cSChuck Lever int status 5567c8d9e7cSChuck Lever ), 5577c8d9e7cSChuck Lever 5587c8d9e7cSChuck Lever TP_ARGS(r_xprt, count, status), 5597c8d9e7cSChuck Lever 5607c8d9e7cSChuck Lever TP_STRUCT__entry( 5617c8d9e7cSChuck Lever __field(const void *, r_xprt) 5627c8d9e7cSChuck Lever __field(unsigned int, count) 5637c8d9e7cSChuck Lever __field(int, status) 5647c8d9e7cSChuck Lever __field(int, posted) 5657c8d9e7cSChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 5667c8d9e7cSChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 5677c8d9e7cSChuck Lever ), 5687c8d9e7cSChuck Lever 5697c8d9e7cSChuck Lever TP_fast_assign( 5707c8d9e7cSChuck Lever __entry->r_xprt = r_xprt; 5717c8d9e7cSChuck Lever __entry->count = count; 5727c8d9e7cSChuck Lever __entry->status = status; 5737c8d9e7cSChuck Lever __entry->posted = r_xprt->rx_buf.rb_posted_receives; 5747c8d9e7cSChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 5757c8d9e7cSChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 5767c8d9e7cSChuck Lever ), 5777c8d9e7cSChuck Lever 5787c8d9e7cSChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: %u new recvs, %d active (rc %d)", 5797c8d9e7cSChuck Lever __get_str(addr), __get_str(port), __entry->r_xprt, 5807c8d9e7cSChuck Lever __entry->count, __entry->posted, __entry->status 581ab03eff5SChuck Lever ) 582ab03eff5SChuck Lever ); 583ab03eff5SChuck Lever 584ab03eff5SChuck Lever /** 585ab03eff5SChuck Lever ** Completion events 586ab03eff5SChuck Lever **/ 587ab03eff5SChuck Lever 588ab03eff5SChuck Lever TRACE_EVENT(xprtrdma_wc_send, 589ab03eff5SChuck Lever TP_PROTO( 590ab03eff5SChuck Lever const struct rpcrdma_sendctx *sc, 591ab03eff5SChuck Lever const struct ib_wc *wc 592ab03eff5SChuck Lever ), 593ab03eff5SChuck Lever 594ab03eff5SChuck Lever TP_ARGS(sc, wc), 595ab03eff5SChuck Lever 596ab03eff5SChuck Lever TP_STRUCT__entry( 597ab03eff5SChuck Lever __field(const void *, req) 598ab03eff5SChuck Lever __field(unsigned int, unmap_count) 599ab03eff5SChuck Lever __field(unsigned int, status) 600ab03eff5SChuck Lever __field(unsigned int, vendor_err) 601ab03eff5SChuck Lever ), 602ab03eff5SChuck Lever 603ab03eff5SChuck Lever TP_fast_assign( 604ab03eff5SChuck Lever __entry->req = sc->sc_req; 605ab03eff5SChuck Lever __entry->unmap_count = sc->sc_unmap_count; 606ab03eff5SChuck Lever __entry->status = wc->status; 607ab03eff5SChuck Lever __entry->vendor_err = __entry->status ? wc->vendor_err : 0; 608ab03eff5SChuck Lever ), 609ab03eff5SChuck Lever 610ab03eff5SChuck Lever TP_printk("req=%p, unmapped %u pages: %s (%u/0x%x)", 611ab03eff5SChuck Lever __entry->req, __entry->unmap_count, 612ab03eff5SChuck Lever rdma_show_wc_status(__entry->status), 613ab03eff5SChuck Lever __entry->status, __entry->vendor_err 614ab03eff5SChuck Lever ) 615ab03eff5SChuck Lever ); 616ab03eff5SChuck Lever 617b4a7f91cSChuck Lever TRACE_EVENT(xprtrdma_wc_receive, 618b4a7f91cSChuck Lever TP_PROTO( 619b4a7f91cSChuck Lever const struct ib_wc *wc 620b4a7f91cSChuck Lever ), 621b4a7f91cSChuck Lever 6220e0b854cSChuck Lever TP_ARGS(wc), 623b4a7f91cSChuck Lever 624b4a7f91cSChuck Lever TP_STRUCT__entry( 6250e0b854cSChuck Lever __field(const void *, cqe) 6260e0b854cSChuck Lever __field(u32, byte_len) 627b4a7f91cSChuck Lever __field(unsigned int, status) 6280e0b854cSChuck Lever __field(u32, vendor_err) 629b4a7f91cSChuck Lever ), 630b4a7f91cSChuck Lever 631b4a7f91cSChuck Lever TP_fast_assign( 6320e0b854cSChuck Lever __entry->cqe = wc->wr_cqe; 633b4a7f91cSChuck Lever __entry->status = wc->status; 6340e0b854cSChuck Lever if (wc->status) { 6350e0b854cSChuck Lever __entry->byte_len = 0; 6360e0b854cSChuck Lever __entry->vendor_err = wc->vendor_err; 6370e0b854cSChuck Lever } else { 6380e0b854cSChuck Lever __entry->byte_len = wc->byte_len; 6390e0b854cSChuck Lever __entry->vendor_err = 0; 6400e0b854cSChuck Lever } 641b4a7f91cSChuck Lever ), 642b4a7f91cSChuck Lever 6430e0b854cSChuck Lever TP_printk("cqe=%p %u bytes: %s (%u/0x%x)", 6440e0b854cSChuck Lever __entry->cqe, __entry->byte_len, 645b4a7f91cSChuck Lever rdma_show_wc_status(__entry->status), 646b4a7f91cSChuck Lever __entry->status, __entry->vendor_err 647b4a7f91cSChuck Lever ) 648b4a7f91cSChuck Lever ); 649b4a7f91cSChuck Lever 65058f10ad4SChuck Lever DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_fastreg); 6512937fedeSChuck Lever DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li); 6522937fedeSChuck Lever DEFINE_FRWR_DONE_EVENT(xprtrdma_wc_li_wake); 6532937fedeSChuck Lever 654d379eaa8SChuck Lever DEFINE_MR_EVENT(localinv); 655d379eaa8SChuck Lever DEFINE_MR_EVENT(map); 656d379eaa8SChuck Lever DEFINE_MR_EVENT(unmap); 657d379eaa8SChuck Lever DEFINE_MR_EVENT(remoteinv); 658d379eaa8SChuck Lever DEFINE_MR_EVENT(recycle); 65958f10ad4SChuck Lever 660b4a7f91cSChuck Lever /** 661b4a7f91cSChuck Lever ** Reply events 662b4a7f91cSChuck Lever **/ 663b4a7f91cSChuck Lever 664b4a7f91cSChuck Lever TRACE_EVENT(xprtrdma_reply, 665b4a7f91cSChuck Lever TP_PROTO( 666b4a7f91cSChuck Lever const struct rpc_task *task, 667b4a7f91cSChuck Lever const struct rpcrdma_rep *rep, 668b4a7f91cSChuck Lever const struct rpcrdma_req *req, 669b4a7f91cSChuck Lever unsigned int credits 670b4a7f91cSChuck Lever ), 671b4a7f91cSChuck Lever 672b4a7f91cSChuck Lever TP_ARGS(task, rep, req, credits), 673b4a7f91cSChuck Lever 674b4a7f91cSChuck Lever TP_STRUCT__entry( 675b4a7f91cSChuck Lever __field(unsigned int, task_id) 676b4a7f91cSChuck Lever __field(unsigned int, client_id) 677b4a7f91cSChuck Lever __field(const void *, rep) 678b4a7f91cSChuck Lever __field(const void *, req) 679b4a7f91cSChuck Lever __field(u32, xid) 680b4a7f91cSChuck Lever __field(unsigned int, credits) 681b4a7f91cSChuck Lever ), 682b4a7f91cSChuck Lever 683b4a7f91cSChuck Lever TP_fast_assign( 684b4a7f91cSChuck Lever __entry->task_id = task->tk_pid; 685b4a7f91cSChuck Lever __entry->client_id = task->tk_client->cl_clid; 686b4a7f91cSChuck Lever __entry->rep = rep; 687b4a7f91cSChuck Lever __entry->req = req; 688b4a7f91cSChuck Lever __entry->xid = be32_to_cpu(rep->rr_xid); 689b4a7f91cSChuck Lever __entry->credits = credits; 690b4a7f91cSChuck Lever ), 691b4a7f91cSChuck Lever 692b4a7f91cSChuck Lever TP_printk("task:%u@%u xid=0x%08x, %u credits, rep=%p -> req=%p", 693b4a7f91cSChuck Lever __entry->task_id, __entry->client_id, __entry->xid, 694b4a7f91cSChuck Lever __entry->credits, __entry->rep, __entry->req 695b4a7f91cSChuck Lever ) 696b4a7f91cSChuck Lever ); 697b4a7f91cSChuck Lever 698b4a7f91cSChuck Lever TRACE_EVENT(xprtrdma_defer_cmp, 699b4a7f91cSChuck Lever TP_PROTO( 700b4a7f91cSChuck Lever const struct rpcrdma_rep *rep 701b4a7f91cSChuck Lever ), 702b4a7f91cSChuck Lever 703b4a7f91cSChuck Lever TP_ARGS(rep), 704b4a7f91cSChuck Lever 705b4a7f91cSChuck Lever TP_STRUCT__entry( 706b4a7f91cSChuck Lever __field(unsigned int, task_id) 707b4a7f91cSChuck Lever __field(unsigned int, client_id) 708b4a7f91cSChuck Lever __field(const void *, rep) 709b4a7f91cSChuck Lever __field(u32, xid) 710b4a7f91cSChuck Lever ), 711b4a7f91cSChuck Lever 712b4a7f91cSChuck Lever TP_fast_assign( 713b4a7f91cSChuck Lever __entry->task_id = rep->rr_rqst->rq_task->tk_pid; 714b4a7f91cSChuck Lever __entry->client_id = rep->rr_rqst->rq_task->tk_client->cl_clid; 715b4a7f91cSChuck Lever __entry->rep = rep; 716b4a7f91cSChuck Lever __entry->xid = be32_to_cpu(rep->rr_xid); 717b4a7f91cSChuck Lever ), 718b4a7f91cSChuck Lever 719b4a7f91cSChuck Lever TP_printk("task:%u@%u xid=0x%08x rep=%p", 720b4a7f91cSChuck Lever __entry->task_id, __entry->client_id, __entry->xid, 721b4a7f91cSChuck Lever __entry->rep 722b4a7f91cSChuck Lever ) 723b4a7f91cSChuck Lever ); 724b4a7f91cSChuck Lever 725b4a7f91cSChuck Lever DEFINE_REPLY_EVENT(xprtrdma_reply_vers); 726b4a7f91cSChuck Lever DEFINE_REPLY_EVENT(xprtrdma_reply_rqst); 727b4a7f91cSChuck Lever DEFINE_REPLY_EVENT(xprtrdma_reply_short); 728b4a7f91cSChuck Lever DEFINE_REPLY_EVENT(xprtrdma_reply_hdr); 729b4a7f91cSChuck Lever 730e11b7c96SChuck Lever TRACE_EVENT(xprtrdma_fixup, 731e11b7c96SChuck Lever TP_PROTO( 732e11b7c96SChuck Lever const struct rpc_rqst *rqst, 733e11b7c96SChuck Lever int len, 734e11b7c96SChuck Lever int hdrlen 735e11b7c96SChuck Lever ), 736e11b7c96SChuck Lever 737e11b7c96SChuck Lever TP_ARGS(rqst, len, hdrlen), 738e11b7c96SChuck Lever 739e11b7c96SChuck Lever TP_STRUCT__entry( 740e11b7c96SChuck Lever __field(unsigned int, task_id) 741e11b7c96SChuck Lever __field(unsigned int, client_id) 742e11b7c96SChuck Lever __field(const void *, base) 743e11b7c96SChuck Lever __field(int, len) 744e11b7c96SChuck Lever __field(int, hdrlen) 745e11b7c96SChuck Lever ), 746e11b7c96SChuck Lever 747e11b7c96SChuck Lever TP_fast_assign( 748e11b7c96SChuck Lever __entry->task_id = rqst->rq_task->tk_pid; 749e11b7c96SChuck Lever __entry->client_id = rqst->rq_task->tk_client->cl_clid; 750e11b7c96SChuck Lever __entry->base = rqst->rq_rcv_buf.head[0].iov_base; 751e11b7c96SChuck Lever __entry->len = len; 752e11b7c96SChuck Lever __entry->hdrlen = hdrlen; 753e11b7c96SChuck Lever ), 754e11b7c96SChuck Lever 755e11b7c96SChuck Lever TP_printk("task:%u@%u base=%p len=%d hdrlen=%d", 756e11b7c96SChuck Lever __entry->task_id, __entry->client_id, 757e11b7c96SChuck Lever __entry->base, __entry->len, __entry->hdrlen 758e11b7c96SChuck Lever ) 759e11b7c96SChuck Lever ); 760e11b7c96SChuck Lever 761e11b7c96SChuck Lever TRACE_EVENT(xprtrdma_fixup_pg, 762e11b7c96SChuck Lever TP_PROTO( 763e11b7c96SChuck Lever const struct rpc_rqst *rqst, 764e11b7c96SChuck Lever int pageno, 765e11b7c96SChuck Lever const void *pos, 766e11b7c96SChuck Lever int len, 767e11b7c96SChuck Lever int curlen 768e11b7c96SChuck Lever ), 769e11b7c96SChuck Lever 770e11b7c96SChuck Lever TP_ARGS(rqst, pageno, pos, len, curlen), 771e11b7c96SChuck Lever 772e11b7c96SChuck Lever TP_STRUCT__entry( 773e11b7c96SChuck Lever __field(unsigned int, task_id) 774e11b7c96SChuck Lever __field(unsigned int, client_id) 775e11b7c96SChuck Lever __field(const void *, pos) 776e11b7c96SChuck Lever __field(int, pageno) 777e11b7c96SChuck Lever __field(int, len) 778e11b7c96SChuck Lever __field(int, curlen) 779e11b7c96SChuck Lever ), 780e11b7c96SChuck Lever 781e11b7c96SChuck Lever TP_fast_assign( 782e11b7c96SChuck Lever __entry->task_id = rqst->rq_task->tk_pid; 783e11b7c96SChuck Lever __entry->client_id = rqst->rq_task->tk_client->cl_clid; 784e11b7c96SChuck Lever __entry->pos = pos; 785e11b7c96SChuck Lever __entry->pageno = pageno; 786e11b7c96SChuck Lever __entry->len = len; 787e11b7c96SChuck Lever __entry->curlen = curlen; 788e11b7c96SChuck Lever ), 789e11b7c96SChuck Lever 790e11b7c96SChuck Lever TP_printk("task:%u@%u pageno=%d pos=%p len=%d curlen=%d", 791e11b7c96SChuck Lever __entry->task_id, __entry->client_id, 792e11b7c96SChuck Lever __entry->pageno, __entry->pos, __entry->len, __entry->curlen 793e11b7c96SChuck Lever ) 794e11b7c96SChuck Lever ); 795e11b7c96SChuck Lever 796e11b7c96SChuck Lever TRACE_EVENT(xprtrdma_decode_seg, 797e11b7c96SChuck Lever TP_PROTO( 798e11b7c96SChuck Lever u32 handle, 799e11b7c96SChuck Lever u32 length, 800e11b7c96SChuck Lever u64 offset 801e11b7c96SChuck Lever ), 802e11b7c96SChuck Lever 803e11b7c96SChuck Lever TP_ARGS(handle, length, offset), 804e11b7c96SChuck Lever 805e11b7c96SChuck Lever TP_STRUCT__entry( 806e11b7c96SChuck Lever __field(u32, handle) 807e11b7c96SChuck Lever __field(u32, length) 808e11b7c96SChuck Lever __field(u64, offset) 809e11b7c96SChuck Lever ), 810e11b7c96SChuck Lever 811e11b7c96SChuck Lever TP_fast_assign( 812e11b7c96SChuck Lever __entry->handle = handle; 813e11b7c96SChuck Lever __entry->length = length; 814e11b7c96SChuck Lever __entry->offset = offset; 815e11b7c96SChuck Lever ), 816e11b7c96SChuck Lever 817e11b7c96SChuck Lever TP_printk("%u@0x%016llx:0x%08x", 818e11b7c96SChuck Lever __entry->length, (unsigned long long)__entry->offset, 819e11b7c96SChuck Lever __entry->handle 820e11b7c96SChuck Lever ) 821e11b7c96SChuck Lever ); 822e11b7c96SChuck Lever 823fc1eb807SChuck Lever /** 824ae724676SChuck Lever ** Allocation/release of rpcrdma_reqs and rpcrdma_reps 825ae724676SChuck Lever **/ 826ae724676SChuck Lever 827ae724676SChuck Lever TRACE_EVENT(xprtrdma_allocate, 828ae724676SChuck Lever TP_PROTO( 829ae724676SChuck Lever const struct rpc_task *task, 830ae724676SChuck Lever const struct rpcrdma_req *req 831ae724676SChuck Lever ), 832ae724676SChuck Lever 833ae724676SChuck Lever TP_ARGS(task, req), 834ae724676SChuck Lever 835ae724676SChuck Lever TP_STRUCT__entry( 836ae724676SChuck Lever __field(unsigned int, task_id) 837ae724676SChuck Lever __field(unsigned int, client_id) 838ae724676SChuck Lever __field(const void *, req) 839ae724676SChuck Lever __field(size_t, callsize) 840ae724676SChuck Lever __field(size_t, rcvsize) 841ae724676SChuck Lever ), 842ae724676SChuck Lever 843ae724676SChuck Lever TP_fast_assign( 844ae724676SChuck Lever __entry->task_id = task->tk_pid; 845ae724676SChuck Lever __entry->client_id = task->tk_client->cl_clid; 846ae724676SChuck Lever __entry->req = req; 847ae724676SChuck Lever __entry->callsize = task->tk_rqstp->rq_callsize; 848ae724676SChuck Lever __entry->rcvsize = task->tk_rqstp->rq_rcvsize; 849ae724676SChuck Lever ), 850ae724676SChuck Lever 8517c8d9e7cSChuck Lever TP_printk("task:%u@%u req=%p (%zu, %zu)", 852ae724676SChuck Lever __entry->task_id, __entry->client_id, 8537c8d9e7cSChuck Lever __entry->req, __entry->callsize, __entry->rcvsize 854ae724676SChuck Lever ) 855ae724676SChuck Lever ); 856ae724676SChuck Lever 857ae724676SChuck Lever TRACE_EVENT(xprtrdma_rpc_done, 858ae724676SChuck Lever TP_PROTO( 859ae724676SChuck Lever const struct rpc_task *task, 860ae724676SChuck Lever const struct rpcrdma_req *req 861ae724676SChuck Lever ), 862ae724676SChuck Lever 863ae724676SChuck Lever TP_ARGS(task, req), 864ae724676SChuck Lever 865ae724676SChuck Lever TP_STRUCT__entry( 866ae724676SChuck Lever __field(unsigned int, task_id) 867ae724676SChuck Lever __field(unsigned int, client_id) 868ae724676SChuck Lever __field(const void *, req) 869ae724676SChuck Lever __field(const void *, rep) 870ae724676SChuck Lever ), 871ae724676SChuck Lever 872ae724676SChuck Lever TP_fast_assign( 873ae724676SChuck Lever __entry->task_id = task->tk_pid; 874ae724676SChuck Lever __entry->client_id = task->tk_client->cl_clid; 875ae724676SChuck Lever __entry->req = req; 876ae724676SChuck Lever __entry->rep = req->rl_reply; 877ae724676SChuck Lever ), 878ae724676SChuck Lever 879ae724676SChuck Lever TP_printk("task:%u@%u req=%p rep=%p", 880ae724676SChuck Lever __entry->task_id, __entry->client_id, 881ae724676SChuck Lever __entry->req, __entry->rep 882ae724676SChuck Lever ) 883ae724676SChuck Lever ); 884ae724676SChuck Lever 885ae724676SChuck Lever /** 886fc1eb807SChuck Lever ** Callback events 887fc1eb807SChuck Lever **/ 888fc1eb807SChuck Lever 889fc1eb807SChuck Lever TRACE_EVENT(xprtrdma_cb_setup, 890fc1eb807SChuck Lever TP_PROTO( 891fc1eb807SChuck Lever const struct rpcrdma_xprt *r_xprt, 892fc1eb807SChuck Lever unsigned int reqs 893fc1eb807SChuck Lever ), 894fc1eb807SChuck Lever 895fc1eb807SChuck Lever TP_ARGS(r_xprt, reqs), 896fc1eb807SChuck Lever 897fc1eb807SChuck Lever TP_STRUCT__entry( 898fc1eb807SChuck Lever __field(const void *, r_xprt) 899fc1eb807SChuck Lever __field(unsigned int, reqs) 900fc1eb807SChuck Lever __string(addr, rpcrdma_addrstr(r_xprt)) 901fc1eb807SChuck Lever __string(port, rpcrdma_portstr(r_xprt)) 902fc1eb807SChuck Lever ), 903fc1eb807SChuck Lever 904fc1eb807SChuck Lever TP_fast_assign( 905fc1eb807SChuck Lever __entry->r_xprt = r_xprt; 906fc1eb807SChuck Lever __entry->reqs = reqs; 907fc1eb807SChuck Lever __assign_str(addr, rpcrdma_addrstr(r_xprt)); 908fc1eb807SChuck Lever __assign_str(port, rpcrdma_portstr(r_xprt)); 909fc1eb807SChuck Lever ), 910fc1eb807SChuck Lever 911fc1eb807SChuck Lever TP_printk("peer=[%s]:%s r_xprt=%p: %u reqs", 912fc1eb807SChuck Lever __get_str(addr), __get_str(port), 913fc1eb807SChuck Lever __entry->r_xprt, __entry->reqs 914fc1eb807SChuck Lever ) 915fc1eb807SChuck Lever ); 916fc1eb807SChuck Lever 917fc1eb807SChuck Lever DEFINE_CB_EVENT(xprtrdma_cb_call); 918fc1eb807SChuck Lever DEFINE_CB_EVENT(xprtrdma_cb_reply); 919fc1eb807SChuck Lever 92098895edbSChuck Lever /** 92198895edbSChuck Lever ** Server-side RPC/RDMA events 92298895edbSChuck Lever **/ 92398895edbSChuck Lever 92498895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_xprt_event, 92598895edbSChuck Lever TP_PROTO( 92698895edbSChuck Lever const struct svc_xprt *xprt 92798895edbSChuck Lever ), 92898895edbSChuck Lever 92998895edbSChuck Lever TP_ARGS(xprt), 93098895edbSChuck Lever 93198895edbSChuck Lever TP_STRUCT__entry( 93298895edbSChuck Lever __field(const void *, xprt) 93398895edbSChuck Lever __string(addr, xprt->xpt_remotebuf) 93498895edbSChuck Lever ), 93598895edbSChuck Lever 93698895edbSChuck Lever TP_fast_assign( 93798895edbSChuck Lever __entry->xprt = xprt; 93898895edbSChuck Lever __assign_str(addr, xprt->xpt_remotebuf); 93998895edbSChuck Lever ), 94098895edbSChuck Lever 94198895edbSChuck Lever TP_printk("xprt=%p addr=%s", 94298895edbSChuck Lever __entry->xprt, __get_str(addr) 94398895edbSChuck Lever ) 94498895edbSChuck Lever ); 94598895edbSChuck Lever 94698895edbSChuck Lever #define DEFINE_XPRT_EVENT(name) \ 94798895edbSChuck Lever DEFINE_EVENT(svcrdma_xprt_event, svcrdma_xprt_##name, \ 94898895edbSChuck Lever TP_PROTO( \ 94998895edbSChuck Lever const struct svc_xprt *xprt \ 95098895edbSChuck Lever ), \ 95198895edbSChuck Lever TP_ARGS(xprt)) 95298895edbSChuck Lever 95398895edbSChuck Lever DEFINE_XPRT_EVENT(accept); 95498895edbSChuck Lever DEFINE_XPRT_EVENT(fail); 95598895edbSChuck Lever DEFINE_XPRT_EVENT(free); 95698895edbSChuck Lever 95798895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_MSG); 95898895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_NOMSG); 95998895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_MSGP); 96098895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_DONE); 96198895edbSChuck Lever TRACE_DEFINE_ENUM(RDMA_ERROR); 96298895edbSChuck Lever 96398895edbSChuck Lever #define show_rpcrdma_proc(x) \ 96498895edbSChuck Lever __print_symbolic(x, \ 96598895edbSChuck Lever { RDMA_MSG, "RDMA_MSG" }, \ 96698895edbSChuck Lever { RDMA_NOMSG, "RDMA_NOMSG" }, \ 96798895edbSChuck Lever { RDMA_MSGP, "RDMA_MSGP" }, \ 96898895edbSChuck Lever { RDMA_DONE, "RDMA_DONE" }, \ 96998895edbSChuck Lever { RDMA_ERROR, "RDMA_ERROR" }) 97098895edbSChuck Lever 97198895edbSChuck Lever TRACE_EVENT(svcrdma_decode_rqst, 97298895edbSChuck Lever TP_PROTO( 97398895edbSChuck Lever __be32 *p, 97498895edbSChuck Lever unsigned int hdrlen 97598895edbSChuck Lever ), 97698895edbSChuck Lever 97798895edbSChuck Lever TP_ARGS(p, hdrlen), 97898895edbSChuck Lever 97998895edbSChuck Lever TP_STRUCT__entry( 98098895edbSChuck Lever __field(u32, xid) 98198895edbSChuck Lever __field(u32, vers) 98298895edbSChuck Lever __field(u32, proc) 98398895edbSChuck Lever __field(u32, credits) 98498895edbSChuck Lever __field(unsigned int, hdrlen) 98598895edbSChuck Lever ), 98698895edbSChuck Lever 98798895edbSChuck Lever TP_fast_assign( 98898895edbSChuck Lever __entry->xid = be32_to_cpup(p++); 98998895edbSChuck Lever __entry->vers = be32_to_cpup(p++); 99098895edbSChuck Lever __entry->credits = be32_to_cpup(p++); 99198895edbSChuck Lever __entry->proc = be32_to_cpup(p); 99298895edbSChuck Lever __entry->hdrlen = hdrlen; 99398895edbSChuck Lever ), 99498895edbSChuck Lever 99598895edbSChuck Lever TP_printk("xid=0x%08x vers=%u credits=%u proc=%s hdrlen=%u", 99698895edbSChuck Lever __entry->xid, __entry->vers, __entry->credits, 99798895edbSChuck Lever show_rpcrdma_proc(__entry->proc), __entry->hdrlen) 99898895edbSChuck Lever ); 99998895edbSChuck Lever 100098895edbSChuck Lever TRACE_EVENT(svcrdma_decode_short, 100198895edbSChuck Lever TP_PROTO( 100298895edbSChuck Lever unsigned int hdrlen 100398895edbSChuck Lever ), 100498895edbSChuck Lever 100598895edbSChuck Lever TP_ARGS(hdrlen), 100698895edbSChuck Lever 100798895edbSChuck Lever TP_STRUCT__entry( 100898895edbSChuck Lever __field(unsigned int, hdrlen) 100998895edbSChuck Lever ), 101098895edbSChuck Lever 101198895edbSChuck Lever TP_fast_assign( 101298895edbSChuck Lever __entry->hdrlen = hdrlen; 101398895edbSChuck Lever ), 101498895edbSChuck Lever 101598895edbSChuck Lever TP_printk("hdrlen=%u", __entry->hdrlen) 101698895edbSChuck Lever ); 101798895edbSChuck Lever 101898895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_badreq_event, 101998895edbSChuck Lever TP_PROTO( 102098895edbSChuck Lever __be32 *p 102198895edbSChuck Lever ), 102298895edbSChuck Lever 102398895edbSChuck Lever TP_ARGS(p), 102498895edbSChuck Lever 102598895edbSChuck Lever TP_STRUCT__entry( 102698895edbSChuck Lever __field(u32, xid) 102798895edbSChuck Lever __field(u32, vers) 102898895edbSChuck Lever __field(u32, proc) 102998895edbSChuck Lever __field(u32, credits) 103098895edbSChuck Lever ), 103198895edbSChuck Lever 103298895edbSChuck Lever TP_fast_assign( 103398895edbSChuck Lever __entry->xid = be32_to_cpup(p++); 103498895edbSChuck Lever __entry->vers = be32_to_cpup(p++); 103598895edbSChuck Lever __entry->credits = be32_to_cpup(p++); 103698895edbSChuck Lever __entry->proc = be32_to_cpup(p); 103798895edbSChuck Lever ), 103898895edbSChuck Lever 103998895edbSChuck Lever TP_printk("xid=0x%08x vers=%u credits=%u proc=%u", 104098895edbSChuck Lever __entry->xid, __entry->vers, __entry->credits, __entry->proc) 104198895edbSChuck Lever ); 104298895edbSChuck Lever 104398895edbSChuck Lever #define DEFINE_BADREQ_EVENT(name) \ 104498895edbSChuck Lever DEFINE_EVENT(svcrdma_badreq_event, svcrdma_decode_##name,\ 104598895edbSChuck Lever TP_PROTO( \ 104698895edbSChuck Lever __be32 *p \ 104798895edbSChuck Lever ), \ 104898895edbSChuck Lever TP_ARGS(p)) 104998895edbSChuck Lever 105098895edbSChuck Lever DEFINE_BADREQ_EVENT(badvers); 105198895edbSChuck Lever DEFINE_BADREQ_EVENT(drop); 105298895edbSChuck Lever DEFINE_BADREQ_EVENT(badproc); 105398895edbSChuck Lever DEFINE_BADREQ_EVENT(parse); 105498895edbSChuck Lever 105598895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_segment_event, 105698895edbSChuck Lever TP_PROTO( 105798895edbSChuck Lever u32 handle, 105898895edbSChuck Lever u32 length, 105998895edbSChuck Lever u64 offset 106098895edbSChuck Lever ), 106198895edbSChuck Lever 106298895edbSChuck Lever TP_ARGS(handle, length, offset), 106398895edbSChuck Lever 106498895edbSChuck Lever TP_STRUCT__entry( 106598895edbSChuck Lever __field(u32, handle) 106698895edbSChuck Lever __field(u32, length) 106798895edbSChuck Lever __field(u64, offset) 106898895edbSChuck Lever ), 106998895edbSChuck Lever 107098895edbSChuck Lever TP_fast_assign( 107198895edbSChuck Lever __entry->handle = handle; 107298895edbSChuck Lever __entry->length = length; 107398895edbSChuck Lever __entry->offset = offset; 107498895edbSChuck Lever ), 107598895edbSChuck Lever 107698895edbSChuck Lever TP_printk("%u@0x%016llx:0x%08x", 107798895edbSChuck Lever __entry->length, (unsigned long long)__entry->offset, 107898895edbSChuck Lever __entry->handle 107998895edbSChuck Lever ) 108098895edbSChuck Lever ); 108198895edbSChuck Lever 108298895edbSChuck Lever #define DEFINE_SEGMENT_EVENT(name) \ 108398895edbSChuck Lever DEFINE_EVENT(svcrdma_segment_event, svcrdma_encode_##name,\ 108498895edbSChuck Lever TP_PROTO( \ 108598895edbSChuck Lever u32 handle, \ 108698895edbSChuck Lever u32 length, \ 108798895edbSChuck Lever u64 offset \ 108898895edbSChuck Lever ), \ 108998895edbSChuck Lever TP_ARGS(handle, length, offset)) 109098895edbSChuck Lever 109198895edbSChuck Lever DEFINE_SEGMENT_EVENT(rseg); 109298895edbSChuck Lever DEFINE_SEGMENT_EVENT(wseg); 109398895edbSChuck Lever 109498895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_chunk_event, 109598895edbSChuck Lever TP_PROTO( 109698895edbSChuck Lever u32 length 109798895edbSChuck Lever ), 109898895edbSChuck Lever 109998895edbSChuck Lever TP_ARGS(length), 110098895edbSChuck Lever 110198895edbSChuck Lever TP_STRUCT__entry( 110298895edbSChuck Lever __field(u32, length) 110398895edbSChuck Lever ), 110498895edbSChuck Lever 110598895edbSChuck Lever TP_fast_assign( 110698895edbSChuck Lever __entry->length = length; 110798895edbSChuck Lever ), 110898895edbSChuck Lever 110998895edbSChuck Lever TP_printk("length=%u", 111098895edbSChuck Lever __entry->length 111198895edbSChuck Lever ) 111298895edbSChuck Lever ); 111398895edbSChuck Lever 111498895edbSChuck Lever #define DEFINE_CHUNK_EVENT(name) \ 111598895edbSChuck Lever DEFINE_EVENT(svcrdma_chunk_event, svcrdma_encode_##name,\ 111698895edbSChuck Lever TP_PROTO( \ 111798895edbSChuck Lever u32 length \ 111898895edbSChuck Lever ), \ 111998895edbSChuck Lever TP_ARGS(length)) 112098895edbSChuck Lever 112198895edbSChuck Lever DEFINE_CHUNK_EVENT(pzr); 112298895edbSChuck Lever DEFINE_CHUNK_EVENT(write); 112398895edbSChuck Lever DEFINE_CHUNK_EVENT(reply); 112498895edbSChuck Lever 112598895edbSChuck Lever TRACE_EVENT(svcrdma_encode_read, 112698895edbSChuck Lever TP_PROTO( 112798895edbSChuck Lever u32 length, 112898895edbSChuck Lever u32 position 112998895edbSChuck Lever ), 113098895edbSChuck Lever 113198895edbSChuck Lever TP_ARGS(length, position), 113298895edbSChuck Lever 113398895edbSChuck Lever TP_STRUCT__entry( 113498895edbSChuck Lever __field(u32, length) 113598895edbSChuck Lever __field(u32, position) 113698895edbSChuck Lever ), 113798895edbSChuck Lever 113898895edbSChuck Lever TP_fast_assign( 113998895edbSChuck Lever __entry->length = length; 114098895edbSChuck Lever __entry->position = position; 114198895edbSChuck Lever ), 114298895edbSChuck Lever 114398895edbSChuck Lever TP_printk("length=%u position=%u", 114498895edbSChuck Lever __entry->length, __entry->position 114598895edbSChuck Lever ) 114698895edbSChuck Lever ); 114798895edbSChuck Lever 114898895edbSChuck Lever DECLARE_EVENT_CLASS(svcrdma_error_event, 114998895edbSChuck Lever TP_PROTO( 115098895edbSChuck Lever __be32 xid 115198895edbSChuck Lever ), 115298895edbSChuck Lever 115398895edbSChuck Lever TP_ARGS(xid), 115498895edbSChuck Lever 115598895edbSChuck Lever TP_STRUCT__entry( 115698895edbSChuck Lever __field(u32, xid) 115798895edbSChuck Lever ), 115898895edbSChuck Lever 115998895edbSChuck Lever TP_fast_assign( 116098895edbSChuck Lever __entry->xid = be32_to_cpu(xid); 116198895edbSChuck Lever ), 116298895edbSChuck Lever 116398895edbSChuck Lever TP_printk("xid=0x%08x", 116498895edbSChuck Lever __entry->xid 116598895edbSChuck Lever ) 116698895edbSChuck Lever ); 116798895edbSChuck Lever 116898895edbSChuck Lever #define DEFINE_ERROR_EVENT(name) \ 116998895edbSChuck Lever DEFINE_EVENT(svcrdma_error_event, svcrdma_err_##name, \ 117098895edbSChuck Lever TP_PROTO( \ 117198895edbSChuck Lever __be32 xid \ 117298895edbSChuck Lever ), \ 117398895edbSChuck Lever TP_ARGS(xid)) 117498895edbSChuck Lever 117598895edbSChuck Lever DEFINE_ERROR_EVENT(vers); 117698895edbSChuck Lever DEFINE_ERROR_EVENT(chunk); 117798895edbSChuck Lever 1178bd2abef3SChuck Lever /** 1179bd2abef3SChuck Lever ** Server-side RDMA API events 1180bd2abef3SChuck Lever **/ 1181bd2abef3SChuck Lever 1182bd2abef3SChuck Lever TRACE_EVENT(svcrdma_dma_map_page, 1183bd2abef3SChuck Lever TP_PROTO( 1184bd2abef3SChuck Lever const struct svcxprt_rdma *rdma, 1185bd2abef3SChuck Lever const void *page 1186bd2abef3SChuck Lever ), 1187bd2abef3SChuck Lever 1188bd2abef3SChuck Lever TP_ARGS(rdma, page), 1189bd2abef3SChuck Lever 1190bd2abef3SChuck Lever TP_STRUCT__entry( 1191bd2abef3SChuck Lever __field(const void *, page); 1192bd2abef3SChuck Lever __string(device, rdma->sc_cm_id->device->name) 1193bd2abef3SChuck Lever __string(addr, rdma->sc_xprt.xpt_remotebuf) 1194bd2abef3SChuck Lever ), 1195bd2abef3SChuck Lever 1196bd2abef3SChuck Lever TP_fast_assign( 1197bd2abef3SChuck Lever __entry->page = page; 1198bd2abef3SChuck Lever __assign_str(device, rdma->sc_cm_id->device->name); 1199bd2abef3SChuck Lever __assign_str(addr, rdma->sc_xprt.xpt_remotebuf); 1200bd2abef3SChuck Lever ), 1201bd2abef3SChuck Lever 1202bd2abef3SChuck Lever TP_printk("addr=%s device=%s page=%p", 1203bd2abef3SChuck Lever __get_str(addr), __get_str(device), __entry->page 1204bd2abef3SChuck Lever ) 1205bd2abef3SChuck Lever ); 1206bd2abef3SChuck Lever 1207bd2abef3SChuck Lever TRACE_EVENT(svcrdma_dma_map_rwctx, 1208bd2abef3SChuck Lever TP_PROTO( 1209bd2abef3SChuck Lever const struct svcxprt_rdma *rdma, 1210bd2abef3SChuck Lever int status 1211bd2abef3SChuck Lever ), 1212bd2abef3SChuck Lever 1213bd2abef3SChuck Lever TP_ARGS(rdma, status), 1214bd2abef3SChuck Lever 1215bd2abef3SChuck Lever TP_STRUCT__entry( 1216bd2abef3SChuck Lever __field(int, status) 1217bd2abef3SChuck Lever __string(device, rdma->sc_cm_id->device->name) 1218bd2abef3SChuck Lever __string(addr, rdma->sc_xprt.xpt_remotebuf) 1219bd2abef3SChuck Lever ), 1220bd2abef3SChuck Lever 1221bd2abef3SChuck Lever TP_fast_assign( 1222bd2abef3SChuck Lever __entry->status = status; 1223bd2abef3SChuck Lever __assign_str(device, rdma->sc_cm_id->device->name); 1224bd2abef3SChuck Lever __assign_str(addr, rdma->sc_xprt.xpt_remotebuf); 1225bd2abef3SChuck Lever ), 1226bd2abef3SChuck Lever 1227bd2abef3SChuck Lever TP_printk("addr=%s device=%s status=%d", 1228bd2abef3SChuck Lever __get_str(addr), __get_str(device), __entry->status 1229bd2abef3SChuck Lever ) 1230bd2abef3SChuck Lever ); 1231bd2abef3SChuck Lever 1232bd2abef3SChuck Lever TRACE_EVENT(svcrdma_send_failed, 1233bd2abef3SChuck Lever TP_PROTO( 1234bd2abef3SChuck Lever const struct svc_rqst *rqst, 1235bd2abef3SChuck Lever int status 1236bd2abef3SChuck Lever ), 1237bd2abef3SChuck Lever 1238bd2abef3SChuck Lever TP_ARGS(rqst, status), 1239bd2abef3SChuck Lever 1240bd2abef3SChuck Lever TP_STRUCT__entry( 1241bd2abef3SChuck Lever __field(int, status) 1242bd2abef3SChuck Lever __field(u32, xid) 1243bd2abef3SChuck Lever __field(const void *, xprt) 1244bd2abef3SChuck Lever __string(addr, rqst->rq_xprt->xpt_remotebuf) 1245bd2abef3SChuck Lever ), 1246bd2abef3SChuck Lever 1247bd2abef3SChuck Lever TP_fast_assign( 1248bd2abef3SChuck Lever __entry->status = status; 1249bd2abef3SChuck Lever __entry->xid = __be32_to_cpu(rqst->rq_xid); 1250bd2abef3SChuck Lever __entry->xprt = rqst->rq_xprt; 1251bd2abef3SChuck Lever __assign_str(addr, rqst->rq_xprt->xpt_remotebuf); 1252bd2abef3SChuck Lever ), 1253bd2abef3SChuck Lever 1254bd2abef3SChuck Lever TP_printk("xprt=%p addr=%s xid=0x%08x status=%d", 1255bd2abef3SChuck Lever __entry->xprt, __get_str(addr), 1256bd2abef3SChuck Lever __entry->xid, __entry->status 1257bd2abef3SChuck Lever ) 1258bd2abef3SChuck Lever ); 1259bd2abef3SChuck Lever 1260bd2abef3SChuck Lever DECLARE_EVENT_CLASS(svcrdma_sendcomp_event, 1261bd2abef3SChuck Lever TP_PROTO( 1262bd2abef3SChuck Lever const struct ib_wc *wc 1263bd2abef3SChuck Lever ), 1264bd2abef3SChuck Lever 1265bd2abef3SChuck Lever TP_ARGS(wc), 1266bd2abef3SChuck Lever 1267bd2abef3SChuck Lever TP_STRUCT__entry( 1268bd2abef3SChuck Lever __field(const void *, cqe) 1269bd2abef3SChuck Lever __field(unsigned int, status) 1270bd2abef3SChuck Lever __field(unsigned int, vendor_err) 1271bd2abef3SChuck Lever ), 1272bd2abef3SChuck Lever 1273bd2abef3SChuck Lever TP_fast_assign( 1274bd2abef3SChuck Lever __entry->cqe = wc->wr_cqe; 1275bd2abef3SChuck Lever __entry->status = wc->status; 1276bd2abef3SChuck Lever if (wc->status) 1277bd2abef3SChuck Lever __entry->vendor_err = wc->vendor_err; 1278bd2abef3SChuck Lever else 1279bd2abef3SChuck Lever __entry->vendor_err = 0; 1280bd2abef3SChuck Lever ), 1281bd2abef3SChuck Lever 1282bd2abef3SChuck Lever TP_printk("cqe=%p status=%s (%u/0x%x)", 1283bd2abef3SChuck Lever __entry->cqe, rdma_show_wc_status(__entry->status), 1284bd2abef3SChuck Lever __entry->status, __entry->vendor_err 1285bd2abef3SChuck Lever ) 1286bd2abef3SChuck Lever ); 1287bd2abef3SChuck Lever 1288bd2abef3SChuck Lever #define DEFINE_SENDCOMP_EVENT(name) \ 1289bd2abef3SChuck Lever DEFINE_EVENT(svcrdma_sendcomp_event, svcrdma_wc_##name, \ 1290bd2abef3SChuck Lever TP_PROTO( \ 1291bd2abef3SChuck Lever const struct ib_wc *wc \ 1292bd2abef3SChuck Lever ), \ 1293bd2abef3SChuck Lever TP_ARGS(wc)) 1294bd2abef3SChuck Lever 1295bd2abef3SChuck Lever TRACE_EVENT(svcrdma_post_send, 1296bd2abef3SChuck Lever TP_PROTO( 1297bd2abef3SChuck Lever const struct ib_send_wr *wr, 1298bd2abef3SChuck Lever int status 1299bd2abef3SChuck Lever ), 1300bd2abef3SChuck Lever 1301bd2abef3SChuck Lever TP_ARGS(wr, status), 1302bd2abef3SChuck Lever 1303bd2abef3SChuck Lever TP_STRUCT__entry( 1304bd2abef3SChuck Lever __field(const void *, cqe) 1305bd2abef3SChuck Lever __field(unsigned int, num_sge) 1306bd2abef3SChuck Lever __field(u32, inv_rkey) 1307bd2abef3SChuck Lever __field(int, status) 1308bd2abef3SChuck Lever ), 1309bd2abef3SChuck Lever 1310bd2abef3SChuck Lever TP_fast_assign( 1311bd2abef3SChuck Lever __entry->cqe = wr->wr_cqe; 1312bd2abef3SChuck Lever __entry->num_sge = wr->num_sge; 1313bd2abef3SChuck Lever __entry->inv_rkey = (wr->opcode == IB_WR_SEND_WITH_INV) ? 1314bd2abef3SChuck Lever wr->ex.invalidate_rkey : 0; 1315bd2abef3SChuck Lever __entry->status = status; 1316bd2abef3SChuck Lever ), 1317bd2abef3SChuck Lever 1318bd2abef3SChuck Lever TP_printk("cqe=%p num_sge=%u inv_rkey=0x%08x status=%d", 1319bd2abef3SChuck Lever __entry->cqe, __entry->num_sge, 1320bd2abef3SChuck Lever __entry->inv_rkey, __entry->status 1321bd2abef3SChuck Lever ) 1322bd2abef3SChuck Lever ); 1323bd2abef3SChuck Lever 1324bd2abef3SChuck Lever DEFINE_SENDCOMP_EVENT(send); 1325bd2abef3SChuck Lever 1326bd2abef3SChuck Lever TRACE_EVENT(svcrdma_post_recv, 1327bd2abef3SChuck Lever TP_PROTO( 1328bd2abef3SChuck Lever const struct ib_recv_wr *wr, 1329bd2abef3SChuck Lever int status 1330bd2abef3SChuck Lever ), 1331bd2abef3SChuck Lever 1332bd2abef3SChuck Lever TP_ARGS(wr, status), 1333bd2abef3SChuck Lever 1334bd2abef3SChuck Lever TP_STRUCT__entry( 1335bd2abef3SChuck Lever __field(const void *, cqe) 1336bd2abef3SChuck Lever __field(int, status) 1337bd2abef3SChuck Lever ), 1338bd2abef3SChuck Lever 1339bd2abef3SChuck Lever TP_fast_assign( 1340bd2abef3SChuck Lever __entry->cqe = wr->wr_cqe; 1341bd2abef3SChuck Lever __entry->status = status; 1342bd2abef3SChuck Lever ), 1343bd2abef3SChuck Lever 1344bd2abef3SChuck Lever TP_printk("cqe=%p status=%d", 1345bd2abef3SChuck Lever __entry->cqe, __entry->status 1346bd2abef3SChuck Lever ) 1347bd2abef3SChuck Lever ); 1348bd2abef3SChuck Lever 1349bd2abef3SChuck Lever TRACE_EVENT(svcrdma_wc_receive, 1350bd2abef3SChuck Lever TP_PROTO( 1351bd2abef3SChuck Lever const struct ib_wc *wc 1352bd2abef3SChuck Lever ), 1353bd2abef3SChuck Lever 1354bd2abef3SChuck Lever TP_ARGS(wc), 1355bd2abef3SChuck Lever 1356bd2abef3SChuck Lever TP_STRUCT__entry( 1357bd2abef3SChuck Lever __field(const void *, cqe) 1358bd2abef3SChuck Lever __field(u32, byte_len) 1359bd2abef3SChuck Lever __field(unsigned int, status) 1360bd2abef3SChuck Lever __field(u32, vendor_err) 1361bd2abef3SChuck Lever ), 1362bd2abef3SChuck Lever 1363bd2abef3SChuck Lever TP_fast_assign( 1364bd2abef3SChuck Lever __entry->cqe = wc->wr_cqe; 1365bd2abef3SChuck Lever __entry->status = wc->status; 1366bd2abef3SChuck Lever if (wc->status) { 1367bd2abef3SChuck Lever __entry->byte_len = 0; 1368bd2abef3SChuck Lever __entry->vendor_err = wc->vendor_err; 1369bd2abef3SChuck Lever } else { 1370bd2abef3SChuck Lever __entry->byte_len = wc->byte_len; 1371bd2abef3SChuck Lever __entry->vendor_err = 0; 1372bd2abef3SChuck Lever } 1373bd2abef3SChuck Lever ), 1374bd2abef3SChuck Lever 1375bd2abef3SChuck Lever TP_printk("cqe=%p byte_len=%u status=%s (%u/0x%x)", 1376bd2abef3SChuck Lever __entry->cqe, __entry->byte_len, 1377bd2abef3SChuck Lever rdma_show_wc_status(__entry->status), 1378bd2abef3SChuck Lever __entry->status, __entry->vendor_err 1379bd2abef3SChuck Lever ) 1380bd2abef3SChuck Lever ); 1381bd2abef3SChuck Lever 1382bd2abef3SChuck Lever TRACE_EVENT(svcrdma_post_rw, 1383bd2abef3SChuck Lever TP_PROTO( 1384bd2abef3SChuck Lever const void *cqe, 1385bd2abef3SChuck Lever int sqecount, 1386bd2abef3SChuck Lever int status 1387bd2abef3SChuck Lever ), 1388bd2abef3SChuck Lever 1389bd2abef3SChuck Lever TP_ARGS(cqe, sqecount, status), 1390bd2abef3SChuck Lever 1391bd2abef3SChuck Lever TP_STRUCT__entry( 1392bd2abef3SChuck Lever __field(const void *, cqe) 1393bd2abef3SChuck Lever __field(int, sqecount) 1394bd2abef3SChuck Lever __field(int, status) 1395bd2abef3SChuck Lever ), 1396bd2abef3SChuck Lever 1397bd2abef3SChuck Lever TP_fast_assign( 1398bd2abef3SChuck Lever __entry->cqe = cqe; 1399bd2abef3SChuck Lever __entry->sqecount = sqecount; 1400bd2abef3SChuck Lever __entry->status = status; 1401bd2abef3SChuck Lever ), 1402bd2abef3SChuck Lever 1403bd2abef3SChuck Lever TP_printk("cqe=%p sqecount=%d status=%d", 1404bd2abef3SChuck Lever __entry->cqe, __entry->sqecount, __entry->status 1405bd2abef3SChuck Lever ) 1406bd2abef3SChuck Lever ); 1407bd2abef3SChuck Lever 1408bd2abef3SChuck Lever DEFINE_SENDCOMP_EVENT(read); 1409bd2abef3SChuck Lever DEFINE_SENDCOMP_EVENT(write); 1410bd2abef3SChuck Lever 1411bd2abef3SChuck Lever TRACE_EVENT(svcrdma_cm_event, 1412bd2abef3SChuck Lever TP_PROTO( 1413bd2abef3SChuck Lever const struct rdma_cm_event *event, 1414bd2abef3SChuck Lever const struct sockaddr *sap 1415bd2abef3SChuck Lever ), 1416bd2abef3SChuck Lever 1417bd2abef3SChuck Lever TP_ARGS(event, sap), 1418bd2abef3SChuck Lever 1419bd2abef3SChuck Lever TP_STRUCT__entry( 1420bd2abef3SChuck Lever __field(unsigned int, event) 1421bd2abef3SChuck Lever __field(int, status) 1422bd2abef3SChuck Lever __array(__u8, addr, INET6_ADDRSTRLEN + 10) 1423bd2abef3SChuck Lever ), 1424bd2abef3SChuck Lever 1425bd2abef3SChuck Lever TP_fast_assign( 1426bd2abef3SChuck Lever __entry->event = event->event; 1427bd2abef3SChuck Lever __entry->status = event->status; 1428bd2abef3SChuck Lever snprintf(__entry->addr, sizeof(__entry->addr) - 1, 1429bd2abef3SChuck Lever "%pISpc", sap); 1430bd2abef3SChuck Lever ), 1431bd2abef3SChuck Lever 1432bd2abef3SChuck Lever TP_printk("addr=%s event=%s (%u/%d)", 1433bd2abef3SChuck Lever __entry->addr, 1434bd2abef3SChuck Lever rdma_show_cm_event(__entry->event), 1435bd2abef3SChuck Lever __entry->event, __entry->status 1436bd2abef3SChuck Lever ) 1437bd2abef3SChuck Lever ); 1438bd2abef3SChuck Lever 1439bd2abef3SChuck Lever TRACE_EVENT(svcrdma_qp_error, 1440bd2abef3SChuck Lever TP_PROTO( 1441bd2abef3SChuck Lever const struct ib_event *event, 1442bd2abef3SChuck Lever const struct sockaddr *sap 1443bd2abef3SChuck Lever ), 1444bd2abef3SChuck Lever 1445bd2abef3SChuck Lever TP_ARGS(event, sap), 1446bd2abef3SChuck Lever 1447bd2abef3SChuck Lever TP_STRUCT__entry( 1448bd2abef3SChuck Lever __field(unsigned int, event) 1449bd2abef3SChuck Lever __string(device, event->device->name) 1450bd2abef3SChuck Lever __array(__u8, addr, INET6_ADDRSTRLEN + 10) 1451bd2abef3SChuck Lever ), 1452bd2abef3SChuck Lever 1453bd2abef3SChuck Lever TP_fast_assign( 1454bd2abef3SChuck Lever __entry->event = event->event; 1455bd2abef3SChuck Lever __assign_str(device, event->device->name); 1456bd2abef3SChuck Lever snprintf(__entry->addr, sizeof(__entry->addr) - 1, 1457bd2abef3SChuck Lever "%pISpc", sap); 1458bd2abef3SChuck Lever ), 1459bd2abef3SChuck Lever 1460bd2abef3SChuck Lever TP_printk("addr=%s dev=%s event=%s (%u)", 1461bd2abef3SChuck Lever __entry->addr, __get_str(device), 1462bd2abef3SChuck Lever rdma_show_ib_event(__entry->event), __entry->event 1463bd2abef3SChuck Lever ) 1464bd2abef3SChuck Lever ); 1465bd2abef3SChuck Lever 1466bd2abef3SChuck Lever DECLARE_EVENT_CLASS(svcrdma_sendqueue_event, 1467bd2abef3SChuck Lever TP_PROTO( 1468bd2abef3SChuck Lever const struct svcxprt_rdma *rdma 1469bd2abef3SChuck Lever ), 1470bd2abef3SChuck Lever 1471bd2abef3SChuck Lever TP_ARGS(rdma), 1472bd2abef3SChuck Lever 1473bd2abef3SChuck Lever TP_STRUCT__entry( 1474bd2abef3SChuck Lever __field(int, avail) 1475bd2abef3SChuck Lever __field(int, depth) 1476bd2abef3SChuck Lever __string(addr, rdma->sc_xprt.xpt_remotebuf) 1477bd2abef3SChuck Lever ), 1478bd2abef3SChuck Lever 1479bd2abef3SChuck Lever TP_fast_assign( 1480bd2abef3SChuck Lever __entry->avail = atomic_read(&rdma->sc_sq_avail); 1481bd2abef3SChuck Lever __entry->depth = rdma->sc_sq_depth; 1482bd2abef3SChuck Lever __assign_str(addr, rdma->sc_xprt.xpt_remotebuf); 1483bd2abef3SChuck Lever ), 1484bd2abef3SChuck Lever 1485bd2abef3SChuck Lever TP_printk("addr=%s sc_sq_avail=%d/%d", 1486bd2abef3SChuck Lever __get_str(addr), __entry->avail, __entry->depth 1487bd2abef3SChuck Lever ) 1488bd2abef3SChuck Lever ); 1489bd2abef3SChuck Lever 1490bd2abef3SChuck Lever #define DEFINE_SQ_EVENT(name) \ 1491bd2abef3SChuck Lever DEFINE_EVENT(svcrdma_sendqueue_event, svcrdma_sq_##name,\ 1492bd2abef3SChuck Lever TP_PROTO( \ 1493bd2abef3SChuck Lever const struct svcxprt_rdma *rdma \ 1494bd2abef3SChuck Lever ), \ 1495bd2abef3SChuck Lever TP_ARGS(rdma)) 1496bd2abef3SChuck Lever 1497bd2abef3SChuck Lever DEFINE_SQ_EVENT(full); 1498bd2abef3SChuck Lever DEFINE_SQ_EVENT(retry); 1499bd2abef3SChuck Lever 1500e48f083eSChuck Lever #endif /* _TRACE_RPCRDMA_H */ 1501e48f083eSChuck Lever 1502e48f083eSChuck Lever #include <trace/define_trace.h> 1503