/* * Copyright(c) 2015, 2016 Intel Corporation. * * This file is provided under a dual BSD/GPLv2 license. When using or * redistributing this file, you may do so under either license. * * GPL LICENSE SUMMARY * * This program is free software; you can redistribute it and/or modify * it under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * BSD LICENSE * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * - Neither the name of Intel Corporation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ #undef TRACE_SYSTEM_VAR #define TRACE_SYSTEM_VAR hfi1 #if !defined(__HFI1_TRACE_H) || defined(TRACE_HEADER_MULTI_READ) #define __HFI1_TRACE_H #include #include #include "hfi.h" #include "mad.h" #include "sdma.h" #define DD_DEV_ENTRY(dd) __string(dev, dev_name(&(dd)->pcidev->dev)) #define DD_DEV_ASSIGN(dd) __assign_str(dev, dev_name(&(dd)->pcidev->dev)) #define packettype_name(etype) { RHF_RCV_TYPE_##etype, #etype } #define show_packettype(etype) \ __print_symbolic(etype, \ packettype_name(EXPECTED), \ packettype_name(EAGER), \ packettype_name(IB), \ packettype_name(ERROR), \ packettype_name(BYPASS)) #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_rx TRACE_EVENT(hfi1_rcvhdr, TP_PROTO(struct hfi1_devdata *dd, u64 eflags, u32 ctxt, u32 etype, u32 hlen, u32 tlen, u32 updegr, u32 etail ), TP_ARGS(dd, ctxt, eflags, etype, hlen, tlen, updegr, etail), TP_STRUCT__entry(DD_DEV_ENTRY(dd) __field(u64, eflags) __field(u32, ctxt) __field(u32, etype) __field(u32, hlen) __field(u32, tlen) __field(u32, updegr) __field(u32, etail) ), TP_fast_assign(DD_DEV_ASSIGN(dd); __entry->eflags = eflags; __entry->ctxt = ctxt; __entry->etype = etype; __entry->hlen = hlen; __entry->tlen = tlen; __entry->updegr = updegr; __entry->etail = etail; ), TP_printk( "[%s] ctxt %d eflags 0x%llx etype %d,%s hlen %d tlen %d updegr %d etail %d", __get_str(dev), __entry->ctxt, __entry->eflags, __entry->etype, show_packettype(__entry->etype), __entry->hlen, __entry->tlen, __entry->updegr, __entry->etail ) ); TRACE_EVENT(hfi1_receive_interrupt, TP_PROTO(struct hfi1_devdata *dd, u32 ctxt), TP_ARGS(dd, ctxt), TP_STRUCT__entry(DD_DEV_ENTRY(dd) __field(u32, ctxt) __field(u8, slow_path) __field(u8, dma_rtail) ), TP_fast_assign(DD_DEV_ASSIGN(dd); __entry->ctxt = ctxt; if (dd->rcd[ctxt]->do_interrupt == &handle_receive_interrupt) { __entry->slow_path = 1; __entry->dma_rtail = 0xFF; } else if (dd->rcd[ctxt]->do_interrupt == &handle_receive_interrupt_dma_rtail){ __entry->dma_rtail = 1; __entry->slow_path = 0; } else if (dd->rcd[ctxt]->do_interrupt == &handle_receive_interrupt_nodma_rtail) { __entry->dma_rtail = 0; __entry->slow_path = 0; } ), TP_printk("[%s] ctxt %d SlowPath: %d DmaRtail: %d", __get_str(dev), __entry->ctxt, __entry->slow_path, __entry->dma_rtail ) ); TRACE_EVENT(hfi1_exp_tid_reg, TP_PROTO(unsigned ctxt, u16 subctxt, u32 rarr, u32 npages, unsigned long va, unsigned long pa, dma_addr_t dma), TP_ARGS(ctxt, subctxt, rarr, npages, va, pa, dma), TP_STRUCT__entry( __field(unsigned, ctxt) __field(u16, subctxt) __field(u32, rarr) __field(u32, npages) __field(unsigned long, va) __field(unsigned long, pa) __field(dma_addr_t, dma) ), TP_fast_assign( __entry->ctxt = ctxt; __entry->subctxt = subctxt; __entry->rarr = rarr; __entry->npages = npages; __entry->va = va; __entry->pa = pa; __entry->dma = dma; ), TP_printk("[%u:%u] entry:%u, %u pages @ 0x%lx, va:0x%lx dma:0x%llx", __entry->ctxt, __entry->subctxt, __entry->rarr, __entry->npages, __entry->pa, __entry->va, __entry->dma ) ); TRACE_EVENT(hfi1_exp_tid_unreg, TP_PROTO(unsigned ctxt, u16 subctxt, u32 rarr, u32 npages, unsigned long va, unsigned long pa, dma_addr_t dma), TP_ARGS(ctxt, subctxt, rarr, npages, va, pa, dma), TP_STRUCT__entry( __field(unsigned, ctxt) __field(u16, subctxt) __field(u32, rarr) __field(u32, npages) __field(unsigned long, va) __field(unsigned long, pa) __field(dma_addr_t, dma) ), TP_fast_assign( __entry->ctxt = ctxt; __entry->subctxt = subctxt; __entry->rarr = rarr; __entry->npages = npages; __entry->va = va; __entry->pa = pa; __entry->dma = dma; ), TP_printk("[%u:%u] entry:%u, %u pages @ 0x%lx, va:0x%lx dma:0x%llx", __entry->ctxt, __entry->subctxt, __entry->rarr, __entry->npages, __entry->pa, __entry->va, __entry->dma ) ); TRACE_EVENT(hfi1_exp_tid_inval, TP_PROTO(unsigned ctxt, u16 subctxt, unsigned long va, u32 rarr, u32 npages, dma_addr_t dma), TP_ARGS(ctxt, subctxt, va, rarr, npages, dma), TP_STRUCT__entry( __field(unsigned, ctxt) __field(u16, subctxt) __field(unsigned long, va) __field(u32, rarr) __field(u32, npages) __field(dma_addr_t, dma) ), TP_fast_assign( __entry->ctxt = ctxt; __entry->subctxt = subctxt; __entry->va = va; __entry->rarr = rarr; __entry->npages = npages; __entry->dma = dma; ), TP_printk("[%u:%u] entry:%u, %u pages @ 0x%lx dma: 0x%llx", __entry->ctxt, __entry->subctxt, __entry->rarr, __entry->npages, __entry->va, __entry->dma ) ); TRACE_EVENT(hfi1_mmu_invalidate, TP_PROTO(unsigned ctxt, u16 subctxt, const char *type, unsigned long start, unsigned long end), TP_ARGS(ctxt, subctxt, type, start, end), TP_STRUCT__entry( __field(unsigned, ctxt) __field(u16, subctxt) __string(type, type) __field(unsigned long, start) __field(unsigned long, end) ), TP_fast_assign( __entry->ctxt = ctxt; __entry->subctxt = subctxt; __assign_str(type, type); __entry->start = start; __entry->end = end; ), TP_printk("[%3u:%02u] MMU Invalidate (%s) 0x%lx - 0x%lx", __entry->ctxt, __entry->subctxt, __get_str(type), __entry->start, __entry->end ) ); #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_tx TRACE_EVENT(hfi1_piofree, TP_PROTO(struct send_context *sc, int extra), TP_ARGS(sc, extra), TP_STRUCT__entry(DD_DEV_ENTRY(sc->dd) __field(u32, sw_index) __field(u32, hw_context) __field(int, extra) ), TP_fast_assign(DD_DEV_ASSIGN(sc->dd); __entry->sw_index = sc->sw_index; __entry->hw_context = sc->hw_context; __entry->extra = extra; ), TP_printk("[%s] ctxt %u(%u) extra %d", __get_str(dev), __entry->sw_index, __entry->hw_context, __entry->extra ) ); TRACE_EVENT(hfi1_wantpiointr, TP_PROTO(struct send_context *sc, u32 needint, u64 credit_ctrl), TP_ARGS(sc, needint, credit_ctrl), TP_STRUCT__entry(DD_DEV_ENTRY(sc->dd) __field(u32, sw_index) __field(u32, hw_context) __field(u32, needint) __field(u64, credit_ctrl) ), TP_fast_assign(DD_DEV_ASSIGN(sc->dd); __entry->sw_index = sc->sw_index; __entry->hw_context = sc->hw_context; __entry->needint = needint; __entry->credit_ctrl = credit_ctrl; ), TP_printk("[%s] ctxt %u(%u) on %d credit_ctrl 0x%llx", __get_str(dev), __entry->sw_index, __entry->hw_context, __entry->needint, (unsigned long long)__entry->credit_ctrl ) ); DECLARE_EVENT_CLASS(hfi1_qpsleepwakeup_template, TP_PROTO(struct rvt_qp *qp, u32 flags), TP_ARGS(qp, flags), TP_STRUCT__entry( DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device)) __field(u32, qpn) __field(u32, flags) __field(u32, s_flags) ), TP_fast_assign( DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)) __entry->flags = flags; __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; ), TP_printk( "[%s] qpn 0x%x flags 0x%x s_flags 0x%x", __get_str(dev), __entry->qpn, __entry->flags, __entry->s_flags ) ); DEFINE_EVENT(hfi1_qpsleepwakeup_template, hfi1_qpwakeup, TP_PROTO(struct rvt_qp *qp, u32 flags), TP_ARGS(qp, flags)); DEFINE_EVENT(hfi1_qpsleepwakeup_template, hfi1_qpsleep, TP_PROTO(struct rvt_qp *qp, u32 flags), TP_ARGS(qp, flags)); #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_ibhdrs u8 ibhdr_exhdr_len(struct hfi1_ib_header *hdr); const char *parse_everbs_hdrs(struct trace_seq *p, u8 opcode, void *ehdrs); #define __parse_ib_ehdrs(op, ehdrs) parse_everbs_hdrs(p, op, ehdrs) const char *parse_sdma_flags(struct trace_seq *p, u64 desc0, u64 desc1); #define __parse_sdma_flags(desc0, desc1) parse_sdma_flags(p, desc0, desc1) #define lrh_name(lrh) { HFI1_##lrh, #lrh } #define show_lnh(lrh) \ __print_symbolic(lrh, \ lrh_name(LRH_BTH), \ lrh_name(LRH_GRH)) #define ib_opcode_name(opcode) { IB_OPCODE_##opcode, #opcode } #define show_ib_opcode(opcode) \ __print_symbolic(opcode, \ ib_opcode_name(RC_SEND_FIRST), \ ib_opcode_name(RC_SEND_MIDDLE), \ ib_opcode_name(RC_SEND_LAST), \ ib_opcode_name(RC_SEND_LAST_WITH_IMMEDIATE), \ ib_opcode_name(RC_SEND_ONLY), \ ib_opcode_name(RC_SEND_ONLY_WITH_IMMEDIATE), \ ib_opcode_name(RC_RDMA_WRITE_FIRST), \ ib_opcode_name(RC_RDMA_WRITE_MIDDLE), \ ib_opcode_name(RC_RDMA_WRITE_LAST), \ ib_opcode_name(RC_RDMA_WRITE_LAST_WITH_IMMEDIATE), \ ib_opcode_name(RC_RDMA_WRITE_ONLY), \ ib_opcode_name(RC_RDMA_WRITE_ONLY_WITH_IMMEDIATE), \ ib_opcode_name(RC_RDMA_READ_REQUEST), \ ib_opcode_name(RC_RDMA_READ_RESPONSE_FIRST), \ ib_opcode_name(RC_RDMA_READ_RESPONSE_MIDDLE), \ ib_opcode_name(RC_RDMA_READ_RESPONSE_LAST), \ ib_opcode_name(RC_RDMA_READ_RESPONSE_ONLY), \ ib_opcode_name(RC_ACKNOWLEDGE), \ ib_opcode_name(RC_ATOMIC_ACKNOWLEDGE), \ ib_opcode_name(RC_COMPARE_SWAP), \ ib_opcode_name(RC_FETCH_ADD), \ ib_opcode_name(UC_SEND_FIRST), \ ib_opcode_name(UC_SEND_MIDDLE), \ ib_opcode_name(UC_SEND_LAST), \ ib_opcode_name(UC_SEND_LAST_WITH_IMMEDIATE), \ ib_opcode_name(UC_SEND_ONLY), \ ib_opcode_name(UC_SEND_ONLY_WITH_IMMEDIATE), \ ib_opcode_name(UC_RDMA_WRITE_FIRST), \ ib_opcode_name(UC_RDMA_WRITE_MIDDLE), \ ib_opcode_name(UC_RDMA_WRITE_LAST), \ ib_opcode_name(UC_RDMA_WRITE_LAST_WITH_IMMEDIATE), \ ib_opcode_name(UC_RDMA_WRITE_ONLY), \ ib_opcode_name(UC_RDMA_WRITE_ONLY_WITH_IMMEDIATE), \ ib_opcode_name(UD_SEND_ONLY), \ ib_opcode_name(UD_SEND_ONLY_WITH_IMMEDIATE), \ ib_opcode_name(CNP)) #define LRH_PRN "vl %d lver %d sl %d lnh %d,%s dlid %.4x len %d slid %.4x" #define BTH_PRN \ "op 0x%.2x,%s se %d m %d pad %d tver %d pkey 0x%.4x " \ "f %d b %d qpn 0x%.6x a %d psn 0x%.8x" #define EHDR_PRN "%s" DECLARE_EVENT_CLASS(hfi1_ibhdr_template, TP_PROTO(struct hfi1_devdata *dd, struct hfi1_ib_header *hdr), TP_ARGS(dd, hdr), TP_STRUCT__entry( DD_DEV_ENTRY(dd) /* LRH */ __field(u8, vl) __field(u8, lver) __field(u8, sl) __field(u8, lnh) __field(u16, dlid) __field(u16, len) __field(u16, slid) /* BTH */ __field(u8, opcode) __field(u8, se) __field(u8, m) __field(u8, pad) __field(u8, tver) __field(u16, pkey) __field(u8, f) __field(u8, b) __field(u32, qpn) __field(u8, a) __field(u32, psn) /* extended headers */ __dynamic_array(u8, ehdrs, ibhdr_exhdr_len(hdr)) ), TP_fast_assign( struct hfi1_other_headers *ohdr; DD_DEV_ASSIGN(dd); /* LRH */ __entry->vl = (u8)(be16_to_cpu(hdr->lrh[0]) >> 12); __entry->lver = (u8)(be16_to_cpu(hdr->lrh[0]) >> 8) & 0xf; __entry->sl = (u8)(be16_to_cpu(hdr->lrh[0]) >> 4) & 0xf; __entry->lnh = (u8)(be16_to_cpu(hdr->lrh[0]) & 3); __entry->dlid = be16_to_cpu(hdr->lrh[1]); /* allow for larger len */ __entry->len = be16_to_cpu(hdr->lrh[2]); __entry->slid = be16_to_cpu(hdr->lrh[3]); /* BTH */ if (__entry->lnh == HFI1_LRH_BTH) ohdr = &hdr->u.oth; else ohdr = &hdr->u.l.oth; __entry->opcode = (be32_to_cpu(ohdr->bth[0]) >> 24) & 0xff; __entry->se = (be32_to_cpu(ohdr->bth[0]) >> 23) & 1; __entry->m = (be32_to_cpu(ohdr->bth[0]) >> 22) & 1; __entry->pad = (be32_to_cpu(ohdr->bth[0]) >> 20) & 3; __entry->tver = (be32_to_cpu(ohdr->bth[0]) >> 16) & 0xf; __entry->pkey = be32_to_cpu(ohdr->bth[0]) & 0xffff; __entry->f = (be32_to_cpu(ohdr->bth[1]) >> HFI1_FECN_SHIFT) & HFI1_FECN_MASK; __entry->b = (be32_to_cpu(ohdr->bth[1]) >> HFI1_BECN_SHIFT) & HFI1_BECN_MASK; __entry->qpn = be32_to_cpu(ohdr->bth[1]) & RVT_QPN_MASK; __entry->a = (be32_to_cpu(ohdr->bth[2]) >> 31) & 1; /* allow for larger PSN */ __entry->psn = be32_to_cpu(ohdr->bth[2]) & 0x7fffffff; /* extended headers */ memcpy(__get_dynamic_array(ehdrs), &ohdr->u, ibhdr_exhdr_len(hdr)); ), TP_printk("[%s] " LRH_PRN " " BTH_PRN " " EHDR_PRN, __get_str(dev), /* LRH */ __entry->vl, __entry->lver, __entry->sl, __entry->lnh, show_lnh(__entry->lnh), __entry->dlid, __entry->len, __entry->slid, /* BTH */ __entry->opcode, show_ib_opcode(__entry->opcode), __entry->se, __entry->m, __entry->pad, __entry->tver, __entry->pkey, __entry->f, __entry->b, __entry->qpn, __entry->a, __entry->psn, /* extended headers */ __parse_ib_ehdrs( __entry->opcode, (void *)__get_dynamic_array(ehdrs)) ) ); DEFINE_EVENT(hfi1_ibhdr_template, input_ibhdr, TP_PROTO(struct hfi1_devdata *dd, struct hfi1_ib_header *hdr), TP_ARGS(dd, hdr)); DEFINE_EVENT(hfi1_ibhdr_template, pio_output_ibhdr, TP_PROTO(struct hfi1_devdata *dd, struct hfi1_ib_header *hdr), TP_ARGS(dd, hdr)); DEFINE_EVENT(hfi1_ibhdr_template, ack_output_ibhdr, TP_PROTO(struct hfi1_devdata *dd, struct hfi1_ib_header *hdr), TP_ARGS(dd, hdr)); DEFINE_EVENT(hfi1_ibhdr_template, sdma_output_ibhdr, TP_PROTO(struct hfi1_devdata *dd, struct hfi1_ib_header *hdr), TP_ARGS(dd, hdr)); #define SNOOP_PRN \ "slid %.4x dlid %.4x qpn 0x%.6x opcode 0x%.2x,%s " \ "svc lvl %d pkey 0x%.4x [header = %d bytes] [data = %d bytes]" #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_snoop TRACE_EVENT(snoop_capture, TP_PROTO(struct hfi1_devdata *dd, int hdr_len, struct hfi1_ib_header *hdr, int data_len, void *data), TP_ARGS(dd, hdr_len, hdr, data_len, data), TP_STRUCT__entry( DD_DEV_ENTRY(dd) __field(u16, slid) __field(u16, dlid) __field(u32, qpn) __field(u8, opcode) __field(u8, sl) __field(u16, pkey) __field(u32, hdr_len) __field(u32, data_len) __field(u8, lnh) __dynamic_array(u8, raw_hdr, hdr_len) __dynamic_array(u8, raw_pkt, data_len) ), TP_fast_assign( struct hfi1_other_headers *ohdr; __entry->lnh = (u8)(be16_to_cpu(hdr->lrh[0]) & 3); if (__entry->lnh == HFI1_LRH_BTH) ohdr = &hdr->u.oth; else ohdr = &hdr->u.l.oth; DD_DEV_ASSIGN(dd); __entry->slid = be16_to_cpu(hdr->lrh[3]); __entry->dlid = be16_to_cpu(hdr->lrh[1]); __entry->qpn = be32_to_cpu(ohdr->bth[1]) & RVT_QPN_MASK; __entry->opcode = (be32_to_cpu(ohdr->bth[0]) >> 24) & 0xff; __entry->sl = (u8)(be16_to_cpu(hdr->lrh[0]) >> 4) & 0xf; __entry->pkey = be32_to_cpu(ohdr->bth[0]) & 0xffff; __entry->hdr_len = hdr_len; __entry->data_len = data_len; memcpy(__get_dynamic_array(raw_hdr), hdr, hdr_len); memcpy(__get_dynamic_array(raw_pkt), data, data_len); ), TP_printk( "[%s] " SNOOP_PRN, __get_str(dev), __entry->slid, __entry->dlid, __entry->qpn, __entry->opcode, show_ib_opcode(__entry->opcode), __entry->sl, __entry->pkey, __entry->hdr_len, __entry->data_len ) ); #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_ctxts #define UCTXT_FMT \ "cred:%u, credaddr:0x%llx, piobase:0x%llx, rcvhdr_cnt:%u, " \ "rcvbase:0x%llx, rcvegrc:%u, rcvegrb:0x%llx" TRACE_EVENT(hfi1_uctxtdata, TP_PROTO(struct hfi1_devdata *dd, struct hfi1_ctxtdata *uctxt), TP_ARGS(dd, uctxt), TP_STRUCT__entry(DD_DEV_ENTRY(dd) __field(unsigned, ctxt) __field(u32, credits) __field(u64, hw_free) __field(u64, piobase) __field(u16, rcvhdrq_cnt) __field(u64, rcvhdrq_phys) __field(u32, eager_cnt) __field(u64, rcvegr_phys) ), TP_fast_assign(DD_DEV_ASSIGN(dd); __entry->ctxt = uctxt->ctxt; __entry->credits = uctxt->sc->credits; __entry->hw_free = (u64)uctxt->sc->hw_free; __entry->piobase = (u64)uctxt->sc->base_addr; __entry->rcvhdrq_cnt = uctxt->rcvhdrq_cnt; __entry->rcvhdrq_phys = uctxt->rcvhdrq_phys; __entry->eager_cnt = uctxt->egrbufs.alloced; __entry->rcvegr_phys = uctxt->egrbufs.rcvtids[0].phys; ), TP_printk("[%s] ctxt %u " UCTXT_FMT, __get_str(dev), __entry->ctxt, __entry->credits, __entry->hw_free, __entry->piobase, __entry->rcvhdrq_cnt, __entry->rcvhdrq_phys, __entry->eager_cnt, __entry->rcvegr_phys ) ); #define CINFO_FMT \ "egrtids:%u, egr_size:%u, hdrq_cnt:%u, hdrq_size:%u, sdma_ring_size:%u" TRACE_EVENT(hfi1_ctxt_info, TP_PROTO(struct hfi1_devdata *dd, unsigned ctxt, unsigned subctxt, struct hfi1_ctxt_info cinfo), TP_ARGS(dd, ctxt, subctxt, cinfo), TP_STRUCT__entry(DD_DEV_ENTRY(dd) __field(unsigned, ctxt) __field(unsigned, subctxt) __field(u16, egrtids) __field(u16, rcvhdrq_cnt) __field(u16, rcvhdrq_size) __field(u16, sdma_ring_size) __field(u32, rcvegr_size) ), TP_fast_assign(DD_DEV_ASSIGN(dd); __entry->ctxt = ctxt; __entry->subctxt = subctxt; __entry->egrtids = cinfo.egrtids; __entry->rcvhdrq_cnt = cinfo.rcvhdrq_cnt; __entry->rcvhdrq_size = cinfo.rcvhdrq_entsize; __entry->sdma_ring_size = cinfo.sdma_ring_size; __entry->rcvegr_size = cinfo.rcvegr_size; ), TP_printk("[%s] ctxt %u:%u " CINFO_FMT, __get_str(dev), __entry->ctxt, __entry->subctxt, __entry->egrtids, __entry->rcvegr_size, __entry->rcvhdrq_cnt, __entry->rcvhdrq_size, __entry->sdma_ring_size ) ); #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_sma #define BCT_FORMAT \ "shared_limit %x vls 0-7 [%x,%x][%x,%x][%x,%x][%x,%x][%x,%x][%x,%x][%x,%x][%x,%x] 15 [%x,%x]" #define BCT(field) \ be16_to_cpu( \ ((struct buffer_control *)__get_dynamic_array(bct))->field \ ) DECLARE_EVENT_CLASS(hfi1_bct_template, TP_PROTO(struct hfi1_devdata *dd, struct buffer_control *bc), TP_ARGS(dd, bc), TP_STRUCT__entry(DD_DEV_ENTRY(dd) __dynamic_array(u8, bct, sizeof(*bc)) ), TP_fast_assign(DD_DEV_ASSIGN(dd); memcpy(__get_dynamic_array(bct), bc, sizeof(*bc)); ), TP_printk(BCT_FORMAT, BCT(overall_shared_limit), BCT(vl[0].dedicated), BCT(vl[0].shared), BCT(vl[1].dedicated), BCT(vl[1].shared), BCT(vl[2].dedicated), BCT(vl[2].shared), BCT(vl[3].dedicated), BCT(vl[3].shared), BCT(vl[4].dedicated), BCT(vl[4].shared), BCT(vl[5].dedicated), BCT(vl[5].shared), BCT(vl[6].dedicated), BCT(vl[6].shared), BCT(vl[7].dedicated), BCT(vl[7].shared), BCT(vl[15].dedicated), BCT(vl[15].shared) ) ); DEFINE_EVENT(hfi1_bct_template, bct_set, TP_PROTO(struct hfi1_devdata *dd, struct buffer_control *bc), TP_ARGS(dd, bc)); DEFINE_EVENT(hfi1_bct_template, bct_get, TP_PROTO(struct hfi1_devdata *dd, struct buffer_control *bc), TP_ARGS(dd, bc)); #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_sdma TRACE_EVENT(hfi1_sdma_descriptor, TP_PROTO(struct sdma_engine *sde, u64 desc0, u64 desc1, u16 e, void *descp), TP_ARGS(sde, desc0, desc1, e, descp), TP_STRUCT__entry(DD_DEV_ENTRY(sde->dd) __field(void *, descp) __field(u64, desc0) __field(u64, desc1) __field(u16, e) __field(u8, idx) ), TP_fast_assign(DD_DEV_ASSIGN(sde->dd); __entry->desc0 = desc0; __entry->desc1 = desc1; __entry->idx = sde->this_idx; __entry->descp = descp; __entry->e = e; ), TP_printk( "[%s] SDE(%u) flags:%s addr:0x%016llx gen:%u len:%u d0:%016llx d1:%016llx to %p,%u", __get_str(dev), __entry->idx, __parse_sdma_flags(__entry->desc0, __entry->desc1), (__entry->desc0 >> SDMA_DESC0_PHY_ADDR_SHIFT) & SDMA_DESC0_PHY_ADDR_MASK, (u8)((__entry->desc1 >> SDMA_DESC1_GENERATION_SHIFT) & SDMA_DESC1_GENERATION_MASK), (u16)((__entry->desc0 >> SDMA_DESC0_BYTE_COUNT_SHIFT) & SDMA_DESC0_BYTE_COUNT_MASK), __entry->desc0, __entry->desc1, __entry->descp, __entry->e ) ); TRACE_EVENT(hfi1_sdma_engine_select, TP_PROTO(struct hfi1_devdata *dd, u32 sel, u8 vl, u8 idx), TP_ARGS(dd, sel, vl, idx), TP_STRUCT__entry(DD_DEV_ENTRY(dd) __field(u32, sel) __field(u8, vl) __field(u8, idx) ), TP_fast_assign(DD_DEV_ASSIGN(dd); __entry->sel = sel; __entry->vl = vl; __entry->idx = idx; ), TP_printk("[%s] selecting SDE %u sel 0x%x vl %u", __get_str(dev), __entry->idx, __entry->sel, __entry->vl ) ); DECLARE_EVENT_CLASS(hfi1_sdma_engine_class, TP_PROTO(struct sdma_engine *sde, u64 status), TP_ARGS(sde, status), TP_STRUCT__entry(DD_DEV_ENTRY(sde->dd) __field(u64, status) __field(u8, idx) ), TP_fast_assign(DD_DEV_ASSIGN(sde->dd); __entry->status = status; __entry->idx = sde->this_idx; ), TP_printk("[%s] SDE(%u) status %llx", __get_str(dev), __entry->idx, (unsigned long long)__entry->status ) ); DEFINE_EVENT(hfi1_sdma_engine_class, hfi1_sdma_engine_interrupt, TP_PROTO(struct sdma_engine *sde, u64 status), TP_ARGS(sde, status) ); DEFINE_EVENT(hfi1_sdma_engine_class, hfi1_sdma_engine_progress, TP_PROTO(struct sdma_engine *sde, u64 status), TP_ARGS(sde, status) ); DECLARE_EVENT_CLASS(hfi1_sdma_ahg_ad, TP_PROTO(struct sdma_engine *sde, int aidx), TP_ARGS(sde, aidx), TP_STRUCT__entry(DD_DEV_ENTRY(sde->dd) __field(int, aidx) __field(u8, idx) ), TP_fast_assign(DD_DEV_ASSIGN(sde->dd); __entry->idx = sde->this_idx; __entry->aidx = aidx; ), TP_printk("[%s] SDE(%u) aidx %d", __get_str(dev), __entry->idx, __entry->aidx ) ); DEFINE_EVENT(hfi1_sdma_ahg_ad, hfi1_ahg_allocate, TP_PROTO(struct sdma_engine *sde, int aidx), TP_ARGS(sde, aidx)); DEFINE_EVENT(hfi1_sdma_ahg_ad, hfi1_ahg_deallocate, TP_PROTO(struct sdma_engine *sde, int aidx), TP_ARGS(sde, aidx)); #ifdef CONFIG_HFI1_DEBUG_SDMA_ORDER TRACE_EVENT(hfi1_sdma_progress, TP_PROTO(struct sdma_engine *sde, u16 hwhead, u16 swhead, struct sdma_txreq *txp ), TP_ARGS(sde, hwhead, swhead, txp), TP_STRUCT__entry(DD_DEV_ENTRY(sde->dd) __field(u64, sn) __field(u16, hwhead) __field(u16, swhead) __field(u16, txnext) __field(u16, tx_tail) __field(u16, tx_head) __field(u8, idx) ), TP_fast_assign(DD_DEV_ASSIGN(sde->dd); __entry->hwhead = hwhead; __entry->swhead = swhead; __entry->tx_tail = sde->tx_tail; __entry->tx_head = sde->tx_head; __entry->txnext = txp ? txp->next_descq_idx : ~0; __entry->idx = sde->this_idx; __entry->sn = txp ? txp->sn : ~0; ), TP_printk( "[%s] SDE(%u) sn %llu hwhead %u swhead %u next_descq_idx %u tx_head %u tx_tail %u", __get_str(dev), __entry->idx, __entry->sn, __entry->hwhead, __entry->swhead, __entry->txnext, __entry->tx_head, __entry->tx_tail ) ); #else TRACE_EVENT(hfi1_sdma_progress, TP_PROTO(struct sdma_engine *sde, u16 hwhead, u16 swhead, struct sdma_txreq *txp ), TP_ARGS(sde, hwhead, swhead, txp), TP_STRUCT__entry(DD_DEV_ENTRY(sde->dd) __field(u16, hwhead) __field(u16, swhead) __field(u16, txnext) __field(u16, tx_tail) __field(u16, tx_head) __field(u8, idx) ), TP_fast_assign(DD_DEV_ASSIGN(sde->dd); __entry->hwhead = hwhead; __entry->swhead = swhead; __entry->tx_tail = sde->tx_tail; __entry->tx_head = sde->tx_head; __entry->txnext = txp ? txp->next_descq_idx : ~0; __entry->idx = sde->this_idx; ), TP_printk( "[%s] SDE(%u) hwhead %u swhead %u next_descq_idx %u tx_head %u tx_tail %u", __get_str(dev), __entry->idx, __entry->hwhead, __entry->swhead, __entry->txnext, __entry->tx_head, __entry->tx_tail ) ); #endif DECLARE_EVENT_CLASS(hfi1_sdma_sn, TP_PROTO(struct sdma_engine *sde, u64 sn), TP_ARGS(sde, sn), TP_STRUCT__entry(DD_DEV_ENTRY(sde->dd) __field(u64, sn) __field(u8, idx) ), TP_fast_assign(DD_DEV_ASSIGN(sde->dd); __entry->sn = sn; __entry->idx = sde->this_idx; ), TP_printk("[%s] SDE(%u) sn %llu", __get_str(dev), __entry->idx, __entry->sn ) ); DEFINE_EVENT(hfi1_sdma_sn, hfi1_sdma_out_sn, TP_PROTO( struct sdma_engine *sde, u64 sn ), TP_ARGS(sde, sn) ); DEFINE_EVENT(hfi1_sdma_sn, hfi1_sdma_in_sn, TP_PROTO(struct sdma_engine *sde, u64 sn), TP_ARGS(sde, sn) ); #define USDMA_HDR_FORMAT \ "[%s:%u:%u:%u] PBC=(0x%x 0x%x) LRH=(0x%x 0x%x) BTH=(0x%x 0x%x 0x%x) KDETH=(0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x) TIDVal=0x%x" TRACE_EVENT(hfi1_sdma_user_header, TP_PROTO(struct hfi1_devdata *dd, u16 ctxt, u8 subctxt, u16 req, struct hfi1_pkt_header *hdr, u32 tidval), TP_ARGS(dd, ctxt, subctxt, req, hdr, tidval), TP_STRUCT__entry( DD_DEV_ENTRY(dd) __field(u16, ctxt) __field(u8, subctxt) __field(u16, req) __field(__le32, pbc0) __field(__le32, pbc1) __field(__be32, lrh0) __field(__be32, lrh1) __field(__be32, bth0) __field(__be32, bth1) __field(__be32, bth2) __field(__le32, kdeth0) __field(__le32, kdeth1) __field(__le32, kdeth2) __field(__le32, kdeth3) __field(__le32, kdeth4) __field(__le32, kdeth5) __field(__le32, kdeth6) __field(__le32, kdeth7) __field(__le32, kdeth8) __field(u32, tidval) ), TP_fast_assign( __le32 *pbc = (__le32 *)hdr->pbc; __be32 *lrh = (__be32 *)hdr->lrh; __be32 *bth = (__be32 *)hdr->bth; __le32 *kdeth = (__le32 *)&hdr->kdeth; DD_DEV_ASSIGN(dd); __entry->ctxt = ctxt; __entry->subctxt = subctxt; __entry->req = req; __entry->pbc0 = pbc[0]; __entry->pbc1 = pbc[1]; __entry->lrh0 = be32_to_cpu(lrh[0]); __entry->lrh1 = be32_to_cpu(lrh[1]); __entry->bth0 = be32_to_cpu(bth[0]); __entry->bth1 = be32_to_cpu(bth[1]); __entry->bth2 = be32_to_cpu(bth[2]); __entry->kdeth0 = kdeth[0]; __entry->kdeth1 = kdeth[1]; __entry->kdeth2 = kdeth[2]; __entry->kdeth3 = kdeth[3]; __entry->kdeth4 = kdeth[4]; __entry->kdeth5 = kdeth[5]; __entry->kdeth6 = kdeth[6]; __entry->kdeth7 = kdeth[7]; __entry->kdeth8 = kdeth[8]; __entry->tidval = tidval; ), TP_printk(USDMA_HDR_FORMAT, __get_str(dev), __entry->ctxt, __entry->subctxt, __entry->req, __entry->pbc1, __entry->pbc0, __entry->lrh0, __entry->lrh1, __entry->bth0, __entry->bth1, __entry->bth2, __entry->kdeth0, __entry->kdeth1, __entry->kdeth2, __entry->kdeth3, __entry->kdeth4, __entry->kdeth5, __entry->kdeth6, __entry->kdeth7, __entry->kdeth8, __entry->tidval ) ); #define SDMA_UREQ_FMT \ "[%s:%u:%u] ver/op=0x%x, iovcnt=%u, npkts=%u, frag=%u, idx=%u" TRACE_EVENT(hfi1_sdma_user_reqinfo, TP_PROTO(struct hfi1_devdata *dd, u16 ctxt, u8 subctxt, u16 *i), TP_ARGS(dd, ctxt, subctxt, i), TP_STRUCT__entry( DD_DEV_ENTRY(dd); __field(u16, ctxt) __field(u8, subctxt) __field(u8, ver_opcode) __field(u8, iovcnt) __field(u16, npkts) __field(u16, fragsize) __field(u16, comp_idx) ), TP_fast_assign( DD_DEV_ASSIGN(dd); __entry->ctxt = ctxt; __entry->subctxt = subctxt; __entry->ver_opcode = i[0] & 0xff; __entry->iovcnt = (i[0] >> 8) & 0xff; __entry->npkts = i[1]; __entry->fragsize = i[2]; __entry->comp_idx = i[3]; ), TP_printk(SDMA_UREQ_FMT, __get_str(dev), __entry->ctxt, __entry->subctxt, __entry->ver_opcode, __entry->iovcnt, __entry->npkts, __entry->fragsize, __entry->comp_idx ) ); #define usdma_complete_name(st) { st, #st } #define show_usdma_complete_state(st) \ __print_symbolic(st, \ usdma_complete_name(FREE), \ usdma_complete_name(QUEUED), \ usdma_complete_name(COMPLETE), \ usdma_complete_name(ERROR)) TRACE_EVENT(hfi1_sdma_user_completion, TP_PROTO(struct hfi1_devdata *dd, u16 ctxt, u8 subctxt, u16 idx, u8 state, int code), TP_ARGS(dd, ctxt, subctxt, idx, state, code), TP_STRUCT__entry( DD_DEV_ENTRY(dd) __field(u16, ctxt) __field(u8, subctxt) __field(u16, idx) __field(u8, state) __field(int, code) ), TP_fast_assign( DD_DEV_ASSIGN(dd); __entry->ctxt = ctxt; __entry->subctxt = subctxt; __entry->idx = idx; __entry->state = state; __entry->code = code; ), TP_printk("[%s:%u:%u:%u] SDMA completion state %s (%d)", __get_str(dev), __entry->ctxt, __entry->subctxt, __entry->idx, show_usdma_complete_state(__entry->state), __entry->code) ); const char *print_u32_array(struct trace_seq *, u32 *, int); #define __print_u32_hex(arr, len) print_u32_array(p, arr, len) TRACE_EVENT(hfi1_sdma_user_header_ahg, TP_PROTO(struct hfi1_devdata *dd, u16 ctxt, u8 subctxt, u16 req, u8 sde, u8 ahgidx, u32 *ahg, int len, u32 tidval), TP_ARGS(dd, ctxt, subctxt, req, sde, ahgidx, ahg, len, tidval), TP_STRUCT__entry( DD_DEV_ENTRY(dd) __field(u16, ctxt) __field(u8, subctxt) __field(u16, req) __field(u8, sde) __field(u8, idx) __field(int, len) __field(u32, tidval) __array(u32, ahg, 10) ), TP_fast_assign( DD_DEV_ASSIGN(dd); __entry->ctxt = ctxt; __entry->subctxt = subctxt; __entry->req = req; __entry->sde = sde; __entry->idx = ahgidx; __entry->len = len; __entry->tidval = tidval; memcpy(__entry->ahg, ahg, len * sizeof(u32)); ), TP_printk("[%s:%u:%u:%u] (SDE%u/AHG%u) ahg[0-%d]=(%s) TIDVal=0x%x", __get_str(dev), __entry->ctxt, __entry->subctxt, __entry->req, __entry->sde, __entry->idx, __entry->len - 1, __print_u32_hex(__entry->ahg, __entry->len), __entry->tidval ) ); TRACE_EVENT(hfi1_sdma_state, TP_PROTO(struct sdma_engine *sde, const char *cstate, const char *nstate ), TP_ARGS(sde, cstate, nstate), TP_STRUCT__entry(DD_DEV_ENTRY(sde->dd) __string(curstate, cstate) __string(newstate, nstate) ), TP_fast_assign(DD_DEV_ASSIGN(sde->dd); __assign_str(curstate, cstate); __assign_str(newstate, nstate); ), TP_printk("[%s] current state %s new state %s", __get_str(dev), __get_str(curstate), __get_str(newstate) ) ); #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_rc DECLARE_EVENT_CLASS(hfi1_rc_template, TP_PROTO(struct rvt_qp *qp, u32 psn), TP_ARGS(qp, psn), TP_STRUCT__entry( DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device)) __field(u32, qpn) __field(u32, s_flags) __field(u32, psn) __field(u32, s_psn) __field(u32, s_next_psn) __field(u32, s_sending_psn) __field(u32, s_sending_hpsn) __field(u32, r_psn) ), TP_fast_assign( DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device)) __entry->qpn = qp->ibqp.qp_num; __entry->s_flags = qp->s_flags; __entry->psn = psn; __entry->s_psn = qp->s_psn; __entry->s_next_psn = qp->s_next_psn; __entry->s_sending_psn = qp->s_sending_psn; __entry->s_sending_hpsn = qp->s_sending_hpsn; __entry->r_psn = qp->r_psn; ), TP_printk( "[%s] qpn 0x%x s_flags 0x%x psn 0x%x s_psn 0x%x s_next_psn 0x%x s_sending_psn 0x%x sending_hpsn 0x%x r_psn 0x%x", __get_str(dev), __entry->qpn, __entry->s_flags, __entry->psn, __entry->s_psn, __entry->s_next_psn, __entry->s_sending_psn, __entry->s_sending_hpsn, __entry->r_psn ) ); DEFINE_EVENT(hfi1_rc_template, hfi1_rc_sendcomplete, TP_PROTO(struct rvt_qp *qp, u32 psn), TP_ARGS(qp, psn) ); DEFINE_EVENT(hfi1_rc_template, hfi1_rc_ack, TP_PROTO(struct rvt_qp *qp, u32 psn), TP_ARGS(qp, psn) ); DEFINE_EVENT(hfi1_rc_template, hfi1_rc_timeout, TP_PROTO(struct rvt_qp *qp, u32 psn), TP_ARGS(qp, psn) ); DEFINE_EVENT(hfi1_rc_template, hfi1_rc_rcv_error, TP_PROTO(struct rvt_qp *qp, u32 psn), TP_ARGS(qp, psn) ); #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_misc TRACE_EVENT(hfi1_interrupt, TP_PROTO(struct hfi1_devdata *dd, const struct is_table *is_entry, int src), TP_ARGS(dd, is_entry, src), TP_STRUCT__entry(DD_DEV_ENTRY(dd) __array(char, buf, 64) __field(int, src) ), TP_fast_assign(DD_DEV_ASSIGN(dd) is_entry->is_name(__entry->buf, 64, src - is_entry->start); __entry->src = src; ), TP_printk("[%s] source: %s [%d]", __get_str(dev), __entry->buf, __entry->src) ); /* * Note: * This produces a REALLY ugly trace in the console output when the string is * too long. */ #undef TRACE_SYSTEM #define TRACE_SYSTEM hfi1_trace #define MAX_MSG_LEN 512 DECLARE_EVENT_CLASS(hfi1_trace_template, TP_PROTO(const char *function, struct va_format *vaf), TP_ARGS(function, vaf), TP_STRUCT__entry(__string(function, function) __dynamic_array(char, msg, MAX_MSG_LEN) ), TP_fast_assign(__assign_str(function, function); WARN_ON_ONCE(vsnprintf (__get_dynamic_array(msg), MAX_MSG_LEN, vaf->fmt, *vaf->va) >= MAX_MSG_LEN); ), TP_printk("(%s) %s", __get_str(function), __get_str(msg)) ); /* * It may be nice to macroize the __hfi1_trace but the va_* stuff requires an * actual function to work and can not be in a macro. */ #define __hfi1_trace_def(lvl) \ void __hfi1_trace_##lvl(const char *funct, char *fmt, ...); \ \ DEFINE_EVENT(hfi1_trace_template, hfi1_ ##lvl, \ TP_PROTO(const char *function, struct va_format *vaf), \ TP_ARGS(function, vaf)) #define __hfi1_trace_fn(lvl) \ void __hfi1_trace_##lvl(const char *func, char *fmt, ...) \ { \ struct va_format vaf = { \ .fmt = fmt, \ }; \ va_list args; \ \ va_start(args, fmt); \ vaf.va = &args; \ trace_hfi1_ ##lvl(func, &vaf); \ va_end(args); \ return; \ } /* * To create a new trace level simply define it below and as a __hfi1_trace_fn * in trace.c. This will create all the hooks for calling * hfi1_cdbg(LVL, fmt, ...); as well as take care of all * the debugfs stuff. */ __hfi1_trace_def(PKT); __hfi1_trace_def(PROC); __hfi1_trace_def(SDMA); __hfi1_trace_def(LINKVERB); __hfi1_trace_def(DEBUG); __hfi1_trace_def(SNOOP); __hfi1_trace_def(CNTR); __hfi1_trace_def(PIO); __hfi1_trace_def(DC8051); __hfi1_trace_def(FIRMWARE); __hfi1_trace_def(RCVCTRL); __hfi1_trace_def(TID); __hfi1_trace_def(MMU); #define hfi1_cdbg(which, fmt, ...) \ __hfi1_trace_##which(__func__, fmt, ##__VA_ARGS__) #define hfi1_dbg(fmt, ...) \ hfi1_cdbg(DEBUG, fmt, ##__VA_ARGS__) /* * Define HFI1_EARLY_DBG at compile time or here to enable early trace * messages. Do not check in an enablement for this. */ #ifdef HFI1_EARLY_DBG #define hfi1_dbg_early(fmt, ...) \ trace_printk(fmt, ##__VA_ARGS__) #else #define hfi1_dbg_early(fmt, ...) #endif #endif /* __HFI1_TRACE_H */ #undef TRACE_INCLUDE_PATH #undef TRACE_INCLUDE_FILE #define TRACE_INCLUDE_PATH . #define TRACE_INCLUDE_FILE trace #include