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