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 21 #include "intel-pt-pkt-decoder.h" 22 23 #define BIT(n) (1 << (n)) 24 25 #define BIT63 ((uint64_t)1 << 63) 26 27 #define NR_FLAG BIT63 28 29 #if __BYTE_ORDER == __BIG_ENDIAN 30 #define le16_to_cpu bswap_16 31 #define le32_to_cpu bswap_32 32 #define le64_to_cpu bswap_64 33 #define memcpy_le64(d, s, n) do { \ 34 memcpy((d), (s), (n)); \ 35 *(d) = le64_to_cpu(*(d)); \ 36 } while (0) 37 #else 38 #define le16_to_cpu 39 #define le32_to_cpu 40 #define le64_to_cpu 41 #define memcpy_le64 memcpy 42 #endif 43 44 static const char * const packet_name[] = { 45 [INTEL_PT_BAD] = "Bad Packet!", 46 [INTEL_PT_PAD] = "PAD", 47 [INTEL_PT_TNT] = "TNT", 48 [INTEL_PT_TIP_PGD] = "TIP.PGD", 49 [INTEL_PT_TIP_PGE] = "TIP.PGE", 50 [INTEL_PT_TSC] = "TSC", 51 [INTEL_PT_TMA] = "TMA", 52 [INTEL_PT_MODE_EXEC] = "MODE.Exec", 53 [INTEL_PT_MODE_TSX] = "MODE.TSX", 54 [INTEL_PT_MTC] = "MTC", 55 [INTEL_PT_TIP] = "TIP", 56 [INTEL_PT_FUP] = "FUP", 57 [INTEL_PT_CYC] = "CYC", 58 [INTEL_PT_VMCS] = "VMCS", 59 [INTEL_PT_PSB] = "PSB", 60 [INTEL_PT_PSBEND] = "PSBEND", 61 [INTEL_PT_CBR] = "CBR", 62 [INTEL_PT_TRACESTOP] = "TraceSTOP", 63 [INTEL_PT_PIP] = "PIP", 64 [INTEL_PT_OVF] = "OVF", 65 [INTEL_PT_MNT] = "MNT", 66 }; 67 68 const char *intel_pt_pkt_name(enum intel_pt_pkt_type type) 69 { 70 return packet_name[type]; 71 } 72 73 static int intel_pt_get_long_tnt(const unsigned char *buf, size_t len, 74 struct intel_pt_pkt *packet) 75 { 76 uint64_t payload; 77 int count; 78 79 if (len < 8) 80 return INTEL_PT_NEED_MORE_BYTES; 81 82 payload = le64_to_cpu(*(uint64_t *)buf); 83 84 for (count = 47; count; count--) { 85 if (payload & BIT63) 86 break; 87 payload <<= 1; 88 } 89 90 packet->type = INTEL_PT_TNT; 91 packet->count = count; 92 packet->payload = payload << 1; 93 return 8; 94 } 95 96 static int intel_pt_get_pip(const unsigned char *buf, size_t len, 97 struct intel_pt_pkt *packet) 98 { 99 uint64_t payload = 0; 100 101 if (len < 8) 102 return INTEL_PT_NEED_MORE_BYTES; 103 104 packet->type = INTEL_PT_PIP; 105 memcpy_le64(&payload, buf + 2, 6); 106 packet->payload = payload >> 1; 107 if (payload & 1) 108 packet->payload |= NR_FLAG; 109 110 return 8; 111 } 112 113 static int intel_pt_get_tracestop(struct intel_pt_pkt *packet) 114 { 115 packet->type = INTEL_PT_TRACESTOP; 116 return 2; 117 } 118 119 static int intel_pt_get_cbr(const unsigned char *buf, size_t len, 120 struct intel_pt_pkt *packet) 121 { 122 if (len < 4) 123 return INTEL_PT_NEED_MORE_BYTES; 124 packet->type = INTEL_PT_CBR; 125 packet->payload = buf[2]; 126 return 4; 127 } 128 129 static int intel_pt_get_vmcs(const unsigned char *buf, size_t len, 130 struct intel_pt_pkt *packet) 131 { 132 unsigned int count = (52 - 5) >> 3; 133 134 if (count < 1 || count > 7) 135 return INTEL_PT_BAD_PACKET; 136 137 if (len < count + 2) 138 return INTEL_PT_NEED_MORE_BYTES; 139 140 packet->type = INTEL_PT_VMCS; 141 packet->count = count; 142 memcpy_le64(&packet->payload, buf + 2, count); 143 144 return count + 2; 145 } 146 147 static int intel_pt_get_ovf(struct intel_pt_pkt *packet) 148 { 149 packet->type = INTEL_PT_OVF; 150 return 2; 151 } 152 153 static int intel_pt_get_psb(const unsigned char *buf, size_t len, 154 struct intel_pt_pkt *packet) 155 { 156 int i; 157 158 if (len < 16) 159 return INTEL_PT_NEED_MORE_BYTES; 160 161 for (i = 2; i < 16; i += 2) { 162 if (buf[i] != 2 || buf[i + 1] != 0x82) 163 return INTEL_PT_BAD_PACKET; 164 } 165 166 packet->type = INTEL_PT_PSB; 167 return 16; 168 } 169 170 static int intel_pt_get_psbend(struct intel_pt_pkt *packet) 171 { 172 packet->type = INTEL_PT_PSBEND; 173 return 2; 174 } 175 176 static int intel_pt_get_tma(const unsigned char *buf, size_t len, 177 struct intel_pt_pkt *packet) 178 { 179 if (len < 7) 180 return INTEL_PT_NEED_MORE_BYTES; 181 182 packet->type = INTEL_PT_TMA; 183 packet->payload = buf[2] | (buf[3] << 8); 184 packet->count = buf[5] | ((buf[6] & BIT(0)) << 8); 185 return 7; 186 } 187 188 static int intel_pt_get_pad(struct intel_pt_pkt *packet) 189 { 190 packet->type = INTEL_PT_PAD; 191 return 1; 192 } 193 194 static int intel_pt_get_mnt(const unsigned char *buf, size_t len, 195 struct intel_pt_pkt *packet) 196 { 197 if (len < 11) 198 return INTEL_PT_NEED_MORE_BYTES; 199 packet->type = INTEL_PT_MNT; 200 memcpy_le64(&packet->payload, buf + 3, 8); 201 return 11 202 ; 203 } 204 205 static int intel_pt_get_3byte(const unsigned char *buf, size_t len, 206 struct intel_pt_pkt *packet) 207 { 208 if (len < 3) 209 return INTEL_PT_NEED_MORE_BYTES; 210 211 switch (buf[2]) { 212 case 0x88: /* MNT */ 213 return intel_pt_get_mnt(buf, len, packet); 214 default: 215 return INTEL_PT_BAD_PACKET; 216 } 217 } 218 219 static int intel_pt_get_ext(const unsigned char *buf, size_t len, 220 struct intel_pt_pkt *packet) 221 { 222 if (len < 2) 223 return INTEL_PT_NEED_MORE_BYTES; 224 225 switch (buf[1]) { 226 case 0xa3: /* Long TNT */ 227 return intel_pt_get_long_tnt(buf, len, packet); 228 case 0x43: /* PIP */ 229 return intel_pt_get_pip(buf, len, packet); 230 case 0x83: /* TraceStop */ 231 return intel_pt_get_tracestop(packet); 232 case 0x03: /* CBR */ 233 return intel_pt_get_cbr(buf, len, packet); 234 case 0xc8: /* VMCS */ 235 return intel_pt_get_vmcs(buf, len, packet); 236 case 0xf3: /* OVF */ 237 return intel_pt_get_ovf(packet); 238 case 0x82: /* PSB */ 239 return intel_pt_get_psb(buf, len, packet); 240 case 0x23: /* PSBEND */ 241 return intel_pt_get_psbend(packet); 242 case 0x73: /* TMA */ 243 return intel_pt_get_tma(buf, len, packet); 244 case 0xC3: /* 3-byte header */ 245 return intel_pt_get_3byte(buf, len, packet); 246 default: 247 return INTEL_PT_BAD_PACKET; 248 } 249 } 250 251 static int intel_pt_get_short_tnt(unsigned int byte, 252 struct intel_pt_pkt *packet) 253 { 254 int count; 255 256 for (count = 6; count; count--) { 257 if (byte & BIT(7)) 258 break; 259 byte <<= 1; 260 } 261 262 packet->type = INTEL_PT_TNT; 263 packet->count = count; 264 packet->payload = (uint64_t)byte << 57; 265 266 return 1; 267 } 268 269 static int intel_pt_get_cyc(unsigned int byte, const unsigned char *buf, 270 size_t len, struct intel_pt_pkt *packet) 271 { 272 unsigned int offs = 1, shift; 273 uint64_t payload = byte >> 3; 274 275 byte >>= 2; 276 len -= 1; 277 for (shift = 5; byte & 1; shift += 7) { 278 if (offs > 9) 279 return INTEL_PT_BAD_PACKET; 280 if (len < offs) 281 return INTEL_PT_NEED_MORE_BYTES; 282 byte = buf[offs++]; 283 payload |= (byte >> 1) << shift; 284 } 285 286 packet->type = INTEL_PT_CYC; 287 packet->payload = payload; 288 return offs; 289 } 290 291 static int intel_pt_get_ip(enum intel_pt_pkt_type type, unsigned int byte, 292 const unsigned char *buf, size_t len, 293 struct intel_pt_pkt *packet) 294 { 295 switch (byte >> 5) { 296 case 0: 297 packet->count = 0; 298 break; 299 case 1: 300 if (len < 3) 301 return INTEL_PT_NEED_MORE_BYTES; 302 packet->count = 2; 303 packet->payload = le16_to_cpu(*(uint16_t *)(buf + 1)); 304 break; 305 case 2: 306 if (len < 5) 307 return INTEL_PT_NEED_MORE_BYTES; 308 packet->count = 4; 309 packet->payload = le32_to_cpu(*(uint32_t *)(buf + 1)); 310 break; 311 case 3: 312 case 6: 313 if (len < 7) 314 return INTEL_PT_NEED_MORE_BYTES; 315 packet->count = 6; 316 memcpy_le64(&packet->payload, buf + 1, 6); 317 break; 318 default: 319 return INTEL_PT_BAD_PACKET; 320 } 321 322 packet->type = type; 323 324 return packet->count + 1; 325 } 326 327 static int intel_pt_get_mode(const unsigned char *buf, size_t len, 328 struct intel_pt_pkt *packet) 329 { 330 if (len < 2) 331 return INTEL_PT_NEED_MORE_BYTES; 332 333 switch (buf[1] >> 5) { 334 case 0: 335 packet->type = INTEL_PT_MODE_EXEC; 336 switch (buf[1] & 3) { 337 case 0: 338 packet->payload = 16; 339 break; 340 case 1: 341 packet->payload = 64; 342 break; 343 case 2: 344 packet->payload = 32; 345 break; 346 default: 347 return INTEL_PT_BAD_PACKET; 348 } 349 break; 350 case 1: 351 packet->type = INTEL_PT_MODE_TSX; 352 if ((buf[1] & 3) == 3) 353 return INTEL_PT_BAD_PACKET; 354 packet->payload = buf[1] & 3; 355 break; 356 default: 357 return INTEL_PT_BAD_PACKET; 358 } 359 360 return 2; 361 } 362 363 static int intel_pt_get_tsc(const unsigned char *buf, size_t len, 364 struct intel_pt_pkt *packet) 365 { 366 if (len < 8) 367 return INTEL_PT_NEED_MORE_BYTES; 368 packet->type = INTEL_PT_TSC; 369 memcpy_le64(&packet->payload, buf + 1, 7); 370 return 8; 371 } 372 373 static int intel_pt_get_mtc(const unsigned char *buf, size_t len, 374 struct intel_pt_pkt *packet) 375 { 376 if (len < 2) 377 return INTEL_PT_NEED_MORE_BYTES; 378 packet->type = INTEL_PT_MTC; 379 packet->payload = buf[1]; 380 return 2; 381 } 382 383 static int intel_pt_do_get_packet(const unsigned char *buf, size_t len, 384 struct intel_pt_pkt *packet) 385 { 386 unsigned int byte; 387 388 memset(packet, 0, sizeof(struct intel_pt_pkt)); 389 390 if (!len) 391 return INTEL_PT_NEED_MORE_BYTES; 392 393 byte = buf[0]; 394 if (!(byte & BIT(0))) { 395 if (byte == 0) 396 return intel_pt_get_pad(packet); 397 if (byte == 2) 398 return intel_pt_get_ext(buf, len, packet); 399 return intel_pt_get_short_tnt(byte, packet); 400 } 401 402 if ((byte & 2)) 403 return intel_pt_get_cyc(byte, buf, len, packet); 404 405 switch (byte & 0x1f) { 406 case 0x0D: 407 return intel_pt_get_ip(INTEL_PT_TIP, byte, buf, len, packet); 408 case 0x11: 409 return intel_pt_get_ip(INTEL_PT_TIP_PGE, byte, buf, len, 410 packet); 411 case 0x01: 412 return intel_pt_get_ip(INTEL_PT_TIP_PGD, byte, buf, len, 413 packet); 414 case 0x1D: 415 return intel_pt_get_ip(INTEL_PT_FUP, byte, buf, len, packet); 416 case 0x19: 417 switch (byte) { 418 case 0x99: 419 return intel_pt_get_mode(buf, len, packet); 420 case 0x19: 421 return intel_pt_get_tsc(buf, len, packet); 422 case 0x59: 423 return intel_pt_get_mtc(buf, len, packet); 424 default: 425 return INTEL_PT_BAD_PACKET; 426 } 427 default: 428 return INTEL_PT_BAD_PACKET; 429 } 430 } 431 432 int intel_pt_get_packet(const unsigned char *buf, size_t len, 433 struct intel_pt_pkt *packet) 434 { 435 int ret; 436 437 ret = intel_pt_do_get_packet(buf, len, packet); 438 if (ret > 0) { 439 while (ret < 8 && len > (size_t)ret && !buf[ret]) 440 ret += 1; 441 } 442 return ret; 443 } 444 445 int intel_pt_pkt_desc(const struct intel_pt_pkt *packet, char *buf, 446 size_t buf_len) 447 { 448 int ret, i, nr; 449 unsigned long long payload = packet->payload; 450 const char *name = intel_pt_pkt_name(packet->type); 451 452 switch (packet->type) { 453 case INTEL_PT_BAD: 454 case INTEL_PT_PAD: 455 case INTEL_PT_PSB: 456 case INTEL_PT_PSBEND: 457 case INTEL_PT_TRACESTOP: 458 case INTEL_PT_OVF: 459 return snprintf(buf, buf_len, "%s", name); 460 case INTEL_PT_TNT: { 461 size_t blen = buf_len; 462 463 ret = snprintf(buf, blen, "%s ", name); 464 if (ret < 0) 465 return ret; 466 buf += ret; 467 blen -= ret; 468 for (i = 0; i < packet->count; i++) { 469 if (payload & BIT63) 470 ret = snprintf(buf, blen, "T"); 471 else 472 ret = snprintf(buf, blen, "N"); 473 if (ret < 0) 474 return ret; 475 buf += ret; 476 blen -= ret; 477 payload <<= 1; 478 } 479 ret = snprintf(buf, blen, " (%d)", packet->count); 480 if (ret < 0) 481 return ret; 482 blen -= ret; 483 return buf_len - blen; 484 } 485 case INTEL_PT_TIP_PGD: 486 case INTEL_PT_TIP_PGE: 487 case INTEL_PT_TIP: 488 case INTEL_PT_FUP: 489 if (!(packet->count)) 490 return snprintf(buf, buf_len, "%s no ip", name); 491 case INTEL_PT_CYC: 492 case INTEL_PT_VMCS: 493 case INTEL_PT_MTC: 494 case INTEL_PT_MNT: 495 case INTEL_PT_CBR: 496 case INTEL_PT_TSC: 497 return snprintf(buf, buf_len, "%s 0x%llx", name, payload); 498 case INTEL_PT_TMA: 499 return snprintf(buf, buf_len, "%s CTC 0x%x FC 0x%x", name, 500 (unsigned)payload, packet->count); 501 case INTEL_PT_MODE_EXEC: 502 return snprintf(buf, buf_len, "%s %lld", name, payload); 503 case INTEL_PT_MODE_TSX: 504 return snprintf(buf, buf_len, "%s TXAbort:%u InTX:%u", 505 name, (unsigned)(payload >> 1) & 1, 506 (unsigned)payload & 1); 507 case INTEL_PT_PIP: 508 nr = packet->payload & NR_FLAG ? 1 : 0; 509 payload &= ~NR_FLAG; 510 ret = snprintf(buf, buf_len, "%s 0x%llx (NR=%d)", 511 name, payload, nr); 512 return ret; 513 default: 514 break; 515 } 516 return snprintf(buf, buf_len, "%s 0x%llx (%d)", 517 name, payload, packet->count); 518 } 519