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