tools/perf/util/intel-pt-decoder/intel-pt-decoder.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * intel_pt_decoder.h: Intel Processor Trace support
   4  * Copyright (c) 2013-2014, Intel Corporation.
   5  */
   6
   7 #ifndef INCLUDE__INTEL_PT_DECODER_H__
   8 #define INCLUDE__INTEL_PT_DECODER_H__
   9
  10 #include <stdint.h>
  11 #include <stddef.h>
  12 #include <stdbool.h>
  13
  14 #include <linux/rbtree.h>
  15
  16 #include "intel-pt-insn-decoder.h"
  17
  18 #define INTEL_PT_IN_TX          (1 << 0)
  19 #define INTEL_PT_ABORT_TX       (1 << 1)
  20 #define INTEL_PT_IFLAG          (1 << 2)
  21 #define INTEL_PT_ASYNC          (1 << 2)
  22 #define INTEL_PT_FUP_IP         (1 << 3)
  23 #define INTEL_PT_SAMPLE_IPC     (1 << 4)
  24
  25 enum intel_pt_sample_type {
  26         INTEL_PT_BRANCH         = 1 << 0,
  27         INTEL_PT_INSTRUCTION    = 1 << 1,
  28         INTEL_PT_TRANSACTION    = 1 << 2,
  29         INTEL_PT_PTW            = 1 << 3,
  30         INTEL_PT_MWAIT_OP       = 1 << 4,
  31         INTEL_PT_PWR_ENTRY      = 1 << 5,
  32         INTEL_PT_EX_STOP        = 1 << 6,
  33         INTEL_PT_PWR_EXIT       = 1 << 7,
  34         INTEL_PT_CBR_CHG        = 1 << 8,
  35         INTEL_PT_TRACE_BEGIN    = 1 << 9,
  36         INTEL_PT_TRACE_END      = 1 << 10,
  37         INTEL_PT_BLK_ITEMS      = 1 << 11,
  38         INTEL_PT_PSB_EVT        = 1 << 12,
  39         INTEL_PT_EVT            = 1 << 13,
  40         INTEL_PT_IFLAG_CHG      = 1 << 14,
  41 };
  42
  43 enum intel_pt_period_type {
  44         INTEL_PT_PERIOD_NONE,
  45         INTEL_PT_PERIOD_INSTRUCTIONS,
  46         INTEL_PT_PERIOD_TICKS,
  47         INTEL_PT_PERIOD_MTC,
  48 };
  49
  50 enum {
  51         INTEL_PT_ERR_NOMEM = 1,
  52         INTEL_PT_ERR_INTERN,
  53         INTEL_PT_ERR_BADPKT,
  54         INTEL_PT_ERR_NODATA,
  55         INTEL_PT_ERR_NOINSN,
  56         INTEL_PT_ERR_MISMAT,
  57         INTEL_PT_ERR_OVR,
  58         INTEL_PT_ERR_LOST,
  59         INTEL_PT_ERR_UNK,
  60         INTEL_PT_ERR_NELOOP,
  61         INTEL_PT_ERR_EPTW,
  62         INTEL_PT_ERR_MAX,
  63 };
  64
  65 enum intel_pt_param_flags {
  66         /*
  67          * FUP packet can contain next linear instruction pointer instead of
  68          * current linear instruction pointer.
  69          */
  70         INTEL_PT_FUP_WITH_NLIP  = 1 << 0,
  71 };
  72
  73 enum intel_pt_blk_type {
  74         INTEL_PT_GP_REGS        = 1,
  75         INTEL_PT_PEBS_BASIC     = 4,
  76         INTEL_PT_PEBS_MEM       = 5,
  77         INTEL_PT_LBR_0          = 8,
  78         INTEL_PT_LBR_1          = 9,
  79         INTEL_PT_LBR_2          = 10,
  80         INTEL_PT_XMM            = 16,
  81         INTEL_PT_BLK_TYPE_MAX
  82 };
  83
  84 /*
  85  * The block type numbers are not sequential but here they are given sequential
  86  * positions to avoid wasting space for array placement.
  87  */
  88 enum intel_pt_blk_type_pos {
  89         INTEL_PT_GP_REGS_POS,
  90         INTEL_PT_PEBS_BASIC_POS,
  91         INTEL_PT_PEBS_MEM_POS,
  92         INTEL_PT_LBR_0_POS,
  93         INTEL_PT_LBR_1_POS,
  94         INTEL_PT_LBR_2_POS,
  95         INTEL_PT_XMM_POS,
  96         INTEL_PT_BLK_TYPE_CNT
  97 };
  98
  99 /* Get the array position for a block type */
 100 static inline int intel_pt_blk_type_pos(enum intel_pt_blk_type blk_type)
 101 {
 102 #define BLK_TYPE(bt) [INTEL_PT_##bt] = INTEL_PT_##bt##_POS + 1
 103         const int map[INTEL_PT_BLK_TYPE_MAX] = {
 104                 BLK_TYPE(GP_REGS),
 105                 BLK_TYPE(PEBS_BASIC),
 106                 BLK_TYPE(PEBS_MEM),
 107                 BLK_TYPE(LBR_0),
 108                 BLK_TYPE(LBR_1),
 109                 BLK_TYPE(LBR_2),
 110                 BLK_TYPE(XMM),
 111         };
 112 #undef BLK_TYPE
 113
 114         return blk_type < INTEL_PT_BLK_TYPE_MAX ? map[blk_type] - 1 : -1;
 115 }
 116
 117 #define INTEL_PT_BLK_ITEM_ID_CNT        32
 118
 119 /*
 120  * Use unions so that the block items can be accessed by name or by array index.
 121  * There is an array of 32-bit masks for each block type, which indicate which
 122  * values are present. Then arrays of 32 64-bit values for each block type.
 123  */
 124 struct intel_pt_blk_items {
 125         union {
 126                 uint32_t mask[INTEL_PT_BLK_TYPE_CNT];
 127                 struct {
 128                         uint32_t has_rflags:1;
 129                         uint32_t has_rip:1;
 130                         uint32_t has_rax:1;
 131                         uint32_t has_rcx:1;
 132                         uint32_t has_rdx:1;
 133                         uint32_t has_rbx:1;
 134                         uint32_t has_rsp:1;
 135                         uint32_t has_rbp:1;
 136                         uint32_t has_rsi:1;
 137                         uint32_t has_rdi:1;
 138                         uint32_t has_r8:1;
 139                         uint32_t has_r9:1;
 140                         uint32_t has_r10:1;
 141                         uint32_t has_r11:1;
 142                         uint32_t has_r12:1;
 143                         uint32_t has_r13:1;
 144                         uint32_t has_r14:1;
 145                         uint32_t has_r15:1;
 146                         uint32_t has_unused_0:14;
 147                         uint32_t has_ip:1;
 148                         uint32_t has_applicable_counters:1;
 149                         uint32_t has_timestamp:1;
 150                         uint32_t has_unused_1:29;
 151                         uint32_t has_mem_access_address:1;
 152                         uint32_t has_mem_aux_info:1;
 153                         uint32_t has_mem_access_latency:1;
 154                         uint32_t has_tsx_aux_info:1;
 155                         uint32_t has_unused_2:28;
 156                         uint32_t has_lbr_0;
 157                         uint32_t has_lbr_1;
 158                         uint32_t has_lbr_2;
 159                         uint32_t has_xmm;
 160                 };
 161         };
 162         union {
 163                 uint64_t val[INTEL_PT_BLK_TYPE_CNT][INTEL_PT_BLK_ITEM_ID_CNT];
 164                 struct {
 165                         struct {
 166                                 uint64_t rflags;
 167                                 uint64_t rip;
 168                                 uint64_t rax;
 169                                 uint64_t rcx;
 170                                 uint64_t rdx;
 171                                 uint64_t rbx;
 172                                 uint64_t rsp;
 173                                 uint64_t rbp;
 174                                 uint64_t rsi;
 175                                 uint64_t rdi;
 176                                 uint64_t r8;
 177                                 uint64_t r9;
 178                                 uint64_t r10;
 179                                 uint64_t r11;
 180                                 uint64_t r12;
 181                                 uint64_t r13;
 182                                 uint64_t r14;
 183                                 uint64_t r15;
 184                                 uint64_t unused_0[INTEL_PT_BLK_ITEM_ID_CNT - 18];
 185                         };
 186                         struct {
 187                                 uint64_t ip;
 188                                 uint64_t applicable_counters;
 189                                 uint64_t timestamp;
 190                                 uint64_t unused_1[INTEL_PT_BLK_ITEM_ID_CNT - 3];
 191                         };
 192                         struct {
 193                                 uint64_t mem_access_address;
 194                                 uint64_t mem_aux_info;
 195                                 uint64_t mem_access_latency;
 196                                 uint64_t tsx_aux_info;
 197                                 uint64_t unused_2[INTEL_PT_BLK_ITEM_ID_CNT - 4];
 198                         };
 199                         uint64_t lbr_0[INTEL_PT_BLK_ITEM_ID_CNT];
 200                         uint64_t lbr_1[INTEL_PT_BLK_ITEM_ID_CNT];
 201                         uint64_t lbr_2[INTEL_PT_BLK_ITEM_ID_CNT];
 202                         uint64_t xmm[INTEL_PT_BLK_ITEM_ID_CNT];
 203                 };
 204         };
 205         bool is_32_bit;
 206 };
 207
 208 struct intel_pt_vmcs_info {
 209         struct rb_node rb_node;
 210         uint64_t vmcs;
 211         uint64_t tsc_offset;
 212         bool reliable;
 213         bool error_printed;
 214 };
 215
 216 /*
 217  * Maximum number of event trace data in one go, assuming at most 1 per type
 218  * and 6-bits of type in the EVD packet.
 219  */
 220 #define INTEL_PT_MAX_EVDS 64
 221
 222 /* Event trace data from EVD packet */
 223 struct intel_pt_evd {
 224         int type;
 225         uint64_t payload;
 226 };
 227
 228 struct intel_pt_state {
 229         enum intel_pt_sample_type type;
 230         bool from_nr;
 231         bool to_nr;
 232         bool from_iflag;
 233         bool to_iflag;
 234         int err;
 235         uint64_t from_ip;
 236         uint64_t to_ip;
 237         uint64_t tot_insn_cnt;
 238         uint64_t tot_cyc_cnt;
 239         uint64_t cycles;
 240         uint64_t timestamp;
 241         uint64_t est_timestamp;
 242         uint64_t trace_nr;
 243         uint64_t ptw_payload;
 244         uint64_t mwait_payload;
 245         uint64_t pwre_payload;
 246         uint64_t pwrx_payload;
 247         uint64_t cbr_payload;
 248         uint64_t psb_offset;
 249         uint32_t cbr;
 250         uint32_t flags;
 251         enum intel_pt_insn_op insn_op;
 252         int insn_len;
 253         char insn[INTEL_PT_INSN_BUF_SZ];
 254         struct intel_pt_blk_items items;
 255         int cfe_type;
 256         int cfe_vector;
 257         int evd_cnt;
 258         struct intel_pt_evd *evd;
 259 };
 260
 261 struct intel_pt_insn;
 262
 263 struct intel_pt_buffer {
 264         const unsigned char *buf;
 265         size_t len;
 266         bool consecutive;
 267         uint64_t ref_timestamp;
 268         uint64_t trace_nr;
 269 };
 270
 271 typedef int (*intel_pt_lookahead_cb_t)(struct intel_pt_buffer *, void *);
 272
 273 struct intel_pt_params {
 274         int (*get_trace)(struct intel_pt_buffer *buffer, void *data);
 275         int (*walk_insn)(struct intel_pt_insn *intel_pt_insn,
 276                          uint64_t *insn_cnt_ptr, uint64_t *ip, uint64_t to_ip,
 277                          uint64_t max_insn_cnt, void *data);
 278         bool (*pgd_ip)(uint64_t ip, void *data);
 279         int (*lookahead)(void *data, intel_pt_lookahead_cb_t cb, void *cb_data);
 280         struct intel_pt_vmcs_info *(*findnew_vmcs_info)(void *data, uint64_t vmcs);
 281         void *data;
 282         bool return_compression;
 283         bool branch_enable;
 284         bool vm_time_correlation;
 285         bool vm_tm_corr_dry_run;
 286         uint64_t first_timestamp;
 287         uint64_t ctl;
 288         uint64_t period;
 289         enum intel_pt_period_type period_type;
 290         unsigned max_non_turbo_ratio;
 291         unsigned int mtc_period;
 292         uint32_t tsc_ctc_ratio_n;
 293         uint32_t tsc_ctc_ratio_d;
 294         enum intel_pt_param_flags flags;
 295         unsigned int quick;
 296         int max_loops;
 297 };
 298
 299 struct intel_pt_decoder;
 300
 301 struct intel_pt_decoder *intel_pt_decoder_new(struct intel_pt_params *params);
 302 void intel_pt_decoder_free(struct intel_pt_decoder *decoder);
 303
 304 const struct intel_pt_state *intel_pt_decode(struct intel_pt_decoder *decoder);
 305
 306 int intel_pt_fast_forward(struct intel_pt_decoder *decoder, uint64_t timestamp);
 307
 308 unsigned char *intel_pt_find_overlap(unsigned char *buf_a, size_t len_a,
 309                                      unsigned char *buf_b, size_t len_b,
 310                                      bool have_tsc, bool *consecutive,
 311                                      bool ooo_tsc);
 312
 313 int intel_pt__strerror(int code, char *buf, size_t buflen);
 314
 315 void intel_pt_set_first_timestamp(struct intel_pt_decoder *decoder,
 316                                   uint64_t first_timestamp);
 317
 318 #endif