arm64: cpufeature: Expose CPUID registers by emulation

This patch adds the hook for emulating MRS instruction to
export the 'user visible' value of supported system registers.
We emulate only the following id space for system registers:

 Op0=3, Op1=0, CRn=0, CRm=[0, 4-7]

The rest will fall back to SIGILL. This capability is also
advertised via a new HWCAP_CPUID.

Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Will Deacon <will.deacon@arm.com>
Reviewed-by: Catalin Marinas <catalin.marinas@arm.com>
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
[will: add missing static keyword to enable_mrs_emulation]
Signed-off-by: Will Deacon <will.deacon@arm.com>

diff --git a/arch/arm64/include/asm/sysreg.h b/arch/arm64/include/asm/sysreg.h
index 36ae882e2dcc8350fbf82c944b43ce8ee668876d..ac24b6e798b1c937a69cc0affcfddaa27ecf9fea 100644 (file)
--- a/arch/arm64/include/asm/sysreg.h
+++ b/arch/arm64/include/asm/sysreg.h
@@ -265,6 +265,10 @@
 #define ID_AA64MMFR0_TGRAN_SUPPORTED   ID_AA64MMFR0_TGRAN64_SUPPORTED
 #endif
 
+
+/* Safe value for MPIDR_EL1: Bit31:RES1, Bit30:U:0, Bit24:MT:0 */
+#define SYS_MPIDR_SAFE_VAL             (1UL << 31)
+
 #ifdef __ASSEMBLY__
 
        .irp    num,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30

diff --git a/arch/arm64/include/uapi/asm/hwcap.h b/arch/arm64/include/uapi/asm/hwcap.h
index a739287ef6a3dec81054636109df24ffd0cd8052..773c90b0545886f84ae22d28fa28b7cbac4aa532 100644 (file)
--- a/arch/arm64/include/uapi/asm/hwcap.h
+++ b/arch/arm64/include/uapi/asm/hwcap.h
@@ -30,5 +30,6 @@
 #define HWCAP_ATOMICS          (1 << 8)
 #define HWCAP_FPHP             (1 << 9)
 #define HWCAP_ASIMDHP          (1 << 10)
+#define HWCAP_CPUID            (1 << 11)
 
 #endif /* _UAPI__ASM_HWCAP_H */

diff --git a/arch/arm64/kernel/cpufeature.c b/arch/arm64/kernel/cpufeature.c
index 9de44807bd34b807881014da29aefc54985df038..8abe6ea907935a675d68feaa6ba4cac821bd22d0 100644 (file)
--- a/arch/arm64/kernel/cpufeature.c
+++ b/arch/arm64/kernel/cpufeature.c
@@ -29,6 +29,7 @@
 #include <asm/mmu_context.h>
 #include <asm/processor.h>
 #include <asm/sysreg.h>
+#include <asm/traps.h>
 #include <asm/virt.h>
 
 unsigned long elf_hwcap __read_mostly;
@@ -940,6 +941,8 @@ static bool cpus_have_elf_hwcap(const struct arm64_cpu_capabilities *cap)
 
 static void __init setup_elf_hwcaps(const struct arm64_cpu_capabilities *hwcaps)
 {
+       /* We support emulation of accesses to CPU ID feature registers */
+       elf_hwcap |= HWCAP_CPUID;
        for (; hwcaps->matches; hwcaps++)
                if (hwcaps->matches(hwcaps, hwcaps->def_scope))
                        cap_set_elf_hwcap(hwcaps);
@@ -1127,3 +1130,101 @@ cpufeature_pan_not_uao(const struct arm64_cpu_capabilities *entry, int __unused)
 {
        return (cpus_have_const_cap(ARM64_HAS_PAN) && !cpus_have_const_cap(ARM64_HAS_UAO));
 }
+
+/*
+ * We emulate only the following system register space.
+ * Op0 = 0x3, CRn = 0x0, Op1 = 0x0, CRm = [0, 4 - 7]
+ * See Table C5-6 System instruction encodings for System register accesses,
+ * ARMv8 ARM(ARM DDI 0487A.f) for more details.
+ */
+static inline bool __attribute_const__ is_emulated(u32 id)
+{
+       return (sys_reg_Op0(id) == 0x3 &&
+               sys_reg_CRn(id) == 0x0 &&
+               sys_reg_Op1(id) == 0x0 &&
+               (sys_reg_CRm(id) == 0 ||
+                ((sys_reg_CRm(id) >= 4) && (sys_reg_CRm(id) <= 7))));
+}
+
+/*
+ * With CRm == 0, reg should be one of :
+ * MIDR_EL1, MPIDR_EL1 or REVIDR_EL1.
+ */
+static inline int emulate_id_reg(u32 id, u64 *valp)
+{
+       switch (id) {
+       case SYS_MIDR_EL1:
+               *valp = read_cpuid_id();
+               break;
+       case SYS_MPIDR_EL1:
+               *valp = SYS_MPIDR_SAFE_VAL;
+               break;
+       case SYS_REVIDR_EL1:
+               /* IMPLEMENTATION DEFINED values are emulated with 0 */
+               *valp = 0;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+static int emulate_sys_reg(u32 id, u64 *valp)
+{
+       struct arm64_ftr_reg *regp;
+
+       if (!is_emulated(id))
+               return -EINVAL;
+
+       if (sys_reg_CRm(id) == 0)
+               return emulate_id_reg(id, valp);
+
+       regp = get_arm64_ftr_reg(id);
+       if (regp)
+               *valp = arm64_ftr_reg_user_value(regp);
+       else
+               /*
+                * The untracked registers are either IMPLEMENTATION DEFINED
+                * (e.g, ID_AFR0_EL1) or reserved RAZ.
+                */
+               *valp = 0;
+       return 0;
+}
+
+static int emulate_mrs(struct pt_regs *regs, u32 insn)
+{
+       int rc;
+       u32 sys_reg, dst;
+       u64 val;
+
+       /*
+        * sys_reg values are defined as used in mrs/msr instruction.
+        * shift the imm value to get the encoding.
+        */
+       sys_reg = (u32)aarch64_insn_decode_immediate(AARCH64_INSN_IMM_16, insn) << 5;
+       rc = emulate_sys_reg(sys_reg, &val);
+       if (!rc) {
+               dst = aarch64_insn_decode_register(AARCH64_INSN_REGTYPE_RT, insn);
+               regs->user_regs.regs[dst] = val;
+               regs->pc += 4;
+       }
+
+       return rc;
+}
+
+static struct undef_hook mrs_hook = {
+       .instr_mask = 0xfff00000,
+       .instr_val  = 0xd5300000,
+       .pstate_mask = COMPAT_PSR_MODE_MASK,
+       .pstate_val = PSR_MODE_EL0t,
+       .fn = emulate_mrs,
+};
+
+static int __init enable_mrs_emulation(void)
+{
+       register_undef_hook(&mrs_hook);
+       return 0;
+}
+
+late_initcall(enable_mrs_emulation);

diff --git a/arch/arm64/kernel/cpuinfo.c b/arch/arm64/kernel/cpuinfo.c
index 7b7be71e87bfa1ed710f3edfb44fa5878e257ed6..4d44edd2b14073266fa13354caf629ae6129513a 100644 (file)
--- a/arch/arm64/kernel/cpuinfo.c
+++ b/arch/arm64/kernel/cpuinfo.c
@@ -63,6 +63,7 @@ static const char *const hwcap_str[] = {
        "atomics",
        "fphp",
        "asimdhp",
+       "cpuid",
        NULL
 };