tools/perf/util/arm-spe-decoder/arm-spe-decoder.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * arm_spe_decoder.c: ARM SPE support
   4  */
   5
   6 #ifndef _GNU_SOURCE
   7 #define _GNU_SOURCE
   8 #endif
   9 #include <errno.h>
  10 #include <inttypes.h>
  11 #include <stdbool.h>
  12 #include <string.h>
  13 #include <stdint.h>
  14 #include <stdlib.h>
  15 #include <linux/bitops.h>
  16 #include <linux/compiler.h>
  17 #include <linux/zalloc.h>
  18
  19 #include "../auxtrace.h"
  20 #include "../debug.h"
  21 #include "../util.h"
  22
  23 #include "arm-spe-decoder.h"
  24
  25 static u64 arm_spe_calc_ip(int index, u64 payload)
  26 {
  27         u64 ns, el, val;
  28
  29         /* Instruction virtual address or Branch target address */
  30         if (index == SPE_ADDR_PKT_HDR_INDEX_INS ||
  31             index == SPE_ADDR_PKT_HDR_INDEX_BRANCH) {
  32                 ns = SPE_ADDR_PKT_GET_NS(payload);
  33                 el = SPE_ADDR_PKT_GET_EL(payload);
  34
  35                 /* Clean highest byte */
  36                 payload = SPE_ADDR_PKT_ADDR_GET_BYTES_0_6(payload);
  37
  38                 /* Fill highest byte for EL1 or EL2 (VHE) mode */
  39                 if (ns && (el == SPE_ADDR_PKT_EL1 || el == SPE_ADDR_PKT_EL2))
  40                         payload |= 0xffULL << SPE_ADDR_PKT_ADDR_BYTE7_SHIFT;
  41
  42         /* Data access virtual address */
  43         } else if (index == SPE_ADDR_PKT_HDR_INDEX_DATA_VIRT) {
  44
  45                 /* Clean tags */
  46                 payload = SPE_ADDR_PKT_ADDR_GET_BYTES_0_6(payload);
  47
  48                 /*
  49                  * Armv8 ARM (ARM DDI 0487F.c), chapter "D10.2.1 Address packet"
  50                  * defines the data virtual address payload format, the top byte
  51                  * (bits [63:56]) is assigned as top-byte tag; so we only can
  52                  * retrieve address value from bits [55:0].
  53                  *
  54                  * According to Documentation/arch/arm64/memory.rst, if detects the
  55                  * specific pattern in bits [55:52] of payload which falls in
  56                  * the kernel space, should fixup the top byte and this allows
  57                  * perf tool to parse DSO symbol for data address correctly.
  58                  *
  59                  * For this reason, if detects the bits [55:52] is 0xf, will
  60                  * fill 0xff into the top byte.
  61                  */
  62                 val = SPE_ADDR_PKT_ADDR_GET_BYTE_6(payload);
  63                 if ((val & 0xf0ULL) == 0xf0ULL)
  64                         payload |= 0xffULL << SPE_ADDR_PKT_ADDR_BYTE7_SHIFT;
  65
  66         /* Data access physical address */
  67         } else if (index == SPE_ADDR_PKT_HDR_INDEX_DATA_PHYS) {
  68                 /* Clean highest byte */
  69                 payload = SPE_ADDR_PKT_ADDR_GET_BYTES_0_6(payload);
  70         } else {
  71                 static u32 seen_idx = 0;
  72                 if (!(seen_idx & BIT(index))) {
  73                         seen_idx |= BIT(index);
  74                         pr_warning("ignoring unsupported address packet index: 0x%x\n", index);
  75                 }
  76         }
  77
  78         return payload;
  79 }
  80
  81 struct arm_spe_decoder *arm_spe_decoder_new(struct arm_spe_params *params)
  82 {
  83         struct arm_spe_decoder *decoder;
  84
  85         if (!params->get_trace)
  86                 return NULL;
  87
  88         decoder = zalloc(sizeof(struct arm_spe_decoder));
  89         if (!decoder)
  90                 return NULL;
  91
  92         decoder->get_trace = params->get_trace;
  93         decoder->data = params->data;
  94
  95         return decoder;
  96 }
  97
  98 void arm_spe_decoder_free(struct arm_spe_decoder *decoder)
  99 {
 100         free(decoder);
 101 }
 102
 103 static int arm_spe_get_data(struct arm_spe_decoder *decoder)
 104 {
 105         struct arm_spe_buffer buffer = { .buf = 0, };
 106         int ret;
 107
 108         pr_debug("Getting more data\n");
 109         ret = decoder->get_trace(&buffer, decoder->data);
 110         if (ret < 0)
 111                 return ret;
 112
 113         decoder->buf = buffer.buf;
 114         decoder->len = buffer.len;
 115
 116         if (!decoder->len)
 117                 pr_debug("No more data\n");
 118
 119         return decoder->len;
 120 }
 121
 122 static int arm_spe_get_next_packet(struct arm_spe_decoder *decoder)
 123 {
 124         int ret;
 125
 126         do {
 127                 if (!decoder->len) {
 128                         ret = arm_spe_get_data(decoder);
 129
 130                         /* Failed to read out trace data */
 131                         if (ret <= 0)
 132                                 return ret;
 133                 }
 134
 135                 ret = arm_spe_get_packet(decoder->buf, decoder->len,
 136                                          &decoder->packet);
 137                 if (ret <= 0) {
 138                         /* Move forward for 1 byte */
 139                         decoder->buf += 1;
 140                         decoder->len -= 1;
 141                         return -EBADMSG;
 142                 }
 143
 144                 decoder->buf += ret;
 145                 decoder->len -= ret;
 146         } while (decoder->packet.type == ARM_SPE_PAD);
 147
 148         return 1;
 149 }
 150
 151 static int arm_spe_read_record(struct arm_spe_decoder *decoder)
 152 {
 153         int err;
 154         int idx;
 155         u64 payload, ip;
 156
 157         memset(&decoder->record, 0x0, sizeof(decoder->record));
 158         decoder->record.context_id = (u64)-1;
 159
 160         while (1) {
 161                 err = arm_spe_get_next_packet(decoder);
 162                 if (err <= 0)
 163                         return err;
 164
 165                 idx = decoder->packet.index;
 166                 payload = decoder->packet.payload;
 167
 168                 switch (decoder->packet.type) {
 169                 case ARM_SPE_TIMESTAMP:
 170                         decoder->record.timestamp = payload;
 171                         return 1;
 172                 case ARM_SPE_END:
 173                         return 1;
 174                 case ARM_SPE_ADDRESS:
 175                         ip = arm_spe_calc_ip(idx, payload);
 176                         if (idx == SPE_ADDR_PKT_HDR_INDEX_INS)
 177                                 decoder->record.from_ip = ip;
 178                         else if (idx == SPE_ADDR_PKT_HDR_INDEX_BRANCH)
 179                                 decoder->record.to_ip = ip;
 180                         else if (idx == SPE_ADDR_PKT_HDR_INDEX_DATA_VIRT)
 181                                 decoder->record.virt_addr = ip;
 182                         else if (idx == SPE_ADDR_PKT_HDR_INDEX_DATA_PHYS)
 183                                 decoder->record.phys_addr = ip;
 184                         break;
 185                 case ARM_SPE_COUNTER:
 186                         if (idx == SPE_CNT_PKT_HDR_INDEX_TOTAL_LAT)
 187                                 decoder->record.latency = payload;
 188                         break;
 189                 case ARM_SPE_CONTEXT:
 190                         decoder->record.context_id = payload;
 191                         break;
 192                 case ARM_SPE_OP_TYPE:
 193                         switch (idx) {
 194                         case SPE_OP_PKT_HDR_CLASS_LD_ST_ATOMIC:
 195                                 decoder->record.op |= ARM_SPE_OP_LDST;
 196                                 if (payload & SPE_OP_PKT_ST)
 197                                         decoder->record.op |= ARM_SPE_OP_ST;
 198                                 else
 199                                         decoder->record.op |= ARM_SPE_OP_LD;
 200                                 if (SPE_OP_PKT_IS_LDST_SVE(payload))
 201                                         decoder->record.op |= ARM_SPE_OP_SVE_LDST;
 202                                 break;
 203                         case SPE_OP_PKT_HDR_CLASS_OTHER:
 204                                 decoder->record.op |= ARM_SPE_OP_OTHER;
 205                                 if (SPE_OP_PKT_IS_OTHER_SVE_OP(payload))
 206                                         decoder->record.op |= ARM_SPE_OP_SVE_OTHER;
 207                                 break;
 208                         case SPE_OP_PKT_HDR_CLASS_BR_ERET:
 209                                 decoder->record.op |= ARM_SPE_OP_BRANCH_ERET;
 210                                 break;
 211                         default:
 212                                 pr_err("Get packet error!\n");
 213                                 return -1;
 214                         }
 215                         break;
 216                 case ARM_SPE_EVENTS:
 217                         if (payload & BIT(EV_L1D_REFILL))
 218                                 decoder->record.type |= ARM_SPE_L1D_MISS;
 219
 220                         if (payload & BIT(EV_L1D_ACCESS))
 221                                 decoder->record.type |= ARM_SPE_L1D_ACCESS;
 222
 223                         if (payload & BIT(EV_TLB_WALK))
 224                                 decoder->record.type |= ARM_SPE_TLB_MISS;
 225
 226                         if (payload & BIT(EV_TLB_ACCESS))
 227                                 decoder->record.type |= ARM_SPE_TLB_ACCESS;
 228
 229                         if (payload & BIT(EV_LLC_MISS))
 230                                 decoder->record.type |= ARM_SPE_LLC_MISS;
 231
 232                         if (payload & BIT(EV_LLC_ACCESS))
 233                                 decoder->record.type |= ARM_SPE_LLC_ACCESS;
 234
 235                         if (payload & BIT(EV_REMOTE_ACCESS))
 236                                 decoder->record.type |= ARM_SPE_REMOTE_ACCESS;
 237
 238                         if (payload & BIT(EV_MISPRED))
 239                                 decoder->record.type |= ARM_SPE_BRANCH_MISS;
 240
 241                         if (payload & BIT(EV_PARTIAL_PREDICATE))
 242                                 decoder->record.type |= ARM_SPE_SVE_PARTIAL_PRED;
 243
 244                         if (payload & BIT(EV_EMPTY_PREDICATE))
 245                                 decoder->record.type |= ARM_SPE_SVE_EMPTY_PRED;
 246
 247                         break;
 248                 case ARM_SPE_DATA_SOURCE:
 249                         decoder->record.source = payload;
 250                         break;
 251                 case ARM_SPE_BAD:
 252                         break;
 253                 case ARM_SPE_PAD:
 254                         break;
 255                 default:
 256                         pr_err("Get packet error!\n");
 257                         return -1;
 258                 }
 259         }
 260
 261         return 0;
 262 }
 263
 264 int arm_spe_decode(struct arm_spe_decoder *decoder)
 265 {
 266         return arm_spe_read_record(decoder);
 267 }