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

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