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 }; 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 >> 1; 108 if (payload & 1) 109 packet->payload |= NR_FLAG; 110 111 return 8; 112 } 113 114 static int intel_pt_get_tracestop(struct intel_pt_pkt *packet) 115 { 116 packet->type = INTEL_PT_TRACESTOP; 117 return 2; 118 } 119 120 static int intel_pt_get_cbr(const unsigned char *buf, size_t len, 121 struct intel_pt_pkt *packet) 122 { 123 if (len < 4) 124 return INTEL_PT_NEED_MORE_BYTES; 125 packet->type = INTEL_PT_CBR; 126 packet->payload = buf[2]; 127 return 4; 128 } 129 130 static int intel_pt_get_vmcs(const unsigned char *buf, size_t len, 131 struct intel_pt_pkt *packet) 132 { 133 unsigned int count = (52 - 5) >> 3; 134 135 if (count < 1 || count > 7) 136 return INTEL_PT_BAD_PACKET; 137 138 if (len < count + 2) 139 return INTEL_PT_NEED_MORE_BYTES; 140 141 packet->type = INTEL_PT_VMCS; 142 packet->count = count; 143 memcpy_le64(&packet->payload, buf + 2, count); 144 145 return count + 2; 146 } 147 148 static int intel_pt_get_ovf(struct intel_pt_pkt *packet) 149 { 150 packet->type = INTEL_PT_OVF; 151 return 2; 152 } 153 154 static int intel_pt_get_psb(const unsigned char *buf, size_t len, 155 struct intel_pt_pkt *packet) 156 { 157 int i; 158 159 if (len < 16) 160 return INTEL_PT_NEED_MORE_BYTES; 161 162 for (i = 2; i < 16; i += 2) { 163 if (buf[i] != 2 || buf[i + 1] != 0x82) 164 return INTEL_PT_BAD_PACKET; 165 } 166 167 packet->type = INTEL_PT_PSB; 168 return 16; 169 } 170 171 static int intel_pt_get_psbend(struct intel_pt_pkt *packet) 172 { 173 packet->type = INTEL_PT_PSBEND; 174 return 2; 175 } 176 177 static int intel_pt_get_tma(const unsigned char *buf, size_t len, 178 struct intel_pt_pkt *packet) 179 { 180 if (len < 7) 181 return INTEL_PT_NEED_MORE_BYTES; 182 183 packet->type = INTEL_PT_TMA; 184 packet->payload = buf[2] | (buf[3] << 8); 185 packet->count = buf[5] | ((buf[6] & BIT(0)) << 8); 186 return 7; 187 } 188 189 static int intel_pt_get_pad(struct intel_pt_pkt *packet) 190 { 191 packet->type = INTEL_PT_PAD; 192 return 1; 193 } 194 195 static int intel_pt_get_mnt(const unsigned char *buf, size_t len, 196 struct intel_pt_pkt *packet) 197 { 198 if (len < 11) 199 return INTEL_PT_NEED_MORE_BYTES; 200 packet->type = INTEL_PT_MNT; 201 memcpy_le64(&packet->payload, buf + 3, 8); 202 return 11 203 ; 204 } 205 206 static 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 220 static int intel_pt_get_ext(const unsigned char *buf, size_t len, 221 struct intel_pt_pkt *packet) 222 { 223 if (len < 2) 224 return INTEL_PT_NEED_MORE_BYTES; 225 226 switch (buf[1]) { 227 case 0xa3: /* Long TNT */ 228 return intel_pt_get_long_tnt(buf, len, packet); 229 case 0x43: /* PIP */ 230 return intel_pt_get_pip(buf, len, packet); 231 case 0x83: /* TraceStop */ 232 return intel_pt_get_tracestop(packet); 233 case 0x03: /* CBR */ 234 return intel_pt_get_cbr(buf, len, packet); 235 case 0xc8: /* VMCS */ 236 return intel_pt_get_vmcs(buf, len, packet); 237 case 0xf3: /* OVF */ 238 return intel_pt_get_ovf(packet); 239 case 0x82: /* PSB */ 240 return intel_pt_get_psb(buf, len, packet); 241 case 0x23: /* PSBEND */ 242 return intel_pt_get_psbend(packet); 243 case 0x73: /* TMA */ 244 return intel_pt_get_tma(buf, len, packet); 245 case 0xC3: /* 3-byte header */ 246 return intel_pt_get_3byte(buf, len, packet); 247 default: 248 return INTEL_PT_BAD_PACKET; 249 } 250 } 251 252 static int intel_pt_get_short_tnt(unsigned int byte, 253 struct intel_pt_pkt *packet) 254 { 255 int count; 256 257 for (count = 6; count; count--) { 258 if (byte & BIT(7)) 259 break; 260 byte <<= 1; 261 } 262 263 packet->type = INTEL_PT_TNT; 264 packet->count = count; 265 packet->payload = (uint64_t)byte << 57; 266 267 return 1; 268 } 269 270 static int intel_pt_get_cyc(unsigned int byte, const unsigned char *buf, 271 size_t len, struct intel_pt_pkt *packet) 272 { 273 unsigned int offs = 1, shift; 274 uint64_t payload = byte >> 3; 275 276 byte >>= 2; 277 len -= 1; 278 for (shift = 5; byte & 1; shift += 7) { 279 if (offs > 9) 280 return INTEL_PT_BAD_PACKET; 281 if (len < offs) 282 return INTEL_PT_NEED_MORE_BYTES; 283 byte = buf[offs++]; 284 payload |= (byte >> 1) << shift; 285 } 286 287 packet->type = INTEL_PT_CYC; 288 packet->payload = payload; 289 return offs; 290 } 291 292 static int intel_pt_get_ip(enum intel_pt_pkt_type type, unsigned int byte, 293 const unsigned char *buf, size_t len, 294 struct intel_pt_pkt *packet) 295 { 296 int ip_len; 297 298 packet->count = byte >> 5; 299 300 switch (packet->count) { 301 case 0: 302 ip_len = 0; 303 break; 304 case 1: 305 if (len < 3) 306 return INTEL_PT_NEED_MORE_BYTES; 307 ip_len = 2; 308 packet->payload = le16_to_cpu(*(uint16_t *)(buf + 1)); 309 break; 310 case 2: 311 if (len < 5) 312 return INTEL_PT_NEED_MORE_BYTES; 313 ip_len = 4; 314 packet->payload = le32_to_cpu(*(uint32_t *)(buf + 1)); 315 break; 316 case 3: 317 case 4: 318 if (len < 7) 319 return INTEL_PT_NEED_MORE_BYTES; 320 ip_len = 6; 321 memcpy_le64(&packet->payload, buf + 1, 6); 322 break; 323 case 6: 324 if (len < 9) 325 return INTEL_PT_NEED_MORE_BYTES; 326 ip_len = 8; 327 packet->payload = le64_to_cpu(*(uint64_t *)(buf + 1)); 328 break; 329 default: 330 return INTEL_PT_BAD_PACKET; 331 } 332 333 packet->type = type; 334 335 return ip_len + 1; 336 } 337 338 static int intel_pt_get_mode(const unsigned char *buf, size_t len, 339 struct intel_pt_pkt *packet) 340 { 341 if (len < 2) 342 return INTEL_PT_NEED_MORE_BYTES; 343 344 switch (buf[1] >> 5) { 345 case 0: 346 packet->type = INTEL_PT_MODE_EXEC; 347 switch (buf[1] & 3) { 348 case 0: 349 packet->payload = 16; 350 break; 351 case 1: 352 packet->payload = 64; 353 break; 354 case 2: 355 packet->payload = 32; 356 break; 357 default: 358 return INTEL_PT_BAD_PACKET; 359 } 360 break; 361 case 1: 362 packet->type = INTEL_PT_MODE_TSX; 363 if ((buf[1] & 3) == 3) 364 return INTEL_PT_BAD_PACKET; 365 packet->payload = buf[1] & 3; 366 break; 367 default: 368 return INTEL_PT_BAD_PACKET; 369 } 370 371 return 2; 372 } 373 374 static int intel_pt_get_tsc(const unsigned char *buf, size_t len, 375 struct intel_pt_pkt *packet) 376 { 377 if (len < 8) 378 return INTEL_PT_NEED_MORE_BYTES; 379 packet->type = INTEL_PT_TSC; 380 memcpy_le64(&packet->payload, buf + 1, 7); 381 return 8; 382 } 383 384 static int intel_pt_get_mtc(const unsigned char *buf, size_t len, 385 struct intel_pt_pkt *packet) 386 { 387 if (len < 2) 388 return INTEL_PT_NEED_MORE_BYTES; 389 packet->type = INTEL_PT_MTC; 390 packet->payload = buf[1]; 391 return 2; 392 } 393 394 static int intel_pt_do_get_packet(const unsigned char *buf, size_t len, 395 struct intel_pt_pkt *packet) 396 { 397 unsigned int byte; 398 399 memset(packet, 0, sizeof(struct intel_pt_pkt)); 400 401 if (!len) 402 return INTEL_PT_NEED_MORE_BYTES; 403 404 byte = buf[0]; 405 if (!(byte & BIT(0))) { 406 if (byte == 0) 407 return intel_pt_get_pad(packet); 408 if (byte == 2) 409 return intel_pt_get_ext(buf, len, packet); 410 return intel_pt_get_short_tnt(byte, packet); 411 } 412 413 if ((byte & 2)) 414 return intel_pt_get_cyc(byte, buf, len, packet); 415 416 switch (byte & 0x1f) { 417 case 0x0D: 418 return intel_pt_get_ip(INTEL_PT_TIP, byte, buf, len, packet); 419 case 0x11: 420 return intel_pt_get_ip(INTEL_PT_TIP_PGE, byte, buf, len, 421 packet); 422 case 0x01: 423 return intel_pt_get_ip(INTEL_PT_TIP_PGD, byte, buf, len, 424 packet); 425 case 0x1D: 426 return intel_pt_get_ip(INTEL_PT_FUP, byte, buf, len, packet); 427 case 0x19: 428 switch (byte) { 429 case 0x99: 430 return intel_pt_get_mode(buf, len, packet); 431 case 0x19: 432 return intel_pt_get_tsc(buf, len, packet); 433 case 0x59: 434 return intel_pt_get_mtc(buf, len, packet); 435 default: 436 return INTEL_PT_BAD_PACKET; 437 } 438 default: 439 return INTEL_PT_BAD_PACKET; 440 } 441 } 442 443 int intel_pt_get_packet(const unsigned char *buf, size_t len, 444 struct intel_pt_pkt *packet) 445 { 446 int ret; 447 448 ret = intel_pt_do_get_packet(buf, len, packet); 449 if (ret > 0) { 450 while (ret < 8 && len > (size_t)ret && !buf[ret]) 451 ret += 1; 452 } 453 return ret; 454 } 455 456 int intel_pt_pkt_desc(const struct intel_pt_pkt *packet, char *buf, 457 size_t buf_len) 458 { 459 int ret, i, nr; 460 unsigned long long payload = packet->payload; 461 const char *name = intel_pt_pkt_name(packet->type); 462 463 switch (packet->type) { 464 case INTEL_PT_BAD: 465 case INTEL_PT_PAD: 466 case INTEL_PT_PSB: 467 case INTEL_PT_PSBEND: 468 case INTEL_PT_TRACESTOP: 469 case INTEL_PT_OVF: 470 return snprintf(buf, buf_len, "%s", name); 471 case INTEL_PT_TNT: { 472 size_t blen = buf_len; 473 474 ret = snprintf(buf, blen, "%s ", name); 475 if (ret < 0) 476 return ret; 477 buf += ret; 478 blen -= ret; 479 for (i = 0; i < packet->count; i++) { 480 if (payload & BIT63) 481 ret = snprintf(buf, blen, "T"); 482 else 483 ret = snprintf(buf, blen, "N"); 484 if (ret < 0) 485 return ret; 486 buf += ret; 487 blen -= ret; 488 payload <<= 1; 489 } 490 ret = snprintf(buf, blen, " (%d)", packet->count); 491 if (ret < 0) 492 return ret; 493 blen -= ret; 494 return buf_len - blen; 495 } 496 case INTEL_PT_TIP_PGD: 497 case INTEL_PT_TIP_PGE: 498 case INTEL_PT_TIP: 499 case INTEL_PT_FUP: 500 if (!(packet->count)) 501 return snprintf(buf, buf_len, "%s no ip", name); 502 __fallthrough; 503 case INTEL_PT_CYC: 504 case INTEL_PT_VMCS: 505 case INTEL_PT_MTC: 506 case INTEL_PT_MNT: 507 case INTEL_PT_CBR: 508 case INTEL_PT_TSC: 509 return snprintf(buf, buf_len, "%s 0x%llx", name, payload); 510 case INTEL_PT_TMA: 511 return snprintf(buf, buf_len, "%s CTC 0x%x FC 0x%x", name, 512 (unsigned)payload, packet->count); 513 case INTEL_PT_MODE_EXEC: 514 return snprintf(buf, buf_len, "%s %lld", name, payload); 515 case INTEL_PT_MODE_TSX: 516 return snprintf(buf, buf_len, "%s TXAbort:%u InTX:%u", 517 name, (unsigned)(payload >> 1) & 1, 518 (unsigned)payload & 1); 519 case INTEL_PT_PIP: 520 nr = packet->payload & NR_FLAG ? 1 : 0; 521 payload &= ~NR_FLAG; 522 ret = snprintf(buf, buf_len, "%s 0x%llx (NR=%d)", 523 name, payload, nr); 524 return ret; 525 default: 526 break; 527 } 528 return snprintf(buf, buf_len, "%s 0x%llx (%d)", 529 name, payload, packet->count); 530 } 531