1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #include <linux/compat.h> |
3 | #include <linux/errno.h> |
4 | #include <linux/kernel.h> |
5 | #include <linux/perf_event.h> |
6 | #include <linux/bug.h> |
7 | #include <linux/sched/task_stack.h> |
8 | |
9 | #include <asm/perf_regs.h> |
10 | #include <asm/ptrace.h> |
11 | |
12 | static u64 perf_ext_regs_value(int idx) |
13 | { |
14 | switch (idx) { |
15 | case PERF_REG_ARM64_VG: |
16 | if (WARN_ON_ONCE(!system_supports_sve())) |
17 | return 0; |
18 | |
19 | /* |
20 | * Vector granule is current length in bits of SVE registers |
21 | * divided by 64. |
22 | */ |
23 | return (task_get_sve_vl(current) * 8) / 64; |
24 | default: |
25 | WARN_ON_ONCE(true); |
26 | return 0; |
27 | } |
28 | } |
29 | |
30 | u64 perf_reg_value(struct pt_regs *regs, int idx) |
31 | { |
32 | if (WARN_ON_ONCE((u32)idx >= PERF_REG_ARM64_EXTENDED_MAX)) |
33 | return 0; |
34 | |
35 | /* |
36 | * Our handling of compat tasks (PERF_SAMPLE_REGS_ABI_32) is weird, but |
37 | * we're stuck with it for ABI compatibility reasons. |
38 | * |
39 | * For a 32-bit consumer inspecting a 32-bit task, then it will look at |
40 | * the first 16 registers (see arch/arm/include/uapi/asm/perf_regs.h). |
41 | * These correspond directly to a prefix of the registers saved in our |
42 | * 'struct pt_regs', with the exception of the PC, so we copy that down |
43 | * (x15 corresponds to SP_hyp in the architecture). |
44 | * |
45 | * So far, so good. |
46 | * |
47 | * The oddity arises when a 64-bit consumer looks at a 32-bit task and |
48 | * asks for registers beyond PERF_REG_ARM_MAX. In this case, we return |
49 | * SP_usr, LR_usr and PC in the positions where the AArch64 SP, LR and |
50 | * PC registers would normally live. The initial idea was to allow a |
51 | * 64-bit unwinder to unwind a 32-bit task and, although it's not clear |
52 | * how well that works in practice, somebody might be relying on it. |
53 | * |
54 | * At the time we make a sample, we don't know whether the consumer is |
55 | * 32-bit or 64-bit, so we have to cater for both possibilities. |
56 | */ |
57 | if (compat_user_mode(regs)) { |
58 | if ((u32)idx == PERF_REG_ARM64_SP) |
59 | return regs->compat_sp; |
60 | if ((u32)idx == PERF_REG_ARM64_LR) |
61 | return regs->compat_lr; |
62 | if (idx == 15) |
63 | return regs->pc; |
64 | } |
65 | |
66 | if ((u32)idx == PERF_REG_ARM64_SP) |
67 | return regs->sp; |
68 | |
69 | if ((u32)idx == PERF_REG_ARM64_PC) |
70 | return regs->pc; |
71 | |
72 | if ((u32)idx >= PERF_REG_ARM64_MAX) |
73 | return perf_ext_regs_value(idx); |
74 | |
75 | return regs->regs[idx]; |
76 | } |
77 | |
78 | #define REG_RESERVED (~((1ULL << PERF_REG_ARM64_MAX) - 1)) |
79 | |
80 | int perf_reg_validate(u64 mask) |
81 | { |
82 | u64 reserved_mask = REG_RESERVED; |
83 | |
84 | if (system_supports_sve()) |
85 | reserved_mask &= ~(1ULL << PERF_REG_ARM64_VG); |
86 | |
87 | if (!mask || mask & reserved_mask) |
88 | return -EINVAL; |
89 | |
90 | return 0; |
91 | } |
92 | |
93 | u64 perf_reg_abi(struct task_struct *task) |
94 | { |
95 | if (is_compat_thread(task_thread_info(task))) |
96 | return PERF_SAMPLE_REGS_ABI_32; |
97 | else |
98 | return PERF_SAMPLE_REGS_ABI_64; |
99 | } |
100 | |
101 | void perf_get_regs_user(struct perf_regs *regs_user, |
102 | struct pt_regs *regs) |
103 | { |
104 | regs_user->regs = task_pt_regs(current); |
105 | regs_user->abi = perf_reg_abi(current); |
106 | } |
107 | |