powerpc/perf/perf_regs.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright 2016 Anju T, IBM Corporation.
0004  */
0005
0006 #include <linux/errno.h>
0007 #include <linux/kernel.h>
0008 #include <linux/sched.h>
0009 #include <linux/sched/task_stack.h>
0010 #include <linux/perf_event.h>
0011 #include <linux/bug.h>
0012 #include <linux/stddef.h>
0013 #include <asm/ptrace.h>
0014 #include <asm/perf_regs.h>
0015
0016 u64 PERF_REG_EXTENDED_MASK;
0017
0018 #define PT_REGS_OFFSET(id, r) [id] = offsetof(struct pt_regs, r)
0019
0020 #define REG_RESERVED (~(PERF_REG_EXTENDED_MASK | PERF_REG_PMU_MASK))
0021
0022 static unsigned int pt_regs_offset[PERF_REG_POWERPC_MAX] = {
0023     PT_REGS_OFFSET(PERF_REG_POWERPC_R0,  gpr[0]),
0024     PT_REGS_OFFSET(PERF_REG_POWERPC_R1,  gpr[1]),
0025     PT_REGS_OFFSET(PERF_REG_POWERPC_R2,  gpr[2]),
0026     PT_REGS_OFFSET(PERF_REG_POWERPC_R3,  gpr[3]),
0027     PT_REGS_OFFSET(PERF_REG_POWERPC_R4,  gpr[4]),
0028     PT_REGS_OFFSET(PERF_REG_POWERPC_R5,  gpr[5]),
0029     PT_REGS_OFFSET(PERF_REG_POWERPC_R6,  gpr[6]),
0030     PT_REGS_OFFSET(PERF_REG_POWERPC_R7,  gpr[7]),
0031     PT_REGS_OFFSET(PERF_REG_POWERPC_R8,  gpr[8]),
0032     PT_REGS_OFFSET(PERF_REG_POWERPC_R9,  gpr[9]),
0033     PT_REGS_OFFSET(PERF_REG_POWERPC_R10, gpr[10]),
0034     PT_REGS_OFFSET(PERF_REG_POWERPC_R11, gpr[11]),
0035     PT_REGS_OFFSET(PERF_REG_POWERPC_R12, gpr[12]),
0036     PT_REGS_OFFSET(PERF_REG_POWERPC_R13, gpr[13]),
0037     PT_REGS_OFFSET(PERF_REG_POWERPC_R14, gpr[14]),
0038     PT_REGS_OFFSET(PERF_REG_POWERPC_R15, gpr[15]),
0039     PT_REGS_OFFSET(PERF_REG_POWERPC_R16, gpr[16]),
0040     PT_REGS_OFFSET(PERF_REG_POWERPC_R17, gpr[17]),
0041     PT_REGS_OFFSET(PERF_REG_POWERPC_R18, gpr[18]),
0042     PT_REGS_OFFSET(PERF_REG_POWERPC_R19, gpr[19]),
0043     PT_REGS_OFFSET(PERF_REG_POWERPC_R20, gpr[20]),
0044     PT_REGS_OFFSET(PERF_REG_POWERPC_R21, gpr[21]),
0045     PT_REGS_OFFSET(PERF_REG_POWERPC_R22, gpr[22]),
0046     PT_REGS_OFFSET(PERF_REG_POWERPC_R23, gpr[23]),
0047     PT_REGS_OFFSET(PERF_REG_POWERPC_R24, gpr[24]),
0048     PT_REGS_OFFSET(PERF_REG_POWERPC_R25, gpr[25]),
0049     PT_REGS_OFFSET(PERF_REG_POWERPC_R26, gpr[26]),
0050     PT_REGS_OFFSET(PERF_REG_POWERPC_R27, gpr[27]),
0051     PT_REGS_OFFSET(PERF_REG_POWERPC_R28, gpr[28]),
0052     PT_REGS_OFFSET(PERF_REG_POWERPC_R29, gpr[29]),
0053     PT_REGS_OFFSET(PERF_REG_POWERPC_R30, gpr[30]),
0054     PT_REGS_OFFSET(PERF_REG_POWERPC_R31, gpr[31]),
0055     PT_REGS_OFFSET(PERF_REG_POWERPC_NIP, nip),
0056     PT_REGS_OFFSET(PERF_REG_POWERPC_MSR, msr),
0057     PT_REGS_OFFSET(PERF_REG_POWERPC_ORIG_R3, orig_gpr3),
0058     PT_REGS_OFFSET(PERF_REG_POWERPC_CTR, ctr),
0059     PT_REGS_OFFSET(PERF_REG_POWERPC_LINK, link),
0060     PT_REGS_OFFSET(PERF_REG_POWERPC_XER, xer),
0061     PT_REGS_OFFSET(PERF_REG_POWERPC_CCR, ccr),
0062 #ifdef CONFIG_PPC64
0063     PT_REGS_OFFSET(PERF_REG_POWERPC_SOFTE, softe),
0064 #else
0065     PT_REGS_OFFSET(PERF_REG_POWERPC_SOFTE, mq),
0066 #endif
0067     PT_REGS_OFFSET(PERF_REG_POWERPC_TRAP, trap),
0068     PT_REGS_OFFSET(PERF_REG_POWERPC_DAR, dar),
0069     PT_REGS_OFFSET(PERF_REG_POWERPC_DSISR, dsisr),
0070     PT_REGS_OFFSET(PERF_REG_POWERPC_SIER, dar),
0071     PT_REGS_OFFSET(PERF_REG_POWERPC_MMCRA, dsisr),
0072 };
0073
0074 /* Function to return the extended register values */
0075 static u64 get_ext_regs_value(int idx)
0076 {
0077     switch (idx) {
0078     case PERF_REG_POWERPC_PMC1 ... PERF_REG_POWERPC_PMC6:
0079         return get_pmcs_ext_regs(idx - PERF_REG_POWERPC_PMC1);
0080     case PERF_REG_POWERPC_MMCR0:
0081         return mfspr(SPRN_MMCR0);
0082     case PERF_REG_POWERPC_MMCR1:
0083         return mfspr(SPRN_MMCR1);
0084     case PERF_REG_POWERPC_MMCR2:
0085         return mfspr(SPRN_MMCR2);
0086 #ifdef CONFIG_PPC64
0087     case PERF_REG_POWERPC_MMCR3:
0088         return mfspr(SPRN_MMCR3);
0089     case PERF_REG_POWERPC_SIER2:
0090         return mfspr(SPRN_SIER2);
0091     case PERF_REG_POWERPC_SIER3:
0092         return mfspr(SPRN_SIER3);
0093     case PERF_REG_POWERPC_SDAR:
0094         return mfspr(SPRN_SDAR);
0095 #endif
0096     case PERF_REG_POWERPC_SIAR:
0097         return mfspr(SPRN_SIAR);
0098     default: return 0;
0099     }
0100 }
0101
0102 u64 perf_reg_value(struct pt_regs *regs, int idx)
0103 {
0104     if (idx == PERF_REG_POWERPC_SIER &&
0105        (IS_ENABLED(CONFIG_FSL_EMB_PERF_EVENT) ||
0106         IS_ENABLED(CONFIG_PPC32) ||
0107         !is_sier_available()))
0108         return 0;
0109
0110     if (idx == PERF_REG_POWERPC_MMCRA &&
0111        (IS_ENABLED(CONFIG_FSL_EMB_PERF_EVENT) ||
0112         IS_ENABLED(CONFIG_PPC32)))
0113         return 0;
0114
0115     if (idx >= PERF_REG_POWERPC_MAX && idx < PERF_REG_EXTENDED_MAX)
0116         return get_ext_regs_value(idx);
0117
0118     /*
0119      * If the idx is referring to value beyond the
0120      * supported registers, return 0 with a warning
0121      */
0122     if (WARN_ON_ONCE(idx >= PERF_REG_EXTENDED_MAX))
0123         return 0;
0124
0125     return regs_get_register(regs, pt_regs_offset[idx]);
0126 }
0127
0128 int perf_reg_validate(u64 mask)
0129 {
0130     if (!mask || mask & REG_RESERVED)
0131         return -EINVAL;
0132     return 0;
0133 }
0134
0135 u64 perf_reg_abi(struct task_struct *task)
0136 {
0137     if (is_tsk_32bit_task(task))
0138         return PERF_SAMPLE_REGS_ABI_32;
0139     else
0140         return PERF_SAMPLE_REGS_ABI_64;
0141 }
0142
0143 void perf_get_regs_user(struct perf_regs *regs_user,
0144             struct pt_regs *regs)
0145 {
0146     regs_user->regs = task_pt_regs(current);
0147     regs_user->abi = (regs_user->regs) ? perf_reg_abi(current) :
0148              PERF_SAMPLE_REGS_ABI_NONE;
0149 }