Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) */
0002 /*
0003  * Copyright(c) 2018 Intel Corporation.
0004  *
0005  */
0006 #if !defined(__HFI1_TRACE_TID_H) || defined(TRACE_HEADER_MULTI_READ)
0007 #define __HFI1_TRACE_TID_H
0008 
0009 #include <linux/tracepoint.h>
0010 #include <linux/trace_seq.h>
0011 
0012 #include "hfi.h"
0013 
0014 #define tidtype_name(type) { PT_##type, #type }
0015 #define show_tidtype(type)                   \
0016 __print_symbolic(type,                       \
0017     tidtype_name(EXPECTED),              \
0018     tidtype_name(EAGER),                 \
0019     tidtype_name(INVALID))               \
0020 
0021 #undef TRACE_SYSTEM
0022 #define TRACE_SYSTEM hfi1_tid
0023 
0024 u8 hfi1_trace_get_tid_ctrl(u32 ent);
0025 u16 hfi1_trace_get_tid_len(u32 ent);
0026 u16 hfi1_trace_get_tid_idx(u32 ent);
0027 
0028 #define OPFN_PARAM_PRN "[%s] qpn 0x%x %s OPFN: qp 0x%x, max read %u, " \
0029                "max write %u, max length %u, jkey 0x%x timeout %u " \
0030                "urg %u"
0031 
0032 #define TID_FLOW_PRN "[%s] qpn 0x%x flow %d: idx %d resp_ib_psn 0x%x " \
0033              "generation 0x%x fpsn 0x%x-%x r_next_psn 0x%x " \
0034              "ib_psn 0x%x-%x npagesets %u tnode_cnt %u " \
0035              "tidcnt %u tid_idx %u tid_offset %u length %u sent %u"
0036 
0037 #define TID_NODE_PRN "[%s] qpn 0x%x  %s idx %u grp base 0x%x map 0x%x " \
0038              "used %u cnt %u"
0039 
0040 #define RSP_INFO_PRN "[%s] qpn 0x%x state 0x%x s_state 0x%x psn 0x%x " \
0041              "r_psn 0x%x r_state 0x%x r_flags 0x%x " \
0042              "r_head_ack_queue %u s_tail_ack_queue %u " \
0043              "s_acked_ack_queue %u s_ack_state 0x%x " \
0044              "s_nak_state 0x%x s_flags 0x%x ps_flags 0x%x " \
0045              "iow_flags 0x%lx"
0046 
0047 #define SENDER_INFO_PRN "[%s] qpn 0x%x state 0x%x s_cur %u s_tail %u " \
0048             "s_head %u s_acked %u s_last %u s_psn 0x%x " \
0049             "s_last_psn 0x%x s_flags 0x%x ps_flags 0x%x " \
0050             "iow_flags 0x%lx s_state 0x%x s_num_rd %u s_retry %u"
0051 
0052 #define TID_READ_SENDER_PRN "[%s] qpn 0x%x newreq %u tid_r_reqs %u " \
0053                 "tid_r_comp %u pending_tid_r_segs %u " \
0054                 "s_flags 0x%x ps_flags 0x%x iow_flags 0x%lx " \
0055                 "s_state 0x%x hw_flow_index %u generation 0x%x " \
0056                 "fpsn 0x%x"
0057 
0058 #define TID_REQ_PRN "[%s] qpn 0x%x newreq %u opcode 0x%x psn 0x%x lpsn 0x%x " \
0059             "cur_seg %u comp_seg %u ack_seg %u alloc_seg %u " \
0060             "total_segs %u setup_head %u clear_tail %u flow_idx %u " \
0061             "acked_tail %u state %u r_ack_psn 0x%x r_flow_psn 0x%x " \
0062             "r_last_ackd 0x%x s_next_psn 0x%x"
0063 
0064 #define RCV_ERR_PRN "[%s] qpn 0x%x s_flags 0x%x state 0x%x " \
0065             "s_acked_ack_queue %u s_tail_ack_queue %u " \
0066             "r_head_ack_queue %u opcode 0x%x psn 0x%x r_psn 0x%x " \
0067             " diff %d"
0068 
0069 #define TID_WRITE_RSPDR_PRN "[%s] qpn 0x%x r_tid_head %u r_tid_tail %u " \
0070                 "r_tid_ack %u r_tid_alloc %u alloc_w_segs %u " \
0071                 "pending_tid_w_segs %u sync_pt %s " \
0072                 "ps_nak_psn 0x%x ps_nak_state 0x%x " \
0073                 "prnr_nak_state 0x%x hw_flow_index %u generation "\
0074                 "0x%x fpsn 0x%x resync %s" \
0075                 "r_next_psn_kdeth 0x%x"
0076 
0077 #define TID_WRITE_SENDER_PRN "[%s] qpn 0x%x newreq %u s_tid_cur %u " \
0078                  "s_tid_tail %u s_tid_head %u " \
0079                  "pending_tid_w_resp %u n_requests %u " \
0080                  "n_tid_requests %u s_flags 0x%x ps_flags 0x%x "\
0081                  "iow_flags 0x%lx s_state 0x%x s_retry %u"
0082 
0083 #define KDETH_EFLAGS_ERR_PRN "[%s] qpn 0x%x  TID ERR: RcvType 0x%x " \
0084                  "RcvTypeError 0x%x PSN 0x%x"
0085 
0086 DECLARE_EVENT_CLASS(/* class */
0087     hfi1_exp_tid_reg_unreg,
0088     TP_PROTO(unsigned int ctxt, u16 subctxt, u32 rarr, u32 npages,
0089          unsigned long va, unsigned long pa, dma_addr_t dma),
0090     TP_ARGS(ctxt, subctxt, rarr, npages, va, pa, dma),
0091     TP_STRUCT__entry(/* entry */
0092         __field(unsigned int, ctxt)
0093         __field(u16, subctxt)
0094         __field(u32, rarr)
0095         __field(u32, npages)
0096         __field(unsigned long, va)
0097         __field(unsigned long, pa)
0098         __field(dma_addr_t, dma)
0099     ),
0100     TP_fast_assign(/* assign */
0101         __entry->ctxt = ctxt;
0102         __entry->subctxt = subctxt;
0103         __entry->rarr = rarr;
0104         __entry->npages = npages;
0105         __entry->va = va;
0106         __entry->pa = pa;
0107         __entry->dma = dma;
0108     ),
0109     TP_printk("[%u:%u] entry:%u, %u pages @ 0x%lx, va:0x%lx dma:0x%llx",
0110           __entry->ctxt,
0111           __entry->subctxt,
0112           __entry->rarr,
0113           __entry->npages,
0114           __entry->pa,
0115           __entry->va,
0116           __entry->dma
0117     )
0118 );
0119 
0120 DEFINE_EVENT(/* exp_tid_unreg */
0121     hfi1_exp_tid_reg_unreg, hfi1_exp_tid_unreg,
0122     TP_PROTO(unsigned int ctxt, u16 subctxt, u32 rarr, u32 npages,
0123          unsigned long va, unsigned long pa, dma_addr_t dma),
0124     TP_ARGS(ctxt, subctxt, rarr, npages, va, pa, dma)
0125 );
0126 
0127 DEFINE_EVENT(/* exp_tid_reg */
0128     hfi1_exp_tid_reg_unreg, hfi1_exp_tid_reg,
0129     TP_PROTO(unsigned int ctxt, u16 subctxt, u32 rarr, u32 npages,
0130          unsigned long va, unsigned long pa, dma_addr_t dma),
0131     TP_ARGS(ctxt, subctxt, rarr, npages, va, pa, dma)
0132 );
0133 
0134 TRACE_EVENT(/* put_tid */
0135     hfi1_put_tid,
0136     TP_PROTO(struct hfi1_devdata *dd,
0137          u32 index, u32 type, unsigned long pa, u16 order),
0138     TP_ARGS(dd, index, type, pa, order),
0139     TP_STRUCT__entry(/* entry */
0140         DD_DEV_ENTRY(dd)
0141         __field(unsigned long, pa)
0142         __field(u32, index)
0143         __field(u32, type)
0144         __field(u16, order)
0145     ),
0146     TP_fast_assign(/* assign */
0147         DD_DEV_ASSIGN(dd);
0148         __entry->pa = pa;
0149         __entry->index = index;
0150         __entry->type = type;
0151         __entry->order = order;
0152     ),
0153     TP_printk("[%s] type %s pa %lx index %u order %u",
0154           __get_str(dev),
0155           show_tidtype(__entry->type),
0156           __entry->pa,
0157           __entry->index,
0158           __entry->order
0159     )
0160 );
0161 
0162 TRACE_EVENT(/* exp_tid_inval */
0163     hfi1_exp_tid_inval,
0164     TP_PROTO(unsigned int ctxt, u16 subctxt, unsigned long va, u32 rarr,
0165          u32 npages, dma_addr_t dma),
0166     TP_ARGS(ctxt, subctxt, va, rarr, npages, dma),
0167     TP_STRUCT__entry(/* entry */
0168         __field(unsigned int, ctxt)
0169         __field(u16, subctxt)
0170         __field(unsigned long, va)
0171         __field(u32, rarr)
0172         __field(u32, npages)
0173         __field(dma_addr_t, dma)
0174     ),
0175     TP_fast_assign(/* assign */
0176         __entry->ctxt = ctxt;
0177         __entry->subctxt = subctxt;
0178         __entry->va = va;
0179         __entry->rarr = rarr;
0180         __entry->npages = npages;
0181         __entry->dma = dma;
0182     ),
0183     TP_printk("[%u:%u] entry:%u, %u pages @ 0x%lx dma: 0x%llx",
0184           __entry->ctxt,
0185           __entry->subctxt,
0186           __entry->rarr,
0187           __entry->npages,
0188           __entry->va,
0189           __entry->dma
0190     )
0191 );
0192 
0193 DECLARE_EVENT_CLASS(/* opfn_state */
0194     hfi1_opfn_state_template,
0195     TP_PROTO(struct rvt_qp *qp),
0196     TP_ARGS(qp),
0197     TP_STRUCT__entry(/* entry */
0198         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0199         __field(u32, qpn)
0200         __field(u16, requested)
0201         __field(u16, completed)
0202         __field(u8, curr)
0203     ),
0204     TP_fast_assign(/* assign */
0205         struct hfi1_qp_priv *priv = qp->priv;
0206 
0207         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0208         __entry->qpn = qp->ibqp.qp_num;
0209         __entry->requested = priv->opfn.requested;
0210         __entry->completed = priv->opfn.completed;
0211         __entry->curr = priv->opfn.curr;
0212     ),
0213     TP_printk(/* print */
0214         "[%s] qpn 0x%x requested 0x%x completed 0x%x curr 0x%x",
0215         __get_str(dev),
0216         __entry->qpn,
0217         __entry->requested,
0218         __entry->completed,
0219         __entry->curr
0220     )
0221 );
0222 
0223 DEFINE_EVENT(/* event */
0224     hfi1_opfn_state_template, hfi1_opfn_state_conn_request,
0225     TP_PROTO(struct rvt_qp *qp),
0226     TP_ARGS(qp)
0227 );
0228 
0229 DEFINE_EVENT(/* event */
0230     hfi1_opfn_state_template, hfi1_opfn_state_sched_conn_request,
0231     TP_PROTO(struct rvt_qp *qp),
0232     TP_ARGS(qp)
0233 );
0234 
0235 DEFINE_EVENT(/* event */
0236     hfi1_opfn_state_template, hfi1_opfn_state_conn_response,
0237     TP_PROTO(struct rvt_qp *qp),
0238     TP_ARGS(qp)
0239 );
0240 
0241 DEFINE_EVENT(/* event */
0242     hfi1_opfn_state_template, hfi1_opfn_state_conn_reply,
0243     TP_PROTO(struct rvt_qp *qp),
0244     TP_ARGS(qp)
0245 );
0246 
0247 DEFINE_EVENT(/* event */
0248     hfi1_opfn_state_template, hfi1_opfn_state_conn_error,
0249     TP_PROTO(struct rvt_qp *qp),
0250     TP_ARGS(qp)
0251 );
0252 
0253 DECLARE_EVENT_CLASS(/* opfn_data */
0254     hfi1_opfn_data_template,
0255     TP_PROTO(struct rvt_qp *qp, u8 capcode, u64 data),
0256     TP_ARGS(qp, capcode, data),
0257     TP_STRUCT__entry(/* entry */
0258         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0259         __field(u32, qpn)
0260         __field(u32, state)
0261         __field(u8, capcode)
0262         __field(u64, data)
0263     ),
0264     TP_fast_assign(/* assign */
0265         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0266         __entry->qpn = qp->ibqp.qp_num;
0267         __entry->state = qp->state;
0268         __entry->capcode = capcode;
0269         __entry->data = data;
0270     ),
0271     TP_printk(/* printk */
0272         "[%s] qpn 0x%x (state 0x%x) Capcode %u data 0x%llx",
0273         __get_str(dev),
0274         __entry->qpn,
0275         __entry->state,
0276         __entry->capcode,
0277         __entry->data
0278     )
0279 );
0280 
0281 DEFINE_EVENT(/* event */
0282     hfi1_opfn_data_template, hfi1_opfn_data_conn_request,
0283     TP_PROTO(struct rvt_qp *qp, u8 capcode, u64 data),
0284     TP_ARGS(qp, capcode, data)
0285 );
0286 
0287 DEFINE_EVENT(/* event */
0288     hfi1_opfn_data_template, hfi1_opfn_data_conn_response,
0289     TP_PROTO(struct rvt_qp *qp, u8 capcode, u64 data),
0290     TP_ARGS(qp, capcode, data)
0291 );
0292 
0293 DEFINE_EVENT(/* event */
0294     hfi1_opfn_data_template, hfi1_opfn_data_conn_reply,
0295     TP_PROTO(struct rvt_qp *qp, u8 capcode, u64 data),
0296     TP_ARGS(qp, capcode, data)
0297 );
0298 
0299 DECLARE_EVENT_CLASS(/* opfn_param */
0300     hfi1_opfn_param_template,
0301     TP_PROTO(struct rvt_qp *qp, char remote,
0302          struct tid_rdma_params *param),
0303     TP_ARGS(qp, remote, param),
0304     TP_STRUCT__entry(/* entry */
0305         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0306         __field(u32, qpn)
0307         __field(char, remote)
0308         __field(u32, param_qp)
0309         __field(u32, max_len)
0310         __field(u16, jkey)
0311         __field(u8, max_read)
0312         __field(u8, max_write)
0313         __field(u8, timeout)
0314         __field(u8, urg)
0315     ),
0316     TP_fast_assign(/* assign */
0317         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0318         __entry->qpn = qp->ibqp.qp_num;
0319         __entry->remote = remote;
0320         __entry->param_qp = param->qp;
0321         __entry->max_len = param->max_len;
0322         __entry->jkey = param->jkey;
0323         __entry->max_read = param->max_read;
0324         __entry->max_write = param->max_write;
0325         __entry->timeout = param->timeout;
0326         __entry->urg = param->urg;
0327     ),
0328     TP_printk(/* print */
0329         OPFN_PARAM_PRN,
0330         __get_str(dev),
0331         __entry->qpn,
0332         __entry->remote ? "remote" : "local",
0333         __entry->param_qp,
0334         __entry->max_read,
0335         __entry->max_write,
0336         __entry->max_len,
0337         __entry->jkey,
0338         __entry->timeout,
0339         __entry->urg
0340     )
0341 );
0342 
0343 DEFINE_EVENT(/* event */
0344     hfi1_opfn_param_template, hfi1_opfn_param,
0345     TP_PROTO(struct rvt_qp *qp, char remote,
0346          struct tid_rdma_params *param),
0347     TP_ARGS(qp, remote, param)
0348 );
0349 
0350 DECLARE_EVENT_CLASS(/* msg */
0351     hfi1_msg_template,
0352     TP_PROTO(struct rvt_qp *qp, const char *msg, u64 more),
0353     TP_ARGS(qp, msg, more),
0354     TP_STRUCT__entry(/* entry */
0355         __field(u32, qpn)
0356         __string(msg, msg)
0357         __field(u64, more)
0358     ),
0359     TP_fast_assign(/* assign */
0360         __entry->qpn = qp ? qp->ibqp.qp_num : 0;
0361         __assign_str(msg, msg);
0362         __entry->more = more;
0363     ),
0364     TP_printk(/* print */
0365         "qpn 0x%x %s 0x%llx",
0366         __entry->qpn,
0367         __get_str(msg),
0368         __entry->more
0369     )
0370 );
0371 
0372 DEFINE_EVENT(/* event */
0373     hfi1_msg_template, hfi1_msg_opfn_conn_request,
0374     TP_PROTO(struct rvt_qp *qp, const char *msg, u64 more),
0375     TP_ARGS(qp, msg, more)
0376 );
0377 
0378 DEFINE_EVENT(/* event */
0379     hfi1_msg_template, hfi1_msg_opfn_conn_error,
0380     TP_PROTO(struct rvt_qp *qp, const char *msg, u64 more),
0381     TP_ARGS(qp, msg, more)
0382 );
0383 
0384 DEFINE_EVENT(/* event */
0385     hfi1_msg_template, hfi1_msg_alloc_tids,
0386     TP_PROTO(struct rvt_qp *qp, const char *msg, u64 more),
0387     TP_ARGS(qp, msg, more)
0388 );
0389 
0390 DEFINE_EVENT(/* event */
0391     hfi1_msg_template, hfi1_msg_tid_restart_req,
0392     TP_PROTO(struct rvt_qp *qp, const char *msg, u64 more),
0393     TP_ARGS(qp, msg, more)
0394 );
0395 
0396 DEFINE_EVENT(/* event */
0397     hfi1_msg_template, hfi1_msg_handle_kdeth_eflags,
0398     TP_PROTO(struct rvt_qp *qp, const char *msg, u64 more),
0399     TP_ARGS(qp, msg, more)
0400 );
0401 
0402 DEFINE_EVENT(/* event */
0403     hfi1_msg_template, hfi1_msg_tid_timeout,
0404     TP_PROTO(struct rvt_qp *qp, const char *msg, u64 more),
0405     TP_ARGS(qp, msg, more)
0406 );
0407 
0408 DEFINE_EVENT(/* event */
0409     hfi1_msg_template, hfi1_msg_tid_retry_timeout,
0410     TP_PROTO(struct rvt_qp *qp, const char *msg, u64 more),
0411     TP_ARGS(qp, msg, more)
0412 );
0413 
0414 DECLARE_EVENT_CLASS(/* tid_flow_page */
0415     hfi1_tid_flow_page_template,
0416     TP_PROTO(struct rvt_qp *qp, struct tid_rdma_flow *flow, u32 index,
0417          char mtu8k, char v1, void *vaddr),
0418     TP_ARGS(qp, flow, index, mtu8k, v1, vaddr),
0419     TP_STRUCT__entry(/* entry */
0420         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0421         __field(u32, qpn)
0422         __field(char, mtu8k)
0423         __field(char, v1)
0424         __field(u32, index)
0425         __field(u64, page)
0426         __field(u64, vaddr)
0427     ),
0428     TP_fast_assign(/* assign */
0429         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0430         __entry->qpn = qp->ibqp.qp_num;
0431         __entry->mtu8k = mtu8k;
0432         __entry->v1 = v1;
0433         __entry->index = index;
0434         __entry->page = vaddr ? (u64)virt_to_page(vaddr) : 0ULL;
0435         __entry->vaddr = (u64)vaddr;
0436     ),
0437     TP_printk(/* print */
0438         "[%s] qpn 0x%x page[%u]: page 0x%llx %s 0x%llx",
0439         __get_str(dev),
0440         __entry->qpn,
0441         __entry->index,
0442         __entry->page,
0443         __entry->mtu8k ? (__entry->v1 ? "v1" : "v0") : "vaddr",
0444         __entry->vaddr
0445     )
0446 );
0447 
0448 DEFINE_EVENT(/* event */
0449     hfi1_tid_flow_page_template, hfi1_tid_flow_page,
0450     TP_PROTO(struct rvt_qp *qp, struct tid_rdma_flow *flow, u32 index,
0451          char mtu8k, char v1, void *vaddr),
0452     TP_ARGS(qp, flow, index, mtu8k, v1, vaddr)
0453 );
0454 
0455 DECLARE_EVENT_CLASS(/* tid_pageset */
0456     hfi1_tid_pageset_template,
0457     TP_PROTO(struct rvt_qp *qp, u32 index, u16 idx, u16 count),
0458     TP_ARGS(qp, index, idx, count),
0459     TP_STRUCT__entry(/* entry */
0460         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0461         __field(u32, qpn)
0462         __field(u32, index)
0463         __field(u16, idx)
0464         __field(u16, count)
0465     ),
0466     TP_fast_assign(/* assign */
0467         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0468         __entry->qpn = qp->ibqp.qp_num;
0469         __entry->index = index;
0470         __entry->idx = idx;
0471         __entry->count = count;
0472     ),
0473     TP_printk(/* print */
0474         "[%s] qpn 0x%x list[%u]: idx %u count %u",
0475         __get_str(dev),
0476         __entry->qpn,
0477         __entry->index,
0478         __entry->idx,
0479         __entry->count
0480     )
0481 );
0482 
0483 DEFINE_EVENT(/* event */
0484     hfi1_tid_pageset_template, hfi1_tid_pageset,
0485     TP_PROTO(struct rvt_qp *qp, u32 index, u16 idx, u16 count),
0486     TP_ARGS(qp, index, idx, count)
0487 );
0488 
0489 DECLARE_EVENT_CLASS(/* tid_fow */
0490     hfi1_tid_flow_template,
0491     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0492     TP_ARGS(qp, index, flow),
0493     TP_STRUCT__entry(/* entry */
0494         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0495         __field(u32, qpn)
0496         __field(int, index)
0497         __field(int, idx)
0498         __field(u32, resp_ib_psn)
0499         __field(u32, generation)
0500         __field(u32, fspsn)
0501         __field(u32, flpsn)
0502         __field(u32, r_next_psn)
0503         __field(u32, ib_spsn)
0504         __field(u32, ib_lpsn)
0505         __field(u32, npagesets)
0506         __field(u32, tnode_cnt)
0507         __field(u32, tidcnt)
0508         __field(u32, tid_idx)
0509         __field(u32, tid_offset)
0510         __field(u32, length)
0511         __field(u32, sent)
0512     ),
0513     TP_fast_assign(/* assign */
0514         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0515         __entry->qpn = qp->ibqp.qp_num;
0516         __entry->index = index;
0517         __entry->idx = flow->idx;
0518         __entry->resp_ib_psn = flow->flow_state.resp_ib_psn;
0519         __entry->generation = flow->flow_state.generation;
0520         __entry->fspsn = full_flow_psn(flow,
0521                            flow->flow_state.spsn);
0522         __entry->flpsn = full_flow_psn(flow,
0523                            flow->flow_state.lpsn);
0524         __entry->r_next_psn = flow->flow_state.r_next_psn;
0525         __entry->ib_spsn = flow->flow_state.ib_spsn;
0526         __entry->ib_lpsn = flow->flow_state.ib_lpsn;
0527         __entry->npagesets = flow->npagesets;
0528         __entry->tnode_cnt = flow->tnode_cnt;
0529         __entry->tidcnt = flow->tidcnt;
0530         __entry->tid_idx = flow->tid_idx;
0531         __entry->tid_offset =  flow->tid_offset;
0532         __entry->length = flow->length;
0533         __entry->sent = flow->sent;
0534     ),
0535     TP_printk(/* print */
0536         TID_FLOW_PRN,
0537         __get_str(dev),
0538         __entry->qpn,
0539         __entry->index,
0540         __entry->idx,
0541         __entry->resp_ib_psn,
0542         __entry->generation,
0543         __entry->fspsn,
0544         __entry->flpsn,
0545         __entry->r_next_psn,
0546         __entry->ib_spsn,
0547         __entry->ib_lpsn,
0548         __entry->npagesets,
0549         __entry->tnode_cnt,
0550         __entry->tidcnt,
0551         __entry->tid_idx,
0552         __entry->tid_offset,
0553         __entry->length,
0554         __entry->sent
0555     )
0556 );
0557 
0558 DEFINE_EVENT(/* event */
0559     hfi1_tid_flow_template, hfi1_tid_flow_alloc,
0560     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0561     TP_ARGS(qp, index, flow)
0562 );
0563 
0564 DEFINE_EVENT(/* event */
0565     hfi1_tid_flow_template, hfi1_tid_flow_build_read_pkt,
0566     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0567     TP_ARGS(qp, index, flow)
0568 );
0569 
0570 DEFINE_EVENT(/* event */
0571     hfi1_tid_flow_template, hfi1_tid_flow_build_read_resp,
0572     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0573     TP_ARGS(qp, index, flow)
0574 );
0575 
0576 DEFINE_EVENT(/* event */
0577     hfi1_tid_flow_template, hfi1_tid_flow_rcv_read_req,
0578     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0579     TP_ARGS(qp, index, flow)
0580 );
0581 
0582 DEFINE_EVENT(/* event */
0583     hfi1_tid_flow_template, hfi1_tid_flow_rcv_read_resp,
0584     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0585     TP_ARGS(qp, index, flow)
0586 );
0587 
0588 DEFINE_EVENT(/* event */
0589     hfi1_tid_flow_template, hfi1_tid_flow_restart_req,
0590     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0591     TP_ARGS(qp, index, flow)
0592 );
0593 
0594 DEFINE_EVENT(/* event */
0595     hfi1_tid_flow_template, hfi1_tid_flow_build_write_resp,
0596     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0597     TP_ARGS(qp, index, flow)
0598 );
0599 
0600 DEFINE_EVENT(/* event */
0601     hfi1_tid_flow_template, hfi1_tid_flow_rcv_write_resp,
0602     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0603     TP_ARGS(qp, index, flow)
0604 );
0605 
0606 DEFINE_EVENT(/* event */
0607     hfi1_tid_flow_template, hfi1_tid_flow_build_write_data,
0608     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0609     TP_ARGS(qp, index, flow)
0610 );
0611 
0612 DEFINE_EVENT(/* event */
0613     hfi1_tid_flow_template, hfi1_tid_flow_rcv_tid_ack,
0614     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0615     TP_ARGS(qp, index, flow)
0616 );
0617 
0618 DEFINE_EVENT(/* event */
0619     hfi1_tid_flow_template, hfi1_tid_flow_rcv_resync,
0620     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0621     TP_ARGS(qp, index, flow)
0622 );
0623 
0624 DEFINE_EVENT(/* event */
0625     hfi1_tid_flow_template, hfi1_tid_flow_handle_kdeth_eflags,
0626     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0627     TP_ARGS(qp, index, flow)
0628 );
0629 
0630 DEFINE_EVENT(/* event */
0631     hfi1_tid_flow_template, hfi1_tid_flow_read_kdeth_eflags,
0632     TP_PROTO(struct rvt_qp *qp, int index, struct tid_rdma_flow *flow),
0633     TP_ARGS(qp, index, flow)
0634 );
0635 
0636 DECLARE_EVENT_CLASS(/* tid_node */
0637     hfi1_tid_node_template,
0638     TP_PROTO(struct rvt_qp *qp, const char *msg, u32 index, u32 base,
0639          u8 map, u8 used, u8 cnt),
0640     TP_ARGS(qp, msg, index, base, map, used, cnt),
0641     TP_STRUCT__entry(/* entry */
0642         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0643         __field(u32, qpn)
0644         __string(msg, msg)
0645         __field(u32, index)
0646         __field(u32, base)
0647         __field(u8, map)
0648         __field(u8, used)
0649         __field(u8, cnt)
0650     ),
0651     TP_fast_assign(/* assign */
0652         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0653         __entry->qpn = qp->ibqp.qp_num;
0654         __assign_str(msg, msg);
0655         __entry->index = index;
0656         __entry->base = base;
0657         __entry->map = map;
0658         __entry->used = used;
0659         __entry->cnt = cnt;
0660     ),
0661     TP_printk(/* print */
0662         TID_NODE_PRN,
0663         __get_str(dev),
0664         __entry->qpn,
0665         __get_str(msg),
0666         __entry->index,
0667         __entry->base,
0668         __entry->map,
0669         __entry->used,
0670         __entry->cnt
0671     )
0672 );
0673 
0674 DEFINE_EVENT(/* event */
0675     hfi1_tid_node_template, hfi1_tid_node_add,
0676     TP_PROTO(struct rvt_qp *qp, const char *msg, u32 index, u32 base,
0677          u8 map, u8 used, u8 cnt),
0678     TP_ARGS(qp, msg, index, base, map, used, cnt)
0679 );
0680 
0681 DECLARE_EVENT_CLASS(/* tid_entry */
0682     hfi1_tid_entry_template,
0683     TP_PROTO(struct rvt_qp *qp, int index, u32 ent),
0684     TP_ARGS(qp, index, ent),
0685     TP_STRUCT__entry(/* entry */
0686         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0687         __field(u32, qpn)
0688         __field(int, index)
0689         __field(u8, ctrl)
0690         __field(u16, idx)
0691         __field(u16, len)
0692     ),
0693     TP_fast_assign(/* assign */
0694         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0695         __entry->qpn = qp->ibqp.qp_num;
0696         __entry->index = index;
0697         __entry->ctrl = hfi1_trace_get_tid_ctrl(ent);
0698         __entry->idx = hfi1_trace_get_tid_idx(ent);
0699         __entry->len = hfi1_trace_get_tid_len(ent);
0700     ),
0701     TP_printk(/* print */
0702         "[%s] qpn 0x%x TID entry %d: idx %u len %u ctrl 0x%x",
0703         __get_str(dev),
0704         __entry->qpn,
0705         __entry->index,
0706         __entry->idx,
0707         __entry->len,
0708         __entry->ctrl
0709     )
0710 );
0711 
0712 DEFINE_EVENT(/* event */
0713     hfi1_tid_entry_template, hfi1_tid_entry_alloc,
0714     TP_PROTO(struct rvt_qp *qp, int index, u32 entry),
0715     TP_ARGS(qp, index, entry)
0716 );
0717 
0718 DEFINE_EVENT(/* event */
0719     hfi1_tid_entry_template, hfi1_tid_entry_build_read_resp,
0720     TP_PROTO(struct rvt_qp *qp, int index, u32 ent),
0721     TP_ARGS(qp, index, ent)
0722 );
0723 
0724 DEFINE_EVENT(/* event */
0725     hfi1_tid_entry_template, hfi1_tid_entry_rcv_read_req,
0726     TP_PROTO(struct rvt_qp *qp, int index, u32 ent),
0727     TP_ARGS(qp, index, ent)
0728 );
0729 
0730 DEFINE_EVENT(/* event */
0731     hfi1_tid_entry_template, hfi1_tid_entry_rcv_write_resp,
0732     TP_PROTO(struct rvt_qp *qp, int index, u32 entry),
0733     TP_ARGS(qp, index, entry)
0734 );
0735 
0736 DEFINE_EVENT(/* event */
0737     hfi1_tid_entry_template, hfi1_tid_entry_build_write_data,
0738     TP_PROTO(struct rvt_qp *qp, int index, u32 entry),
0739     TP_ARGS(qp, index, entry)
0740 );
0741 
0742 DECLARE_EVENT_CLASS(/* rsp_info */
0743     hfi1_responder_info_template,
0744     TP_PROTO(struct rvt_qp *qp, u32 psn),
0745     TP_ARGS(qp, psn),
0746     TP_STRUCT__entry(/* entry */
0747         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0748         __field(u32, qpn)
0749         __field(u8, state)
0750         __field(u8, s_state)
0751         __field(u32, psn)
0752         __field(u32, r_psn)
0753         __field(u8, r_state)
0754         __field(u8, r_flags)
0755         __field(u8, r_head_ack_queue)
0756         __field(u8, s_tail_ack_queue)
0757         __field(u8, s_acked_ack_queue)
0758         __field(u8, s_ack_state)
0759         __field(u8, s_nak_state)
0760         __field(u8, r_nak_state)
0761         __field(u32, s_flags)
0762         __field(u32, ps_flags)
0763         __field(unsigned long, iow_flags)
0764     ),
0765     TP_fast_assign(/* assign */
0766         struct hfi1_qp_priv *priv = qp->priv;
0767 
0768         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0769         __entry->qpn = qp->ibqp.qp_num;
0770         __entry->state = qp->state;
0771         __entry->s_state = qp->s_state;
0772         __entry->psn = psn;
0773         __entry->r_psn = qp->r_psn;
0774         __entry->r_state = qp->r_state;
0775         __entry->r_flags = qp->r_flags;
0776         __entry->r_head_ack_queue = qp->r_head_ack_queue;
0777         __entry->s_tail_ack_queue = qp->s_tail_ack_queue;
0778         __entry->s_acked_ack_queue = qp->s_acked_ack_queue;
0779         __entry->s_ack_state = qp->s_ack_state;
0780         __entry->s_nak_state = qp->s_nak_state;
0781         __entry->s_flags = qp->s_flags;
0782         __entry->ps_flags = priv->s_flags;
0783         __entry->iow_flags = priv->s_iowait.flags;
0784     ),
0785     TP_printk(/* print */
0786         RSP_INFO_PRN,
0787         __get_str(dev),
0788         __entry->qpn,
0789         __entry->state,
0790         __entry->s_state,
0791         __entry->psn,
0792         __entry->r_psn,
0793         __entry->r_state,
0794         __entry->r_flags,
0795         __entry->r_head_ack_queue,
0796         __entry->s_tail_ack_queue,
0797         __entry->s_acked_ack_queue,
0798         __entry->s_ack_state,
0799         __entry->s_nak_state,
0800         __entry->s_flags,
0801         __entry->ps_flags,
0802         __entry->iow_flags
0803     )
0804 );
0805 
0806 DEFINE_EVENT(/* event */
0807     hfi1_responder_info_template, hfi1_rsp_make_rc_ack,
0808     TP_PROTO(struct rvt_qp *qp, u32 psn),
0809     TP_ARGS(qp, psn)
0810 );
0811 
0812 DEFINE_EVENT(/* event */
0813     hfi1_responder_info_template, hfi1_rsp_rcv_tid_read_req,
0814     TP_PROTO(struct rvt_qp *qp, u32 psn),
0815     TP_ARGS(qp, psn)
0816 );
0817 
0818 DEFINE_EVENT(/* event */
0819     hfi1_responder_info_template, hfi1_rsp_tid_rcv_error,
0820     TP_PROTO(struct rvt_qp *qp, u32 psn),
0821     TP_ARGS(qp, psn)
0822 );
0823 
0824 DEFINE_EVENT(/* event */
0825     hfi1_responder_info_template, hfi1_rsp_tid_write_alloc_res,
0826     TP_PROTO(struct rvt_qp *qp, u32 psn),
0827     TP_ARGS(qp, psn)
0828 );
0829 
0830 DEFINE_EVENT(/* event */
0831     hfi1_responder_info_template, hfi1_rsp_rcv_tid_write_req,
0832     TP_PROTO(struct rvt_qp *qp, u32 psn),
0833     TP_ARGS(qp, psn)
0834 );
0835 
0836 DEFINE_EVENT(/* event */
0837     hfi1_responder_info_template, hfi1_rsp_build_tid_write_resp,
0838     TP_PROTO(struct rvt_qp *qp, u32 psn),
0839     TP_ARGS(qp, psn)
0840 );
0841 
0842 DEFINE_EVENT(/* event */
0843     hfi1_responder_info_template, hfi1_rsp_rcv_tid_write_data,
0844     TP_PROTO(struct rvt_qp *qp, u32 psn),
0845     TP_ARGS(qp, psn)
0846 );
0847 
0848 DEFINE_EVENT(/* event */
0849     hfi1_responder_info_template, hfi1_rsp_make_tid_ack,
0850     TP_PROTO(struct rvt_qp *qp, u32 psn),
0851     TP_ARGS(qp, psn)
0852 );
0853 
0854 DEFINE_EVENT(/* event */
0855     hfi1_responder_info_template, hfi1_rsp_handle_kdeth_eflags,
0856     TP_PROTO(struct rvt_qp *qp, u32 psn),
0857     TP_ARGS(qp, psn)
0858 );
0859 
0860 DEFINE_EVENT(/* event */
0861     hfi1_responder_info_template, hfi1_rsp_read_kdeth_eflags,
0862     TP_PROTO(struct rvt_qp *qp, u32 psn),
0863     TP_ARGS(qp, psn)
0864 );
0865 
0866 DECLARE_EVENT_CLASS(/* sender_info */
0867     hfi1_sender_info_template,
0868     TP_PROTO(struct rvt_qp *qp),
0869     TP_ARGS(qp),
0870     TP_STRUCT__entry(/* entry */
0871         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0872         __field(u32, qpn)
0873         __field(u8, state)
0874         __field(u32, s_cur)
0875         __field(u32, s_tail)
0876         __field(u32, s_head)
0877         __field(u32, s_acked)
0878         __field(u32, s_last)
0879         __field(u32, s_psn)
0880         __field(u32, s_last_psn)
0881         __field(u32, s_flags)
0882         __field(u32, ps_flags)
0883         __field(unsigned long, iow_flags)
0884         __field(u8, s_state)
0885         __field(u8, s_num_rd)
0886         __field(u8, s_retry)
0887     ),
0888     TP_fast_assign(/* assign */
0889         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0890         __entry->qpn = qp->ibqp.qp_num;
0891         __entry->state = qp->state;
0892         __entry->s_cur = qp->s_cur;
0893         __entry->s_tail = qp->s_tail;
0894         __entry->s_head = qp->s_head;
0895         __entry->s_acked = qp->s_acked;
0896         __entry->s_last = qp->s_last;
0897         __entry->s_psn = qp->s_psn;
0898         __entry->s_last_psn = qp->s_last_psn;
0899         __entry->s_flags = qp->s_flags;
0900         __entry->ps_flags = ((struct hfi1_qp_priv *)qp->priv)->s_flags;
0901         __entry->iow_flags =
0902             ((struct hfi1_qp_priv *)qp->priv)->s_iowait.flags;
0903         __entry->s_state = qp->s_state;
0904         __entry->s_num_rd = qp->s_num_rd_atomic;
0905         __entry->s_retry = qp->s_retry;
0906     ),
0907     TP_printk(/* print */
0908         SENDER_INFO_PRN,
0909         __get_str(dev),
0910         __entry->qpn,
0911         __entry->state,
0912         __entry->s_cur,
0913         __entry->s_tail,
0914         __entry->s_head,
0915         __entry->s_acked,
0916         __entry->s_last,
0917         __entry->s_psn,
0918         __entry->s_last_psn,
0919         __entry->s_flags,
0920         __entry->ps_flags,
0921         __entry->iow_flags,
0922         __entry->s_state,
0923         __entry->s_num_rd,
0924         __entry->s_retry
0925     )
0926 );
0927 
0928 DEFINE_EVENT(/* event */
0929     hfi1_sender_info_template, hfi1_sender_make_rc_req,
0930     TP_PROTO(struct rvt_qp *qp),
0931     TP_ARGS(qp)
0932 );
0933 
0934 DEFINE_EVENT(/* event */
0935     hfi1_sender_info_template, hfi1_sender_reset_psn,
0936     TP_PROTO(struct rvt_qp *qp),
0937     TP_ARGS(qp)
0938 );
0939 
0940 DEFINE_EVENT(/* event */
0941     hfi1_sender_info_template, hfi1_sender_restart_rc,
0942     TP_PROTO(struct rvt_qp *qp),
0943     TP_ARGS(qp)
0944 );
0945 
0946 DEFINE_EVENT(/* event */
0947     hfi1_sender_info_template, hfi1_sender_do_rc_ack,
0948     TP_PROTO(struct rvt_qp *qp),
0949     TP_ARGS(qp)
0950 );
0951 
0952 DEFINE_EVENT(/* event */
0953     hfi1_sender_info_template, hfi1_sender_rcv_tid_read_resp,
0954     TP_PROTO(struct rvt_qp *qp),
0955     TP_ARGS(qp)
0956 );
0957 
0958 DEFINE_EVENT(/* event */
0959     hfi1_sender_info_template, hfi1_sender_rcv_tid_ack,
0960     TP_PROTO(struct rvt_qp *qp),
0961     TP_ARGS(qp)
0962 );
0963 
0964 DEFINE_EVENT(/* event */
0965     hfi1_sender_info_template, hfi1_sender_make_tid_pkt,
0966     TP_PROTO(struct rvt_qp *qp),
0967     TP_ARGS(qp)
0968 );
0969 
0970 DEFINE_EVENT(/* event */
0971     hfi1_sender_info_template, hfi1_sender_read_kdeth_eflags,
0972     TP_PROTO(struct rvt_qp *qp),
0973     TP_ARGS(qp)
0974 );
0975 
0976 DECLARE_EVENT_CLASS(/* tid_read_sender */
0977     hfi1_tid_read_sender_template,
0978     TP_PROTO(struct rvt_qp *qp, char newreq),
0979     TP_ARGS(qp, newreq),
0980     TP_STRUCT__entry(/* entry */
0981         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
0982         __field(u32, qpn)
0983         __field(char, newreq)
0984         __field(u32, tid_r_reqs)
0985         __field(u32, tid_r_comp)
0986         __field(u32, pending_tid_r_segs)
0987         __field(u32, s_flags)
0988         __field(u32, ps_flags)
0989         __field(unsigned long, iow_flags)
0990         __field(u8, s_state)
0991         __field(u32, hw_flow_index)
0992         __field(u32, generation)
0993         __field(u32, fpsn)
0994     ),
0995     TP_fast_assign(/* assign */
0996         struct hfi1_qp_priv *priv = qp->priv;
0997 
0998         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
0999         __entry->qpn = qp->ibqp.qp_num;
1000         __entry->newreq = newreq;
1001         __entry->tid_r_reqs = priv->tid_r_reqs;
1002         __entry->tid_r_comp = priv->tid_r_comp;
1003         __entry->pending_tid_r_segs = priv->pending_tid_r_segs;
1004         __entry->s_flags = qp->s_flags;
1005         __entry->ps_flags = priv->s_flags;
1006         __entry->iow_flags = priv->s_iowait.flags;
1007         __entry->s_state = priv->s_state;
1008         __entry->hw_flow_index = priv->flow_state.index;
1009         __entry->generation = priv->flow_state.generation;
1010         __entry->fpsn = priv->flow_state.psn;
1011     ),
1012     TP_printk(/* print */
1013         TID_READ_SENDER_PRN,
1014         __get_str(dev),
1015         __entry->qpn,
1016         __entry->newreq,
1017         __entry->tid_r_reqs,
1018         __entry->tid_r_comp,
1019         __entry->pending_tid_r_segs,
1020         __entry->s_flags,
1021         __entry->ps_flags,
1022         __entry->iow_flags,
1023         __entry->s_state,
1024         __entry->hw_flow_index,
1025         __entry->generation,
1026         __entry->fpsn
1027     )
1028 );
1029 
1030 DEFINE_EVENT(/* event */
1031     hfi1_tid_read_sender_template, hfi1_tid_read_sender_make_req,
1032     TP_PROTO(struct rvt_qp *qp, char newreq),
1033     TP_ARGS(qp, newreq)
1034 );
1035 
1036 DEFINE_EVENT(/* event */
1037     hfi1_tid_read_sender_template, hfi1_tid_read_sender_kdeth_eflags,
1038     TP_PROTO(struct rvt_qp *qp, char newreq),
1039     TP_ARGS(qp, newreq)
1040 );
1041 
1042 DECLARE_EVENT_CLASS(/* tid_rdma_request */
1043     hfi1_tid_rdma_request_template,
1044     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1045          struct tid_rdma_request *req),
1046     TP_ARGS(qp, newreq, opcode, psn, lpsn, req),
1047     TP_STRUCT__entry(/* entry */
1048         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
1049         __field(u32, qpn)
1050         __field(char, newreq)
1051         __field(u8, opcode)
1052         __field(u32, psn)
1053         __field(u32, lpsn)
1054         __field(u32, cur_seg)
1055         __field(u32, comp_seg)
1056         __field(u32, ack_seg)
1057         __field(u32, alloc_seg)
1058         __field(u32, total_segs)
1059         __field(u16, setup_head)
1060         __field(u16, clear_tail)
1061         __field(u16, flow_idx)
1062         __field(u16, acked_tail)
1063         __field(u32, state)
1064         __field(u32, r_ack_psn)
1065         __field(u32, r_flow_psn)
1066         __field(u32, r_last_acked)
1067         __field(u32, s_next_psn)
1068     ),
1069     TP_fast_assign(/* assign */
1070         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
1071         __entry->qpn = qp->ibqp.qp_num;
1072         __entry->newreq = newreq;
1073         __entry->opcode = opcode;
1074         __entry->psn = psn;
1075         __entry->lpsn = lpsn;
1076         __entry->cur_seg = req->cur_seg;
1077         __entry->comp_seg = req->comp_seg;
1078         __entry->ack_seg = req->ack_seg;
1079         __entry->alloc_seg = req->alloc_seg;
1080         __entry->total_segs = req->total_segs;
1081         __entry->setup_head = req->setup_head;
1082         __entry->clear_tail = req->clear_tail;
1083         __entry->flow_idx = req->flow_idx;
1084         __entry->acked_tail = req->acked_tail;
1085         __entry->state = req->state;
1086         __entry->r_ack_psn = req->r_ack_psn;
1087         __entry->r_flow_psn = req->r_flow_psn;
1088         __entry->r_last_acked = req->r_last_acked;
1089         __entry->s_next_psn = req->s_next_psn;
1090     ),
1091     TP_printk(/* print */
1092         TID_REQ_PRN,
1093         __get_str(dev),
1094         __entry->qpn,
1095         __entry->newreq,
1096         __entry->opcode,
1097         __entry->psn,
1098         __entry->lpsn,
1099         __entry->cur_seg,
1100         __entry->comp_seg,
1101         __entry->ack_seg,
1102         __entry->alloc_seg,
1103         __entry->total_segs,
1104         __entry->setup_head,
1105         __entry->clear_tail,
1106         __entry->flow_idx,
1107         __entry->acked_tail,
1108         __entry->state,
1109         __entry->r_ack_psn,
1110         __entry->r_flow_psn,
1111         __entry->r_last_acked,
1112         __entry->s_next_psn
1113     )
1114 );
1115 
1116 DEFINE_EVENT(/* event */
1117     hfi1_tid_rdma_request_template, hfi1_tid_req_make_req_read,
1118     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1119          struct tid_rdma_request *req),
1120     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1121 );
1122 
1123 DEFINE_EVENT(/* event */
1124     hfi1_tid_rdma_request_template, hfi1_tid_req_build_read_req,
1125     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1126          struct tid_rdma_request *req),
1127     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1128 );
1129 
1130 DEFINE_EVENT(/* event */
1131     hfi1_tid_rdma_request_template, hfi1_tid_req_rcv_read_req,
1132     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1133          struct tid_rdma_request *req),
1134     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1135 );
1136 
1137 DEFINE_EVENT(/* event */
1138     hfi1_tid_rdma_request_template, hfi1_tid_req_rcv_read_resp,
1139     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1140          struct tid_rdma_request *req),
1141     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1142 );
1143 
1144 DEFINE_EVENT(/* event */
1145     hfi1_tid_rdma_request_template, hfi1_tid_req_rcv_err,
1146     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1147          struct tid_rdma_request *req),
1148     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1149 );
1150 
1151 DEFINE_EVENT(/* event */
1152     hfi1_tid_rdma_request_template, hfi1_tid_req_restart_req,
1153     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1154          struct tid_rdma_request *req),
1155     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1156 );
1157 
1158 DEFINE_EVENT(/* event */
1159     hfi1_tid_rdma_request_template, hfi1_tid_req_setup_tid_wqe,
1160     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1161          struct tid_rdma_request *req),
1162     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1163 );
1164 
1165 DEFINE_EVENT(/* event */
1166     hfi1_tid_rdma_request_template, hfi1_tid_req_write_alloc_res,
1167     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1168          struct tid_rdma_request *req),
1169     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1170 );
1171 
1172 DEFINE_EVENT(/* event */
1173     hfi1_tid_rdma_request_template, hfi1_tid_req_rcv_write_req,
1174     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1175          struct tid_rdma_request *req),
1176     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1177 );
1178 
1179 DEFINE_EVENT(/* event */
1180     hfi1_tid_rdma_request_template, hfi1_tid_req_build_write_resp,
1181     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1182          struct tid_rdma_request *req),
1183     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1184 );
1185 
1186 DEFINE_EVENT(/* event */
1187     hfi1_tid_rdma_request_template, hfi1_tid_req_rcv_write_resp,
1188     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1189          struct tid_rdma_request *req),
1190     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1191 );
1192 
1193 DEFINE_EVENT(/* event */
1194     hfi1_tid_rdma_request_template, hfi1_tid_req_rcv_write_data,
1195     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1196          struct tid_rdma_request *req),
1197     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1198 );
1199 
1200 DEFINE_EVENT(/* event */
1201     hfi1_tid_rdma_request_template, hfi1_tid_req_rcv_tid_ack,
1202     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1203          struct tid_rdma_request *req),
1204     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1205 );
1206 
1207 DEFINE_EVENT(/* event */
1208     hfi1_tid_rdma_request_template, hfi1_tid_req_tid_retry_timeout,
1209     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1210          struct tid_rdma_request *req),
1211     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1212 );
1213 
1214 DEFINE_EVENT(/* event */
1215     hfi1_tid_rdma_request_template, hfi1_tid_req_rcv_resync,
1216     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1217          struct tid_rdma_request *req),
1218     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1219 );
1220 
1221 DEFINE_EVENT(/* event */
1222     hfi1_tid_rdma_request_template, hfi1_tid_req_make_tid_pkt,
1223     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1224          struct tid_rdma_request *req),
1225     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1226 );
1227 
1228 DEFINE_EVENT(/* event */
1229     hfi1_tid_rdma_request_template, hfi1_tid_req_make_tid_ack,
1230     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1231          struct tid_rdma_request *req),
1232     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1233 );
1234 
1235 DEFINE_EVENT(/* event */
1236     hfi1_tid_rdma_request_template, hfi1_tid_req_handle_kdeth_eflags,
1237     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1238          struct tid_rdma_request *req),
1239     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1240 );
1241 
1242 DEFINE_EVENT(/* event */
1243     hfi1_tid_rdma_request_template, hfi1_tid_req_read_kdeth_eflags,
1244     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1245          struct tid_rdma_request *req),
1246     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1247 );
1248 
1249 DEFINE_EVENT(/* event */
1250     hfi1_tid_rdma_request_template, hfi1_tid_req_make_rc_ack_write,
1251     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1252          struct tid_rdma_request *req),
1253     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1254 );
1255 
1256 DEFINE_EVENT(/* event */
1257     hfi1_tid_rdma_request_template, hfi1_tid_req_make_req_write,
1258     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1259          struct tid_rdma_request *req),
1260     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1261 );
1262 
1263 DEFINE_EVENT(/* event */
1264     hfi1_tid_rdma_request_template, hfi1_tid_req_update_num_rd_atomic,
1265     TP_PROTO(struct rvt_qp *qp, char newreq, u8 opcode, u32 psn, u32 lpsn,
1266          struct tid_rdma_request *req),
1267     TP_ARGS(qp, newreq, opcode, psn, lpsn, req)
1268 );
1269 
1270 DECLARE_EVENT_CLASS(/* rc_rcv_err */
1271     hfi1_rc_rcv_err_template,
1272     TP_PROTO(struct rvt_qp *qp, u32 opcode, u32 psn, int diff),
1273     TP_ARGS(qp, opcode, psn, diff),
1274     TP_STRUCT__entry(/* entry */
1275         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
1276         __field(u32, qpn)
1277         __field(u32, s_flags)
1278         __field(u8, state)
1279         __field(u8, s_acked_ack_queue)
1280         __field(u8, s_tail_ack_queue)
1281         __field(u8, r_head_ack_queue)
1282         __field(u32, opcode)
1283         __field(u32, psn)
1284         __field(u32, r_psn)
1285         __field(int, diff)
1286     ),
1287     TP_fast_assign(/* assign */
1288         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
1289         __entry->qpn = qp->ibqp.qp_num;
1290         __entry->s_flags = qp->s_flags;
1291         __entry->state = qp->state;
1292         __entry->s_acked_ack_queue = qp->s_acked_ack_queue;
1293         __entry->s_tail_ack_queue = qp->s_tail_ack_queue;
1294         __entry->r_head_ack_queue = qp->r_head_ack_queue;
1295         __entry->opcode = opcode;
1296         __entry->psn = psn;
1297         __entry->r_psn = qp->r_psn;
1298         __entry->diff = diff;
1299     ),
1300     TP_printk(/* print */
1301         RCV_ERR_PRN,
1302         __get_str(dev),
1303         __entry->qpn,
1304         __entry->s_flags,
1305         __entry->state,
1306         __entry->s_acked_ack_queue,
1307         __entry->s_tail_ack_queue,
1308         __entry->r_head_ack_queue,
1309         __entry->opcode,
1310         __entry->psn,
1311         __entry->r_psn,
1312         __entry->diff
1313     )
1314 );
1315 
1316 DEFINE_EVENT(/* event */
1317     hfi1_rc_rcv_err_template, hfi1_tid_rdma_rcv_err,
1318     TP_PROTO(struct rvt_qp *qp, u32 opcode, u32 psn, int diff),
1319     TP_ARGS(qp, opcode, psn, diff)
1320 );
1321 
1322 DECLARE_EVENT_CLASS(/* sge  */
1323     hfi1_sge_template,
1324     TP_PROTO(struct rvt_qp *qp, int index, struct rvt_sge *sge),
1325     TP_ARGS(qp, index, sge),
1326     TP_STRUCT__entry(/* entry */
1327         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
1328         __field(u32, qpn)
1329         __field(int, index)
1330         __field(u64, vaddr)
1331         __field(u32, sge_length)
1332     ),
1333     TP_fast_assign(/* assign */
1334         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
1335         __entry->qpn = qp->ibqp.qp_num;
1336         __entry->index = index;
1337         __entry->vaddr = (u64)sge->vaddr;
1338         __entry->sge_length = sge->sge_length;
1339     ),
1340     TP_printk(/* print */
1341         "[%s] qpn 0x%x sge %d: vaddr 0x%llx sge_length %u",
1342         __get_str(dev),
1343         __entry->qpn,
1344         __entry->index,
1345         __entry->vaddr,
1346         __entry->sge_length
1347     )
1348 );
1349 
1350 DEFINE_EVENT(/* event */
1351     hfi1_sge_template, hfi1_sge_check_align,
1352     TP_PROTO(struct rvt_qp *qp, int index, struct rvt_sge *sge),
1353     TP_ARGS(qp, index, sge)
1354 );
1355 
1356 DECLARE_EVENT_CLASS(/* tid_write_sp */
1357     hfi1_tid_write_rsp_template,
1358     TP_PROTO(struct rvt_qp *qp),
1359     TP_ARGS(qp),
1360     TP_STRUCT__entry(/* entry */
1361         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
1362         __field(u32, qpn)
1363         __field(u32, r_tid_head)
1364         __field(u32, r_tid_tail)
1365         __field(u32, r_tid_ack)
1366         __field(u32, r_tid_alloc)
1367         __field(u32, alloc_w_segs)
1368         __field(u32, pending_tid_w_segs)
1369         __field(bool, sync_pt)
1370         __field(u32, ps_nak_psn)
1371         __field(u8, ps_nak_state)
1372         __field(u8, prnr_nak_state)
1373         __field(u32, hw_flow_index)
1374         __field(u32, generation)
1375         __field(u32, fpsn)
1376         __field(bool, resync)
1377         __field(u32, r_next_psn_kdeth)
1378     ),
1379     TP_fast_assign(/* assign */
1380         struct hfi1_qp_priv *priv = qp->priv;
1381 
1382         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
1383         __entry->qpn = qp->ibqp.qp_num;
1384         __entry->r_tid_head = priv->r_tid_head;
1385         __entry->r_tid_tail = priv->r_tid_tail;
1386         __entry->r_tid_ack = priv->r_tid_ack;
1387         __entry->r_tid_alloc = priv->r_tid_alloc;
1388         __entry->alloc_w_segs = priv->alloc_w_segs;
1389         __entry->pending_tid_w_segs = priv->pending_tid_w_segs;
1390         __entry->sync_pt = priv->sync_pt;
1391         __entry->ps_nak_psn = priv->s_nak_psn;
1392         __entry->ps_nak_state = priv->s_nak_state;
1393         __entry->prnr_nak_state = priv->rnr_nak_state;
1394         __entry->hw_flow_index = priv->flow_state.index;
1395         __entry->generation = priv->flow_state.generation;
1396         __entry->fpsn = priv->flow_state.psn;
1397         __entry->resync = priv->resync;
1398         __entry->r_next_psn_kdeth = priv->r_next_psn_kdeth;
1399     ),
1400     TP_printk(/* print */
1401         TID_WRITE_RSPDR_PRN,
1402         __get_str(dev),
1403         __entry->qpn,
1404         __entry->r_tid_head,
1405         __entry->r_tid_tail,
1406         __entry->r_tid_ack,
1407         __entry->r_tid_alloc,
1408         __entry->alloc_w_segs,
1409         __entry->pending_tid_w_segs,
1410         __entry->sync_pt ? "yes" : "no",
1411         __entry->ps_nak_psn,
1412         __entry->ps_nak_state,
1413         __entry->prnr_nak_state,
1414         __entry->hw_flow_index,
1415         __entry->generation,
1416         __entry->fpsn,
1417         __entry->resync ? "yes" : "no",
1418         __entry->r_next_psn_kdeth
1419     )
1420 );
1421 
1422 DEFINE_EVENT(/* event */
1423     hfi1_tid_write_rsp_template, hfi1_tid_write_rsp_alloc_res,
1424     TP_PROTO(struct rvt_qp *qp),
1425     TP_ARGS(qp)
1426 );
1427 
1428 DEFINE_EVENT(/* event */
1429     hfi1_tid_write_rsp_template, hfi1_tid_write_rsp_rcv_req,
1430     TP_PROTO(struct rvt_qp *qp),
1431     TP_ARGS(qp)
1432 );
1433 
1434 DEFINE_EVENT(/* event */
1435     hfi1_tid_write_rsp_template, hfi1_tid_write_rsp_build_resp,
1436     TP_PROTO(struct rvt_qp *qp),
1437     TP_ARGS(qp)
1438 );
1439 
1440 DEFINE_EVENT(/* event */
1441     hfi1_tid_write_rsp_template, hfi1_tid_write_rsp_rcv_data,
1442     TP_PROTO(struct rvt_qp *qp),
1443     TP_ARGS(qp)
1444 );
1445 
1446 DEFINE_EVENT(/* event */
1447     hfi1_tid_write_rsp_template, hfi1_tid_write_rsp_rcv_resync,
1448     TP_PROTO(struct rvt_qp *qp),
1449     TP_ARGS(qp)
1450 );
1451 
1452 DEFINE_EVENT(/* event */
1453     hfi1_tid_write_rsp_template, hfi1_tid_write_rsp_make_tid_ack,
1454     TP_PROTO(struct rvt_qp *qp),
1455     TP_ARGS(qp)
1456 );
1457 
1458 DEFINE_EVENT(/* event */
1459     hfi1_tid_write_rsp_template, hfi1_tid_write_rsp_handle_kdeth_eflags,
1460     TP_PROTO(struct rvt_qp *qp),
1461     TP_ARGS(qp)
1462 );
1463 
1464 DEFINE_EVENT(/* event */
1465     hfi1_tid_write_rsp_template, hfi1_tid_write_rsp_make_rc_ack,
1466     TP_PROTO(struct rvt_qp *qp),
1467     TP_ARGS(qp)
1468 );
1469 
1470 DECLARE_EVENT_CLASS(/* tid_write_sender */
1471     hfi1_tid_write_sender_template,
1472     TP_PROTO(struct rvt_qp *qp, char newreq),
1473     TP_ARGS(qp, newreq),
1474     TP_STRUCT__entry(/* entry */
1475         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
1476         __field(u32, qpn)
1477         __field(char, newreq)
1478         __field(u32, s_tid_cur)
1479         __field(u32, s_tid_tail)
1480         __field(u32, s_tid_head)
1481         __field(u32, pending_tid_w_resp)
1482         __field(u32, n_requests)
1483         __field(u32, n_tid_requests)
1484         __field(u32, s_flags)
1485         __field(u32, ps_flags)
1486         __field(unsigned long, iow_flags)
1487         __field(u8, s_state)
1488         __field(u8, s_retry)
1489     ),
1490     TP_fast_assign(/* assign */
1491         struct hfi1_qp_priv *priv = qp->priv;
1492 
1493         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
1494         __entry->qpn = qp->ibqp.qp_num;
1495         __entry->newreq = newreq;
1496         __entry->s_tid_cur = priv->s_tid_cur;
1497         __entry->s_tid_tail = priv->s_tid_tail;
1498         __entry->s_tid_head = priv->s_tid_head;
1499         __entry->pending_tid_w_resp = priv->pending_tid_w_resp;
1500         __entry->n_requests = atomic_read(&priv->n_requests);
1501         __entry->n_tid_requests = atomic_read(&priv->n_tid_requests);
1502         __entry->s_flags = qp->s_flags;
1503         __entry->ps_flags = priv->s_flags;
1504         __entry->iow_flags = priv->s_iowait.flags;
1505         __entry->s_state = priv->s_state;
1506         __entry->s_retry = priv->s_retry;
1507     ),
1508     TP_printk(/* print */
1509         TID_WRITE_SENDER_PRN,
1510         __get_str(dev),
1511         __entry->qpn,
1512         __entry->newreq,
1513         __entry->s_tid_cur,
1514         __entry->s_tid_tail,
1515         __entry->s_tid_head,
1516         __entry->pending_tid_w_resp,
1517         __entry->n_requests,
1518         __entry->n_tid_requests,
1519         __entry->s_flags,
1520         __entry->ps_flags,
1521         __entry->iow_flags,
1522         __entry->s_state,
1523         __entry->s_retry
1524     )
1525 );
1526 
1527 DEFINE_EVENT(/* event */
1528     hfi1_tid_write_sender_template, hfi1_tid_write_sender_rcv_resp,
1529     TP_PROTO(struct rvt_qp *qp, char newreq),
1530     TP_ARGS(qp, newreq)
1531 );
1532 
1533 DEFINE_EVENT(/* event */
1534     hfi1_tid_write_sender_template, hfi1_tid_write_sender_rcv_tid_ack,
1535     TP_PROTO(struct rvt_qp *qp, char newreq),
1536     TP_ARGS(qp, newreq)
1537 );
1538 
1539 DEFINE_EVENT(/* event */
1540     hfi1_tid_write_sender_template, hfi1_tid_write_sender_retry_timeout,
1541     TP_PROTO(struct rvt_qp *qp, char newreq),
1542     TP_ARGS(qp, newreq)
1543 );
1544 
1545 DEFINE_EVENT(/* event */
1546     hfi1_tid_write_sender_template, hfi1_tid_write_sender_make_tid_pkt,
1547     TP_PROTO(struct rvt_qp *qp, char newreq),
1548     TP_ARGS(qp, newreq)
1549 );
1550 
1551 DEFINE_EVENT(/* event */
1552     hfi1_tid_write_sender_template, hfi1_tid_write_sender_make_req,
1553     TP_PROTO(struct rvt_qp *qp, char newreq),
1554     TP_ARGS(qp, newreq)
1555 );
1556 
1557 DEFINE_EVENT(/* event */
1558     hfi1_tid_write_sender_template, hfi1_tid_write_sender_restart_rc,
1559     TP_PROTO(struct rvt_qp *qp, char newreq),
1560     TP_ARGS(qp, newreq)
1561 );
1562 
1563 DECLARE_EVENT_CLASS(/* tid_ack */
1564     hfi1_tid_ack_template,
1565     TP_PROTO(struct rvt_qp *qp, u32 aeth, u32 psn,
1566          u32 req_psn, u32 resync_psn),
1567     TP_ARGS(qp, aeth, psn, req_psn, resync_psn),
1568     TP_STRUCT__entry(/* entry */
1569         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
1570         __field(u32, qpn)
1571         __field(u32, aeth)
1572         __field(u32, psn)
1573         __field(u32, req_psn)
1574         __field(u32, resync_psn)
1575     ),
1576     TP_fast_assign(/* assign */
1577         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
1578         __entry->qpn = qp->ibqp.qp_num;
1579         __entry->aeth = aeth;
1580         __entry->psn = psn;
1581         __entry->req_psn = req_psn;
1582         __entry->resync_psn = resync_psn;
1583         ),
1584     TP_printk(/* print */
1585         "[%s] qpn 0x%x aeth 0x%x psn 0x%x req_psn 0x%x resync_psn 0x%x",
1586         __get_str(dev),
1587         __entry->qpn,
1588         __entry->aeth,
1589         __entry->psn,
1590         __entry->req_psn,
1591         __entry->resync_psn
1592     )
1593 );
1594 
1595 DEFINE_EVENT(/* rcv_tid_ack */
1596     hfi1_tid_ack_template, hfi1_rcv_tid_ack,
1597     TP_PROTO(struct rvt_qp *qp, u32 aeth, u32 psn,
1598          u32 req_psn, u32 resync_psn),
1599     TP_ARGS(qp, aeth, psn, req_psn, resync_psn)
1600 );
1601 
1602 DECLARE_EVENT_CLASS(/* kdeth_eflags_error */
1603     hfi1_kdeth_eflags_error_template,
1604     TP_PROTO(struct rvt_qp *qp, u8 rcv_type, u8 rte, u32 psn),
1605     TP_ARGS(qp, rcv_type, rte, psn),
1606     TP_STRUCT__entry(/* entry */
1607         DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
1608         __field(u32, qpn)
1609         __field(u8, rcv_type)
1610         __field(u8, rte)
1611         __field(u32, psn)
1612     ),
1613     TP_fast_assign(/* assign */
1614         DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device));
1615         __entry->qpn = qp->ibqp.qp_num;
1616         __entry->rcv_type = rcv_type;
1617         __entry->rte = rte;
1618         __entry->psn = psn;
1619     ),
1620     TP_printk(/* print */
1621         KDETH_EFLAGS_ERR_PRN,
1622         __get_str(dev),
1623         __entry->qpn,
1624         __entry->rcv_type,
1625         __entry->rte,
1626         __entry->psn
1627     )
1628 );
1629 
1630 DEFINE_EVENT(/* event */
1631     hfi1_kdeth_eflags_error_template, hfi1_eflags_err_write,
1632     TP_PROTO(struct rvt_qp *qp, u8 rcv_type, u8 rte, u32 psn),
1633     TP_ARGS(qp, rcv_type, rte, psn)
1634 );
1635 
1636 #endif /* __HFI1_TRACE_TID_H */
1637 
1638 #undef TRACE_INCLUDE_PATH
1639 #undef TRACE_INCLUDE_FILE
1640 #define TRACE_INCLUDE_PATH .
1641 #define TRACE_INCLUDE_FILE trace_tid
1642 #include <trace/define_trace.h>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!