tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c

   1 /*
   2  * intel_pt_pkt_decoder.c: Intel Processor Trace support
   3  * Copyright (c) 2013-2014, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  */
  15
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <endian.h>
  19 #include <byteswap.h>
  20 #include <linux/compiler.h>
  21
  22 #include "intel-pt-pkt-decoder.h"
  23
  24 #define BIT(n)          (1 << (n))
  25
  26 #define BIT63           ((uint64_t)1 << 63)
  27
  28 #define NR_FLAG         BIT63
  29
  30 #if __BYTE_ORDER == __BIG_ENDIAN
  31 #define le16_to_cpu bswap_16
  32 #define le32_to_cpu bswap_32
  33 #define le64_to_cpu bswap_64
  34 #define memcpy_le64(d, s, n) do { \
  35         memcpy((d), (s), (n));    \
  36         *(d) = le64_to_cpu(*(d)); \
  37 } while (0)
  38 #else
  39 #define le16_to_cpu
  40 #define le32_to_cpu
  41 #define le64_to_cpu
  42 #define memcpy_le64 memcpy
  43 #endif
  44
  45 static const char * const packet_name[] = {
  46         [INTEL_PT_BAD]          = "Bad Packet!",
  47         [INTEL_PT_PAD]          = "PAD",
  48         [INTEL_PT_TNT]          = "TNT",
  49         [INTEL_PT_TIP_PGD]      = "TIP.PGD",
  50         [INTEL_PT_TIP_PGE]      = "TIP.PGE",
  51         [INTEL_PT_TSC]          = "TSC",
  52         [INTEL_PT_TMA]          = "TMA",
  53         [INTEL_PT_MODE_EXEC]    = "MODE.Exec",
  54         [INTEL_PT_MODE_TSX]     = "MODE.TSX",
  55         [INTEL_PT_MTC]          = "MTC",
  56         [INTEL_PT_TIP]          = "TIP",
  57         [INTEL_PT_FUP]          = "FUP",
  58         [INTEL_PT_CYC]          = "CYC",
  59         [INTEL_PT_VMCS]         = "VMCS",
  60         [INTEL_PT_PSB]          = "PSB",
  61         [INTEL_PT_PSBEND]       = "PSBEND",
  62         [INTEL_PT_CBR]          = "CBR",
  63         [INTEL_PT_TRACESTOP]    = "TraceSTOP",
  64         [INTEL_PT_PIP]          = "PIP",
  65         [INTEL_PT_OVF]          = "OVF",
  66         [INTEL_PT_MNT]          = "MNT",
  67         [INTEL_PT_PTWRITE]      = "PTWRITE",
  68         [INTEL_PT_PTWRITE_IP]   = "PTWRITE",
  69         [INTEL_PT_EXSTOP]       = "EXSTOP",
  70         [INTEL_PT_EXSTOP_IP]    = "EXSTOP",
  71         [INTEL_PT_MWAIT]        = "MWAIT",
  72         [INTEL_PT_PWRE]         = "PWRE",
  73         [INTEL_PT_PWRX]         = "PWRX",
  74 };
  75
  76 const char *intel_pt_pkt_name(enum intel_pt_pkt_type type)
  77 {
  78         return packet_name[type];
  79 }
  80
  81 static int intel_pt_get_long_tnt(const unsigned char *buf, size_t len,
  82                                  struct intel_pt_pkt *packet)
  83 {
  84         uint64_t payload;
  85         int count;
  86
  87         if (len < 8)
  88                 return INTEL_PT_NEED_MORE_BYTES;
  89
  90         payload = le64_to_cpu(*(uint64_t *)buf);
  91
  92         for (count = 47; count; count--) {
  93                 if (payload & BIT63)
  94                         break;
  95                 payload <<= 1;
  96         }
  97
  98         packet->type = INTEL_PT_TNT;
  99         packet->count = count;
 100         packet->payload = payload << 1;
 101         return 8;
 102 }
 103
 104 static int intel_pt_get_pip(const unsigned char *buf, size_t len,
 105                             struct intel_pt_pkt *packet)
 106 {
 107         uint64_t payload = 0;
 108
 109         if (len < 8)
 110                 return INTEL_PT_NEED_MORE_BYTES;
 111
 112         packet->type = INTEL_PT_PIP;
 113         memcpy_le64(&payload, buf + 2, 6);
 114         packet->payload = payload >> 1;
 115         if (payload & 1)
 116                 packet->payload |= NR_FLAG;
 117
 118         return 8;
 119 }
 120
 121 static int intel_pt_get_tracestop(struct intel_pt_pkt *packet)
 122 {
 123         packet->type = INTEL_PT_TRACESTOP;
 124         return 2;
 125 }
 126
 127 static int intel_pt_get_cbr(const unsigned char *buf, size_t len,
 128                             struct intel_pt_pkt *packet)
 129 {
 130         if (len < 4)
 131                 return INTEL_PT_NEED_MORE_BYTES;
 132         packet->type = INTEL_PT_CBR;
 133         packet->payload = le16_to_cpu(*(uint16_t *)(buf + 2));
 134         return 4;
 135 }
 136
 137 static int intel_pt_get_vmcs(const unsigned char *buf, size_t len,
 138                              struct intel_pt_pkt *packet)
 139 {
 140         unsigned int count = (52 - 5) >> 3;
 141
 142         if (count < 1 || count > 7)
 143                 return INTEL_PT_BAD_PACKET;
 144
 145         if (len < count + 2)
 146                 return INTEL_PT_NEED_MORE_BYTES;
 147
 148         packet->type = INTEL_PT_VMCS;
 149         packet->count = count;
 150         memcpy_le64(&packet->payload, buf + 2, count);
 151
 152         return count + 2;
 153 }
 154
 155 static int intel_pt_get_ovf(struct intel_pt_pkt *packet)
 156 {
 157         packet->type = INTEL_PT_OVF;
 158         return 2;
 159 }
 160
 161 static int intel_pt_get_psb(const unsigned char *buf, size_t len,
 162                             struct intel_pt_pkt *packet)
 163 {
 164         int i;
 165
 166         if (len < 16)
 167                 return INTEL_PT_NEED_MORE_BYTES;
 168
 169         for (i = 2; i < 16; i += 2) {
 170                 if (buf[i] != 2 || buf[i + 1] != 0x82)
 171                         return INTEL_PT_BAD_PACKET;
 172         }
 173
 174         packet->type = INTEL_PT_PSB;
 175         return 16;
 176 }
 177
 178 static int intel_pt_get_psbend(struct intel_pt_pkt *packet)
 179 {
 180         packet->type = INTEL_PT_PSBEND;
 181         return 2;
 182 }
 183
 184 static int intel_pt_get_tma(const unsigned char *buf, size_t len,
 185                             struct intel_pt_pkt *packet)
 186 {
 187         if (len < 7)
 188                 return INTEL_PT_NEED_MORE_BYTES;
 189
 190         packet->type = INTEL_PT_TMA;
 191         packet->payload = buf[2] | (buf[3] << 8);
 192         packet->count = buf[5] | ((buf[6] & BIT(0)) << 8);
 193         return 7;
 194 }
 195
 196 static int intel_pt_get_pad(struct intel_pt_pkt *packet)
 197 {
 198         packet->type = INTEL_PT_PAD;
 199         return 1;
 200 }
 201
 202 static int intel_pt_get_mnt(const unsigned char *buf, size_t len,
 203                             struct intel_pt_pkt *packet)
 204 {
 205         if (len < 11)
 206                 return INTEL_PT_NEED_MORE_BYTES;
 207         packet->type = INTEL_PT_MNT;
 208         memcpy_le64(&packet->payload, buf + 3, 8);
 209         return 11
 210 ;
 211 }
 212
 213 static int intel_pt_get_3byte(const unsigned char *buf, size_t len,
 214                               struct intel_pt_pkt *packet)
 215 {
 216         if (len < 3)
 217                 return INTEL_PT_NEED_MORE_BYTES;
 218
 219         switch (buf[2]) {
 220         case 0x88: /* MNT */
 221                 return intel_pt_get_mnt(buf, len, packet);
 222         default:
 223                 return INTEL_PT_BAD_PACKET;
 224         }
 225 }
 226
 227 static int intel_pt_get_ptwrite(const unsigned char *buf, size_t len,
 228                                 struct intel_pt_pkt *packet)
 229 {
 230         packet->count = (buf[1] >> 5) & 0x3;
 231         packet->type = buf[1] & BIT(7) ? INTEL_PT_PTWRITE_IP :
 232                                          INTEL_PT_PTWRITE;
 233
 234         switch (packet->count) {
 235         case 0:
 236                 if (len < 6)
 237                         return INTEL_PT_NEED_MORE_BYTES;
 238                 packet->payload = le32_to_cpu(*(uint32_t *)(buf + 2));
 239                 return 6;
 240         case 1:
 241                 if (len < 10)
 242                         return INTEL_PT_NEED_MORE_BYTES;
 243                 packet->payload = le64_to_cpu(*(uint64_t *)(buf + 2));
 244                 return 10;
 245         default:
 246                 return INTEL_PT_BAD_PACKET;
 247         }
 248 }
 249
 250 static int intel_pt_get_exstop(struct intel_pt_pkt *packet)
 251 {
 252         packet->type = INTEL_PT_EXSTOP;
 253         return 2;
 254 }
 255
 256 static int intel_pt_get_exstop_ip(struct intel_pt_pkt *packet)
 257 {
 258         packet->type = INTEL_PT_EXSTOP_IP;
 259         return 2;
 260 }
 261
 262 static int intel_pt_get_mwait(const unsigned char *buf, size_t len,
 263                               struct intel_pt_pkt *packet)
 264 {
 265         if (len < 10)
 266                 return INTEL_PT_NEED_MORE_BYTES;
 267         packet->type = INTEL_PT_MWAIT;
 268         packet->payload = le64_to_cpu(*(uint64_t *)(buf + 2));
 269         return 10;
 270 }
 271
 272 static int intel_pt_get_pwre(const unsigned char *buf, size_t len,
 273                              struct intel_pt_pkt *packet)
 274 {
 275         if (len < 4)
 276                 return INTEL_PT_NEED_MORE_BYTES;
 277         packet->type = INTEL_PT_PWRE;
 278         memcpy_le64(&packet->payload, buf + 2, 2);
 279         return 4;
 280 }
 281
 282 static int intel_pt_get_pwrx(const unsigned char *buf, size_t len,
 283                              struct intel_pt_pkt *packet)
 284 {
 285         if (len < 7)
 286                 return INTEL_PT_NEED_MORE_BYTES;
 287         packet->type = INTEL_PT_PWRX;
 288         memcpy_le64(&packet->payload, buf + 2, 5);
 289         return 7;
 290 }
 291
 292 static int intel_pt_get_ext(const unsigned char *buf, size_t len,
 293                             struct intel_pt_pkt *packet)
 294 {
 295         if (len < 2)
 296                 return INTEL_PT_NEED_MORE_BYTES;
 297
 298         if ((buf[1] & 0x1f) == 0x12)
 299                 return intel_pt_get_ptwrite(buf, len, packet);
 300
 301         switch (buf[1]) {
 302         case 0xa3: /* Long TNT */
 303                 return intel_pt_get_long_tnt(buf, len, packet);
 304         case 0x43: /* PIP */
 305                 return intel_pt_get_pip(buf, len, packet);
 306         case 0x83: /* TraceStop */
 307                 return intel_pt_get_tracestop(packet);
 308         case 0x03: /* CBR */
 309                 return intel_pt_get_cbr(buf, len, packet);
 310         case 0xc8: /* VMCS */
 311                 return intel_pt_get_vmcs(buf, len, packet);
 312         case 0xf3: /* OVF */
 313                 return intel_pt_get_ovf(packet);
 314         case 0x82: /* PSB */
 315                 return intel_pt_get_psb(buf, len, packet);
 316         case 0x23: /* PSBEND */
 317                 return intel_pt_get_psbend(packet);
 318         case 0x73: /* TMA */
 319                 return intel_pt_get_tma(buf, len, packet);
 320         case 0xC3: /* 3-byte header */
 321                 return intel_pt_get_3byte(buf, len, packet);
 322         case 0x62: /* EXSTOP no IP */
 323                 return intel_pt_get_exstop(packet);
 324         case 0xE2: /* EXSTOP with IP */
 325                 return intel_pt_get_exstop_ip(packet);
 326         case 0xC2: /* MWAIT */
 327                 return intel_pt_get_mwait(buf, len, packet);
 328         case 0x22: /* PWRE */
 329                 return intel_pt_get_pwre(buf, len, packet);
 330         case 0xA2: /* PWRX */
 331                 return intel_pt_get_pwrx(buf, len, packet);
 332         default:
 333                 return INTEL_PT_BAD_PACKET;
 334         }
 335 }
 336
 337 static int intel_pt_get_short_tnt(unsigned int byte,
 338                                   struct intel_pt_pkt *packet)
 339 {
 340         int count;
 341
 342         for (count = 6; count; count--) {
 343                 if (byte & BIT(7))
 344                         break;
 345                 byte <<= 1;
 346         }
 347
 348         packet->type = INTEL_PT_TNT;
 349         packet->count = count;
 350         packet->payload = (uint64_t)byte << 57;
 351
 352         return 1;
 353 }
 354
 355 static int intel_pt_get_cyc(unsigned int byte, const unsigned char *buf,
 356                             size_t len, struct intel_pt_pkt *packet)
 357 {
 358         unsigned int offs = 1, shift;
 359         uint64_t payload = byte >> 3;
 360
 361         byte >>= 2;
 362         len -= 1;
 363         for (shift = 5; byte & 1; shift += 7) {
 364                 if (offs > 9)
 365                         return INTEL_PT_BAD_PACKET;
 366                 if (len < offs)
 367                         return INTEL_PT_NEED_MORE_BYTES;
 368                 byte = buf[offs++];
 369                 payload |= (byte >> 1) << shift;
 370         }
 371
 372         packet->type = INTEL_PT_CYC;
 373         packet->payload = payload;
 374         return offs;
 375 }
 376
 377 static int intel_pt_get_ip(enum intel_pt_pkt_type type, unsigned int byte,
 378                            const unsigned char *buf, size_t len,
 379                            struct intel_pt_pkt *packet)
 380 {
 381         int ip_len;
 382
 383         packet->count = byte >> 5;
 384
 385         switch (packet->count) {
 386         case 0:
 387                 ip_len = 0;
 388                 break;
 389         case 1:
 390                 if (len < 3)
 391                         return INTEL_PT_NEED_MORE_BYTES;
 392                 ip_len = 2;
 393                 packet->payload = le16_to_cpu(*(uint16_t *)(buf + 1));
 394                 break;
 395         case 2:
 396                 if (len < 5)
 397                         return INTEL_PT_NEED_MORE_BYTES;
 398                 ip_len = 4;
 399                 packet->payload = le32_to_cpu(*(uint32_t *)(buf + 1));
 400                 break;
 401         case 3:
 402         case 4:
 403                 if (len < 7)
 404                         return INTEL_PT_NEED_MORE_BYTES;
 405                 ip_len = 6;
 406                 memcpy_le64(&packet->payload, buf + 1, 6);
 407                 break;
 408         case 6:
 409                 if (len < 9)
 410                         return INTEL_PT_NEED_MORE_BYTES;
 411                 ip_len = 8;
 412                 packet->payload = le64_to_cpu(*(uint64_t *)(buf + 1));
 413                 break;
 414         default:
 415                 return INTEL_PT_BAD_PACKET;
 416         }
 417
 418         packet->type = type;
 419
 420         return ip_len + 1;
 421 }
 422
 423 static int intel_pt_get_mode(const unsigned char *buf, size_t len,
 424                              struct intel_pt_pkt *packet)
 425 {
 426         if (len < 2)
 427                 return INTEL_PT_NEED_MORE_BYTES;
 428
 429         switch (buf[1] >> 5) {
 430         case 0:
 431                 packet->type = INTEL_PT_MODE_EXEC;
 432                 switch (buf[1] & 3) {
 433                 case 0:
 434                         packet->payload = 16;
 435                         break;
 436                 case 1:
 437                         packet->payload = 64;
 438                         break;
 439                 case 2:
 440                         packet->payload = 32;
 441                         break;
 442                 default:
 443                         return INTEL_PT_BAD_PACKET;
 444                 }
 445                 break;
 446         case 1:
 447                 packet->type = INTEL_PT_MODE_TSX;
 448                 if ((buf[1] & 3) == 3)
 449                         return INTEL_PT_BAD_PACKET;
 450                 packet->payload = buf[1] & 3;
 451                 break;
 452         default:
 453                 return INTEL_PT_BAD_PACKET;
 454         }
 455
 456         return 2;
 457 }
 458
 459 static int intel_pt_get_tsc(const unsigned char *buf, size_t len,
 460                             struct intel_pt_pkt *packet)
 461 {
 462         if (len < 8)
 463                 return INTEL_PT_NEED_MORE_BYTES;
 464         packet->type = INTEL_PT_TSC;
 465         memcpy_le64(&packet->payload, buf + 1, 7);
 466         return 8;
 467 }
 468
 469 static int intel_pt_get_mtc(const unsigned char *buf, size_t len,
 470                             struct intel_pt_pkt *packet)
 471 {
 472         if (len < 2)
 473                 return INTEL_PT_NEED_MORE_BYTES;
 474         packet->type = INTEL_PT_MTC;
 475         packet->payload = buf[1];
 476         return 2;
 477 }
 478
 479 static int intel_pt_do_get_packet(const unsigned char *buf, size_t len,
 480                                   struct intel_pt_pkt *packet)
 481 {
 482         unsigned int byte;
 483
 484         memset(packet, 0, sizeof(struct intel_pt_pkt));
 485
 486         if (!len)
 487                 return INTEL_PT_NEED_MORE_BYTES;
 488
 489         byte = buf[0];
 490         if (!(byte & BIT(0))) {
 491                 if (byte == 0)
 492                         return intel_pt_get_pad(packet);
 493                 if (byte == 2)
 494                         return intel_pt_get_ext(buf, len, packet);
 495                 return intel_pt_get_short_tnt(byte, packet);
 496         }
 497
 498         if ((byte & 2))
 499                 return intel_pt_get_cyc(byte, buf, len, packet);
 500
 501         switch (byte & 0x1f) {
 502         case 0x0D:
 503                 return intel_pt_get_ip(INTEL_PT_TIP, byte, buf, len, packet);
 504         case 0x11:
 505                 return intel_pt_get_ip(INTEL_PT_TIP_PGE, byte, buf, len,
 506                                        packet);
 507         case 0x01:
 508                 return intel_pt_get_ip(INTEL_PT_TIP_PGD, byte, buf, len,
 509                                        packet);
 510         case 0x1D:
 511                 return intel_pt_get_ip(INTEL_PT_FUP, byte, buf, len, packet);
 512         case 0x19:
 513                 switch (byte) {
 514                 case 0x99:
 515                         return intel_pt_get_mode(buf, len, packet);
 516                 case 0x19:
 517                         return intel_pt_get_tsc(buf, len, packet);
 518                 case 0x59:
 519                         return intel_pt_get_mtc(buf, len, packet);
 520                 default:
 521                         return INTEL_PT_BAD_PACKET;
 522                 }
 523         default:
 524                 return INTEL_PT_BAD_PACKET;
 525         }
 526 }
 527
 528 int intel_pt_get_packet(const unsigned char *buf, size_t len,
 529                         struct intel_pt_pkt *packet)
 530 {
 531         int ret;
 532
 533         ret = intel_pt_do_get_packet(buf, len, packet);
 534         if (ret > 0) {
 535                 while (ret < 8 && len > (size_t)ret && !buf[ret])
 536                         ret += 1;
 537         }
 538         return ret;
 539 }
 540
 541 int intel_pt_pkt_desc(const struct intel_pt_pkt *packet, char *buf,
 542                       size_t buf_len)
 543 {
 544         int ret, i, nr;
 545         unsigned long long payload = packet->payload;
 546         const char *name = intel_pt_pkt_name(packet->type);
 547
 548         switch (packet->type) {
 549         case INTEL_PT_BAD:
 550         case INTEL_PT_PAD:
 551         case INTEL_PT_PSB:
 552         case INTEL_PT_PSBEND:
 553         case INTEL_PT_TRACESTOP:
 554         case INTEL_PT_OVF:
 555                 return snprintf(buf, buf_len, "%s", name);
 556         case INTEL_PT_TNT: {
 557                 size_t blen = buf_len;
 558
 559                 ret = snprintf(buf, blen, "%s ", name);
 560                 if (ret < 0)
 561                         return ret;
 562                 buf += ret;
 563                 blen -= ret;
 564                 for (i = 0; i < packet->count; i++) {
 565                         if (payload & BIT63)
 566                                 ret = snprintf(buf, blen, "T");
 567                         else
 568                                 ret = snprintf(buf, blen, "N");
 569                         if (ret < 0)
 570                                 return ret;
 571                         buf += ret;
 572                         blen -= ret;
 573                         payload <<= 1;
 574                 }
 575                 ret = snprintf(buf, blen, " (%d)", packet->count);
 576                 if (ret < 0)
 577                         return ret;
 578                 blen -= ret;
 579                 return buf_len - blen;
 580         }
 581         case INTEL_PT_TIP_PGD:
 582         case INTEL_PT_TIP_PGE:
 583         case INTEL_PT_TIP:
 584         case INTEL_PT_FUP:
 585                 if (!(packet->count))
 586                         return snprintf(buf, buf_len, "%s no ip", name);
 587                 __fallthrough;
 588         case INTEL_PT_CYC:
 589         case INTEL_PT_VMCS:
 590         case INTEL_PT_MTC:
 591         case INTEL_PT_MNT:
 592         case INTEL_PT_CBR:
 593         case INTEL_PT_TSC:
 594                 return snprintf(buf, buf_len, "%s 0x%llx", name, payload);
 595         case INTEL_PT_TMA:
 596                 return snprintf(buf, buf_len, "%s CTC 0x%x FC 0x%x", name,
 597                                 (unsigned)payload, packet->count);
 598         case INTEL_PT_MODE_EXEC:
 599                 return snprintf(buf, buf_len, "%s %lld", name, payload);
 600         case INTEL_PT_MODE_TSX:
 601                 return snprintf(buf, buf_len, "%s TXAbort:%u InTX:%u",
 602                                 name, (unsigned)(payload >> 1) & 1,
 603                                 (unsigned)payload & 1);
 604         case INTEL_PT_PIP:
 605                 nr = packet->payload & NR_FLAG ? 1 : 0;
 606                 payload &= ~NR_FLAG;
 607                 ret = snprintf(buf, buf_len, "%s 0x%llx (NR=%d)",
 608                                name, payload, nr);
 609                 return ret;
 610         case INTEL_PT_PTWRITE:
 611                 return snprintf(buf, buf_len, "%s 0x%llx IP:0", name, payload);
 612         case INTEL_PT_PTWRITE_IP:
 613                 return snprintf(buf, buf_len, "%s 0x%llx IP:1", name, payload);
 614         case INTEL_PT_EXSTOP:
 615                 return snprintf(buf, buf_len, "%s IP:0", name);
 616         case INTEL_PT_EXSTOP_IP:
 617                 return snprintf(buf, buf_len, "%s IP:1", name);
 618         case INTEL_PT_MWAIT:
 619                 return snprintf(buf, buf_len, "%s 0x%llx Hints 0x%x Extensions 0x%x",
 620                                 name, payload, (unsigned int)(payload & 0xff),
 621                                 (unsigned int)((payload >> 32) & 0x3));
 622         case INTEL_PT_PWRE:
 623                 return snprintf(buf, buf_len, "%s 0x%llx HW:%u CState:%u Sub-CState:%u",
 624                                 name, payload, !!(payload & 0x80),
 625                                 (unsigned int)((payload >> 12) & 0xf),
 626                                 (unsigned int)((payload >> 8) & 0xf));
 627         case INTEL_PT_PWRX:
 628                 return snprintf(buf, buf_len, "%s 0x%llx Last CState:%u Deepest CState:%u Wake Reason 0x%x",
 629                                 name, payload,
 630                                 (unsigned int)((payload >> 4) & 0xf),
 631                                 (unsigned int)(payload & 0xf),
 632                                 (unsigned int)((payload >> 8) & 0xf));
 633         default:
 634                 break;
 635         }
 636         return snprintf(buf, buf_len, "%s 0x%llx (%d)",
 637                         name, payload, packet->count);
 638 }