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 index == SPE_ADDR_PKT_HDR_INDEX_PREV_BRANCH) { 33 ns = SPE_ADDR_PKT_GET_NS(payload); 34 el = SPE_ADDR_PKT_GET_EL(payload); 35 36 /* Clean highest byte */ 37 payload = SPE_ADDR_PKT_ADDR_GET_BYTES_0_6(payload); 38 39 /* Fill highest byte for EL1 or EL2 (VHE) mode */ 40 if (ns && (el == SPE_ADDR_PKT_EL1 || el == SPE_ADDR_PKT_EL2)) 41 payload |= 0xffULL << SPE_ADDR_PKT_ADDR_BYTE7_SHIFT; 42 43 /* Data access virtual address */ 44 } else if (index == SPE_ADDR_PKT_HDR_INDEX_DATA_VIRT) { 45 46 /* Clean tags */ 47 payload = SPE_ADDR_PKT_ADDR_GET_BYTES_0_6(payload); 48 49 /* 50 * Armv8 ARM (ARM DDI 0487F.c), chapter "D10.2.1 Address packet" 51 * defines the data virtual address payload format, the top byte 52 * (bits [63:56]) is assigned as top-byte tag; so we only can 53 * retrieve address value from bits [55:0]. 54 * 55 * According to Documentation/arch/arm64/memory.rst, if detects the 56 * specific pattern in bits [55:52] of payload which falls in 57 * the kernel space, should fixup the top byte and this allows 58 * perf tool to parse DSO symbol for data address correctly. 59 * 60 * For this reason, if detects the bits [55:52] is 0xf, will 61 * fill 0xff into the top byte. 62 */ 63 val = SPE_ADDR_PKT_ADDR_GET_BYTE_6(payload); 64 if ((val & 0xf0ULL) == 0xf0ULL) 65 payload |= 0xffULL << SPE_ADDR_PKT_ADDR_BYTE7_SHIFT; 66 67 /* Data access physical address */ 68 } else if (index == SPE_ADDR_PKT_HDR_INDEX_DATA_PHYS) { 69 /* Clean highest byte */ 70 payload = SPE_ADDR_PKT_ADDR_GET_BYTES_0_6(payload); 71 } else { 72 static u32 seen_idx = 0; 73 if (!(seen_idx & BIT(index))) { 74 seen_idx |= BIT(index); 75 pr_warning("ignoring unsupported address packet index: 0x%x\n", index); 76 } 77 } 78 79 return payload; 80 } 81 82 struct arm_spe_decoder *arm_spe_decoder_new(struct arm_spe_params *params) 83 { 84 struct arm_spe_decoder *decoder; 85 86 if (!params->get_trace) 87 return NULL; 88 89 decoder = zalloc(sizeof(struct arm_spe_decoder)); 90 if (!decoder) 91 return NULL; 92 93 decoder->get_trace = params->get_trace; 94 decoder->data = params->data; 95 96 return decoder; 97 } 98 99 void arm_spe_decoder_free(struct arm_spe_decoder *decoder) 100 { 101 free(decoder); 102 } 103 104 static int arm_spe_get_data(struct arm_spe_decoder *decoder) 105 { 106 struct arm_spe_buffer buffer = { .buf = 0, }; 107 int ret; 108 109 pr_debug("Getting more data\n"); 110 ret = decoder->get_trace(&buffer, decoder->data); 111 if (ret < 0) 112 return ret; 113 114 decoder->buf = buffer.buf; 115 decoder->len = buffer.len; 116 117 if (!decoder->len) 118 pr_debug("No more data\n"); 119 120 return decoder->len; 121 } 122 123 static int arm_spe_get_next_packet(struct arm_spe_decoder *decoder, 124 struct arm_spe_pkt *packet) 125 { 126 int ret; 127 128 do { 129 if (!decoder->len) { 130 ret = arm_spe_get_data(decoder); 131 132 /* Failed to read out trace data */ 133 if (ret <= 0) 134 return ret; 135 } 136 137 ret = arm_spe_get_packet(decoder->buf, decoder->len, 138 packet, decoder->midr); 139 140 if (ret <= 0) { 141 /* Move forward for 1 byte */ 142 decoder->buf += 1; 143 decoder->len -= 1; 144 return -EBADMSG; 145 } 146 147 decoder->buf += ret; 148 decoder->len -= ret; 149 } while (packet->type == ARM_SPE_PAD); 150 151 return 1; 152 } 153 154 static int arm_spe_read_record(struct arm_spe_decoder *decoder) 155 { 156 int err; 157 int idx; 158 u64 payload, ip; 159 struct arm_spe_pkt packet; 160 161 memset(&decoder->record, 0x0, sizeof(decoder->record)); 162 decoder->record.context_id = (u64)-1; 163 164 while (1) { 165 err = arm_spe_get_next_packet(decoder, &packet); 166 if (err <= 0) 167 return err; 168 169 idx = packet.index; 170 payload = packet.payload; 171 172 switch (packet.type) { 173 case ARM_SPE_TIMESTAMP: 174 decoder->record.timestamp = payload; 175 return 1; 176 case ARM_SPE_END: 177 return 1; 178 case ARM_SPE_ADDRESS: 179 ip = arm_spe_calc_ip(idx, payload); 180 if (idx == SPE_ADDR_PKT_HDR_INDEX_INS) 181 decoder->record.from_ip = ip; 182 else if (idx == SPE_ADDR_PKT_HDR_INDEX_BRANCH) 183 decoder->record.to_ip = ip; 184 else if (idx == SPE_ADDR_PKT_HDR_INDEX_DATA_VIRT) 185 decoder->record.virt_addr = ip; 186 else if (idx == SPE_ADDR_PKT_HDR_INDEX_DATA_PHYS) 187 decoder->record.phys_addr = ip; 188 else if (idx == SPE_ADDR_PKT_HDR_INDEX_PREV_BRANCH) 189 decoder->record.prev_br_tgt = ip; 190 break; 191 case ARM_SPE_COUNTER: 192 if (idx == SPE_CNT_PKT_HDR_INDEX_TOTAL_LAT) 193 decoder->record.latency = payload; 194 break; 195 case ARM_SPE_CONTEXT: 196 decoder->record.context_id = payload; 197 break; 198 case ARM_SPE_OP_TYPE: 199 switch (idx) { 200 case SPE_OP_PKT_HDR_CLASS_LD_ST_ATOMIC: 201 decoder->record.op |= ARM_SPE_OP_LDST; 202 if (payload & SPE_OP_PKT_ST) 203 decoder->record.op |= ARM_SPE_OP_ST; 204 else 205 decoder->record.op |= ARM_SPE_OP_LD; 206 207 if (SPE_OP_PKT_LDST_SUBCLASS_GP_REG(payload)) { 208 decoder->record.op |= ARM_SPE_OP_GP_REG; 209 } else if (SPE_OP_PKT_LDST_SUBCLASS_SIMD_FP(payload)) { 210 decoder->record.op |= ARM_SPE_OP_SIMD_FP; 211 } else if (SPE_OP_PKT_LDST_SUBCLASS_UNSPEC_REG(payload)) { 212 decoder->record.op |= ARM_SPE_OP_UNSPEC_REG; 213 } else if (SPE_OP_PKT_LDST_SUBCLASS_NV_SYSREG(payload)) { 214 decoder->record.op |= ARM_SPE_OP_NV_SYSREG; 215 } else if (SPE_OP_PKT_LDST_SUBCLASS_MTE_TAG(payload)) { 216 decoder->record.op |= ARM_SPE_OP_MTE_TAG; 217 } else if (SPE_OP_PKT_LDST_SUBCLASS_EXTENDED(payload)) { 218 if (payload & SPE_OP_PKT_AR) 219 decoder->record.op |= ARM_SPE_OP_AR; 220 if (payload & SPE_OP_PKT_EXCL) 221 decoder->record.op |= ARM_SPE_OP_EXCL; 222 if (payload & SPE_OP_PKT_AT) 223 decoder->record.op |= ARM_SPE_OP_ATOMIC; 224 } else if (SPE_OP_PKT_LDST_SUBCLASS_SVE_SME_REG(payload)) { 225 decoder->record.op |= ARM_SPE_OP_SVE; 226 if (payload & SPE_OP_PKT_SVE_PRED) 227 decoder->record.op |= ARM_SPE_OP_PRED; 228 if (payload & SPE_OP_PKT_SVE_SG) 229 decoder->record.op |= ARM_SPE_OP_SG; 230 } else if (SPE_OP_PKT_LDST_SUBCLASS_MEMCPY(payload)) { 231 decoder->record.op |= ARM_SPE_OP_MEMCPY; 232 } else if (SPE_OP_PKT_LDST_SUBCLASS_MEMSET(payload)) { 233 decoder->record.op |= ARM_SPE_OP_MEMSET; 234 } else if (SPE_OP_PKT_LDST_SUBCLASS_GCS(payload)) { 235 decoder->record.op |= ARM_SPE_OP_GCS; 236 if (payload & SPE_OP_PKT_GCS_COMM) 237 decoder->record.op |= ARM_SPE_OP_COMM; 238 } 239 240 break; 241 case SPE_OP_PKT_HDR_CLASS_OTHER: 242 decoder->record.op |= ARM_SPE_OP_OTHER; 243 if (SPE_OP_PKT_OTHER_SUBCLASS_SVE(payload)) { 244 decoder->record.op |= ARM_SPE_OP_SVE | ARM_SPE_OP_DP; 245 if (payload & SPE_OP_PKT_OTHER_FP) 246 decoder->record.op |= ARM_SPE_OP_FP; 247 if (payload & SPE_OP_PKT_SVE_PRED) 248 decoder->record.op |= ARM_SPE_OP_PRED; 249 } else if (SPE_OP_PKT_OTHER_SUBCLASS_SME(payload)) { 250 decoder->record.op |= ARM_SPE_OP_SME; 251 if (payload & SPE_OP_PKT_OTHER_FP) 252 decoder->record.op |= ARM_SPE_OP_FP; 253 } else if (SPE_OP_PKT_OTHER_SUBCLASS_OTHER(payload)) { 254 if (payload & SPE_OP_PKT_OTHER_ASE) 255 decoder->record.op |= ARM_SPE_OP_ASE; 256 if (payload & SPE_OP_PKT_OTHER_FP) 257 decoder->record.op |= ARM_SPE_OP_FP; 258 if (payload & SPE_OP_PKT_COND) 259 decoder->record.op |= ARM_SPE_OP_COND; 260 } 261 break; 262 case SPE_OP_PKT_HDR_CLASS_BR_ERET: 263 decoder->record.op |= ARM_SPE_OP_BRANCH_ERET; 264 if (payload & SPE_OP_PKT_COND) 265 decoder->record.op |= ARM_SPE_OP_BR_COND; 266 if (payload & SPE_OP_PKT_INDIRECT_BRANCH) 267 decoder->record.op |= ARM_SPE_OP_BR_INDIRECT; 268 if (payload & SPE_OP_PKT_GCS) 269 decoder->record.op |= ARM_SPE_OP_BR_GCS; 270 if (SPE_OP_PKT_CR_BL(payload)) 271 decoder->record.op |= ARM_SPE_OP_BR_CR_BL; 272 if (SPE_OP_PKT_CR_RET(payload)) 273 decoder->record.op |= ARM_SPE_OP_BR_CR_RET; 274 if (SPE_OP_PKT_CR_NON_BL_RET(payload)) 275 decoder->record.op |= ARM_SPE_OP_BR_CR_NON_BL_RET; 276 break; 277 default: 278 pr_err("Get packet error!\n"); 279 return -1; 280 } 281 break; 282 case ARM_SPE_EVENTS: 283 decoder->record.type = payload; 284 break; 285 case ARM_SPE_DATA_SOURCE: 286 decoder->record.source = payload; 287 break; 288 case ARM_SPE_BAD: 289 break; 290 case ARM_SPE_PAD: 291 break; 292 default: 293 pr_err("Get packet error!\n"); 294 return -1; 295 } 296 } 297 298 return 0; 299 } 300 301 int arm_spe_decode(struct arm_spe_decoder *decoder) 302 { 303 return arm_spe_read_record(decoder); 304 } 305