projects/linux·blob master · refs

304 lines · 8.4 KiB

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
25static 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
82struct 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
99void arm_spe_decoder_free(struct arm_spe_decoder *decoder)
100{
101 free(decoder);
102}
103
104static 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
123static 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
154static 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
301int arm_spe_decode(struct arm_spe_decoder *decoder)
302{
303 return arm_spe_read_record(decoder);
304}