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

   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 |= ((uint64_t)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 }