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