drivers/staging/rdma/hfi1/trace.h

   1 /*
   2  *
   3  * This file is provided under a dual BSD/GPLv2 license.  When using or
   4  * redistributing this file, you may do so under either license.
   5  *
   6  * GPL LICENSE SUMMARY
   7  *
   8  * Copyright(c) 2015 Intel Corporation.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of version 2 of the GNU General Public License as
  12  * published by the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * BSD LICENSE
  20  *
  21  * Copyright(c) 2015 Intel Corporation.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  *
  27  *  - Redistributions of source code must retain the above copyright
  28  *    notice, this list of conditions and the following disclaimer.
  29  *  - Redistributions in binary form must reproduce the above copyright
  30  *    notice, this list of conditions and the following disclaimer in
  31  *    the documentation and/or other materials provided with the
  32  *    distribution.
  33  *  - Neither the name of Intel Corporation nor the names of its
  34  *    contributors may be used to endorse or promote products derived
  35  *    from this software without specific prior written permission.
  36  *
  37  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  38  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  39  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  40  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  41  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  42  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  43  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  44  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  45  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  46  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  47  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48  *
  49  */
  50 #undef TRACE_SYSTEM_VAR
  51 #define TRACE_SYSTEM_VAR hfi1
  52
  53 #if !defined(__HFI1_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
  54 #define __HFI1_TRACE_H
  55
  56 #include <linux/tracepoint.h>
  57 #include <linux/trace_seq.h>
  58
  59 #include "hfi.h"
  60 #include "mad.h"
  61 #include "sdma.h"
  62
  63 #define DD_DEV_ENTRY(dd)       __string(dev, dev_name(&(dd)->pcidev->dev))
  64 #define DD_DEV_ASSIGN(dd)      __assign_str(dev, dev_name(&(dd)->pcidev->dev))
  65
  66 #define packettype_name(etype) { RHF_RCV_TYPE_##etype, #etype }
  67 #define show_packettype(etype)                  \
  68 __print_symbolic(etype,                         \
  69         packettype_name(EXPECTED),              \
  70         packettype_name(EAGER),                 \
  71         packettype_name(IB),                    \
  72         packettype_name(ERROR),                 \
  73         packettype_name(BYPASS))
  74
  75 #undef TRACE_SYSTEM
  76 #define TRACE_SYSTEM hfi1_rx
  77
  78 TRACE_EVENT(hfi1_rcvhdr,
  79         TP_PROTO(struct hfi1_devdata *dd,
  80                  u64 eflags,
  81                  u32 ctxt,
  82                  u32 etype,
  83                  u32 hlen,
  84                  u32 tlen,
  85                  u32 updegr,
  86                  u32 etail),
  87         TP_ARGS(dd, ctxt, eflags, etype, hlen, tlen, updegr, etail),
  88         TP_STRUCT__entry(
  89                 DD_DEV_ENTRY(dd)
  90                 __field(u64, eflags)
  91                 __field(u32, ctxt)
  92                 __field(u32, etype)
  93                 __field(u32, hlen)
  94                 __field(u32, tlen)
  95                 __field(u32, updegr)
  96                 __field(u32, etail)
  97         ),
  98         TP_fast_assign(
  99                 DD_DEV_ASSIGN(dd);
 100                 __entry->eflags = eflags;
 101                 __entry->ctxt = ctxt;
 102                 __entry->etype = etype;
 103                 __entry->hlen = hlen;
 104                 __entry->tlen = tlen;
 105                 __entry->updegr = updegr;
 106                 __entry->etail = etail;
 107         ),
 108         TP_printk(
 109 "[%s] ctxt %d eflags 0x%llx etype %d,%s hlen %d tlen %d updegr %d etail %d",
 110                 __get_str(dev),
 111                 __entry->ctxt,
 112                 __entry->eflags,
 113                 __entry->etype, show_packettype(__entry->etype),
 114                 __entry->hlen,
 115                 __entry->tlen,
 116                 __entry->updegr,
 117                 __entry->etail
 118         )
 119 );
 120
 121 TRACE_EVENT(hfi1_receive_interrupt,
 122         TP_PROTO(struct hfi1_devdata *dd, u32 ctxt),
 123         TP_ARGS(dd, ctxt),
 124         TP_STRUCT__entry(
 125                 DD_DEV_ENTRY(dd)
 126                 __field(u32, ctxt)
 127                 __field(u8, slow_path)
 128                 __field(u8, dma_rtail)
 129         ),
 130         TP_fast_assign(
 131                 DD_DEV_ASSIGN(dd);
 132                 __entry->ctxt = ctxt;
 133                 if (dd->rcd[ctxt]->do_interrupt ==
 134                     &handle_receive_interrupt) {
 135                         __entry->slow_path = 1;
 136                         __entry->dma_rtail = 0xFF;
 137                 } else if (dd->rcd[ctxt]->do_interrupt ==
 138                         &handle_receive_interrupt_dma_rtail){
 139                         __entry->dma_rtail = 1;
 140                         __entry->slow_path = 0;
 141                 } else if (dd->rcd[ctxt]->do_interrupt ==
 142                          &handle_receive_interrupt_nodma_rtail) {
 143                         __entry->dma_rtail = 0;
 144                         __entry->slow_path = 0;
 145                 }
 146         ),
 147         TP_printk(
 148                 "[%s] ctxt %d SlowPath: %d DmaRtail: %d",
 149                 __get_str(dev),
 150                 __entry->ctxt,
 151                 __entry->slow_path,
 152                 __entry->dma_rtail
 153         )
 154 );
 155
 156 const char *print_u64_array(struct trace_seq *, u64 *, int);
 157
 158 TRACE_EVENT(hfi1_exp_tid_map,
 159             TP_PROTO(unsigned ctxt, u16 subctxt, int dir,
 160                      unsigned long *maps, u16 count),
 161             TP_ARGS(ctxt, subctxt, dir, maps, count),
 162             TP_STRUCT__entry(
 163                     __field(unsigned, ctxt)
 164                     __field(u16, subctxt)
 165                     __field(int, dir)
 166                     __field(u16, count)
 167                     __dynamic_array(unsigned long, maps, sizeof(*maps) * count)
 168                     ),
 169             TP_fast_assign(
 170                     __entry->ctxt = ctxt;
 171                     __entry->subctxt = subctxt;
 172                     __entry->dir = dir;
 173                     __entry->count = count;
 174                     memcpy(__get_dynamic_array(maps), maps,
 175                            sizeof(*maps) * count);
 176                     ),
 177             TP_printk("[%3u:%02u] %s tidmaps %s",
 178                       __entry->ctxt,
 179                       __entry->subctxt,
 180                       (__entry->dir ? ">" : "<"),
 181                       print_u64_array(p, __get_dynamic_array(maps),
 182                                       __entry->count)
 183                     )
 184         );
 185
 186 TRACE_EVENT(hfi1_exp_rcv_set,
 187             TP_PROTO(unsigned ctxt, u16 subctxt, u32 tid,
 188                      unsigned long vaddr, u64 phys_addr, void *page),
 189             TP_ARGS(ctxt, subctxt, tid, vaddr, phys_addr, page),
 190             TP_STRUCT__entry(
 191                     __field(unsigned, ctxt)
 192                     __field(u16, subctxt)
 193                     __field(u32, tid)
 194                     __field(unsigned long, vaddr)
 195                     __field(u64, phys_addr)
 196                     __field(void *, page)
 197                     ),
 198             TP_fast_assign(
 199                     __entry->ctxt = ctxt;
 200                     __entry->subctxt = subctxt;
 201                     __entry->tid = tid;
 202                     __entry->vaddr = vaddr;
 203                     __entry->phys_addr = phys_addr;
 204                     __entry->page = page;
 205                     ),
 206             TP_printk("[%u:%u] TID %u, vaddrs 0x%lx, physaddr 0x%llx, pgp %p",
 207                       __entry->ctxt,
 208                       __entry->subctxt,
 209                       __entry->tid,
 210                       __entry->vaddr,
 211                       __entry->phys_addr,
 212                       __entry->page
 213                     )
 214         );
 215
 216 TRACE_EVENT(hfi1_exp_rcv_free,
 217             TP_PROTO(unsigned ctxt, u16 subctxt, u32 tid,
 218                      unsigned long phys, void *page),
 219             TP_ARGS(ctxt, subctxt, tid, phys, page),
 220             TP_STRUCT__entry(
 221                     __field(unsigned, ctxt)
 222                     __field(u16, subctxt)
 223                     __field(u32, tid)
 224                     __field(unsigned long, phys)
 225                     __field(void *, page)
 226                     ),
 227             TP_fast_assign(
 228                     __entry->ctxt = ctxt;
 229                     __entry->subctxt = subctxt;
 230                     __entry->tid = tid;
 231                     __entry->phys = phys;
 232                     __entry->page = page;
 233                     ),
 234             TP_printk("[%u:%u] freeing TID %u, 0x%lx, pgp %p",
 235                       __entry->ctxt,
 236                       __entry->subctxt,
 237                       __entry->tid,
 238                       __entry->phys,
 239                       __entry->page
 240                     )
 241         );
 242 #undef TRACE_SYSTEM
 243 #define TRACE_SYSTEM hfi1_tx
 244
 245 TRACE_EVENT(hfi1_piofree,
 246         TP_PROTO(struct send_context *sc, int extra),
 247         TP_ARGS(sc, extra),
 248         TP_STRUCT__entry(
 249                 DD_DEV_ENTRY(sc->dd)
 250                 __field(u32, sw_index)
 251                 __field(u32, hw_context)
 252                 __field(int, extra)
 253         ),
 254         TP_fast_assign(
 255                 DD_DEV_ASSIGN(sc->dd);
 256                 __entry->sw_index = sc->sw_index;
 257                 __entry->hw_context = sc->hw_context;
 258                 __entry->extra = extra;
 259         ),
 260         TP_printk(
 261                 "[%s] ctxt %u(%u) extra %d",
 262                 __get_str(dev),
 263                 __entry->sw_index,
 264                 __entry->hw_context,
 265                 __entry->extra
 266         )
 267 );
 268
 269 TRACE_EVENT(hfi1_wantpiointr,
 270         TP_PROTO(struct send_context *sc, u32 needint, u64 credit_ctrl),
 271         TP_ARGS(sc, needint, credit_ctrl),
 272         TP_STRUCT__entry(
 273                 DD_DEV_ENTRY(sc->dd)
 274                 __field(u32, sw_index)
 275                 __field(u32, hw_context)
 276                 __field(u32, needint)
 277                 __field(u64, credit_ctrl)
 278         ),
 279         TP_fast_assign(
 280                 DD_DEV_ASSIGN(sc->dd);
 281                 __entry->sw_index = sc->sw_index;
 282                 __entry->hw_context = sc->hw_context;
 283                 __entry->needint = needint;
 284                 __entry->credit_ctrl = credit_ctrl;
 285         ),
 286         TP_printk(
 287                 "[%s] ctxt %u(%u) on %d credit_ctrl 0x%llx",
 288                 __get_str(dev),
 289                 __entry->sw_index,
 290                 __entry->hw_context,
 291                 __entry->needint,
 292                 (unsigned long long)__entry->credit_ctrl
 293         )
 294 );
 295
 296 DECLARE_EVENT_CLASS(hfi1_qpsleepwakeup_template,
 297         TP_PROTO(struct hfi1_qp *qp, u32 flags),
 298         TP_ARGS(qp, flags),
 299         TP_STRUCT__entry(
 300                 DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
 301                 __field(u32, qpn)
 302                 __field(u32, flags)
 303                 __field(u32, s_flags)
 304         ),
 305         TP_fast_assign(
 306                 DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
 307                 __entry->flags = flags;
 308                 __entry->qpn = qp->ibqp.qp_num;
 309                 __entry->s_flags = qp->s_flags;
 310         ),
 311         TP_printk(
 312                 "[%s] qpn 0x%x flags 0x%x s_flags 0x%x",
 313                 __get_str(dev),
 314                 __entry->qpn,
 315                 __entry->flags,
 316                 __entry->s_flags
 317         )
 318 );
 319
 320 DEFINE_EVENT(hfi1_qpsleepwakeup_template, hfi1_qpwakeup,
 321              TP_PROTO(struct hfi1_qp *qp, u32 flags),
 322              TP_ARGS(qp, flags));
 323
 324 DEFINE_EVENT(hfi1_qpsleepwakeup_template, hfi1_qpsleep,
 325              TP_PROTO(struct hfi1_qp *qp, u32 flags),
 326              TP_ARGS(qp, flags));
 327
 328 #undef TRACE_SYSTEM
 329 #define TRACE_SYSTEM hfi1_qphash
 330 DECLARE_EVENT_CLASS(hfi1_qphash_template,
 331         TP_PROTO(struct hfi1_qp *qp, u32 bucket),
 332         TP_ARGS(qp, bucket),
 333         TP_STRUCT__entry(
 334                 DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
 335                 __field(u32, qpn)
 336                 __field(u32, bucket)
 337         ),
 338         TP_fast_assign(
 339                 DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
 340                 __entry->qpn = qp->ibqp.qp_num;
 341                 __entry->bucket = bucket;
 342         ),
 343         TP_printk(
 344                 "[%s] qpn 0x%x bucket %u",
 345                 __get_str(dev),
 346                 __entry->qpn,
 347                 __entry->bucket
 348         )
 349 );
 350
 351 DEFINE_EVENT(hfi1_qphash_template, hfi1_qpinsert,
 352         TP_PROTO(struct hfi1_qp *qp, u32 bucket),
 353         TP_ARGS(qp, bucket));
 354
 355 DEFINE_EVENT(hfi1_qphash_template, hfi1_qpremove,
 356         TP_PROTO(struct hfi1_qp *qp, u32 bucket),
 357         TP_ARGS(qp, bucket));
 358
 359 #undef TRACE_SYSTEM
 360 #define TRACE_SYSTEM hfi1_ibhdrs
 361
 362 u8 ibhdr_exhdr_len(struct hfi1_ib_header *hdr);
 363 const char *parse_everbs_hdrs(
 364         struct trace_seq *p,
 365         u8 opcode,
 366         void *ehdrs);
 367
 368 #define __parse_ib_ehdrs(op, ehdrs) parse_everbs_hdrs(p, op, ehdrs)
 369
 370 const char *parse_sdma_flags(
 371         struct trace_seq *p,
 372         u64 desc0, u64 desc1);
 373
 374 #define __parse_sdma_flags(desc0, desc1) parse_sdma_flags(p, desc0, desc1)
 375
 376
 377 #define lrh_name(lrh) { HFI1_##lrh, #lrh }
 378 #define show_lnh(lrh)                    \
 379 __print_symbolic(lrh,                    \
 380         lrh_name(LRH_BTH),               \
 381         lrh_name(LRH_GRH))
 382
 383 #define ib_opcode_name(opcode) { IB_OPCODE_##opcode, #opcode  }
 384 #define show_ib_opcode(opcode)                             \
 385 __print_symbolic(opcode,                                   \
 386         ib_opcode_name(RC_SEND_FIRST),                     \
 387         ib_opcode_name(RC_SEND_MIDDLE),                    \
 388         ib_opcode_name(RC_SEND_LAST),                      \
 389         ib_opcode_name(RC_SEND_LAST_WITH_IMMEDIATE),       \
 390         ib_opcode_name(RC_SEND_ONLY),                      \
 391         ib_opcode_name(RC_SEND_ONLY_WITH_IMMEDIATE),       \
 392         ib_opcode_name(RC_RDMA_WRITE_FIRST),               \
 393         ib_opcode_name(RC_RDMA_WRITE_MIDDLE),              \
 394         ib_opcode_name(RC_RDMA_WRITE_LAST),                \
 395         ib_opcode_name(RC_RDMA_WRITE_LAST_WITH_IMMEDIATE), \
 396         ib_opcode_name(RC_RDMA_WRITE_ONLY),                \
 397         ib_opcode_name(RC_RDMA_WRITE_ONLY_WITH_IMMEDIATE), \
 398         ib_opcode_name(RC_RDMA_READ_REQUEST),              \
 399         ib_opcode_name(RC_RDMA_READ_RESPONSE_FIRST),       \
 400         ib_opcode_name(RC_RDMA_READ_RESPONSE_MIDDLE),      \
 401         ib_opcode_name(RC_RDMA_READ_RESPONSE_LAST),        \
 402         ib_opcode_name(RC_RDMA_READ_RESPONSE_ONLY),        \
 403         ib_opcode_name(RC_ACKNOWLEDGE),                    \
 404         ib_opcode_name(RC_ATOMIC_ACKNOWLEDGE),             \
 405         ib_opcode_name(RC_COMPARE_SWAP),                   \
 406         ib_opcode_name(RC_FETCH_ADD),                      \
 407         ib_opcode_name(UC_SEND_FIRST),                     \
 408         ib_opcode_name(UC_SEND_MIDDLE),                    \
 409         ib_opcode_name(UC_SEND_LAST),                      \
 410         ib_opcode_name(UC_SEND_LAST_WITH_IMMEDIATE),       \
 411         ib_opcode_name(UC_SEND_ONLY),                      \
 412         ib_opcode_name(UC_SEND_ONLY_WITH_IMMEDIATE),       \
 413         ib_opcode_name(UC_RDMA_WRITE_FIRST),               \
 414         ib_opcode_name(UC_RDMA_WRITE_MIDDLE),              \
 415         ib_opcode_name(UC_RDMA_WRITE_LAST),                \
 416         ib_opcode_name(UC_RDMA_WRITE_LAST_WITH_IMMEDIATE), \
 417         ib_opcode_name(UC_RDMA_WRITE_ONLY),                \
 418         ib_opcode_name(UC_RDMA_WRITE_ONLY_WITH_IMMEDIATE), \
 419         ib_opcode_name(UD_SEND_ONLY),                      \
 420         ib_opcode_name(UD_SEND_ONLY_WITH_IMMEDIATE),       \
 421         ib_opcode_name(CNP))
 422
 423
 424 #define LRH_PRN "vl %d lver %d sl %d lnh %d,%s dlid %.4x len %d slid %.4x"
 425 #define BTH_PRN \
 426         "op 0x%.2x,%s se %d m %d pad %d tver %d pkey 0x%.4x " \
 427         "f %d b %d qpn 0x%.6x a %d psn 0x%.8x"
 428 #define EHDR_PRN "%s"
 429
 430 DECLARE_EVENT_CLASS(hfi1_ibhdr_template,
 431         TP_PROTO(struct hfi1_devdata *dd,
 432                  struct hfi1_ib_header *hdr),
 433         TP_ARGS(dd, hdr),
 434         TP_STRUCT__entry(
 435                 DD_DEV_ENTRY(dd)
 436                 /* LRH */
 437                 __field(u8, vl)
 438                 __field(u8, lver)
 439                 __field(u8, sl)
 440                 __field(u8, lnh)
 441                 __field(u16, dlid)
 442                 __field(u16, len)
 443                 __field(u16, slid)
 444                 /* BTH */
 445                 __field(u8, opcode)
 446                 __field(u8, se)
 447                 __field(u8, m)
 448                 __field(u8, pad)
 449                 __field(u8, tver)
 450                 __field(u16, pkey)
 451                 __field(u8, f)
 452                 __field(u8, b)
 453                 __field(u32, qpn)
 454                 __field(u8, a)
 455                 __field(u32, psn)
 456                 /* extended headers */
 457                 __dynamic_array(u8, ehdrs, ibhdr_exhdr_len(hdr))
 458         ),
 459         TP_fast_assign(
 460                 struct hfi1_other_headers *ohdr;
 461
 462                 DD_DEV_ASSIGN(dd);
 463                 /* LRH */
 464                 __entry->vl =
 465                         (u8)(be16_to_cpu(hdr->lrh[0]) >> 12);
 466                 __entry->lver =
 467                         (u8)(be16_to_cpu(hdr->lrh[0]) >> 8) & 0xf;
 468                 __entry->sl =
 469                         (u8)(be16_to_cpu(hdr->lrh[0]) >> 4) & 0xf;
 470                 __entry->lnh =
 471                         (u8)(be16_to_cpu(hdr->lrh[0]) & 3);
 472                 __entry->dlid =
 473                         be16_to_cpu(hdr->lrh[1]);
 474                 /* allow for larger len */
 475                 __entry->len =
 476                         be16_to_cpu(hdr->lrh[2]);
 477                 __entry->slid =
 478                         be16_to_cpu(hdr->lrh[3]);
 479                 /* BTH */
 480                 if (__entry->lnh == HFI1_LRH_BTH)
 481                         ohdr = &hdr->u.oth;
 482                 else
 483                         ohdr = &hdr->u.l.oth;
 484                 __entry->opcode =
 485                         (be32_to_cpu(ohdr->bth[0]) >> 24) & 0xff;
 486                 __entry->se =
 487                         (be32_to_cpu(ohdr->bth[0]) >> 23) & 1;
 488                 __entry->m =
 489                          (be32_to_cpu(ohdr->bth[0]) >> 22) & 1;
 490                 __entry->pad =
 491                         (be32_to_cpu(ohdr->bth[0]) >> 20) & 3;
 492                 __entry->tver =
 493                         (be32_to_cpu(ohdr->bth[0]) >> 16) & 0xf;
 494                 __entry->pkey =
 495                         be32_to_cpu(ohdr->bth[0]) & 0xffff;
 496                 __entry->f =
 497                         (be32_to_cpu(ohdr->bth[1]) >> HFI1_FECN_SHIFT)
 498                         & HFI1_FECN_MASK;
 499                 __entry->b =
 500                         (be32_to_cpu(ohdr->bth[1]) >> HFI1_BECN_SHIFT)
 501                         & HFI1_BECN_MASK;
 502                 __entry->qpn =
 503                         be32_to_cpu(ohdr->bth[1]) & HFI1_QPN_MASK;
 504                 __entry->a =
 505                         (be32_to_cpu(ohdr->bth[2]) >> 31) & 1;
 506                 /* allow for larger PSN */
 507                 __entry->psn =
 508                         be32_to_cpu(ohdr->bth[2]) & 0x7fffffff;
 509                 /* extended headers */
 510                  memcpy(
 511                         __get_dynamic_array(ehdrs),
 512                         &ohdr->u,
 513                         ibhdr_exhdr_len(hdr));
 514         ),
 515         TP_printk("[%s] " LRH_PRN " " BTH_PRN " " EHDR_PRN,
 516                 __get_str(dev),
 517                 /* LRH */
 518                 __entry->vl,
 519                 __entry->lver,
 520                 __entry->sl,
 521                 __entry->lnh, show_lnh(__entry->lnh),
 522                 __entry->dlid,
 523                 __entry->len,
 524                 __entry->slid,
 525                 /* BTH */
 526                 __entry->opcode, show_ib_opcode(__entry->opcode),
 527                 __entry->se,
 528                 __entry->m,
 529                 __entry->pad,
 530                 __entry->tver,
 531                 __entry->pkey,
 532                 __entry->f,
 533                 __entry->b,
 534                 __entry->qpn,
 535                 __entry->a,
 536                 __entry->psn,
 537                 /* extended headers */
 538                 __parse_ib_ehdrs(
 539                         __entry->opcode,
 540                         (void *)__get_dynamic_array(ehdrs))
 541         )
 542 );
 543
 544 DEFINE_EVENT(hfi1_ibhdr_template, input_ibhdr,
 545              TP_PROTO(struct hfi1_devdata *dd, struct hfi1_ib_header *hdr),
 546              TP_ARGS(dd, hdr));
 547
 548 DEFINE_EVENT(hfi1_ibhdr_template, output_ibhdr,
 549              TP_PROTO(struct hfi1_devdata *dd, struct hfi1_ib_header *hdr),
 550              TP_ARGS(dd, hdr));
 551
 552 #define SNOOP_PRN \
 553         "slid %.4x dlid %.4x qpn 0x%.6x opcode 0x%.2x,%s " \
 554         "svc lvl %d pkey 0x%.4x [header = %d bytes] [data = %d bytes]"
 555
 556 #undef TRACE_SYSTEM
 557 #define TRACE_SYSTEM hfi1_snoop
 558
 559
 560 TRACE_EVENT(snoop_capture,
 561         TP_PROTO(struct hfi1_devdata *dd,
 562                  int hdr_len,
 563                  struct hfi1_ib_header *hdr,
 564                  int data_len,
 565                  void *data),
 566         TP_ARGS(dd, hdr_len, hdr, data_len, data),
 567         TP_STRUCT__entry(
 568                 DD_DEV_ENTRY(dd)
 569                 __field(u16, slid)
 570                 __field(u16, dlid)
 571                 __field(u32, qpn)
 572                 __field(u8, opcode)
 573                 __field(u8, sl)
 574                 __field(u16, pkey)
 575                 __field(u32, hdr_len)
 576                 __field(u32, data_len)
 577                 __field(u8, lnh)
 578                 __dynamic_array(u8, raw_hdr, hdr_len)
 579                 __dynamic_array(u8, raw_pkt, data_len)
 580         ),
 581         TP_fast_assign(
 582                 struct hfi1_other_headers *ohdr;
 583
 584                 __entry->lnh = (u8)(be16_to_cpu(hdr->lrh[0]) & 3);
 585                 if (__entry->lnh == HFI1_LRH_BTH)
 586                         ohdr = &hdr->u.oth;
 587                 else
 588                         ohdr = &hdr->u.l.oth;
 589                 DD_DEV_ASSIGN(dd);
 590                 __entry->slid = be16_to_cpu(hdr->lrh[3]);
 591                 __entry->dlid = be16_to_cpu(hdr->lrh[1]);
 592                 __entry->qpn = be32_to_cpu(ohdr->bth[1]) & HFI1_QPN_MASK;
 593                 __entry->opcode = (be32_to_cpu(ohdr->bth[0]) >> 24) & 0xff;
 594                 __entry->sl = (u8)(be16_to_cpu(hdr->lrh[0]) >> 4) & 0xf;
 595                 __entry->pkey = be32_to_cpu(ohdr->bth[0]) & 0xffff;
 596                 __entry->hdr_len = hdr_len;
 597                 __entry->data_len = data_len;
 598                 memcpy(__get_dynamic_array(raw_hdr), hdr, hdr_len);
 599                 memcpy(__get_dynamic_array(raw_pkt), data, data_len);
 600         ),
 601         TP_printk("[%s] " SNOOP_PRN,
 602                 __get_str(dev),
 603                 __entry->slid,
 604                 __entry->dlid,
 605                 __entry->qpn,
 606                 __entry->opcode,
 607                 show_ib_opcode(__entry->opcode),
 608                 __entry->sl,
 609                 __entry->pkey,
 610                 __entry->hdr_len,
 611                 __entry->data_len
 612         )
 613 );
 614
 615 #undef TRACE_SYSTEM
 616 #define TRACE_SYSTEM hfi1_ctxts
 617
 618 #define UCTXT_FMT \
 619         "cred:%u, credaddr:0x%llx, piobase:0x%llx, rcvhdr_cnt:%u, "     \
 620         "rcvbase:0x%llx, rcvegrc:%u, rcvegrb:0x%llx"
 621 TRACE_EVENT(hfi1_uctxtdata,
 622             TP_PROTO(struct hfi1_devdata *dd, struct hfi1_ctxtdata *uctxt),
 623             TP_ARGS(dd, uctxt),
 624             TP_STRUCT__entry(
 625                     DD_DEV_ENTRY(dd)
 626                     __field(unsigned, ctxt)
 627                     __field(u32, credits)
 628                     __field(u64, hw_free)
 629                     __field(u64, piobase)
 630                     __field(u16, rcvhdrq_cnt)
 631                     __field(u64, rcvhdrq_phys)
 632                     __field(u32, eager_cnt)
 633                     __field(u64, rcvegr_phys)
 634                     ),
 635             TP_fast_assign(
 636                     DD_DEV_ASSIGN(dd);
 637                     __entry->ctxt = uctxt->ctxt;
 638                     __entry->credits = uctxt->sc->credits;
 639                     __entry->hw_free = (u64)uctxt->sc->hw_free;
 640                     __entry->piobase = (u64)uctxt->sc->base_addr;
 641                     __entry->rcvhdrq_cnt = uctxt->rcvhdrq_cnt;
 642                     __entry->rcvhdrq_phys = uctxt->rcvhdrq_phys;
 643                     __entry->eager_cnt = uctxt->egrbufs.alloced;
 644                     __entry->rcvegr_phys = uctxt->egrbufs.rcvtids[0].phys;
 645                     ),
 646             TP_printk(
 647                     "[%s] ctxt %u " UCTXT_FMT,
 648                     __get_str(dev),
 649                     __entry->ctxt,
 650                     __entry->credits,
 651                     __entry->hw_free,
 652                     __entry->piobase,
 653                     __entry->rcvhdrq_cnt,
 654                     __entry->rcvhdrq_phys,
 655                     __entry->eager_cnt,
 656                     __entry->rcvegr_phys
 657                     )
 658         );
 659
 660 #define CINFO_FMT \
 661         "egrtids:%u, egr_size:%u, hdrq_cnt:%u, hdrq_size:%u, sdma_ring_size:%u"
 662 TRACE_EVENT(hfi1_ctxt_info,
 663             TP_PROTO(struct hfi1_devdata *dd, unsigned ctxt, unsigned subctxt,
 664                      struct hfi1_ctxt_info cinfo),
 665             TP_ARGS(dd, ctxt, subctxt, cinfo),
 666             TP_STRUCT__entry(
 667                     DD_DEV_ENTRY(dd)
 668                     __field(unsigned, ctxt)
 669                     __field(unsigned, subctxt)
 670                     __field(u16, egrtids)
 671                     __field(u16, rcvhdrq_cnt)
 672                     __field(u16, rcvhdrq_size)
 673                     __field(u16, sdma_ring_size)
 674                     __field(u32, rcvegr_size)
 675                     ),
 676             TP_fast_assign(
 677                     DD_DEV_ASSIGN(dd);
 678                     __entry->ctxt = ctxt;
 679                     __entry->subctxt = subctxt;
 680                     __entry->egrtids = cinfo.egrtids;
 681                     __entry->rcvhdrq_cnt = cinfo.rcvhdrq_cnt;
 682                     __entry->rcvhdrq_size = cinfo.rcvhdrq_entsize;
 683                     __entry->sdma_ring_size = cinfo.sdma_ring_size;
 684                     __entry->rcvegr_size = cinfo.rcvegr_size;
 685                     ),
 686             TP_printk(
 687                     "[%s] ctxt %u:%u " CINFO_FMT,
 688                     __get_str(dev),
 689                     __entry->ctxt,
 690                     __entry->subctxt,
 691                     __entry->egrtids,
 692                     __entry->rcvegr_size,
 693                     __entry->rcvhdrq_cnt,
 694                     __entry->rcvhdrq_size,
 695                     __entry->sdma_ring_size
 696                     )
 697         );
 698
 699 #undef TRACE_SYSTEM
 700 #define TRACE_SYSTEM hfi1_sma
 701
 702 #define BCT_FORMAT \
 703         "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]"
 704
 705 #define BCT(field) \
 706         be16_to_cpu( \
 707                 ((struct buffer_control *)__get_dynamic_array(bct))->field \
 708         )
 709
 710 DECLARE_EVENT_CLASS(hfi1_bct_template,
 711         TP_PROTO(struct hfi1_devdata *dd, struct buffer_control *bc),
 712         TP_ARGS(dd, bc),
 713         TP_STRUCT__entry(
 714                 DD_DEV_ENTRY(dd)
 715                 __dynamic_array(u8, bct, sizeof(*bc))
 716         ),
 717         TP_fast_assign(
 718                 DD_DEV_ASSIGN(dd);
 719                 memcpy(
 720                         __get_dynamic_array(bct),
 721                         bc,
 722                         sizeof(*bc));
 723         ),
 724         TP_printk(BCT_FORMAT,
 725                 BCT(overall_shared_limit),
 726
 727                 BCT(vl[0].dedicated),
 728                 BCT(vl[0].shared),
 729
 730                 BCT(vl[1].dedicated),
 731                 BCT(vl[1].shared),
 732
 733                 BCT(vl[2].dedicated),
 734                 BCT(vl[2].shared),
 735
 736                 BCT(vl[3].dedicated),
 737                 BCT(vl[3].shared),
 738
 739                 BCT(vl[4].dedicated),
 740                 BCT(vl[4].shared),
 741
 742                 BCT(vl[5].dedicated),
 743                 BCT(vl[5].shared),
 744
 745                 BCT(vl[6].dedicated),
 746                 BCT(vl[6].shared),
 747
 748                 BCT(vl[7].dedicated),
 749                 BCT(vl[7].shared),
 750
 751                 BCT(vl[15].dedicated),
 752                 BCT(vl[15].shared)
 753         )
 754 );
 755
 756
 757 DEFINE_EVENT(hfi1_bct_template, bct_set,
 758              TP_PROTO(struct hfi1_devdata *dd, struct buffer_control *bc),
 759              TP_ARGS(dd, bc));
 760
 761 DEFINE_EVENT(hfi1_bct_template, bct_get,
 762              TP_PROTO(struct hfi1_devdata *dd, struct buffer_control *bc),
 763              TP_ARGS(dd, bc));
 764
 765 #undef TRACE_SYSTEM
 766 #define TRACE_SYSTEM hfi1_sdma
 767
 768 TRACE_EVENT(hfi1_sdma_descriptor,
 769         TP_PROTO(
 770                 struct sdma_engine *sde,
 771                 u64 desc0,
 772                 u64 desc1,
 773                 u16 e,
 774                 void *descp),
 775         TP_ARGS(sde, desc0, desc1, e, descp),
 776         TP_STRUCT__entry(
 777                 DD_DEV_ENTRY(sde->dd)
 778                 __field(void *, descp)
 779                 __field(u64, desc0)
 780                 __field(u64, desc1)
 781                 __field(u16, e)
 782                 __field(u8, idx)
 783         ),
 784         TP_fast_assign(
 785                 DD_DEV_ASSIGN(sde->dd);
 786                 __entry->desc0 = desc0;
 787                 __entry->desc1 = desc1;
 788                 __entry->idx = sde->this_idx;
 789                 __entry->descp = descp;
 790                 __entry->e = e;
 791         ),
 792         TP_printk(
 793                 "[%s] SDE(%u) flags:%s addr:0x%016llx gen:%u len:%u d0:%016llx d1:%016llx to %p,%u",
 794                 __get_str(dev),
 795                 __entry->idx,
 796                 __parse_sdma_flags(__entry->desc0, __entry->desc1),
 797                 (__entry->desc0 >> SDMA_DESC0_PHY_ADDR_SHIFT)
 798                         & SDMA_DESC0_PHY_ADDR_MASK,
 799                 (u8)((__entry->desc1 >> SDMA_DESC1_GENERATION_SHIFT)
 800                         & SDMA_DESC1_GENERATION_MASK),
 801                 (u16)((__entry->desc0 >> SDMA_DESC0_BYTE_COUNT_SHIFT)
 802                         & SDMA_DESC0_BYTE_COUNT_MASK),
 803                 __entry->desc0,
 804                 __entry->desc1,
 805                 __entry->descp,
 806                 __entry->e
 807         )
 808 );
 809
 810 TRACE_EVENT(hfi1_sdma_engine_select,
 811         TP_PROTO(struct hfi1_devdata *dd, u32 sel, u8 vl, u8 idx),
 812         TP_ARGS(dd, sel, vl, idx),
 813         TP_STRUCT__entry(
 814                 DD_DEV_ENTRY(dd)
 815                 __field(u32, sel)
 816                 __field(u8, vl)
 817                 __field(u8, idx)
 818         ),
 819         TP_fast_assign(
 820                 DD_DEV_ASSIGN(dd);
 821                 __entry->sel = sel;
 822                 __entry->vl = vl;
 823                 __entry->idx = idx;
 824         ),
 825         TP_printk(
 826                 "[%s] selecting SDE %u sel 0x%x vl %u",
 827                 __get_str(dev),
 828                 __entry->idx,
 829                 __entry->sel,
 830                 __entry->vl
 831         )
 832 );
 833
 834 DECLARE_EVENT_CLASS(hfi1_sdma_engine_class,
 835         TP_PROTO(
 836                 struct sdma_engine *sde,
 837                 u64 status
 838         ),
 839         TP_ARGS(sde, status),
 840         TP_STRUCT__entry(
 841                 DD_DEV_ENTRY(sde->dd)
 842                 __field(u64, status)
 843                 __field(u8, idx)
 844         ),
 845         TP_fast_assign(
 846                 DD_DEV_ASSIGN(sde->dd);
 847                 __entry->status = status;
 848                 __entry->idx = sde->this_idx;
 849         ),
 850         TP_printk(
 851                 "[%s] SDE(%u) status %llx",
 852                 __get_str(dev),
 853                 __entry->idx,
 854                 (unsigned long long)__entry->status
 855         )
 856 );
 857
 858 DEFINE_EVENT(hfi1_sdma_engine_class, hfi1_sdma_engine_interrupt,
 859         TP_PROTO(
 860                 struct sdma_engine *sde,
 861                 u64 status
 862         ),
 863         TP_ARGS(sde, status)
 864 );
 865
 866 DEFINE_EVENT(hfi1_sdma_engine_class, hfi1_sdma_engine_progress,
 867         TP_PROTO(
 868                 struct sdma_engine *sde,
 869                 u64 status
 870         ),
 871         TP_ARGS(sde, status)
 872 );
 873
 874 DECLARE_EVENT_CLASS(hfi1_sdma_ahg_ad,
 875         TP_PROTO(
 876                 struct sdma_engine *sde,
 877                 int aidx
 878         ),
 879         TP_ARGS(sde, aidx),
 880         TP_STRUCT__entry(
 881                 DD_DEV_ENTRY(sde->dd)
 882                 __field(int, aidx)
 883                 __field(u8, idx)
 884         ),
 885         TP_fast_assign(
 886                 DD_DEV_ASSIGN(sde->dd);
 887                 __entry->idx = sde->this_idx;
 888                 __entry->aidx = aidx;
 889         ),
 890         TP_printk(
 891                 "[%s] SDE(%u) aidx %d",
 892                 __get_str(dev),
 893                 __entry->idx,
 894                 __entry->aidx
 895         )
 896 );
 897
 898 DEFINE_EVENT(hfi1_sdma_ahg_ad, hfi1_ahg_allocate,
 899              TP_PROTO(
 900                 struct sdma_engine *sde,
 901                 int aidx
 902              ),
 903              TP_ARGS(sde, aidx));
 904
 905 DEFINE_EVENT(hfi1_sdma_ahg_ad, hfi1_ahg_deallocate,
 906              TP_PROTO(
 907                 struct sdma_engine *sde,
 908                 int aidx
 909              ),
 910              TP_ARGS(sde, aidx));
 911
 912 #ifdef CONFIG_HFI1_DEBUG_SDMA_ORDER
 913 TRACE_EVENT(hfi1_sdma_progress,
 914         TP_PROTO(
 915                 struct sdma_engine *sde,
 916                 u16 hwhead,
 917                 u16 swhead,
 918                 struct sdma_txreq *txp
 919         ),
 920         TP_ARGS(sde, hwhead, swhead, txp),
 921         TP_STRUCT__entry(
 922                 DD_DEV_ENTRY(sde->dd)
 923                 __field(u64, sn)
 924                 __field(u16, hwhead)
 925                 __field(u16, swhead)
 926                 __field(u16, txnext)
 927                 __field(u16, tx_tail)
 928                 __field(u16, tx_head)
 929                 __field(u8, idx)
 930         ),
 931         TP_fast_assign(
 932                 DD_DEV_ASSIGN(sde->dd);
 933                 __entry->hwhead = hwhead;
 934                 __entry->swhead = swhead;
 935                 __entry->tx_tail = sde->tx_tail;
 936                 __entry->tx_head = sde->tx_head;
 937                 __entry->txnext = txp ? txp->next_descq_idx : ~0;
 938                 __entry->idx = sde->this_idx;
 939                 __entry->sn = txp ? txp->sn : ~0;
 940         ),
 941         TP_printk(
 942                 "[%s] SDE(%u) sn %llu hwhead %u swhead %u next_descq_idx %u tx_head %u tx_tail %u",
 943                 __get_str(dev),
 944                 __entry->idx,
 945                 __entry->sn,
 946                 __entry->hwhead,
 947                 __entry->swhead,
 948                 __entry->txnext,
 949                 __entry->tx_head,
 950                 __entry->tx_tail
 951         )
 952 );
 953 #else
 954 TRACE_EVENT(hfi1_sdma_progress,
 955             TP_PROTO(
 956                 struct sdma_engine *sde,
 957                 u16 hwhead,
 958                 u16 swhead,
 959                 struct sdma_txreq *txp
 960             ),
 961         TP_ARGS(sde, hwhead, swhead, txp),
 962         TP_STRUCT__entry(
 963                 DD_DEV_ENTRY(sde->dd)
 964                 __field(u16, hwhead)
 965                 __field(u16, swhead)
 966                 __field(u16, txnext)
 967                 __field(u16, tx_tail)
 968                 __field(u16, tx_head)
 969                 __field(u8, idx)
 970         ),
 971         TP_fast_assign(
 972                 DD_DEV_ASSIGN(sde->dd);
 973                 __entry->hwhead = hwhead;
 974                 __entry->swhead = swhead;
 975                 __entry->tx_tail = sde->tx_tail;
 976                 __entry->tx_head = sde->tx_head;
 977                 __entry->txnext = txp ? txp->next_descq_idx : ~0;
 978                 __entry->idx = sde->this_idx;
 979         ),
 980         TP_printk(
 981                 "[%s] SDE(%u) hwhead %u swhead %u next_descq_idx %u tx_head %u tx_tail %u",
 982                 __get_str(dev),
 983                 __entry->idx,
 984                 __entry->hwhead,
 985                 __entry->swhead,
 986                 __entry->txnext,
 987                 __entry->tx_head,
 988                 __entry->tx_tail
 989         )
 990 );
 991 #endif
 992
 993 DECLARE_EVENT_CLASS(hfi1_sdma_sn,
 994         TP_PROTO(
 995                 struct sdma_engine *sde,
 996                 u64 sn
 997         ),
 998         TP_ARGS(sde, sn),
 999         TP_STRUCT__entry(
1000                 DD_DEV_ENTRY(sde->dd)
1001                 __field(u64, sn)
1002                 __field(u8, idx)
1003         ),
1004         TP_fast_assign(
1005                 DD_DEV_ASSIGN(sde->dd);
1006                 __entry->sn = sn;
1007                 __entry->idx = sde->this_idx;
1008         ),
1009         TP_printk(
1010                 "[%s] SDE(%u) sn %llu",
1011                 __get_str(dev),
1012                 __entry->idx,
1013                 __entry->sn
1014         )
1015 );
1016
1017 DEFINE_EVENT(hfi1_sdma_sn, hfi1_sdma_out_sn,
1018              TP_PROTO(
1019                 struct sdma_engine *sde,
1020                 u64 sn
1021              ),
1022              TP_ARGS(sde, sn)
1023 );
1024
1025 DEFINE_EVENT(hfi1_sdma_sn, hfi1_sdma_in_sn,
1026              TP_PROTO(
1027                 struct sdma_engine *sde,
1028                 u64 sn
1029              ),
1030              TP_ARGS(sde, sn)
1031 );
1032
1033 #define USDMA_HDR_FORMAT \
1034         "[%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"
1035
1036 TRACE_EVENT(hfi1_sdma_user_header,
1037             TP_PROTO(struct hfi1_devdata *dd, u16 ctxt, u8 subctxt, u16 req,
1038                      struct hfi1_pkt_header *hdr, u32 tidval),
1039             TP_ARGS(dd, ctxt, subctxt, req, hdr, tidval),
1040             TP_STRUCT__entry(
1041                     DD_DEV_ENTRY(dd)
1042                     __field(u16, ctxt)
1043                     __field(u8, subctxt)
1044                     __field(u16, req)
1045                     __field(__le32, pbc0)
1046                     __field(__le32, pbc1)
1047                     __field(__be32, lrh0)
1048                     __field(__be32, lrh1)
1049                     __field(__be32, bth0)
1050                     __field(__be32, bth1)
1051                     __field(__be32, bth2)
1052                     __field(__le32, kdeth0)
1053                     __field(__le32, kdeth1)
1054                     __field(__le32, kdeth2)
1055                     __field(__le32, kdeth3)
1056                     __field(__le32, kdeth4)
1057                     __field(__le32, kdeth5)
1058                     __field(__le32, kdeth6)
1059                     __field(__le32, kdeth7)
1060                     __field(__le32, kdeth8)
1061                     __field(u32, tidval)
1062                     ),
1063             TP_fast_assign(
1064                     __le32 *pbc = (__le32 *)hdr->pbc;
1065                     __be32 *lrh = (__be32 *)hdr->lrh;
1066                     __be32 *bth = (__be32 *)hdr->bth;
1067                     __le32 *kdeth = (__le32 *)&hdr->kdeth;
1068
1069                     DD_DEV_ASSIGN(dd);
1070                     __entry->ctxt = ctxt;
1071                     __entry->subctxt = subctxt;
1072                     __entry->req = req;
1073                     __entry->pbc0 = pbc[0];
1074                     __entry->pbc1 = pbc[1];
1075                     __entry->lrh0 = be32_to_cpu(lrh[0]);
1076                     __entry->lrh1 = be32_to_cpu(lrh[1]);
1077                     __entry->bth0 = be32_to_cpu(bth[0]);
1078                     __entry->bth1 = be32_to_cpu(bth[1]);
1079                     __entry->bth2 = be32_to_cpu(bth[2]);
1080                     __entry->kdeth0 = kdeth[0];
1081                     __entry->kdeth1 = kdeth[1];
1082                     __entry->kdeth2 = kdeth[2];
1083                     __entry->kdeth3 = kdeth[3];
1084                     __entry->kdeth4 = kdeth[4];
1085                     __entry->kdeth5 = kdeth[5];
1086                     __entry->kdeth6 = kdeth[6];
1087                     __entry->kdeth7 = kdeth[7];
1088                     __entry->kdeth8 = kdeth[8];
1089                     __entry->tidval = tidval;
1090                     ),
1091             TP_printk(USDMA_HDR_FORMAT,
1092                       __get_str(dev),
1093                       __entry->ctxt,
1094                       __entry->subctxt,
1095                       __entry->req,
1096                       __entry->pbc1,
1097                       __entry->pbc0,
1098                       __entry->lrh0,
1099                       __entry->lrh1,
1100                       __entry->bth0,
1101                       __entry->bth1,
1102                       __entry->bth2,
1103                       __entry->kdeth0,
1104                       __entry->kdeth1,
1105                       __entry->kdeth2,
1106                       __entry->kdeth3,
1107                       __entry->kdeth4,
1108                       __entry->kdeth5,
1109                       __entry->kdeth6,
1110                       __entry->kdeth7,
1111                       __entry->kdeth8,
1112                       __entry->tidval
1113                     )
1114         );
1115
1116 #define SDMA_UREQ_FMT \
1117         "[%s:%u:%u] ver/op=0x%x, iovcnt=%u, npkts=%u, frag=%u, idx=%u"
1118 TRACE_EVENT(hfi1_sdma_user_reqinfo,
1119             TP_PROTO(struct hfi1_devdata *dd, u16 ctxt, u8 subctxt, u16 *i),
1120             TP_ARGS(dd, ctxt, subctxt, i),
1121             TP_STRUCT__entry(
1122                     DD_DEV_ENTRY(dd);
1123                     __field(u16, ctxt)
1124                     __field(u8, subctxt)
1125                     __field(u8, ver_opcode)
1126                     __field(u8, iovcnt)
1127                     __field(u16, npkts)
1128                     __field(u16, fragsize)
1129                     __field(u16, comp_idx)
1130                     ),
1131             TP_fast_assign(
1132                     DD_DEV_ASSIGN(dd);
1133                     __entry->ctxt = ctxt;
1134                     __entry->subctxt = subctxt;
1135                     __entry->ver_opcode = i[0] & 0xff;
1136                     __entry->iovcnt = (i[0] >> 8) & 0xff;
1137                     __entry->npkts = i[1];
1138                     __entry->fragsize = i[2];
1139                     __entry->comp_idx = i[3];
1140                     ),
1141             TP_printk(SDMA_UREQ_FMT,
1142                       __get_str(dev),
1143                       __entry->ctxt,
1144                       __entry->subctxt,
1145                       __entry->ver_opcode,
1146                       __entry->iovcnt,
1147                       __entry->npkts,
1148                       __entry->fragsize,
1149                       __entry->comp_idx
1150                     )
1151         );
1152
1153 #define usdma_complete_name(st) { st, #st }
1154 #define show_usdma_complete_state(st)                   \
1155         __print_symbolic(st,                            \
1156                          usdma_complete_name(FREE),     \
1157                          usdma_complete_name(QUEUED),   \
1158                          usdma_complete_name(COMPLETE), \
1159                          usdma_complete_name(ERROR))
1160
1161 TRACE_EVENT(hfi1_sdma_user_completion,
1162             TP_PROTO(struct hfi1_devdata *dd, u16 ctxt, u8 subctxt, u16 idx,
1163                      u8 state, int code),
1164             TP_ARGS(dd, ctxt, subctxt, idx, state, code),
1165             TP_STRUCT__entry(
1166                     DD_DEV_ENTRY(dd)
1167                     __field(u16, ctxt)
1168                     __field(u8, subctxt)
1169                     __field(u16, idx)
1170                     __field(u8, state)
1171                     __field(int, code)
1172                     ),
1173             TP_fast_assign(
1174                     DD_DEV_ASSIGN(dd);
1175                     __entry->ctxt = ctxt;
1176                     __entry->subctxt = subctxt;
1177                     __entry->idx = idx;
1178                     __entry->state = state;
1179                     __entry->code = code;
1180                     ),
1181             TP_printk("[%s:%u:%u:%u] SDMA completion state %s (%d)",
1182                       __get_str(dev), __entry->ctxt, __entry->subctxt,
1183                       __entry->idx, show_usdma_complete_state(__entry->state),
1184                       __entry->code)
1185         );
1186
1187 const char *print_u32_array(struct trace_seq *, u32 *, int);
1188 #define __print_u32_hex(arr, len) print_u32_array(p, arr, len)
1189
1190 TRACE_EVENT(hfi1_sdma_user_header_ahg,
1191             TP_PROTO(struct hfi1_devdata *dd, u16 ctxt, u8 subctxt, u16 req,
1192                      u8 sde, u8 ahgidx, u32 *ahg, int len, u32 tidval),
1193             TP_ARGS(dd, ctxt, subctxt, req, sde, ahgidx, ahg, len, tidval),
1194             TP_STRUCT__entry(
1195                     DD_DEV_ENTRY(dd)
1196                     __field(u16, ctxt)
1197                     __field(u8, subctxt)
1198                     __field(u16, req)
1199                     __field(u8, sde)
1200                     __field(u8, idx)
1201                     __field(int, len)
1202                     __field(u32, tidval)
1203                     __array(u32, ahg, 10)
1204                     ),
1205             TP_fast_assign(
1206                     DD_DEV_ASSIGN(dd);
1207                     __entry->ctxt = ctxt;
1208                     __entry->subctxt = subctxt;
1209                     __entry->req = req;
1210                     __entry->sde = sde;
1211                     __entry->idx = ahgidx;
1212                     __entry->len = len;
1213                     __entry->tidval = tidval;
1214                     memcpy(__entry->ahg, ahg, len * sizeof(u32));
1215                     ),
1216             TP_printk("[%s:%u:%u:%u] (SDE%u/AHG%u) ahg[0-%d]=(%s) TIDVal=0x%x",
1217                       __get_str(dev),
1218                       __entry->ctxt,
1219                       __entry->subctxt,
1220                       __entry->req,
1221                       __entry->sde,
1222                       __entry->idx,
1223                       __entry->len - 1,
1224                       __print_u32_hex(__entry->ahg, __entry->len),
1225                       __entry->tidval
1226                     )
1227         );
1228
1229 TRACE_EVENT(hfi1_sdma_state,
1230         TP_PROTO(
1231                 struct sdma_engine *sde,
1232                 const char *cstate,
1233                 const char *nstate
1234         ),
1235         TP_ARGS(sde, cstate, nstate),
1236         TP_STRUCT__entry(
1237                 DD_DEV_ENTRY(sde->dd)
1238                 __string(curstate, cstate)
1239                 __string(newstate, nstate)
1240         ),
1241         TP_fast_assign(
1242                 DD_DEV_ASSIGN(sde->dd);
1243                 __assign_str(curstate, cstate);
1244                 __assign_str(newstate, nstate);
1245         ),
1246         TP_printk("[%s] current state %s new state %s",
1247                 __get_str(dev),
1248                 __get_str(curstate),
1249                 __get_str(newstate)
1250         )
1251 );
1252
1253 #undef TRACE_SYSTEM
1254 #define TRACE_SYSTEM hfi1_rc
1255
1256 DECLARE_EVENT_CLASS(hfi1_rc_template,
1257         TP_PROTO(struct hfi1_qp *qp, u32 psn),
1258         TP_ARGS(qp, psn),
1259         TP_STRUCT__entry(
1260                 DD_DEV_ENTRY(dd_from_ibdev(qp->ibqp.device))
1261                 __field(u32, qpn)
1262                 __field(u32, s_flags)
1263                 __field(u32, psn)
1264                 __field(u32, s_psn)
1265                 __field(u32, s_next_psn)
1266                 __field(u32, s_sending_psn)
1267                 __field(u32, s_sending_hpsn)
1268                 __field(u32, r_psn)
1269         ),
1270         TP_fast_assign(
1271                 DD_DEV_ASSIGN(dd_from_ibdev(qp->ibqp.device))
1272                 __entry->qpn = qp->ibqp.qp_num;
1273                 __entry->s_flags = qp->s_flags;
1274                 __entry->psn = psn;
1275                 __entry->s_psn = qp->s_psn;
1276                 __entry->s_next_psn = qp->s_next_psn;
1277                 __entry->s_sending_psn = qp->s_sending_psn;
1278                 __entry->s_sending_hpsn = qp->s_sending_hpsn;
1279                 __entry->r_psn = qp->r_psn;
1280         ),
1281         TP_printk(
1282                 "[%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",
1283                 __get_str(dev),
1284                 __entry->qpn,
1285                 __entry->s_flags,
1286                 __entry->psn,
1287                 __entry->s_psn,
1288                 __entry->s_next_psn,
1289                 __entry->s_sending_psn,
1290                 __entry->s_sending_hpsn,
1291                 __entry->r_psn
1292         )
1293 );
1294
1295 DEFINE_EVENT(hfi1_rc_template, hfi1_rc_sendcomplete,
1296              TP_PROTO(struct hfi1_qp *qp, u32 psn),
1297              TP_ARGS(qp, psn)
1298 );
1299
1300 DEFINE_EVENT(hfi1_rc_template, hfi1_rc_ack,
1301              TP_PROTO(struct hfi1_qp *qp, u32 psn),
1302              TP_ARGS(qp, psn)
1303 );
1304
1305 DEFINE_EVENT(hfi1_rc_template, hfi1_rc_timeout,
1306              TP_PROTO(struct hfi1_qp *qp, u32 psn),
1307              TP_ARGS(qp, psn)
1308 );
1309
1310 DEFINE_EVENT(hfi1_rc_template, hfi1_rc_rcv_error,
1311              TP_PROTO(struct hfi1_qp *qp, u32 psn),
1312              TP_ARGS(qp, psn)
1313 );
1314
1315 #undef TRACE_SYSTEM
1316 #define TRACE_SYSTEM hfi1_misc
1317
1318 TRACE_EVENT(hfi1_interrupt,
1319         TP_PROTO(struct hfi1_devdata *dd, const struct is_table *is_entry,
1320                  int src),
1321         TP_ARGS(dd, is_entry, src),
1322         TP_STRUCT__entry(
1323                 DD_DEV_ENTRY(dd)
1324                 __array(char, buf, 64)
1325                 __field(int, src)
1326         ),
1327         TP_fast_assign(
1328                 DD_DEV_ASSIGN(dd)
1329                 is_entry->is_name(__entry->buf, 64, src - is_entry->start);
1330                 __entry->src = src;
1331         ),
1332         TP_printk("[%s] source: %s [%d]", __get_str(dev), __entry->buf,
1333                   __entry->src)
1334 );
1335
1336 /*
1337  * Note:
1338  * This produces a REALLY ugly trace in the console output when the string is
1339  * too long.
1340  */
1341
1342 #undef TRACE_SYSTEM
1343 #define TRACE_SYSTEM hfi1_trace
1344
1345 #define MAX_MSG_LEN 512
1346
1347 DECLARE_EVENT_CLASS(hfi1_trace_template,
1348         TP_PROTO(const char *function, struct va_format *vaf),
1349         TP_ARGS(function, vaf),
1350         TP_STRUCT__entry(
1351                 __string(function, function)
1352                 __dynamic_array(char, msg, MAX_MSG_LEN)
1353         ),
1354         TP_fast_assign(
1355                 __assign_str(function, function);
1356                 WARN_ON_ONCE(vsnprintf(__get_dynamic_array(msg),
1357                      MAX_MSG_LEN, vaf->fmt,
1358                      *vaf->va) >= MAX_MSG_LEN);
1359         ),
1360         TP_printk("(%s) %s",
1361                   __get_str(function),
1362                   __get_str(msg))
1363 );
1364
1365 /*
1366  * It may be nice to macroize the __hfi1_trace but the va_* stuff requires an
1367  * actual function to work and can not be in a macro.
1368  */
1369 #define __hfi1_trace_def(lvl) \
1370 void __hfi1_trace_##lvl(const char *funct, char *fmt, ...);             \
1371                                                                         \
1372 DEFINE_EVENT(hfi1_trace_template, hfi1_ ##lvl,                          \
1373         TP_PROTO(const char *function, struct va_format *vaf),          \
1374         TP_ARGS(function, vaf))
1375
1376 #define __hfi1_trace_fn(lvl) \
1377 void __hfi1_trace_##lvl(const char *func, char *fmt, ...)               \
1378 {                                                                       \
1379         struct va_format vaf = {                                        \
1380                 .fmt = fmt,                                             \
1381         };                                                              \
1382         va_list args;                                                   \
1383                                                                         \
1384         va_start(args, fmt);                                            \
1385         vaf.va = &args;                                                 \
1386         trace_hfi1_ ##lvl(func, &vaf);                                  \
1387         va_end(args);                                                   \
1388         return;                                                         \
1389 }
1390
1391 /*
1392  * To create a new trace level simply define it below and as a __hfi1_trace_fn
1393  * in trace.c. This will create all the hooks for calling
1394  * hfi1_cdbg(LVL, fmt, ...); as well as take care of all
1395  * the debugfs stuff.
1396  */
1397 __hfi1_trace_def(PKT);
1398 __hfi1_trace_def(PROC);
1399 __hfi1_trace_def(SDMA);
1400 __hfi1_trace_def(LINKVERB);
1401 __hfi1_trace_def(DEBUG);
1402 __hfi1_trace_def(SNOOP);
1403 __hfi1_trace_def(CNTR);
1404 __hfi1_trace_def(PIO);
1405 __hfi1_trace_def(DC8051);
1406 __hfi1_trace_def(FIRMWARE);
1407 __hfi1_trace_def(RCVCTRL);
1408 __hfi1_trace_def(TID);
1409
1410 #define hfi1_cdbg(which, fmt, ...) \
1411         __hfi1_trace_##which(__func__, fmt, ##__VA_ARGS__)
1412
1413 #define hfi1_dbg(fmt, ...) \
1414         hfi1_cdbg(DEBUG, fmt, ##__VA_ARGS__)
1415
1416 /*
1417  * Define HFI1_EARLY_DBG at compile time or here to enable early trace
1418  * messages. Do not check in an enablement for this.
1419  */
1420
1421 #ifdef HFI1_EARLY_DBG
1422 #define hfi1_dbg_early(fmt, ...) \
1423         trace_printk(fmt, ##__VA_ARGS__)
1424 #else
1425 #define hfi1_dbg_early(fmt, ...)
1426 #endif
1427
1428 #endif /* __HFI1_TRACE_H */
1429
1430 #undef TRACE_INCLUDE_PATH
1431 #undef TRACE_INCLUDE_FILE
1432 #define TRACE_INCLUDE_PATH .
1433 #define TRACE_INCLUDE_FILE trace
1434 #include <trace/define_trace.h>