* [PATCH v2 1/6] KVM: arm64: Move CPU ID feature registers emulation into a separate file
2023-02-12 21:58 [PATCH v2 0/6] Support writable CPU ID registers from userspace Jing Zhang
@ 2023-02-12 21:58 ` Jing Zhang
2023-02-24 1:01 ` Reiji Watanabe
2023-02-12 21:58 ` [PATCH v2 2/6] KVM: arm64: Save ID registers' sanitized value per guest Jing Zhang
` (4 subsequent siblings)
5 siblings, 1 reply; 16+ messages in thread
From: Jing Zhang @ 2023-02-12 21:58 UTC (permalink / raw)
To: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton
Cc: Will Deacon, Paolo Bonzini, James Morse, Alexandru Elisei,
Suzuki K Poulose, Fuad Tabba, Reiji Watanabe, Ricardo Koller,
Raghavendra Rao Ananta, Jing Zhang
Create a new file id_regs.c for CPU ID feature registers emulation code,
which are moved from sys_regs.c and tweak sys_regs code accordingly.
No functional change intended.
Signed-off-by: Jing Zhang <jingzhangos@google.com>
---
arch/arm64/kvm/Makefile | 2 +-
arch/arm64/kvm/id_regs.c | 486 ++++++++++++++++++++++++++++++++++++++
arch/arm64/kvm/sys_regs.c | 463 ++----------------------------------
arch/arm64/kvm/sys_regs.h | 28 +++
4 files changed, 541 insertions(+), 438 deletions(-)
create mode 100644 arch/arm64/kvm/id_regs.c
diff --git a/arch/arm64/kvm/Makefile b/arch/arm64/kvm/Makefile
index c0c050e53157..a6a315fcd81e 100644
--- a/arch/arm64/kvm/Makefile
+++ b/arch/arm64/kvm/Makefile
@@ -13,7 +13,7 @@ obj-$(CONFIG_KVM) += hyp/
kvm-y += arm.o mmu.o mmio.o psci.o hypercalls.o pvtime.o \
inject_fault.o va_layout.o handle_exit.o \
guest.o debug.o reset.o sys_regs.o stacktrace.o \
- vgic-sys-reg-v3.o fpsimd.o pkvm.o \
+ vgic-sys-reg-v3.o fpsimd.o pkvm.o id_regs.o \
arch_timer.o trng.o vmid.o emulate-nested.o nested.o \
vgic/vgic.o vgic/vgic-init.o \
vgic/vgic-irqfd.o vgic/vgic-v2.o \
diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
new file mode 100644
index 000000000000..7f30d683de21
--- /dev/null
+++ b/arch/arm64/kvm/id_regs.c
@@ -0,0 +1,486 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2023 - Google LLC
+ * Author: Jing Zhang <jingzhangos@google.com>
+ *
+ * Moved from arch/arm64/kvm/sys_regs.c
+ * Copyright (C) 2012,2013 - ARM Ltd
+ * Author: Marc Zyngier <marc.zyngier@arm.com>
+ */
+
+#include <linux/bitfield.h>
+#include <linux/bsearch.h>
+#include <linux/kvm_host.h>
+#include <asm/kvm_emulate.h>
+#include <asm/sysreg.h>
+#include <asm/cpufeature.h>
+#include <asm/kvm_nested.h>
+
+#include "sys_regs.h"
+
+static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
+{
+ if (kvm_vcpu_has_pmu(vcpu))
+ return vcpu->kvm->arch.dfr0_pmuver.imp;
+
+ return vcpu->kvm->arch.dfr0_pmuver.unimp;
+}
+
+static u8 perfmon_to_pmuver(u8 perfmon)
+{
+ switch (perfmon) {
+ case ID_DFR0_EL1_PerfMon_PMUv3:
+ return ID_AA64DFR0_EL1_PMUVer_IMP;
+ case ID_DFR0_EL1_PerfMon_IMPDEF:
+ return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
+ default:
+ /* Anything ARMv8.1+ and NI have the same value. For now. */
+ return perfmon;
+ }
+}
+
+static u8 pmuver_to_perfmon(u8 pmuver)
+{
+ switch (pmuver) {
+ case ID_AA64DFR0_EL1_PMUVer_IMP:
+ return ID_DFR0_EL1_PerfMon_PMUv3;
+ case ID_AA64DFR0_EL1_PMUVer_IMP_DEF:
+ return ID_DFR0_EL1_PerfMon_IMPDEF;
+ default:
+ /* Anything ARMv8.1+ and NI have the same value. For now. */
+ return pmuver;
+ }
+}
+
+/* Read a sanitised cpufeature ID register by sys_reg_desc */
+static u64 read_id_reg(const struct kvm_vcpu *vcpu, struct sys_reg_desc const *r)
+{
+ u32 id = reg_to_encoding(r);
+ u64 val;
+
+ if (sysreg_visible_as_raz(vcpu, r))
+ return 0;
+
+ val = read_sanitised_ftr_reg(id);
+
+ switch (id) {
+ case SYS_ID_AA64PFR0_EL1:
+ if (!vcpu_has_sve(vcpu))
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_SVE);
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_AMU);
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2),
+ (u64)vcpu->kvm->arch.pfr0_csv2);
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3),
+ (u64)vcpu->kvm->arch.pfr0_csv3);
+ if (kvm_vgic_global_state.type == VGIC_V3) {
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC), 1);
+ }
+ break;
+ case SYS_ID_AA64PFR1_EL1:
+ if (!kvm_has_mte(vcpu->kvm))
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_MTE);
+
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_SME);
+ break;
+ case SYS_ID_AA64ISAR1_EL1:
+ if (!vcpu_has_ptrauth(vcpu))
+ val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_APA) |
+ ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_API) |
+ ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPA) |
+ ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPI));
+ break;
+ case SYS_ID_AA64ISAR2_EL1:
+ if (!vcpu_has_ptrauth(vcpu))
+ val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_APA3) |
+ ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_GPA3));
+ if (!cpus_have_final_cap(ARM64_HAS_WFXT))
+ val &= ~ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_WFxT);
+ break;
+ case SYS_ID_AA64DFR0_EL1:
+ /* Limit debug to ARMv8.0 */
+ val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer), 6);
+ /* Set PMUver to the required version */
+ val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
+ vcpu_pmuver(vcpu));
+ /* Hide SPE from guests */
+ val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMSVer);
+ break;
+ case SYS_ID_DFR0_EL1:
+ val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon),
+ pmuver_to_perfmon(vcpu_pmuver(vcpu)));
+ break;
+ case SYS_ID_AA64MMFR2_EL1:
+ val &= ~ID_AA64MMFR2_EL1_CCIDX_MASK;
+ break;
+ case SYS_ID_MMFR4_EL1:
+ val &= ~ARM64_FEATURE_MASK(ID_MMFR4_EL1_CCIDX);
+ break;
+ }
+
+ return val;
+}
+
+/* cpufeature ID register access trap handlers */
+
+static bool access_id_reg(struct kvm_vcpu *vcpu,
+ struct sys_reg_params *p,
+ const struct sys_reg_desc *r)
+{
+ if (p->is_write)
+ return write_to_read_only(vcpu, p, r);
+
+ p->regval = read_id_reg(vcpu, r);
+ if (vcpu_has_nv(vcpu))
+ access_nested_id_reg(vcpu, p, r);
+
+ return true;
+}
+
+/*
+ * cpufeature ID register user accessors
+ *
+ * For now, these registers are immutable for userspace, so no values
+ * are stored, and for set_id_reg() we don't allow the effective value
+ * to be changed.
+ */
+static int get_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
+ u64 *val)
+{
+ *val = read_id_reg(vcpu, rd);
+ return 0;
+}
+
+static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
+ u64 val)
+{
+ /* This is what we mean by invariant: you can't change it. */
+ if (val != read_id_reg(vcpu, rd))
+ return -EINVAL;
+
+ return 0;
+}
+
+static unsigned int id_visibility(const struct kvm_vcpu *vcpu,
+ const struct sys_reg_desc *r)
+{
+ u32 id = reg_to_encoding(r);
+
+ switch (id) {
+ case SYS_ID_AA64ZFR0_EL1:
+ if (!vcpu_has_sve(vcpu))
+ return REG_RAZ;
+ break;
+ }
+
+ return 0;
+}
+
+static unsigned int aa32_id_visibility(const struct kvm_vcpu *vcpu,
+ const struct sys_reg_desc *r)
+{
+ /*
+ * AArch32 ID registers are UNKNOWN if AArch32 isn't implemented at any
+ * EL. Promote to RAZ/WI in order to guarantee consistency between
+ * systems.
+ */
+ if (!kvm_supports_32bit_el0())
+ return REG_RAZ | REG_USER_WI;
+
+ return id_visibility(vcpu, r);
+}
+
+static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
+ const struct sys_reg_desc *rd,
+ u64 val)
+{
+ u8 csv2, csv3;
+
+ /*
+ * Allow AA64PFR0_EL1.CSV2 to be set from userspace as long as
+ * it doesn't promise more than what is actually provided (the
+ * guest could otherwise be covered in ectoplasmic residue).
+ */
+ csv2 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV2_SHIFT);
+ if (csv2 > 1 ||
+ (csv2 && arm64_get_spectre_v2_state() != SPECTRE_UNAFFECTED))
+ return -EINVAL;
+
+ /* Same thing for CSV3 */
+ csv3 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV3_SHIFT);
+ if (csv3 > 1 ||
+ (csv3 && arm64_get_meltdown_state() != SPECTRE_UNAFFECTED))
+ return -EINVAL;
+
+ /* We can only differ with CSV[23], and anything else is an error */
+ val ^= read_id_reg(vcpu, rd);
+ val &= ~(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2) |
+ ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3));
+ if (val)
+ return -EINVAL;
+
+ vcpu->kvm->arch.pfr0_csv2 = csv2;
+ vcpu->kvm->arch.pfr0_csv3 = csv3;
+
+ return 0;
+}
+
+static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
+ const struct sys_reg_desc *rd,
+ u64 val)
+{
+ u8 pmuver, host_pmuver;
+ bool valid_pmu;
+
+ host_pmuver = kvm_arm_pmu_get_pmuver_limit();
+
+ /*
+ * Allow AA64DFR0_EL1.PMUver to be set from userspace as long
+ * as it doesn't promise more than what the HW gives us. We
+ * allow an IMPDEF PMU though, only if no PMU is supported
+ * (KVM backward compatibility handling).
+ */
+ pmuver = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), val);
+ if ((pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF && pmuver > host_pmuver))
+ return -EINVAL;
+
+ valid_pmu = (pmuver != 0 && pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF);
+
+ /* Make sure view register and PMU support do match */
+ if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
+ return -EINVAL;
+
+ /* We can only differ with PMUver, and anything else is an error */
+ val ^= read_id_reg(vcpu, rd);
+ val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
+ if (val)
+ return -EINVAL;
+
+ if (valid_pmu)
+ vcpu->kvm->arch.dfr0_pmuver.imp = pmuver;
+ else
+ vcpu->kvm->arch.dfr0_pmuver.unimp = pmuver;
+
+ return 0;
+}
+
+static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
+ const struct sys_reg_desc *rd,
+ u64 val)
+{
+ u8 perfmon, host_perfmon;
+ bool valid_pmu;
+
+ host_perfmon = pmuver_to_perfmon(kvm_arm_pmu_get_pmuver_limit());
+
+ /*
+ * Allow DFR0_EL1.PerfMon to be set from userspace as long as
+ * it doesn't promise more than what the HW gives us on the
+ * AArch64 side (as everything is emulated with that), and
+ * that this is a PMUv3.
+ */
+ perfmon = FIELD_GET(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), val);
+ if ((perfmon != ID_DFR0_EL1_PerfMon_IMPDEF && perfmon > host_perfmon) ||
+ (perfmon != 0 && perfmon < ID_DFR0_EL1_PerfMon_PMUv3))
+ return -EINVAL;
+
+ valid_pmu = (perfmon != 0 && perfmon != ID_DFR0_EL1_PerfMon_IMPDEF);
+
+ /* Make sure view register and PMU support do match */
+ if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
+ return -EINVAL;
+
+ /* We can only differ with PerfMon, and anything else is an error */
+ val ^= read_id_reg(vcpu, rd);
+ val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
+ if (val)
+ return -EINVAL;
+
+ if (valid_pmu)
+ vcpu->kvm->arch.dfr0_pmuver.imp = perfmon_to_pmuver(perfmon);
+ else
+ vcpu->kvm->arch.dfr0_pmuver.unimp = perfmon_to_pmuver(perfmon);
+
+ return 0;
+}
+
+/* sys_reg_desc initialiser for known cpufeature ID registers */
+#define ID_SANITISED(name) { \
+ SYS_DESC(SYS_##name), \
+ .access = access_id_reg, \
+ .get_user = get_id_reg, \
+ .set_user = set_id_reg, \
+ .visibility = id_visibility, \
+}
+
+/* sys_reg_desc initialiser for known cpufeature ID registers */
+#define AA32_ID_SANITISED(name) { \
+ SYS_DESC(SYS_##name), \
+ .access = access_id_reg, \
+ .get_user = get_id_reg, \
+ .set_user = set_id_reg, \
+ .visibility = aa32_id_visibility, \
+}
+
+/*
+ * sys_reg_desc initialiser for architecturally unallocated cpufeature ID
+ * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
+ * (1 <= crm < 8, 0 <= Op2 < 8).
+ */
+#define ID_UNALLOCATED(crm, op2) { \
+ Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
+ .access = access_id_reg, \
+ .get_user = get_id_reg, \
+ .set_user = set_id_reg, \
+ .visibility = raz_visibility \
+}
+
+/*
+ * sys_reg_desc initialiser for known ID registers that we hide from guests.
+ * For now, these are exposed just like unallocated ID regs: they appear
+ * RAZ for the guest.
+ */
+#define ID_HIDDEN(name) { \
+ SYS_DESC(SYS_##name), \
+ .access = access_id_reg, \
+ .get_user = get_id_reg, \
+ .set_user = set_id_reg, \
+ .visibility = raz_visibility, \
+}
+
+static const struct sys_reg_desc id_reg_descs[] = {
+ /*
+ * ID regs: all ID_SANITISED() entries here must have corresponding
+ * entries in arm64_ftr_regs[].
+ */
+
+ /* AArch64 mappings of the AArch32 ID registers */
+ /* CRm=1 */
+ AA32_ID_SANITISED(ID_PFR0_EL1),
+ AA32_ID_SANITISED(ID_PFR1_EL1),
+ { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
+ .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
+ .visibility = aa32_id_visibility, },
+ ID_HIDDEN(ID_AFR0_EL1),
+ AA32_ID_SANITISED(ID_MMFR0_EL1),
+ AA32_ID_SANITISED(ID_MMFR1_EL1),
+ AA32_ID_SANITISED(ID_MMFR2_EL1),
+ AA32_ID_SANITISED(ID_MMFR3_EL1),
+
+ /* CRm=2 */
+ AA32_ID_SANITISED(ID_ISAR0_EL1),
+ AA32_ID_SANITISED(ID_ISAR1_EL1),
+ AA32_ID_SANITISED(ID_ISAR2_EL1),
+ AA32_ID_SANITISED(ID_ISAR3_EL1),
+ AA32_ID_SANITISED(ID_ISAR4_EL1),
+ AA32_ID_SANITISED(ID_ISAR5_EL1),
+ AA32_ID_SANITISED(ID_MMFR4_EL1),
+ AA32_ID_SANITISED(ID_ISAR6_EL1),
+
+ /* CRm=3 */
+ AA32_ID_SANITISED(MVFR0_EL1),
+ AA32_ID_SANITISED(MVFR1_EL1),
+ AA32_ID_SANITISED(MVFR2_EL1),
+ ID_UNALLOCATED(3, 3),
+ AA32_ID_SANITISED(ID_PFR2_EL1),
+ ID_HIDDEN(ID_DFR1_EL1),
+ AA32_ID_SANITISED(ID_MMFR5_EL1),
+ ID_UNALLOCATED(3, 7),
+
+ /* AArch64 ID registers */
+ /* CRm=4 */
+ { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
+ .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
+ ID_SANITISED(ID_AA64PFR1_EL1),
+ ID_UNALLOCATED(4, 2),
+ ID_UNALLOCATED(4, 3),
+ ID_SANITISED(ID_AA64ZFR0_EL1),
+ ID_HIDDEN(ID_AA64SMFR0_EL1),
+ ID_UNALLOCATED(4, 6),
+ ID_UNALLOCATED(4, 7),
+
+ /* CRm=5 */
+ { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
+ .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
+ ID_SANITISED(ID_AA64DFR1_EL1),
+ ID_UNALLOCATED(5, 2),
+ ID_UNALLOCATED(5, 3),
+ ID_HIDDEN(ID_AA64AFR0_EL1),
+ ID_HIDDEN(ID_AA64AFR1_EL1),
+ ID_UNALLOCATED(5, 6),
+ ID_UNALLOCATED(5, 7),
+
+ /* CRm=6 */
+ ID_SANITISED(ID_AA64ISAR0_EL1),
+ ID_SANITISED(ID_AA64ISAR1_EL1),
+ ID_SANITISED(ID_AA64ISAR2_EL1),
+ ID_UNALLOCATED(6, 3),
+ ID_UNALLOCATED(6, 4),
+ ID_UNALLOCATED(6, 5),
+ ID_UNALLOCATED(6, 6),
+ ID_UNALLOCATED(6, 7),
+
+ /* CRm=7 */
+ ID_SANITISED(ID_AA64MMFR0_EL1),
+ ID_SANITISED(ID_AA64MMFR1_EL1),
+ ID_SANITISED(ID_AA64MMFR2_EL1),
+ ID_UNALLOCATED(7, 3),
+ ID_UNALLOCATED(7, 4),
+ ID_UNALLOCATED(7, 5),
+ ID_UNALLOCATED(7, 6),
+ ID_UNALLOCATED(7, 7),
+};
+
+const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params)
+{
+ return find_reg(params, id_reg_descs, ARRAY_SIZE(id_reg_descs));
+}
+
+void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
+{
+ unsigned long i;
+
+ for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++)
+ if (id_reg_descs[i].reset)
+ id_reg_descs[i].reset(vcpu, &id_reg_descs[i]);
+}
+
+int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
+{
+ return kvm_sys_reg_get_user(vcpu, reg,
+ id_reg_descs, ARRAY_SIZE(id_reg_descs));
+}
+
+int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
+{
+ return kvm_sys_reg_set_user(vcpu, reg,
+ id_reg_descs, ARRAY_SIZE(id_reg_descs));
+}
+
+bool kvm_arm_check_idreg_table(void)
+{
+ return check_sysreg_table(id_reg_descs, ARRAY_SIZE(id_reg_descs), false);
+}
+
+/* Assumed ordered tables, see kvm_sys_reg_table_init. */
+int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind)
+{
+ const struct sys_reg_desc *i2, *end2;
+ unsigned int total = 0;
+ int err;
+
+ i2 = id_reg_descs;
+ end2 = id_reg_descs + ARRAY_SIZE(id_reg_descs);
+
+ while (i2 != end2) {
+ err = walk_one_sys_reg(vcpu, i2++, &uind, &total);
+ if (err)
+ return err;
+ }
+ return total;
+}
diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
index 53749d3a0996..3b23b7a67eb5 100644
--- a/arch/arm64/kvm/sys_regs.c
+++ b/arch/arm64/kvm/sys_regs.c
@@ -53,16 +53,6 @@ static bool read_from_write_only(struct kvm_vcpu *vcpu,
return false;
}
-static bool write_to_read_only(struct kvm_vcpu *vcpu,
- struct sys_reg_params *params,
- const struct sys_reg_desc *r)
-{
- WARN_ONCE(1, "Unexpected sys_reg write to read-only register\n");
- print_sys_reg_instr(params);
- kvm_inject_undefined(vcpu);
- return false;
-}
-
u64 vcpu_read_sys_reg(const struct kvm_vcpu *vcpu, int reg)
{
u64 val = 0x8badf00d8badf00d;
@@ -1153,163 +1143,6 @@ static bool access_arch_timer(struct kvm_vcpu *vcpu,
return true;
}
-static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
-{
- if (kvm_vcpu_has_pmu(vcpu))
- return vcpu->kvm->arch.dfr0_pmuver.imp;
-
- return vcpu->kvm->arch.dfr0_pmuver.unimp;
-}
-
-static u8 perfmon_to_pmuver(u8 perfmon)
-{
- switch (perfmon) {
- case ID_DFR0_EL1_PerfMon_PMUv3:
- return ID_AA64DFR0_EL1_PMUVer_IMP;
- case ID_DFR0_EL1_PerfMon_IMPDEF:
- return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
- default:
- /* Anything ARMv8.1+ and NI have the same value. For now. */
- return perfmon;
- }
-}
-
-static u8 pmuver_to_perfmon(u8 pmuver)
-{
- switch (pmuver) {
- case ID_AA64DFR0_EL1_PMUVer_IMP:
- return ID_DFR0_EL1_PerfMon_PMUv3;
- case ID_AA64DFR0_EL1_PMUVer_IMP_DEF:
- return ID_DFR0_EL1_PerfMon_IMPDEF;
- default:
- /* Anything ARMv8.1+ and NI have the same value. For now. */
- return pmuver;
- }
-}
-
-/* Read a sanitised cpufeature ID register by sys_reg_desc */
-static u64 read_id_reg(const struct kvm_vcpu *vcpu, struct sys_reg_desc const *r)
-{
- u32 id = reg_to_encoding(r);
- u64 val;
-
- if (sysreg_visible_as_raz(vcpu, r))
- return 0;
-
- val = read_sanitised_ftr_reg(id);
-
- switch (id) {
- case SYS_ID_AA64PFR0_EL1:
- if (!vcpu_has_sve(vcpu))
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_SVE);
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_AMU);
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2), (u64)vcpu->kvm->arch.pfr0_csv2);
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3), (u64)vcpu->kvm->arch.pfr0_csv3);
- if (kvm_vgic_global_state.type == VGIC_V3) {
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC), 1);
- }
- break;
- case SYS_ID_AA64PFR1_EL1:
- if (!kvm_has_mte(vcpu->kvm))
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_MTE);
-
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_SME);
- break;
- case SYS_ID_AA64ISAR1_EL1:
- if (!vcpu_has_ptrauth(vcpu))
- val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_APA) |
- ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_API) |
- ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPA) |
- ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPI));
- break;
- case SYS_ID_AA64ISAR2_EL1:
- if (!vcpu_has_ptrauth(vcpu))
- val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_APA3) |
- ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_GPA3));
- if (!cpus_have_final_cap(ARM64_HAS_WFXT))
- val &= ~ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_WFxT);
- break;
- case SYS_ID_AA64DFR0_EL1:
- /* Limit debug to ARMv8.0 */
- val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer), 6);
- /* Set PMUver to the required version */
- val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
- vcpu_pmuver(vcpu));
- /* Hide SPE from guests */
- val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMSVer);
- break;
- case SYS_ID_DFR0_EL1:
- val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon),
- pmuver_to_perfmon(vcpu_pmuver(vcpu)));
- break;
- case SYS_ID_AA64MMFR2_EL1:
- val &= ~ID_AA64MMFR2_EL1_CCIDX_MASK;
- break;
- case SYS_ID_MMFR4_EL1:
- val &= ~ARM64_FEATURE_MASK(ID_MMFR4_EL1_CCIDX);
- break;
- }
-
- return val;
-}
-
-static unsigned int id_visibility(const struct kvm_vcpu *vcpu,
- const struct sys_reg_desc *r)
-{
- u32 id = reg_to_encoding(r);
-
- switch (id) {
- case SYS_ID_AA64ZFR0_EL1:
- if (!vcpu_has_sve(vcpu))
- return REG_RAZ;
- break;
- }
-
- return 0;
-}
-
-static unsigned int aa32_id_visibility(const struct kvm_vcpu *vcpu,
- const struct sys_reg_desc *r)
-{
- /*
- * AArch32 ID registers are UNKNOWN if AArch32 isn't implemented at any
- * EL. Promote to RAZ/WI in order to guarantee consistency between
- * systems.
- */
- if (!kvm_supports_32bit_el0())
- return REG_RAZ | REG_USER_WI;
-
- return id_visibility(vcpu, r);
-}
-
-static unsigned int raz_visibility(const struct kvm_vcpu *vcpu,
- const struct sys_reg_desc *r)
-{
- return REG_RAZ;
-}
-
-/* cpufeature ID register access trap handlers */
-
-static bool access_id_reg(struct kvm_vcpu *vcpu,
- struct sys_reg_params *p,
- const struct sys_reg_desc *r)
-{
- if (p->is_write)
- return write_to_read_only(vcpu, p, r);
-
- p->regval = read_id_reg(vcpu, r);
- if (vcpu_has_nv(vcpu))
- access_nested_id_reg(vcpu, p, r);
-
- return true;
-}
-
/* Visibility overrides for SVE-specific control registers */
static unsigned int sve_visibility(const struct kvm_vcpu *vcpu,
const struct sys_reg_desc *rd)
@@ -1320,144 +1153,6 @@ static unsigned int sve_visibility(const struct kvm_vcpu *vcpu,
return REG_HIDDEN;
}
-static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
- const struct sys_reg_desc *rd,
- u64 val)
-{
- u8 csv2, csv3;
-
- /*
- * Allow AA64PFR0_EL1.CSV2 to be set from userspace as long as
- * it doesn't promise more than what is actually provided (the
- * guest could otherwise be covered in ectoplasmic residue).
- */
- csv2 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV2_SHIFT);
- if (csv2 > 1 ||
- (csv2 && arm64_get_spectre_v2_state() != SPECTRE_UNAFFECTED))
- return -EINVAL;
-
- /* Same thing for CSV3 */
- csv3 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV3_SHIFT);
- if (csv3 > 1 ||
- (csv3 && arm64_get_meltdown_state() != SPECTRE_UNAFFECTED))
- return -EINVAL;
-
- /* We can only differ with CSV[23], and anything else is an error */
- val ^= read_id_reg(vcpu, rd);
- val &= ~(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2) |
- ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3));
- if (val)
- return -EINVAL;
-
- vcpu->kvm->arch.pfr0_csv2 = csv2;
- vcpu->kvm->arch.pfr0_csv3 = csv3;
-
- return 0;
-}
-
-static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
- const struct sys_reg_desc *rd,
- u64 val)
-{
- u8 pmuver, host_pmuver;
- bool valid_pmu;
-
- host_pmuver = kvm_arm_pmu_get_pmuver_limit();
-
- /*
- * Allow AA64DFR0_EL1.PMUver to be set from userspace as long
- * as it doesn't promise more than what the HW gives us. We
- * allow an IMPDEF PMU though, only if no PMU is supported
- * (KVM backward compatibility handling).
- */
- pmuver = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), val);
- if ((pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF && pmuver > host_pmuver))
- return -EINVAL;
-
- valid_pmu = (pmuver != 0 && pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF);
-
- /* Make sure view register and PMU support do match */
- if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
- return -EINVAL;
-
- /* We can only differ with PMUver, and anything else is an error */
- val ^= read_id_reg(vcpu, rd);
- val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
- if (val)
- return -EINVAL;
-
- if (valid_pmu)
- vcpu->kvm->arch.dfr0_pmuver.imp = pmuver;
- else
- vcpu->kvm->arch.dfr0_pmuver.unimp = pmuver;
-
- return 0;
-}
-
-static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
- const struct sys_reg_desc *rd,
- u64 val)
-{
- u8 perfmon, host_perfmon;
- bool valid_pmu;
-
- host_perfmon = pmuver_to_perfmon(kvm_arm_pmu_get_pmuver_limit());
-
- /*
- * Allow DFR0_EL1.PerfMon to be set from userspace as long as
- * it doesn't promise more than what the HW gives us on the
- * AArch64 side (as everything is emulated with that), and
- * that this is a PMUv3.
- */
- perfmon = FIELD_GET(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), val);
- if ((perfmon != ID_DFR0_EL1_PerfMon_IMPDEF && perfmon > host_perfmon) ||
- (perfmon != 0 && perfmon < ID_DFR0_EL1_PerfMon_PMUv3))
- return -EINVAL;
-
- valid_pmu = (perfmon != 0 && perfmon != ID_DFR0_EL1_PerfMon_IMPDEF);
-
- /* Make sure view register and PMU support do match */
- if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
- return -EINVAL;
-
- /* We can only differ with PerfMon, and anything else is an error */
- val ^= read_id_reg(vcpu, rd);
- val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
- if (val)
- return -EINVAL;
-
- if (valid_pmu)
- vcpu->kvm->arch.dfr0_pmuver.imp = perfmon_to_pmuver(perfmon);
- else
- vcpu->kvm->arch.dfr0_pmuver.unimp = perfmon_to_pmuver(perfmon);
-
- return 0;
-}
-
-/*
- * cpufeature ID register user accessors
- *
- * For now, these registers are immutable for userspace, so no values
- * are stored, and for set_id_reg() we don't allow the effective value
- * to be changed.
- */
-static int get_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
- u64 *val)
-{
- *val = read_id_reg(vcpu, rd);
- return 0;
-}
-
-static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
- u64 val)
-{
- /* This is what we mean by invariant: you can't change it. */
- if (val != read_id_reg(vcpu, rd))
- return -EINVAL;
-
- return 0;
-}
-
static int get_raz_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
u64 *val)
{
@@ -1642,50 +1337,6 @@ static unsigned int elx2_visibility(const struct kvm_vcpu *vcpu,
.visibility = elx2_visibility, \
}
-/* sys_reg_desc initialiser for known cpufeature ID registers */
-#define ID_SANITISED(name) { \
- SYS_DESC(SYS_##name), \
- .access = access_id_reg, \
- .get_user = get_id_reg, \
- .set_user = set_id_reg, \
- .visibility = id_visibility, \
-}
-
-/* sys_reg_desc initialiser for known cpufeature ID registers */
-#define AA32_ID_SANITISED(name) { \
- SYS_DESC(SYS_##name), \
- .access = access_id_reg, \
- .get_user = get_id_reg, \
- .set_user = set_id_reg, \
- .visibility = aa32_id_visibility, \
-}
-
-/*
- * sys_reg_desc initialiser for architecturally unallocated cpufeature ID
- * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
- * (1 <= crm < 8, 0 <= Op2 < 8).
- */
-#define ID_UNALLOCATED(crm, op2) { \
- Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
- .access = access_id_reg, \
- .get_user = get_id_reg, \
- .set_user = set_id_reg, \
- .visibility = raz_visibility \
-}
-
-/*
- * sys_reg_desc initialiser for known ID registers that we hide from guests.
- * For now, these are exposed just like unallocated ID regs: they appear
- * RAZ for the guest.
- */
-#define ID_HIDDEN(name) { \
- SYS_DESC(SYS_##name), \
- .access = access_id_reg, \
- .get_user = get_id_reg, \
- .set_user = set_id_reg, \
- .visibility = raz_visibility, \
-}
-
static bool access_sp_el1(struct kvm_vcpu *vcpu,
struct sys_reg_params *p,
const struct sys_reg_desc *r)
@@ -1776,87 +1427,6 @@ static const struct sys_reg_desc sys_reg_descs[] = {
{ SYS_DESC(SYS_MPIDR_EL1), NULL, reset_mpidr, MPIDR_EL1 },
- /*
- * ID regs: all ID_SANITISED() entries here must have corresponding
- * entries in arm64_ftr_regs[].
- */
-
- /* AArch64 mappings of the AArch32 ID registers */
- /* CRm=1 */
- AA32_ID_SANITISED(ID_PFR0_EL1),
- AA32_ID_SANITISED(ID_PFR1_EL1),
- { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
- .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
- .visibility = aa32_id_visibility, },
- ID_HIDDEN(ID_AFR0_EL1),
- AA32_ID_SANITISED(ID_MMFR0_EL1),
- AA32_ID_SANITISED(ID_MMFR1_EL1),
- AA32_ID_SANITISED(ID_MMFR2_EL1),
- AA32_ID_SANITISED(ID_MMFR3_EL1),
-
- /* CRm=2 */
- AA32_ID_SANITISED(ID_ISAR0_EL1),
- AA32_ID_SANITISED(ID_ISAR1_EL1),
- AA32_ID_SANITISED(ID_ISAR2_EL1),
- AA32_ID_SANITISED(ID_ISAR3_EL1),
- AA32_ID_SANITISED(ID_ISAR4_EL1),
- AA32_ID_SANITISED(ID_ISAR5_EL1),
- AA32_ID_SANITISED(ID_MMFR4_EL1),
- AA32_ID_SANITISED(ID_ISAR6_EL1),
-
- /* CRm=3 */
- AA32_ID_SANITISED(MVFR0_EL1),
- AA32_ID_SANITISED(MVFR1_EL1),
- AA32_ID_SANITISED(MVFR2_EL1),
- ID_UNALLOCATED(3,3),
- AA32_ID_SANITISED(ID_PFR2_EL1),
- ID_HIDDEN(ID_DFR1_EL1),
- AA32_ID_SANITISED(ID_MMFR5_EL1),
- ID_UNALLOCATED(3,7),
-
- /* AArch64 ID registers */
- /* CRm=4 */
- { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
- .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
- ID_SANITISED(ID_AA64PFR1_EL1),
- ID_UNALLOCATED(4,2),
- ID_UNALLOCATED(4,3),
- ID_SANITISED(ID_AA64ZFR0_EL1),
- ID_HIDDEN(ID_AA64SMFR0_EL1),
- ID_UNALLOCATED(4,6),
- ID_UNALLOCATED(4,7),
-
- /* CRm=5 */
- { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
- .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
- ID_SANITISED(ID_AA64DFR1_EL1),
- ID_UNALLOCATED(5,2),
- ID_UNALLOCATED(5,3),
- ID_HIDDEN(ID_AA64AFR0_EL1),
- ID_HIDDEN(ID_AA64AFR1_EL1),
- ID_UNALLOCATED(5,6),
- ID_UNALLOCATED(5,7),
-
- /* CRm=6 */
- ID_SANITISED(ID_AA64ISAR0_EL1),
- ID_SANITISED(ID_AA64ISAR1_EL1),
- ID_SANITISED(ID_AA64ISAR2_EL1),
- ID_UNALLOCATED(6,3),
- ID_UNALLOCATED(6,4),
- ID_UNALLOCATED(6,5),
- ID_UNALLOCATED(6,6),
- ID_UNALLOCATED(6,7),
-
- /* CRm=7 */
- ID_SANITISED(ID_AA64MMFR0_EL1),
- ID_SANITISED(ID_AA64MMFR1_EL1),
- ID_SANITISED(ID_AA64MMFR2_EL1),
- ID_UNALLOCATED(7,3),
- ID_UNALLOCATED(7,4),
- ID_UNALLOCATED(7,5),
- ID_UNALLOCATED(7,6),
- ID_UNALLOCATED(7,7),
-
{ SYS_DESC(SYS_SCTLR_EL1), access_vm_reg, reset_val, SCTLR_EL1, 0x00C50078 },
{ SYS_DESC(SYS_ACTLR_EL1), access_actlr, reset_actlr, ACTLR_EL1 },
{ SYS_DESC(SYS_CPACR_EL1), NULL, reset_val, CPACR_EL1, 0 },
@@ -2531,8 +2101,8 @@ static const struct sys_reg_desc cp15_64_regs[] = {
{ SYS_DESC(SYS_AARCH32_CNTP_CVAL), access_arch_timer },
};
-static bool check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
- bool is_32)
+bool check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
+ bool is_32)
{
unsigned int i;
@@ -2883,7 +2453,9 @@ static bool emulate_sys_reg(struct kvm_vcpu *vcpu,
{
const struct sys_reg_desc *r;
- r = find_reg(params, sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
+ r = kvm_arm_find_id_reg(params);
+ if (!r)
+ r = find_reg(params, sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
if (likely(r)) {
perform_access(vcpu, params, r);
@@ -2912,6 +2484,8 @@ void kvm_reset_sys_regs(struct kvm_vcpu *vcpu)
{
unsigned long i;
+ kvm_arm_reset_id_regs(vcpu);
+
for (i = 0; i < ARRAY_SIZE(sys_reg_descs); i++)
if (sys_reg_descs[i].reset)
sys_reg_descs[i].reset(vcpu, &sys_reg_descs[i]);
@@ -3160,6 +2734,10 @@ int kvm_arm_sys_reg_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg
if (err != -ENOENT)
return err;
+ err = kvm_arm_get_id_reg(vcpu, reg);
+ if (err != -ENOENT)
+ return err;
+
return kvm_sys_reg_get_user(vcpu, reg,
sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
}
@@ -3204,6 +2782,10 @@ int kvm_arm_sys_reg_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg
if (err != -ENOENT)
return err;
+ err = kvm_arm_set_id_reg(vcpu, reg);
+ if (err != -ENOENT)
+ return err;
+
return kvm_sys_reg_set_user(vcpu, reg,
sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
}
@@ -3250,10 +2832,10 @@ static bool copy_reg_to_user(const struct sys_reg_desc *reg, u64 __user **uind)
return true;
}
-static int walk_one_sys_reg(const struct kvm_vcpu *vcpu,
- const struct sys_reg_desc *rd,
- u64 __user **uind,
- unsigned int *total)
+int walk_one_sys_reg(const struct kvm_vcpu *vcpu,
+ const struct sys_reg_desc *rd,
+ u64 __user **uind,
+ unsigned int *total)
{
/*
* Ignore registers we trap but don't save,
@@ -3294,6 +2876,7 @@ unsigned long kvm_arm_num_sys_reg_descs(struct kvm_vcpu *vcpu)
{
return ARRAY_SIZE(invariant_sys_regs)
+ num_demux_regs()
+ + kvm_arm_walk_id_regs(vcpu, (u64 __user *)NULL)
+ walk_sys_regs(vcpu, (u64 __user *)NULL);
}
@@ -3309,6 +2892,11 @@ int kvm_arm_copy_sys_reg_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
uindices++;
}
+ err = kvm_arm_walk_id_regs(vcpu, uindices);
+ if (err < 0)
+ return err;
+ uindices += err;
+
err = walk_sys_regs(vcpu, uindices);
if (err < 0)
return err;
@@ -3323,6 +2911,7 @@ int __init kvm_sys_reg_table_init(void)
unsigned int i;
/* Make sure tables are unique and in order. */
+ valid &= kvm_arm_check_idreg_table();
valid &= check_sysreg_table(sys_reg_descs, ARRAY_SIZE(sys_reg_descs), false);
valid &= check_sysreg_table(cp14_regs, ARRAY_SIZE(cp14_regs), true);
valid &= check_sysreg_table(cp14_64_regs, ARRAY_SIZE(cp14_64_regs), true);
diff --git a/arch/arm64/kvm/sys_regs.h b/arch/arm64/kvm/sys_regs.h
index 6b11f2cc7146..96a52936d130 100644
--- a/arch/arm64/kvm/sys_regs.h
+++ b/arch/arm64/kvm/sys_regs.h
@@ -210,6 +210,22 @@ find_reg(const struct sys_reg_params *params, const struct sys_reg_desc table[],
return __inline_bsearch((void *)pval, table, num, sizeof(table[0]), match_sys_reg);
}
+static inline unsigned int raz_visibility(const struct kvm_vcpu *vcpu,
+ const struct sys_reg_desc *r)
+{
+ return REG_RAZ;
+}
+
+static inline bool write_to_read_only(struct kvm_vcpu *vcpu,
+ struct sys_reg_params *params,
+ const struct sys_reg_desc *r)
+{
+ WARN_ONCE(1, "Unexpected sys_reg write to read-only register\n");
+ print_sys_reg_instr(params);
+ kvm_inject_undefined(vcpu);
+ return false;
+}
+
const struct sys_reg_desc *get_reg_by_id(u64 id,
const struct sys_reg_desc table[],
unsigned int num);
@@ -220,6 +236,18 @@ int kvm_sys_reg_get_user(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg,
const struct sys_reg_desc table[], unsigned int num);
int kvm_sys_reg_set_user(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg,
const struct sys_reg_desc table[], unsigned int num);
+bool check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
+ bool is_32);
+int walk_one_sys_reg(const struct kvm_vcpu *vcpu,
+ const struct sys_reg_desc *rd,
+ u64 __user **uind,
+ unsigned int *total);
+const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params);
+void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu);
+int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
+int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
+bool kvm_arm_check_idreg_table(void);
+int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind);
#define AA32(_x) .aarch32_map = AA32_##_x
#define Op0(_x) .Op0 = _x
--
2.39.1.581.gbfd45094c4-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 16+ messages in thread* Re: [PATCH v2 1/6] KVM: arm64: Move CPU ID feature registers emulation into a separate file
2023-02-12 21:58 ` [PATCH v2 1/6] KVM: arm64: Move CPU ID feature registers emulation into a separate file Jing Zhang
@ 2023-02-24 1:01 ` Reiji Watanabe
2023-02-24 11:05 ` Marc Zyngier
2023-02-27 2:54 ` Jing Zhang
0 siblings, 2 replies; 16+ messages in thread
From: Reiji Watanabe @ 2023-02-24 1:01 UTC (permalink / raw)
To: Jing Zhang
Cc: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton, Will Deacon,
Paolo Bonzini, James Morse, Alexandru Elisei, Suzuki K Poulose,
Fuad Tabba, Ricardo Koller, Raghavendra Rao Ananta
Hi Jing,
On Sun, Feb 12, 2023 at 1:58 PM Jing Zhang <jingzhangos@google.com> wrote:
>
> Create a new file id_regs.c for CPU ID feature registers emulation code,
> which are moved from sys_regs.c and tweak sys_regs code accordingly.
>
> No functional change intended.
>
> Signed-off-by: Jing Zhang <jingzhangos@google.com>
> ---
> arch/arm64/kvm/Makefile | 2 +-
> arch/arm64/kvm/id_regs.c | 486 ++++++++++++++++++++++++++++++++++++++
> arch/arm64/kvm/sys_regs.c | 463 ++----------------------------------
> arch/arm64/kvm/sys_regs.h | 28 +++
> 4 files changed, 541 insertions(+), 438 deletions(-)
> create mode 100644 arch/arm64/kvm/id_regs.c
>
> diff --git a/arch/arm64/kvm/Makefile b/arch/arm64/kvm/Makefile
> index c0c050e53157..a6a315fcd81e 100644
> --- a/arch/arm64/kvm/Makefile
> +++ b/arch/arm64/kvm/Makefile
> @@ -13,7 +13,7 @@ obj-$(CONFIG_KVM) += hyp/
> kvm-y += arm.o mmu.o mmio.o psci.o hypercalls.o pvtime.o \
> inject_fault.o va_layout.o handle_exit.o \
> guest.o debug.o reset.o sys_regs.o stacktrace.o \
> - vgic-sys-reg-v3.o fpsimd.o pkvm.o \
> + vgic-sys-reg-v3.o fpsimd.o pkvm.o id_regs.o \
> arch_timer.o trng.o vmid.o emulate-nested.o nested.o \
> vgic/vgic.o vgic/vgic-init.o \
> vgic/vgic-irqfd.o vgic/vgic-v2.o \
> diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
> new file mode 100644
> index 000000000000..7f30d683de21
> --- /dev/null
> +++ b/arch/arm64/kvm/id_regs.c
> @@ -0,0 +1,486 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (C) 2023 - Google LLC
> + * Author: Jing Zhang <jingzhangos@google.com>
> + *
> + * Moved from arch/arm64/kvm/sys_regs.c
> + * Copyright (C) 2012,2013 - ARM Ltd
> + * Author: Marc Zyngier <marc.zyngier@arm.com>
> + */
> +
> +#include <linux/bitfield.h>
> +#include <linux/bsearch.h>
> +#include <linux/kvm_host.h>
> +#include <asm/kvm_emulate.h>
> +#include <asm/sysreg.h>
> +#include <asm/cpufeature.h>
> +#include <asm/kvm_nested.h>
> +
> +#include "sys_regs.h"
> +
> +static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> +{
> + if (kvm_vcpu_has_pmu(vcpu))
> + return vcpu->kvm->arch.dfr0_pmuver.imp;
> +
> + return vcpu->kvm->arch.dfr0_pmuver.unimp;
> +}
> +
> +static u8 perfmon_to_pmuver(u8 perfmon)
> +{
> + switch (perfmon) {
> + case ID_DFR0_EL1_PerfMon_PMUv3:
> + return ID_AA64DFR0_EL1_PMUVer_IMP;
> + case ID_DFR0_EL1_PerfMon_IMPDEF:
> + return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
> + default:
> + /* Anything ARMv8.1+ and NI have the same value. For now. */
> + return perfmon;
> + }
> +}
> +
> +static u8 pmuver_to_perfmon(u8 pmuver)
> +{
> + switch (pmuver) {
> + case ID_AA64DFR0_EL1_PMUVer_IMP:
> + return ID_DFR0_EL1_PerfMon_PMUv3;
> + case ID_AA64DFR0_EL1_PMUVer_IMP_DEF:
> + return ID_DFR0_EL1_PerfMon_IMPDEF;
> + default:
> + /* Anything ARMv8.1+ and NI have the same value. For now. */
> + return pmuver;
> + }
> +}
> +
> +/* Read a sanitised cpufeature ID register by sys_reg_desc */
> +static u64 read_id_reg(const struct kvm_vcpu *vcpu, struct sys_reg_desc const *r)
> +{
> + u32 id = reg_to_encoding(r);
> + u64 val;
> +
> + if (sysreg_visible_as_raz(vcpu, r))
> + return 0;
> +
> + val = read_sanitised_ftr_reg(id);
> +
> + switch (id) {
> + case SYS_ID_AA64PFR0_EL1:
> + if (!vcpu_has_sve(vcpu))
> + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_SVE);
> + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_AMU);
> + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
> + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2),
> + (u64)vcpu->kvm->arch.pfr0_csv2);
> + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
> + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3),
> + (u64)vcpu->kvm->arch.pfr0_csv3);
> + if (kvm_vgic_global_state.type == VGIC_V3) {
> + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC);
> + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC), 1);
> + }
> + break;
> + case SYS_ID_AA64PFR1_EL1:
> + if (!kvm_has_mte(vcpu->kvm))
> + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_MTE);
> +
> + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_SME);
> + break;
> + case SYS_ID_AA64ISAR1_EL1:
> + if (!vcpu_has_ptrauth(vcpu))
> + val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_APA) |
> + ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_API) |
> + ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPA) |
> + ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPI));
> + break;
> + case SYS_ID_AA64ISAR2_EL1:
> + if (!vcpu_has_ptrauth(vcpu))
> + val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_APA3) |
> + ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_GPA3));
> + if (!cpus_have_final_cap(ARM64_HAS_WFXT))
> + val &= ~ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_WFxT);
> + break;
> + case SYS_ID_AA64DFR0_EL1:
> + /* Limit debug to ARMv8.0 */
> + val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer);
> + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer), 6);
> + /* Set PMUver to the required version */
> + val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
> + vcpu_pmuver(vcpu));
> + /* Hide SPE from guests */
> + val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMSVer);
> + break;
> + case SYS_ID_DFR0_EL1:
> + val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon),
> + pmuver_to_perfmon(vcpu_pmuver(vcpu)));
> + break;
> + case SYS_ID_AA64MMFR2_EL1:
> + val &= ~ID_AA64MMFR2_EL1_CCIDX_MASK;
> + break;
> + case SYS_ID_MMFR4_EL1:
> + val &= ~ARM64_FEATURE_MASK(ID_MMFR4_EL1_CCIDX);
> + break;
> + }
> +
> + return val;
> +}
> +
> +/* cpufeature ID register access trap handlers */
> +
> +static bool access_id_reg(struct kvm_vcpu *vcpu,
> + struct sys_reg_params *p,
> + const struct sys_reg_desc *r)
> +{
> + if (p->is_write)
> + return write_to_read_only(vcpu, p, r);
> +
> + p->regval = read_id_reg(vcpu, r);
> + if (vcpu_has_nv(vcpu))
> + access_nested_id_reg(vcpu, p, r);
> +
> + return true;
> +}
> +
> +/*
> + * cpufeature ID register user accessors
> + *
> + * For now, these registers are immutable for userspace, so no values
> + * are stored, and for set_id_reg() we don't allow the effective value
> + * to be changed.
> + */
> +static int get_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> + u64 *val)
> +{
> + *val = read_id_reg(vcpu, rd);
> + return 0;
> +}
> +
> +static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> + u64 val)
> +{
> + /* This is what we mean by invariant: you can't change it. */
> + if (val != read_id_reg(vcpu, rd))
> + return -EINVAL;
> +
> + return 0;
> +}
> +
> +static unsigned int id_visibility(const struct kvm_vcpu *vcpu,
> + const struct sys_reg_desc *r)
> +{
> + u32 id = reg_to_encoding(r);
> +
> + switch (id) {
> + case SYS_ID_AA64ZFR0_EL1:
> + if (!vcpu_has_sve(vcpu))
> + return REG_RAZ;
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static unsigned int aa32_id_visibility(const struct kvm_vcpu *vcpu,
> + const struct sys_reg_desc *r)
> +{
> + /*
> + * AArch32 ID registers are UNKNOWN if AArch32 isn't implemented at any
> + * EL. Promote to RAZ/WI in order to guarantee consistency between
> + * systems.
> + */
> + if (!kvm_supports_32bit_el0())
> + return REG_RAZ | REG_USER_WI;
> +
> + return id_visibility(vcpu, r);
> +}
> +
> +static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
> + const struct sys_reg_desc *rd,
> + u64 val)
> +{
> + u8 csv2, csv3;
> +
> + /*
> + * Allow AA64PFR0_EL1.CSV2 to be set from userspace as long as
> + * it doesn't promise more than what is actually provided (the
> + * guest could otherwise be covered in ectoplasmic residue).
> + */
> + csv2 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV2_SHIFT);
> + if (csv2 > 1 ||
> + (csv2 && arm64_get_spectre_v2_state() != SPECTRE_UNAFFECTED))
> + return -EINVAL;
> +
> + /* Same thing for CSV3 */
> + csv3 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV3_SHIFT);
> + if (csv3 > 1 ||
> + (csv3 && arm64_get_meltdown_state() != SPECTRE_UNAFFECTED))
> + return -EINVAL;
> +
> + /* We can only differ with CSV[23], and anything else is an error */
> + val ^= read_id_reg(vcpu, rd);
> + val &= ~(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2) |
> + ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3));
> + if (val)
> + return -EINVAL;
> +
> + vcpu->kvm->arch.pfr0_csv2 = csv2;
> + vcpu->kvm->arch.pfr0_csv3 = csv3;
> +
> + return 0;
> +}
> +
> +static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
> + const struct sys_reg_desc *rd,
> + u64 val)
> +{
> + u8 pmuver, host_pmuver;
> + bool valid_pmu;
> +
> + host_pmuver = kvm_arm_pmu_get_pmuver_limit();
> +
> + /*
> + * Allow AA64DFR0_EL1.PMUver to be set from userspace as long
> + * as it doesn't promise more than what the HW gives us. We
> + * allow an IMPDEF PMU though, only if no PMU is supported
> + * (KVM backward compatibility handling).
> + */
> + pmuver = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), val);
> + if ((pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF && pmuver > host_pmuver))
> + return -EINVAL;
> +
> + valid_pmu = (pmuver != 0 && pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF);
> +
> + /* Make sure view register and PMU support do match */
> + if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
> + return -EINVAL;
> +
> + /* We can only differ with PMUver, and anything else is an error */
> + val ^= read_id_reg(vcpu, rd);
> + val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> + if (val)
> + return -EINVAL;
> +
> + if (valid_pmu)
> + vcpu->kvm->arch.dfr0_pmuver.imp = pmuver;
> + else
> + vcpu->kvm->arch.dfr0_pmuver.unimp = pmuver;
> +
> + return 0;
> +}
> +
> +static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> + const struct sys_reg_desc *rd,
> + u64 val)
> +{
> + u8 perfmon, host_perfmon;
> + bool valid_pmu;
> +
> + host_perfmon = pmuver_to_perfmon(kvm_arm_pmu_get_pmuver_limit());
> +
> + /*
> + * Allow DFR0_EL1.PerfMon to be set from userspace as long as
> + * it doesn't promise more than what the HW gives us on the
> + * AArch64 side (as everything is emulated with that), and
> + * that this is a PMUv3.
> + */
> + perfmon = FIELD_GET(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), val);
> + if ((perfmon != ID_DFR0_EL1_PerfMon_IMPDEF && perfmon > host_perfmon) ||
> + (perfmon != 0 && perfmon < ID_DFR0_EL1_PerfMon_PMUv3))
> + return -EINVAL;
> +
> + valid_pmu = (perfmon != 0 && perfmon != ID_DFR0_EL1_PerfMon_IMPDEF);
> +
> + /* Make sure view register and PMU support do match */
> + if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
> + return -EINVAL;
> +
> + /* We can only differ with PerfMon, and anything else is an error */
> + val ^= read_id_reg(vcpu, rd);
> + val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> + if (val)
> + return -EINVAL;
> +
> + if (valid_pmu)
> + vcpu->kvm->arch.dfr0_pmuver.imp = perfmon_to_pmuver(perfmon);
> + else
> + vcpu->kvm->arch.dfr0_pmuver.unimp = perfmon_to_pmuver(perfmon);
> +
> + return 0;
> +}
> +
> +/* sys_reg_desc initialiser for known cpufeature ID registers */
> +#define ID_SANITISED(name) { \
> + SYS_DESC(SYS_##name), \
> + .access = access_id_reg, \
> + .get_user = get_id_reg, \
> + .set_user = set_id_reg, \
> + .visibility = id_visibility, \
> +}
> +
> +/* sys_reg_desc initialiser for known cpufeature ID registers */
> +#define AA32_ID_SANITISED(name) { \
> + SYS_DESC(SYS_##name), \
> + .access = access_id_reg, \
> + .get_user = get_id_reg, \
> + .set_user = set_id_reg, \
> + .visibility = aa32_id_visibility, \
> +}
> +
> +/*
> + * sys_reg_desc initialiser for architecturally unallocated cpufeature ID
> + * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
> + * (1 <= crm < 8, 0 <= Op2 < 8).
> + */
> +#define ID_UNALLOCATED(crm, op2) { \
> + Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> + .access = access_id_reg, \
> + .get_user = get_id_reg, \
> + .set_user = set_id_reg, \
> + .visibility = raz_visibility \
> +}
> +
> +/*
> + * sys_reg_desc initialiser for known ID registers that we hide from guests.
> + * For now, these are exposed just like unallocated ID regs: they appear
> + * RAZ for the guest.
> + */
> +#define ID_HIDDEN(name) { \
> + SYS_DESC(SYS_##name), \
> + .access = access_id_reg, \
> + .get_user = get_id_reg, \
> + .set_user = set_id_reg, \
> + .visibility = raz_visibility, \
> +}
> +
> +static const struct sys_reg_desc id_reg_descs[] = {
> + /*
> + * ID regs: all ID_SANITISED() entries here must have corresponding
> + * entries in arm64_ftr_regs[].
> + */
> +
> + /* AArch64 mappings of the AArch32 ID registers */
> + /* CRm=1 */
> + AA32_ID_SANITISED(ID_PFR0_EL1),
> + AA32_ID_SANITISED(ID_PFR1_EL1),
> + { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
> + .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
> + .visibility = aa32_id_visibility, },
> + ID_HIDDEN(ID_AFR0_EL1),
> + AA32_ID_SANITISED(ID_MMFR0_EL1),
> + AA32_ID_SANITISED(ID_MMFR1_EL1),
> + AA32_ID_SANITISED(ID_MMFR2_EL1),
> + AA32_ID_SANITISED(ID_MMFR3_EL1),
> +
> + /* CRm=2 */
> + AA32_ID_SANITISED(ID_ISAR0_EL1),
> + AA32_ID_SANITISED(ID_ISAR1_EL1),
> + AA32_ID_SANITISED(ID_ISAR2_EL1),
> + AA32_ID_SANITISED(ID_ISAR3_EL1),
> + AA32_ID_SANITISED(ID_ISAR4_EL1),
> + AA32_ID_SANITISED(ID_ISAR5_EL1),
> + AA32_ID_SANITISED(ID_MMFR4_EL1),
> + AA32_ID_SANITISED(ID_ISAR6_EL1),
> +
> + /* CRm=3 */
> + AA32_ID_SANITISED(MVFR0_EL1),
> + AA32_ID_SANITISED(MVFR1_EL1),
> + AA32_ID_SANITISED(MVFR2_EL1),
> + ID_UNALLOCATED(3, 3),
> + AA32_ID_SANITISED(ID_PFR2_EL1),
> + ID_HIDDEN(ID_DFR1_EL1),
> + AA32_ID_SANITISED(ID_MMFR5_EL1),
> + ID_UNALLOCATED(3, 7),
> +
> + /* AArch64 ID registers */
> + /* CRm=4 */
> + { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
> + .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
> + ID_SANITISED(ID_AA64PFR1_EL1),
> + ID_UNALLOCATED(4, 2),
> + ID_UNALLOCATED(4, 3),
> + ID_SANITISED(ID_AA64ZFR0_EL1),
> + ID_HIDDEN(ID_AA64SMFR0_EL1),
> + ID_UNALLOCATED(4, 6),
> + ID_UNALLOCATED(4, 7),
> +
> + /* CRm=5 */
> + { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
> + .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
> + ID_SANITISED(ID_AA64DFR1_EL1),
> + ID_UNALLOCATED(5, 2),
> + ID_UNALLOCATED(5, 3),
> + ID_HIDDEN(ID_AA64AFR0_EL1),
> + ID_HIDDEN(ID_AA64AFR1_EL1),
> + ID_UNALLOCATED(5, 6),
> + ID_UNALLOCATED(5, 7),
> +
> + /* CRm=6 */
> + ID_SANITISED(ID_AA64ISAR0_EL1),
> + ID_SANITISED(ID_AA64ISAR1_EL1),
> + ID_SANITISED(ID_AA64ISAR2_EL1),
> + ID_UNALLOCATED(6, 3),
> + ID_UNALLOCATED(6, 4),
> + ID_UNALLOCATED(6, 5),
> + ID_UNALLOCATED(6, 6),
> + ID_UNALLOCATED(6, 7),
> +
> + /* CRm=7 */
> + ID_SANITISED(ID_AA64MMFR0_EL1),
> + ID_SANITISED(ID_AA64MMFR1_EL1),
> + ID_SANITISED(ID_AA64MMFR2_EL1),
> + ID_UNALLOCATED(7, 3),
> + ID_UNALLOCATED(7, 4),
> + ID_UNALLOCATED(7, 5),
> + ID_UNALLOCATED(7, 6),
> + ID_UNALLOCATED(7, 7),
> +};
> +
> +const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params)
> +{
You might want to check if the param indicates the ID register,
before running the binary search for the ID register table.
(I have the same comment to kvm_arm_get_id_reg() and
kvm_arm_set_id_reg()).
> + return find_reg(params, id_reg_descs, ARRAY_SIZE(id_reg_descs));
> +}
> +
> +void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> +{
> + unsigned long i;
> +
> + for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++)
> + if (id_reg_descs[i].reset)
> + id_reg_descs[i].reset(vcpu, &id_reg_descs[i]);
> +}
> +
> +int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> +{
> + return kvm_sys_reg_get_user(vcpu, reg,
> + id_reg_descs, ARRAY_SIZE(id_reg_descs));
> +}
> +
> +int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> +{
> + return kvm_sys_reg_set_user(vcpu, reg,
> + id_reg_descs, ARRAY_SIZE(id_reg_descs));
> +}
> +
> +bool kvm_arm_check_idreg_table(void)
> +{
> + return check_sysreg_table(id_reg_descs, ARRAY_SIZE(id_reg_descs), false);
> +}
> +
> +/* Assumed ordered tables, see kvm_sys_reg_table_init. */
I don't think we need this comment, as the code doesn't seem to assume that.
> +int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind)
> +{
> + const struct sys_reg_desc *i2, *end2;
> + unsigned int total = 0;
> + int err;
> +
> + i2 = id_reg_descs;
> + end2 = id_reg_descs + ARRAY_SIZE(id_reg_descs);
> +
> + while (i2 != end2) {
> + err = walk_one_sys_reg(vcpu, i2++, &uind, &total);
> + if (err)
> + return err;
> + }
> + return total;
> +}
> diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
> index 53749d3a0996..3b23b7a67eb5 100644
> --- a/arch/arm64/kvm/sys_regs.c
> +++ b/arch/arm64/kvm/sys_regs.c
> @@ -53,16 +53,6 @@ static bool read_from_write_only(struct kvm_vcpu *vcpu,
> return false;
> }
>
> -static bool write_to_read_only(struct kvm_vcpu *vcpu,
> - struct sys_reg_params *params,
> - const struct sys_reg_desc *r)
> -{
> - WARN_ONCE(1, "Unexpected sys_reg write to read-only register\n");
> - print_sys_reg_instr(params);
> - kvm_inject_undefined(vcpu);
> - return false;
> -}
> -
> u64 vcpu_read_sys_reg(const struct kvm_vcpu *vcpu, int reg)
> {
> u64 val = 0x8badf00d8badf00d;
> @@ -1153,163 +1143,6 @@ static bool access_arch_timer(struct kvm_vcpu *vcpu,
> return true;
> }
>
> -static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> -{
> - if (kvm_vcpu_has_pmu(vcpu))
> - return vcpu->kvm->arch.dfr0_pmuver.imp;
> -
> - return vcpu->kvm->arch.dfr0_pmuver.unimp;
> -}
> -
> -static u8 perfmon_to_pmuver(u8 perfmon)
> -{
> - switch (perfmon) {
> - case ID_DFR0_EL1_PerfMon_PMUv3:
> - return ID_AA64DFR0_EL1_PMUVer_IMP;
> - case ID_DFR0_EL1_PerfMon_IMPDEF:
> - return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
> - default:
> - /* Anything ARMv8.1+ and NI have the same value. For now. */
> - return perfmon;
> - }
> -}
> -
> -static u8 pmuver_to_perfmon(u8 pmuver)
> -{
> - switch (pmuver) {
> - case ID_AA64DFR0_EL1_PMUVer_IMP:
> - return ID_DFR0_EL1_PerfMon_PMUv3;
> - case ID_AA64DFR0_EL1_PMUVer_IMP_DEF:
> - return ID_DFR0_EL1_PerfMon_IMPDEF;
> - default:
> - /* Anything ARMv8.1+ and NI have the same value. For now. */
> - return pmuver;
> - }
> -}
> -
> -/* Read a sanitised cpufeature ID register by sys_reg_desc */
> -static u64 read_id_reg(const struct kvm_vcpu *vcpu, struct sys_reg_desc const *r)
> -{
> - u32 id = reg_to_encoding(r);
> - u64 val;
> -
> - if (sysreg_visible_as_raz(vcpu, r))
> - return 0;
> -
> - val = read_sanitised_ftr_reg(id);
> -
> - switch (id) {
> - case SYS_ID_AA64PFR0_EL1:
> - if (!vcpu_has_sve(vcpu))
> - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_SVE);
> - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_AMU);
> - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
> - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2), (u64)vcpu->kvm->arch.pfr0_csv2);
> - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
> - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3), (u64)vcpu->kvm->arch.pfr0_csv3);
> - if (kvm_vgic_global_state.type == VGIC_V3) {
> - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC);
> - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC), 1);
> - }
> - break;
> - case SYS_ID_AA64PFR1_EL1:
> - if (!kvm_has_mte(vcpu->kvm))
> - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_MTE);
> -
> - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_SME);
> - break;
> - case SYS_ID_AA64ISAR1_EL1:
> - if (!vcpu_has_ptrauth(vcpu))
> - val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_APA) |
> - ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_API) |
> - ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPA) |
> - ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPI));
> - break;
> - case SYS_ID_AA64ISAR2_EL1:
> - if (!vcpu_has_ptrauth(vcpu))
> - val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_APA3) |
> - ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_GPA3));
> - if (!cpus_have_final_cap(ARM64_HAS_WFXT))
> - val &= ~ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_WFxT);
> - break;
> - case SYS_ID_AA64DFR0_EL1:
> - /* Limit debug to ARMv8.0 */
> - val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer);
> - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer), 6);
> - /* Set PMUver to the required version */
> - val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
> - vcpu_pmuver(vcpu));
> - /* Hide SPE from guests */
> - val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMSVer);
> - break;
> - case SYS_ID_DFR0_EL1:
> - val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon),
> - pmuver_to_perfmon(vcpu_pmuver(vcpu)));
> - break;
> - case SYS_ID_AA64MMFR2_EL1:
> - val &= ~ID_AA64MMFR2_EL1_CCIDX_MASK;
> - break;
> - case SYS_ID_MMFR4_EL1:
> - val &= ~ARM64_FEATURE_MASK(ID_MMFR4_EL1_CCIDX);
> - break;
> - }
> -
> - return val;
> -}
> -
> -static unsigned int id_visibility(const struct kvm_vcpu *vcpu,
> - const struct sys_reg_desc *r)
> -{
> - u32 id = reg_to_encoding(r);
> -
> - switch (id) {
> - case SYS_ID_AA64ZFR0_EL1:
> - if (!vcpu_has_sve(vcpu))
> - return REG_RAZ;
> - break;
> - }
> -
> - return 0;
> -}
> -
> -static unsigned int aa32_id_visibility(const struct kvm_vcpu *vcpu,
> - const struct sys_reg_desc *r)
> -{
> - /*
> - * AArch32 ID registers are UNKNOWN if AArch32 isn't implemented at any
> - * EL. Promote to RAZ/WI in order to guarantee consistency between
> - * systems.
> - */
> - if (!kvm_supports_32bit_el0())
> - return REG_RAZ | REG_USER_WI;
> -
> - return id_visibility(vcpu, r);
> -}
> -
> -static unsigned int raz_visibility(const struct kvm_vcpu *vcpu,
> - const struct sys_reg_desc *r)
> -{
> - return REG_RAZ;
> -}
> -
> -/* cpufeature ID register access trap handlers */
> -
> -static bool access_id_reg(struct kvm_vcpu *vcpu,
> - struct sys_reg_params *p,
> - const struct sys_reg_desc *r)
> -{
> - if (p->is_write)
> - return write_to_read_only(vcpu, p, r);
> -
> - p->regval = read_id_reg(vcpu, r);
> - if (vcpu_has_nv(vcpu))
> - access_nested_id_reg(vcpu, p, r);
> -
> - return true;
> -}
> -
> /* Visibility overrides for SVE-specific control registers */
> static unsigned int sve_visibility(const struct kvm_vcpu *vcpu,
> const struct sys_reg_desc *rd)
> @@ -1320,144 +1153,6 @@ static unsigned int sve_visibility(const struct kvm_vcpu *vcpu,
> return REG_HIDDEN;
> }
>
> -static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
> - const struct sys_reg_desc *rd,
> - u64 val)
> -{
> - u8 csv2, csv3;
> -
> - /*
> - * Allow AA64PFR0_EL1.CSV2 to be set from userspace as long as
> - * it doesn't promise more than what is actually provided (the
> - * guest could otherwise be covered in ectoplasmic residue).
> - */
> - csv2 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV2_SHIFT);
> - if (csv2 > 1 ||
> - (csv2 && arm64_get_spectre_v2_state() != SPECTRE_UNAFFECTED))
> - return -EINVAL;
> -
> - /* Same thing for CSV3 */
> - csv3 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV3_SHIFT);
> - if (csv3 > 1 ||
> - (csv3 && arm64_get_meltdown_state() != SPECTRE_UNAFFECTED))
> - return -EINVAL;
> -
> - /* We can only differ with CSV[23], and anything else is an error */
> - val ^= read_id_reg(vcpu, rd);
> - val &= ~(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2) |
> - ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3));
> - if (val)
> - return -EINVAL;
> -
> - vcpu->kvm->arch.pfr0_csv2 = csv2;
> - vcpu->kvm->arch.pfr0_csv3 = csv3;
> -
> - return 0;
> -}
> -
> -static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
> - const struct sys_reg_desc *rd,
> - u64 val)
> -{
> - u8 pmuver, host_pmuver;
> - bool valid_pmu;
> -
> - host_pmuver = kvm_arm_pmu_get_pmuver_limit();
> -
> - /*
> - * Allow AA64DFR0_EL1.PMUver to be set from userspace as long
> - * as it doesn't promise more than what the HW gives us. We
> - * allow an IMPDEF PMU though, only if no PMU is supported
> - * (KVM backward compatibility handling).
> - */
> - pmuver = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), val);
> - if ((pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF && pmuver > host_pmuver))
> - return -EINVAL;
> -
> - valid_pmu = (pmuver != 0 && pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF);
> -
> - /* Make sure view register and PMU support do match */
> - if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
> - return -EINVAL;
> -
> - /* We can only differ with PMUver, and anything else is an error */
> - val ^= read_id_reg(vcpu, rd);
> - val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> - if (val)
> - return -EINVAL;
> -
> - if (valid_pmu)
> - vcpu->kvm->arch.dfr0_pmuver.imp = pmuver;
> - else
> - vcpu->kvm->arch.dfr0_pmuver.unimp = pmuver;
> -
> - return 0;
> -}
> -
> -static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> - const struct sys_reg_desc *rd,
> - u64 val)
> -{
> - u8 perfmon, host_perfmon;
> - bool valid_pmu;
> -
> - host_perfmon = pmuver_to_perfmon(kvm_arm_pmu_get_pmuver_limit());
> -
> - /*
> - * Allow DFR0_EL1.PerfMon to be set from userspace as long as
> - * it doesn't promise more than what the HW gives us on the
> - * AArch64 side (as everything is emulated with that), and
> - * that this is a PMUv3.
> - */
> - perfmon = FIELD_GET(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), val);
> - if ((perfmon != ID_DFR0_EL1_PerfMon_IMPDEF && perfmon > host_perfmon) ||
> - (perfmon != 0 && perfmon < ID_DFR0_EL1_PerfMon_PMUv3))
> - return -EINVAL;
> -
> - valid_pmu = (perfmon != 0 && perfmon != ID_DFR0_EL1_PerfMon_IMPDEF);
> -
> - /* Make sure view register and PMU support do match */
> - if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
> - return -EINVAL;
> -
> - /* We can only differ with PerfMon, and anything else is an error */
> - val ^= read_id_reg(vcpu, rd);
> - val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> - if (val)
> - return -EINVAL;
> -
> - if (valid_pmu)
> - vcpu->kvm->arch.dfr0_pmuver.imp = perfmon_to_pmuver(perfmon);
> - else
> - vcpu->kvm->arch.dfr0_pmuver.unimp = perfmon_to_pmuver(perfmon);
> -
> - return 0;
> -}
> -
> -/*
> - * cpufeature ID register user accessors
> - *
> - * For now, these registers are immutable for userspace, so no values
> - * are stored, and for set_id_reg() we don't allow the effective value
> - * to be changed.
> - */
> -static int get_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> - u64 *val)
> -{
> - *val = read_id_reg(vcpu, rd);
> - return 0;
> -}
> -
> -static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> - u64 val)
> -{
> - /* This is what we mean by invariant: you can't change it. */
> - if (val != read_id_reg(vcpu, rd))
> - return -EINVAL;
> -
> - return 0;
> -}
> -
> static int get_raz_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> u64 *val)
> {
> @@ -1642,50 +1337,6 @@ static unsigned int elx2_visibility(const struct kvm_vcpu *vcpu,
> .visibility = elx2_visibility, \
> }
>
> -/* sys_reg_desc initialiser for known cpufeature ID registers */
> -#define ID_SANITISED(name) { \
> - SYS_DESC(SYS_##name), \
> - .access = access_id_reg, \
> - .get_user = get_id_reg, \
> - .set_user = set_id_reg, \
> - .visibility = id_visibility, \
> -}
> -
> -/* sys_reg_desc initialiser for known cpufeature ID registers */
> -#define AA32_ID_SANITISED(name) { \
> - SYS_DESC(SYS_##name), \
> - .access = access_id_reg, \
> - .get_user = get_id_reg, \
> - .set_user = set_id_reg, \
> - .visibility = aa32_id_visibility, \
> -}
> -
> -/*
> - * sys_reg_desc initialiser for architecturally unallocated cpufeature ID
> - * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
> - * (1 <= crm < 8, 0 <= Op2 < 8).
> - */
> -#define ID_UNALLOCATED(crm, op2) { \
> - Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> - .access = access_id_reg, \
> - .get_user = get_id_reg, \
> - .set_user = set_id_reg, \
> - .visibility = raz_visibility \
> -}
> -
> -/*
> - * sys_reg_desc initialiser for known ID registers that we hide from guests.
> - * For now, these are exposed just like unallocated ID regs: they appear
> - * RAZ for the guest.
> - */
> -#define ID_HIDDEN(name) { \
> - SYS_DESC(SYS_##name), \
> - .access = access_id_reg, \
> - .get_user = get_id_reg, \
> - .set_user = set_id_reg, \
> - .visibility = raz_visibility, \
> -}
> -
> static bool access_sp_el1(struct kvm_vcpu *vcpu,
> struct sys_reg_params *p,
> const struct sys_reg_desc *r)
> @@ -1776,87 +1427,6 @@ static const struct sys_reg_desc sys_reg_descs[] = {
>
> { SYS_DESC(SYS_MPIDR_EL1), NULL, reset_mpidr, MPIDR_EL1 },
>
> - /*
> - * ID regs: all ID_SANITISED() entries here must have corresponding
> - * entries in arm64_ftr_regs[].
> - */
> -
> - /* AArch64 mappings of the AArch32 ID registers */
> - /* CRm=1 */
> - AA32_ID_SANITISED(ID_PFR0_EL1),
> - AA32_ID_SANITISED(ID_PFR1_EL1),
> - { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
> - .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
> - .visibility = aa32_id_visibility, },
> - ID_HIDDEN(ID_AFR0_EL1),
> - AA32_ID_SANITISED(ID_MMFR0_EL1),
> - AA32_ID_SANITISED(ID_MMFR1_EL1),
> - AA32_ID_SANITISED(ID_MMFR2_EL1),
> - AA32_ID_SANITISED(ID_MMFR3_EL1),
> -
> - /* CRm=2 */
> - AA32_ID_SANITISED(ID_ISAR0_EL1),
> - AA32_ID_SANITISED(ID_ISAR1_EL1),
> - AA32_ID_SANITISED(ID_ISAR2_EL1),
> - AA32_ID_SANITISED(ID_ISAR3_EL1),
> - AA32_ID_SANITISED(ID_ISAR4_EL1),
> - AA32_ID_SANITISED(ID_ISAR5_EL1),
> - AA32_ID_SANITISED(ID_MMFR4_EL1),
> - AA32_ID_SANITISED(ID_ISAR6_EL1),
> -
> - /* CRm=3 */
> - AA32_ID_SANITISED(MVFR0_EL1),
> - AA32_ID_SANITISED(MVFR1_EL1),
> - AA32_ID_SANITISED(MVFR2_EL1),
> - ID_UNALLOCATED(3,3),
> - AA32_ID_SANITISED(ID_PFR2_EL1),
> - ID_HIDDEN(ID_DFR1_EL1),
> - AA32_ID_SANITISED(ID_MMFR5_EL1),
> - ID_UNALLOCATED(3,7),
> -
> - /* AArch64 ID registers */
> - /* CRm=4 */
> - { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
> - .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
> - ID_SANITISED(ID_AA64PFR1_EL1),
> - ID_UNALLOCATED(4,2),
> - ID_UNALLOCATED(4,3),
> - ID_SANITISED(ID_AA64ZFR0_EL1),
> - ID_HIDDEN(ID_AA64SMFR0_EL1),
> - ID_UNALLOCATED(4,6),
> - ID_UNALLOCATED(4,7),
> -
> - /* CRm=5 */
> - { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
> - .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
> - ID_SANITISED(ID_AA64DFR1_EL1),
> - ID_UNALLOCATED(5,2),
> - ID_UNALLOCATED(5,3),
> - ID_HIDDEN(ID_AA64AFR0_EL1),
> - ID_HIDDEN(ID_AA64AFR1_EL1),
> - ID_UNALLOCATED(5,6),
> - ID_UNALLOCATED(5,7),
> -
> - /* CRm=6 */
> - ID_SANITISED(ID_AA64ISAR0_EL1),
> - ID_SANITISED(ID_AA64ISAR1_EL1),
> - ID_SANITISED(ID_AA64ISAR2_EL1),
> - ID_UNALLOCATED(6,3),
> - ID_UNALLOCATED(6,4),
> - ID_UNALLOCATED(6,5),
> - ID_UNALLOCATED(6,6),
> - ID_UNALLOCATED(6,7),
> -
> - /* CRm=7 */
> - ID_SANITISED(ID_AA64MMFR0_EL1),
> - ID_SANITISED(ID_AA64MMFR1_EL1),
> - ID_SANITISED(ID_AA64MMFR2_EL1),
> - ID_UNALLOCATED(7,3),
> - ID_UNALLOCATED(7,4),
> - ID_UNALLOCATED(7,5),
> - ID_UNALLOCATED(7,6),
> - ID_UNALLOCATED(7,7),
> -
> { SYS_DESC(SYS_SCTLR_EL1), access_vm_reg, reset_val, SCTLR_EL1, 0x00C50078 },
> { SYS_DESC(SYS_ACTLR_EL1), access_actlr, reset_actlr, ACTLR_EL1 },
> { SYS_DESC(SYS_CPACR_EL1), NULL, reset_val, CPACR_EL1, 0 },
> @@ -2531,8 +2101,8 @@ static const struct sys_reg_desc cp15_64_regs[] = {
> { SYS_DESC(SYS_AARCH32_CNTP_CVAL), access_arch_timer },
> };
>
> -static bool check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
> - bool is_32)
> +bool check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
> + bool is_32)
> {
> unsigned int i;
>
> @@ -2883,7 +2453,9 @@ static bool emulate_sys_reg(struct kvm_vcpu *vcpu,
> {
> const struct sys_reg_desc *r;
>
> - r = find_reg(params, sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
> + r = kvm_arm_find_id_reg(params);
It appears that this is the only one code that enforces id_regs.c
to expose sys_reg_desc of ID registers. Although I'm not sure your
intention, you might want to create emulate_id_reg(), instead of
exposing that unnecessarily ?
Thank you,
Reiji
> + if (!r)
> + r = find_reg(params, sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
>
> if (likely(r)) {
> perform_access(vcpu, params, r);
> @@ -2912,6 +2484,8 @@ void kvm_reset_sys_regs(struct kvm_vcpu *vcpu)
> {
> unsigned long i;
>
> + kvm_arm_reset_id_regs(vcpu);
> +
> for (i = 0; i < ARRAY_SIZE(sys_reg_descs); i++)
> if (sys_reg_descs[i].reset)
> sys_reg_descs[i].reset(vcpu, &sys_reg_descs[i]);
> @@ -3160,6 +2734,10 @@ int kvm_arm_sys_reg_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg
> if (err != -ENOENT)
> return err;
>
> + err = kvm_arm_get_id_reg(vcpu, reg);
> + if (err != -ENOENT)
> + return err;
> +
> return kvm_sys_reg_get_user(vcpu, reg,
> sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
> }
> @@ -3204,6 +2782,10 @@ int kvm_arm_sys_reg_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg
> if (err != -ENOENT)
> return err;
>
> + err = kvm_arm_set_id_reg(vcpu, reg);
> + if (err != -ENOENT)
> + return err;
> +
> return kvm_sys_reg_set_user(vcpu, reg,
> sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
> }
> @@ -3250,10 +2832,10 @@ static bool copy_reg_to_user(const struct sys_reg_desc *reg, u64 __user **uind)
> return true;
> }
>
> -static int walk_one_sys_reg(const struct kvm_vcpu *vcpu,
> - const struct sys_reg_desc *rd,
> - u64 __user **uind,
> - unsigned int *total)
> +int walk_one_sys_reg(const struct kvm_vcpu *vcpu,
> + const struct sys_reg_desc *rd,
> + u64 __user **uind,
> + unsigned int *total)
> {
> /*
> * Ignore registers we trap but don't save,
> @@ -3294,6 +2876,7 @@ unsigned long kvm_arm_num_sys_reg_descs(struct kvm_vcpu *vcpu)
> {
> return ARRAY_SIZE(invariant_sys_regs)
> + num_demux_regs()
> + + kvm_arm_walk_id_regs(vcpu, (u64 __user *)NULL)
> + walk_sys_regs(vcpu, (u64 __user *)NULL);
> }
>
> @@ -3309,6 +2892,11 @@ int kvm_arm_copy_sys_reg_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
> uindices++;
> }
>
> + err = kvm_arm_walk_id_regs(vcpu, uindices);
> + if (err < 0)
> + return err;
> + uindices += err;
> +
> err = walk_sys_regs(vcpu, uindices);
> if (err < 0)
> return err;
> @@ -3323,6 +2911,7 @@ int __init kvm_sys_reg_table_init(void)
> unsigned int i;
>
> /* Make sure tables are unique and in order. */
> + valid &= kvm_arm_check_idreg_table();
> valid &= check_sysreg_table(sys_reg_descs, ARRAY_SIZE(sys_reg_descs), false);
> valid &= check_sysreg_table(cp14_regs, ARRAY_SIZE(cp14_regs), true);
> valid &= check_sysreg_table(cp14_64_regs, ARRAY_SIZE(cp14_64_regs), true);
> diff --git a/arch/arm64/kvm/sys_regs.h b/arch/arm64/kvm/sys_regs.h
> index 6b11f2cc7146..96a52936d130 100644
> --- a/arch/arm64/kvm/sys_regs.h
> +++ b/arch/arm64/kvm/sys_regs.h
> @@ -210,6 +210,22 @@ find_reg(const struct sys_reg_params *params, const struct sys_reg_desc table[],
> return __inline_bsearch((void *)pval, table, num, sizeof(table[0]), match_sys_reg);
> }
>
> +static inline unsigned int raz_visibility(const struct kvm_vcpu *vcpu,
> + const struct sys_reg_desc *r)
> +{
> + return REG_RAZ;
> +}
> +
> +static inline bool write_to_read_only(struct kvm_vcpu *vcpu,
> + struct sys_reg_params *params,
> + const struct sys_reg_desc *r)
> +{
> + WARN_ONCE(1, "Unexpected sys_reg write to read-only register\n");
> + print_sys_reg_instr(params);
> + kvm_inject_undefined(vcpu);
> + return false;
> +}
> +
> const struct sys_reg_desc *get_reg_by_id(u64 id,
> const struct sys_reg_desc table[],
> unsigned int num);
> @@ -220,6 +236,18 @@ int kvm_sys_reg_get_user(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg,
> const struct sys_reg_desc table[], unsigned int num);
> int kvm_sys_reg_set_user(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg,
> const struct sys_reg_desc table[], unsigned int num);
> +bool check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
> + bool is_32);
> +int walk_one_sys_reg(const struct kvm_vcpu *vcpu,
> + const struct sys_reg_desc *rd,
> + u64 __user **uind,
> + unsigned int *total);
> +const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params);
> +void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu);
> +int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
> +int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
> +bool kvm_arm_check_idreg_table(void);
> +int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind);
>
> #define AA32(_x) .aarch32_map = AA32_##_x
> #define Op0(_x) .Op0 = _x
> --
> 2.39.1.581.gbfd45094c4-goog
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [PATCH v2 1/6] KVM: arm64: Move CPU ID feature registers emulation into a separate file
2023-02-24 1:01 ` Reiji Watanabe
@ 2023-02-24 11:05 ` Marc Zyngier
2023-02-27 2:54 ` Jing Zhang
1 sibling, 0 replies; 16+ messages in thread
From: Marc Zyngier @ 2023-02-24 11:05 UTC (permalink / raw)
To: Reiji Watanabe
Cc: Jing Zhang, KVM, KVMARM, ARMLinux, Oliver Upton, Will Deacon,
Paolo Bonzini, James Morse, Alexandru Elisei, Suzuki K Poulose,
Fuad Tabba, Ricardo Koller, Raghavendra Rao Ananta
On Fri, 24 Feb 2023 01:01:44 +0000,
Reiji Watanabe <reijiw@google.com> wrote:
[...]
> > +const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params)
> > +{
>
> You might want to check if the param indicates the ID register,
> before running the binary search for the ID register table.
> (I have the same comment to kvm_arm_get_id_reg() and
> kvm_arm_set_id_reg()).
It would be much better if the discrimination was done in
emulate_sys_reg(), just like we do for NV[1].
Save yourself pointless search on the critical path, and make the
decoding tree visible in one place.
>
> > + return find_reg(params, id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > +}
> > +
> > +void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> > +{
> > + unsigned long i;
> > +
> > + for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++)
> > + if (id_reg_descs[i].reset)
> > + id_reg_descs[i].reset(vcpu, &id_reg_descs[i]);
> > +}
> > +
> > +int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > +{
> > + return kvm_sys_reg_get_user(vcpu, reg,
> > + id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > +}
> > +
> > +int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > +{
> > + return kvm_sys_reg_set_user(vcpu, reg,
> > + id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > +}
> > +
> > +bool kvm_arm_check_idreg_table(void)
> > +{
> > + return check_sysreg_table(id_reg_descs, ARRAY_SIZE(id_reg_descs), false);
> > +}
> > +
> > +/* Assumed ordered tables, see kvm_sys_reg_table_init. */
>
> I don't think we need this comment, as the code doesn't seem to
> assume that.
Yeah, it only makes sense for the binary search.
Thanks,
M.
[1] https://lore.kernel.org/linux-arm-kernel/20230131092504.2880505-1-maz@kernel.org/T/#mced7be0152816d3a1d02cf8c8b95d3ab3ef4e0c8
--
Without deviation from the norm, progress is not possible.
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [PATCH v2 1/6] KVM: arm64: Move CPU ID feature registers emulation into a separate file
2023-02-24 1:01 ` Reiji Watanabe
2023-02-24 11:05 ` Marc Zyngier
@ 2023-02-27 2:54 ` Jing Zhang
1 sibling, 0 replies; 16+ messages in thread
From: Jing Zhang @ 2023-02-27 2:54 UTC (permalink / raw)
To: Reiji Watanabe
Cc: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton, Will Deacon,
Paolo Bonzini, James Morse, Alexandru Elisei, Suzuki K Poulose,
Fuad Tabba, Ricardo Koller, Raghavendra Rao Ananta
Hi Reiji, Marc,
On Thu, Feb 23, 2023 at 5:02 PM Reiji Watanabe <reijiw@google.com> wrote:
>
> Hi Jing,
>
> On Sun, Feb 12, 2023 at 1:58 PM Jing Zhang <jingzhangos@google.com> wrote:
> >
> > Create a new file id_regs.c for CPU ID feature registers emulation code,
> > which are moved from sys_regs.c and tweak sys_regs code accordingly.
> >
> > No functional change intended.
> >
> > Signed-off-by: Jing Zhang <jingzhangos@google.com>
> > ---
> > arch/arm64/kvm/Makefile | 2 +-
> > arch/arm64/kvm/id_regs.c | 486 ++++++++++++++++++++++++++++++++++++++
> > arch/arm64/kvm/sys_regs.c | 463 ++----------------------------------
> > arch/arm64/kvm/sys_regs.h | 28 +++
> > 4 files changed, 541 insertions(+), 438 deletions(-)
> > create mode 100644 arch/arm64/kvm/id_regs.c
> >
> > diff --git a/arch/arm64/kvm/Makefile b/arch/arm64/kvm/Makefile
> > index c0c050e53157..a6a315fcd81e 100644
> > --- a/arch/arm64/kvm/Makefile
> > +++ b/arch/arm64/kvm/Makefile
> > @@ -13,7 +13,7 @@ obj-$(CONFIG_KVM) += hyp/
> > kvm-y += arm.o mmu.o mmio.o psci.o hypercalls.o pvtime.o \
> > inject_fault.o va_layout.o handle_exit.o \
> > guest.o debug.o reset.o sys_regs.o stacktrace.o \
> > - vgic-sys-reg-v3.o fpsimd.o pkvm.o \
> > + vgic-sys-reg-v3.o fpsimd.o pkvm.o id_regs.o \
> > arch_timer.o trng.o vmid.o emulate-nested.o nested.o \
> > vgic/vgic.o vgic/vgic-init.o \
> > vgic/vgic-irqfd.o vgic/vgic-v2.o \
> > diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
> > new file mode 100644
> > index 000000000000..7f30d683de21
> > --- /dev/null
> > +++ b/arch/arm64/kvm/id_regs.c
> > @@ -0,0 +1,486 @@
> > +// SPDX-License-Identifier: GPL-2.0-only
> > +/*
> > + * Copyright (C) 2023 - Google LLC
> > + * Author: Jing Zhang <jingzhangos@google.com>
> > + *
> > + * Moved from arch/arm64/kvm/sys_regs.c
> > + * Copyright (C) 2012,2013 - ARM Ltd
> > + * Author: Marc Zyngier <marc.zyngier@arm.com>
> > + */
> > +
> > +#include <linux/bitfield.h>
> > +#include <linux/bsearch.h>
> > +#include <linux/kvm_host.h>
> > +#include <asm/kvm_emulate.h>
> > +#include <asm/sysreg.h>
> > +#include <asm/cpufeature.h>
> > +#include <asm/kvm_nested.h>
> > +
> > +#include "sys_regs.h"
> > +
> > +static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> > +{
> > + if (kvm_vcpu_has_pmu(vcpu))
> > + return vcpu->kvm->arch.dfr0_pmuver.imp;
> > +
> > + return vcpu->kvm->arch.dfr0_pmuver.unimp;
> > +}
> > +
> > +static u8 perfmon_to_pmuver(u8 perfmon)
> > +{
> > + switch (perfmon) {
> > + case ID_DFR0_EL1_PerfMon_PMUv3:
> > + return ID_AA64DFR0_EL1_PMUVer_IMP;
> > + case ID_DFR0_EL1_PerfMon_IMPDEF:
> > + return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
> > + default:
> > + /* Anything ARMv8.1+ and NI have the same value. For now. */
> > + return perfmon;
> > + }
> > +}
> > +
> > +static u8 pmuver_to_perfmon(u8 pmuver)
> > +{
> > + switch (pmuver) {
> > + case ID_AA64DFR0_EL1_PMUVer_IMP:
> > + return ID_DFR0_EL1_PerfMon_PMUv3;
> > + case ID_AA64DFR0_EL1_PMUVer_IMP_DEF:
> > + return ID_DFR0_EL1_PerfMon_IMPDEF;
> > + default:
> > + /* Anything ARMv8.1+ and NI have the same value. For now. */
> > + return pmuver;
> > + }
> > +}
> > +
> > +/* Read a sanitised cpufeature ID register by sys_reg_desc */
> > +static u64 read_id_reg(const struct kvm_vcpu *vcpu, struct sys_reg_desc const *r)
> > +{
> > + u32 id = reg_to_encoding(r);
> > + u64 val;
> > +
> > + if (sysreg_visible_as_raz(vcpu, r))
> > + return 0;
> > +
> > + val = read_sanitised_ftr_reg(id);
> > +
> > + switch (id) {
> > + case SYS_ID_AA64PFR0_EL1:
> > + if (!vcpu_has_sve(vcpu))
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_SVE);
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_AMU);
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
> > + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2),
> > + (u64)vcpu->kvm->arch.pfr0_csv2);
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
> > + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3),
> > + (u64)vcpu->kvm->arch.pfr0_csv3);
> > + if (kvm_vgic_global_state.type == VGIC_V3) {
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC);
> > + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC), 1);
> > + }
> > + break;
> > + case SYS_ID_AA64PFR1_EL1:
> > + if (!kvm_has_mte(vcpu->kvm))
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_MTE);
> > +
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_SME);
> > + break;
> > + case SYS_ID_AA64ISAR1_EL1:
> > + if (!vcpu_has_ptrauth(vcpu))
> > + val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_APA) |
> > + ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_API) |
> > + ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPA) |
> > + ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPI));
> > + break;
> > + case SYS_ID_AA64ISAR2_EL1:
> > + if (!vcpu_has_ptrauth(vcpu))
> > + val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_APA3) |
> > + ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_GPA3));
> > + if (!cpus_have_final_cap(ARM64_HAS_WFXT))
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_WFxT);
> > + break;
> > + case SYS_ID_AA64DFR0_EL1:
> > + /* Limit debug to ARMv8.0 */
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer);
> > + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer), 6);
> > + /* Set PMUver to the required version */
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> > + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
> > + vcpu_pmuver(vcpu));
> > + /* Hide SPE from guests */
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMSVer);
> > + break;
> > + case SYS_ID_DFR0_EL1:
> > + val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> > + val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon),
> > + pmuver_to_perfmon(vcpu_pmuver(vcpu)));
> > + break;
> > + case SYS_ID_AA64MMFR2_EL1:
> > + val &= ~ID_AA64MMFR2_EL1_CCIDX_MASK;
> > + break;
> > + case SYS_ID_MMFR4_EL1:
> > + val &= ~ARM64_FEATURE_MASK(ID_MMFR4_EL1_CCIDX);
> > + break;
> > + }
> > +
> > + return val;
> > +}
> > +
> > +/* cpufeature ID register access trap handlers */
> > +
> > +static bool access_id_reg(struct kvm_vcpu *vcpu,
> > + struct sys_reg_params *p,
> > + const struct sys_reg_desc *r)
> > +{
> > + if (p->is_write)
> > + return write_to_read_only(vcpu, p, r);
> > +
> > + p->regval = read_id_reg(vcpu, r);
> > + if (vcpu_has_nv(vcpu))
> > + access_nested_id_reg(vcpu, p, r);
> > +
> > + return true;
> > +}
> > +
> > +/*
> > + * cpufeature ID register user accessors
> > + *
> > + * For now, these registers are immutable for userspace, so no values
> > + * are stored, and for set_id_reg() we don't allow the effective value
> > + * to be changed.
> > + */
> > +static int get_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> > + u64 *val)
> > +{
> > + *val = read_id_reg(vcpu, rd);
> > + return 0;
> > +}
> > +
> > +static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> > + u64 val)
> > +{
> > + /* This is what we mean by invariant: you can't change it. */
> > + if (val != read_id_reg(vcpu, rd))
> > + return -EINVAL;
> > +
> > + return 0;
> > +}
> > +
> > +static unsigned int id_visibility(const struct kvm_vcpu *vcpu,
> > + const struct sys_reg_desc *r)
> > +{
> > + u32 id = reg_to_encoding(r);
> > +
> > + switch (id) {
> > + case SYS_ID_AA64ZFR0_EL1:
> > + if (!vcpu_has_sve(vcpu))
> > + return REG_RAZ;
> > + break;
> > + }
> > +
> > + return 0;
> > +}
> > +
> > +static unsigned int aa32_id_visibility(const struct kvm_vcpu *vcpu,
> > + const struct sys_reg_desc *r)
> > +{
> > + /*
> > + * AArch32 ID registers are UNKNOWN if AArch32 isn't implemented at any
> > + * EL. Promote to RAZ/WI in order to guarantee consistency between
> > + * systems.
> > + */
> > + if (!kvm_supports_32bit_el0())
> > + return REG_RAZ | REG_USER_WI;
> > +
> > + return id_visibility(vcpu, r);
> > +}
> > +
> > +static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
> > + const struct sys_reg_desc *rd,
> > + u64 val)
> > +{
> > + u8 csv2, csv3;
> > +
> > + /*
> > + * Allow AA64PFR0_EL1.CSV2 to be set from userspace as long as
> > + * it doesn't promise more than what is actually provided (the
> > + * guest could otherwise be covered in ectoplasmic residue).
> > + */
> > + csv2 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV2_SHIFT);
> > + if (csv2 > 1 ||
> > + (csv2 && arm64_get_spectre_v2_state() != SPECTRE_UNAFFECTED))
> > + return -EINVAL;
> > +
> > + /* Same thing for CSV3 */
> > + csv3 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV3_SHIFT);
> > + if (csv3 > 1 ||
> > + (csv3 && arm64_get_meltdown_state() != SPECTRE_UNAFFECTED))
> > + return -EINVAL;
> > +
> > + /* We can only differ with CSV[23], and anything else is an error */
> > + val ^= read_id_reg(vcpu, rd);
> > + val &= ~(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2) |
> > + ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3));
> > + if (val)
> > + return -EINVAL;
> > +
> > + vcpu->kvm->arch.pfr0_csv2 = csv2;
> > + vcpu->kvm->arch.pfr0_csv3 = csv3;
> > +
> > + return 0;
> > +}
> > +
> > +static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
> > + const struct sys_reg_desc *rd,
> > + u64 val)
> > +{
> > + u8 pmuver, host_pmuver;
> > + bool valid_pmu;
> > +
> > + host_pmuver = kvm_arm_pmu_get_pmuver_limit();
> > +
> > + /*
> > + * Allow AA64DFR0_EL1.PMUver to be set from userspace as long
> > + * as it doesn't promise more than what the HW gives us. We
> > + * allow an IMPDEF PMU though, only if no PMU is supported
> > + * (KVM backward compatibility handling).
> > + */
> > + pmuver = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), val);
> > + if ((pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF && pmuver > host_pmuver))
> > + return -EINVAL;
> > +
> > + valid_pmu = (pmuver != 0 && pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF);
> > +
> > + /* Make sure view register and PMU support do match */
> > + if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
> > + return -EINVAL;
> > +
> > + /* We can only differ with PMUver, and anything else is an error */
> > + val ^= read_id_reg(vcpu, rd);
> > + val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> > + if (val)
> > + return -EINVAL;
> > +
> > + if (valid_pmu)
> > + vcpu->kvm->arch.dfr0_pmuver.imp = pmuver;
> > + else
> > + vcpu->kvm->arch.dfr0_pmuver.unimp = pmuver;
> > +
> > + return 0;
> > +}
> > +
> > +static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > + const struct sys_reg_desc *rd,
> > + u64 val)
> > +{
> > + u8 perfmon, host_perfmon;
> > + bool valid_pmu;
> > +
> > + host_perfmon = pmuver_to_perfmon(kvm_arm_pmu_get_pmuver_limit());
> > +
> > + /*
> > + * Allow DFR0_EL1.PerfMon to be set from userspace as long as
> > + * it doesn't promise more than what the HW gives us on the
> > + * AArch64 side (as everything is emulated with that), and
> > + * that this is a PMUv3.
> > + */
> > + perfmon = FIELD_GET(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), val);
> > + if ((perfmon != ID_DFR0_EL1_PerfMon_IMPDEF && perfmon > host_perfmon) ||
> > + (perfmon != 0 && perfmon < ID_DFR0_EL1_PerfMon_PMUv3))
> > + return -EINVAL;
> > +
> > + valid_pmu = (perfmon != 0 && perfmon != ID_DFR0_EL1_PerfMon_IMPDEF);
> > +
> > + /* Make sure view register and PMU support do match */
> > + if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
> > + return -EINVAL;
> > +
> > + /* We can only differ with PerfMon, and anything else is an error */
> > + val ^= read_id_reg(vcpu, rd);
> > + val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> > + if (val)
> > + return -EINVAL;
> > +
> > + if (valid_pmu)
> > + vcpu->kvm->arch.dfr0_pmuver.imp = perfmon_to_pmuver(perfmon);
> > + else
> > + vcpu->kvm->arch.dfr0_pmuver.unimp = perfmon_to_pmuver(perfmon);
> > +
> > + return 0;
> > +}
> > +
> > +/* sys_reg_desc initialiser for known cpufeature ID registers */
> > +#define ID_SANITISED(name) { \
> > + SYS_DESC(SYS_##name), \
> > + .access = access_id_reg, \
> > + .get_user = get_id_reg, \
> > + .set_user = set_id_reg, \
> > + .visibility = id_visibility, \
> > +}
> > +
> > +/* sys_reg_desc initialiser for known cpufeature ID registers */
> > +#define AA32_ID_SANITISED(name) { \
> > + SYS_DESC(SYS_##name), \
> > + .access = access_id_reg, \
> > + .get_user = get_id_reg, \
> > + .set_user = set_id_reg, \
> > + .visibility = aa32_id_visibility, \
> > +}
> > +
> > +/*
> > + * sys_reg_desc initialiser for architecturally unallocated cpufeature ID
> > + * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
> > + * (1 <= crm < 8, 0 <= Op2 < 8).
> > + */
> > +#define ID_UNALLOCATED(crm, op2) { \
> > + Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> > + .access = access_id_reg, \
> > + .get_user = get_id_reg, \
> > + .set_user = set_id_reg, \
> > + .visibility = raz_visibility \
> > +}
> > +
> > +/*
> > + * sys_reg_desc initialiser for known ID registers that we hide from guests.
> > + * For now, these are exposed just like unallocated ID regs: they appear
> > + * RAZ for the guest.
> > + */
> > +#define ID_HIDDEN(name) { \
> > + SYS_DESC(SYS_##name), \
> > + .access = access_id_reg, \
> > + .get_user = get_id_reg, \
> > + .set_user = set_id_reg, \
> > + .visibility = raz_visibility, \
> > +}
> > +
> > +static const struct sys_reg_desc id_reg_descs[] = {
> > + /*
> > + * ID regs: all ID_SANITISED() entries here must have corresponding
> > + * entries in arm64_ftr_regs[].
> > + */
> > +
> > + /* AArch64 mappings of the AArch32 ID registers */
> > + /* CRm=1 */
> > + AA32_ID_SANITISED(ID_PFR0_EL1),
> > + AA32_ID_SANITISED(ID_PFR1_EL1),
> > + { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
> > + .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
> > + .visibility = aa32_id_visibility, },
> > + ID_HIDDEN(ID_AFR0_EL1),
> > + AA32_ID_SANITISED(ID_MMFR0_EL1),
> > + AA32_ID_SANITISED(ID_MMFR1_EL1),
> > + AA32_ID_SANITISED(ID_MMFR2_EL1),
> > + AA32_ID_SANITISED(ID_MMFR3_EL1),
> > +
> > + /* CRm=2 */
> > + AA32_ID_SANITISED(ID_ISAR0_EL1),
> > + AA32_ID_SANITISED(ID_ISAR1_EL1),
> > + AA32_ID_SANITISED(ID_ISAR2_EL1),
> > + AA32_ID_SANITISED(ID_ISAR3_EL1),
> > + AA32_ID_SANITISED(ID_ISAR4_EL1),
> > + AA32_ID_SANITISED(ID_ISAR5_EL1),
> > + AA32_ID_SANITISED(ID_MMFR4_EL1),
> > + AA32_ID_SANITISED(ID_ISAR6_EL1),
> > +
> > + /* CRm=3 */
> > + AA32_ID_SANITISED(MVFR0_EL1),
> > + AA32_ID_SANITISED(MVFR1_EL1),
> > + AA32_ID_SANITISED(MVFR2_EL1),
> > + ID_UNALLOCATED(3, 3),
> > + AA32_ID_SANITISED(ID_PFR2_EL1),
> > + ID_HIDDEN(ID_DFR1_EL1),
> > + AA32_ID_SANITISED(ID_MMFR5_EL1),
> > + ID_UNALLOCATED(3, 7),
> > +
> > + /* AArch64 ID registers */
> > + /* CRm=4 */
> > + { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
> > + .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
> > + ID_SANITISED(ID_AA64PFR1_EL1),
> > + ID_UNALLOCATED(4, 2),
> > + ID_UNALLOCATED(4, 3),
> > + ID_SANITISED(ID_AA64ZFR0_EL1),
> > + ID_HIDDEN(ID_AA64SMFR0_EL1),
> > + ID_UNALLOCATED(4, 6),
> > + ID_UNALLOCATED(4, 7),
> > +
> > + /* CRm=5 */
> > + { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
> > + .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
> > + ID_SANITISED(ID_AA64DFR1_EL1),
> > + ID_UNALLOCATED(5, 2),
> > + ID_UNALLOCATED(5, 3),
> > + ID_HIDDEN(ID_AA64AFR0_EL1),
> > + ID_HIDDEN(ID_AA64AFR1_EL1),
> > + ID_UNALLOCATED(5, 6),
> > + ID_UNALLOCATED(5, 7),
> > +
> > + /* CRm=6 */
> > + ID_SANITISED(ID_AA64ISAR0_EL1),
> > + ID_SANITISED(ID_AA64ISAR1_EL1),
> > + ID_SANITISED(ID_AA64ISAR2_EL1),
> > + ID_UNALLOCATED(6, 3),
> > + ID_UNALLOCATED(6, 4),
> > + ID_UNALLOCATED(6, 5),
> > + ID_UNALLOCATED(6, 6),
> > + ID_UNALLOCATED(6, 7),
> > +
> > + /* CRm=7 */
> > + ID_SANITISED(ID_AA64MMFR0_EL1),
> > + ID_SANITISED(ID_AA64MMFR1_EL1),
> > + ID_SANITISED(ID_AA64MMFR2_EL1),
> > + ID_UNALLOCATED(7, 3),
> > + ID_UNALLOCATED(7, 4),
> > + ID_UNALLOCATED(7, 5),
> > + ID_UNALLOCATED(7, 6),
> > + ID_UNALLOCATED(7, 7),
> > +};
> > +
> > +const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params)
> > +{
>
> You might want to check if the param indicates the ID register,
> before running the binary search for the ID register table.
> (I have the same comment to kvm_arm_get_id_reg() and
> kvm_arm_set_id_reg()).
>
The check (is_id_reg()) was added in the 5th commit when ID register
descriptor was added.
> > + return find_reg(params, id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > +}
> > +
> > +void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> > +{
> > + unsigned long i;
> > +
> > + for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++)
> > + if (id_reg_descs[i].reset)
> > + id_reg_descs[i].reset(vcpu, &id_reg_descs[i]);
> > +}
> > +
> > +int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > +{
> > + return kvm_sys_reg_get_user(vcpu, reg,
> > + id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > +}
> > +
> > +int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > +{
> > + return kvm_sys_reg_set_user(vcpu, reg,
> > + id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > +}
> > +
> > +bool kvm_arm_check_idreg_table(void)
> > +{
> > + return check_sysreg_table(id_reg_descs, ARRAY_SIZE(id_reg_descs), false);
> > +}
> > +
> > +/* Assumed ordered tables, see kvm_sys_reg_table_init. */
>
> I don't think we need this comment, as the code doesn't seem to assume that.
>
Sure, will remove it.
> > +int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind)
> > +{
> > + const struct sys_reg_desc *i2, *end2;
> > + unsigned int total = 0;
> > + int err;
> > +
> > + i2 = id_reg_descs;
> > + end2 = id_reg_descs + ARRAY_SIZE(id_reg_descs);
> > +
> > + while (i2 != end2) {
> > + err = walk_one_sys_reg(vcpu, i2++, &uind, &total);
> > + if (err)
> > + return err;
> > + }
> > + return total;
> > +}
> > diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
> > index 53749d3a0996..3b23b7a67eb5 100644
> > --- a/arch/arm64/kvm/sys_regs.c
> > +++ b/arch/arm64/kvm/sys_regs.c
> > @@ -53,16 +53,6 @@ static bool read_from_write_only(struct kvm_vcpu *vcpu,
> > return false;
> > }
> >
> > -static bool write_to_read_only(struct kvm_vcpu *vcpu,
> > - struct sys_reg_params *params,
> > - const struct sys_reg_desc *r)
> > -{
> > - WARN_ONCE(1, "Unexpected sys_reg write to read-only register\n");
> > - print_sys_reg_instr(params);
> > - kvm_inject_undefined(vcpu);
> > - return false;
> > -}
> > -
> > u64 vcpu_read_sys_reg(const struct kvm_vcpu *vcpu, int reg)
> > {
> > u64 val = 0x8badf00d8badf00d;
> > @@ -1153,163 +1143,6 @@ static bool access_arch_timer(struct kvm_vcpu *vcpu,
> > return true;
> > }
> >
> > -static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> > -{
> > - if (kvm_vcpu_has_pmu(vcpu))
> > - return vcpu->kvm->arch.dfr0_pmuver.imp;
> > -
> > - return vcpu->kvm->arch.dfr0_pmuver.unimp;
> > -}
> > -
> > -static u8 perfmon_to_pmuver(u8 perfmon)
> > -{
> > - switch (perfmon) {
> > - case ID_DFR0_EL1_PerfMon_PMUv3:
> > - return ID_AA64DFR0_EL1_PMUVer_IMP;
> > - case ID_DFR0_EL1_PerfMon_IMPDEF:
> > - return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
> > - default:
> > - /* Anything ARMv8.1+ and NI have the same value. For now. */
> > - return perfmon;
> > - }
> > -}
> > -
> > -static u8 pmuver_to_perfmon(u8 pmuver)
> > -{
> > - switch (pmuver) {
> > - case ID_AA64DFR0_EL1_PMUVer_IMP:
> > - return ID_DFR0_EL1_PerfMon_PMUv3;
> > - case ID_AA64DFR0_EL1_PMUVer_IMP_DEF:
> > - return ID_DFR0_EL1_PerfMon_IMPDEF;
> > - default:
> > - /* Anything ARMv8.1+ and NI have the same value. For now. */
> > - return pmuver;
> > - }
> > -}
> > -
> > -/* Read a sanitised cpufeature ID register by sys_reg_desc */
> > -static u64 read_id_reg(const struct kvm_vcpu *vcpu, struct sys_reg_desc const *r)
> > -{
> > - u32 id = reg_to_encoding(r);
> > - u64 val;
> > -
> > - if (sysreg_visible_as_raz(vcpu, r))
> > - return 0;
> > -
> > - val = read_sanitised_ftr_reg(id);
> > -
> > - switch (id) {
> > - case SYS_ID_AA64PFR0_EL1:
> > - if (!vcpu_has_sve(vcpu))
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_SVE);
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_AMU);
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
> > - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2), (u64)vcpu->kvm->arch.pfr0_csv2);
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
> > - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3), (u64)vcpu->kvm->arch.pfr0_csv3);
> > - if (kvm_vgic_global_state.type == VGIC_V3) {
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC);
> > - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC), 1);
> > - }
> > - break;
> > - case SYS_ID_AA64PFR1_EL1:
> > - if (!kvm_has_mte(vcpu->kvm))
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_MTE);
> > -
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64PFR1_EL1_SME);
> > - break;
> > - case SYS_ID_AA64ISAR1_EL1:
> > - if (!vcpu_has_ptrauth(vcpu))
> > - val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_APA) |
> > - ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_API) |
> > - ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPA) |
> > - ARM64_FEATURE_MASK(ID_AA64ISAR1_EL1_GPI));
> > - break;
> > - case SYS_ID_AA64ISAR2_EL1:
> > - if (!vcpu_has_ptrauth(vcpu))
> > - val &= ~(ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_APA3) |
> > - ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_GPA3));
> > - if (!cpus_have_final_cap(ARM64_HAS_WFXT))
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_WFxT);
> > - break;
> > - case SYS_ID_AA64DFR0_EL1:
> > - /* Limit debug to ARMv8.0 */
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer);
> > - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer), 6);
> > - /* Set PMUver to the required version */
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> > - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
> > - vcpu_pmuver(vcpu));
> > - /* Hide SPE from guests */
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMSVer);
> > - break;
> > - case SYS_ID_DFR0_EL1:
> > - val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> > - val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon),
> > - pmuver_to_perfmon(vcpu_pmuver(vcpu)));
> > - break;
> > - case SYS_ID_AA64MMFR2_EL1:
> > - val &= ~ID_AA64MMFR2_EL1_CCIDX_MASK;
> > - break;
> > - case SYS_ID_MMFR4_EL1:
> > - val &= ~ARM64_FEATURE_MASK(ID_MMFR4_EL1_CCIDX);
> > - break;
> > - }
> > -
> > - return val;
> > -}
> > -
> > -static unsigned int id_visibility(const struct kvm_vcpu *vcpu,
> > - const struct sys_reg_desc *r)
> > -{
> > - u32 id = reg_to_encoding(r);
> > -
> > - switch (id) {
> > - case SYS_ID_AA64ZFR0_EL1:
> > - if (!vcpu_has_sve(vcpu))
> > - return REG_RAZ;
> > - break;
> > - }
> > -
> > - return 0;
> > -}
> > -
> > -static unsigned int aa32_id_visibility(const struct kvm_vcpu *vcpu,
> > - const struct sys_reg_desc *r)
> > -{
> > - /*
> > - * AArch32 ID registers are UNKNOWN if AArch32 isn't implemented at any
> > - * EL. Promote to RAZ/WI in order to guarantee consistency between
> > - * systems.
> > - */
> > - if (!kvm_supports_32bit_el0())
> > - return REG_RAZ | REG_USER_WI;
> > -
> > - return id_visibility(vcpu, r);
> > -}
> > -
> > -static unsigned int raz_visibility(const struct kvm_vcpu *vcpu,
> > - const struct sys_reg_desc *r)
> > -{
> > - return REG_RAZ;
> > -}
> > -
> > -/* cpufeature ID register access trap handlers */
> > -
> > -static bool access_id_reg(struct kvm_vcpu *vcpu,
> > - struct sys_reg_params *p,
> > - const struct sys_reg_desc *r)
> > -{
> > - if (p->is_write)
> > - return write_to_read_only(vcpu, p, r);
> > -
> > - p->regval = read_id_reg(vcpu, r);
> > - if (vcpu_has_nv(vcpu))
> > - access_nested_id_reg(vcpu, p, r);
> > -
> > - return true;
> > -}
> > -
> > /* Visibility overrides for SVE-specific control registers */
> > static unsigned int sve_visibility(const struct kvm_vcpu *vcpu,
> > const struct sys_reg_desc *rd)
> > @@ -1320,144 +1153,6 @@ static unsigned int sve_visibility(const struct kvm_vcpu *vcpu,
> > return REG_HIDDEN;
> > }
> >
> > -static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
> > - const struct sys_reg_desc *rd,
> > - u64 val)
> > -{
> > - u8 csv2, csv3;
> > -
> > - /*
> > - * Allow AA64PFR0_EL1.CSV2 to be set from userspace as long as
> > - * it doesn't promise more than what is actually provided (the
> > - * guest could otherwise be covered in ectoplasmic residue).
> > - */
> > - csv2 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV2_SHIFT);
> > - if (csv2 > 1 ||
> > - (csv2 && arm64_get_spectre_v2_state() != SPECTRE_UNAFFECTED))
> > - return -EINVAL;
> > -
> > - /* Same thing for CSV3 */
> > - csv3 = cpuid_feature_extract_unsigned_field(val, ID_AA64PFR0_EL1_CSV3_SHIFT);
> > - if (csv3 > 1 ||
> > - (csv3 && arm64_get_meltdown_state() != SPECTRE_UNAFFECTED))
> > - return -EINVAL;
> > -
> > - /* We can only differ with CSV[23], and anything else is an error */
> > - val ^= read_id_reg(vcpu, rd);
> > - val &= ~(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2) |
> > - ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3));
> > - if (val)
> > - return -EINVAL;
> > -
> > - vcpu->kvm->arch.pfr0_csv2 = csv2;
> > - vcpu->kvm->arch.pfr0_csv3 = csv3;
> > -
> > - return 0;
> > -}
> > -
> > -static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
> > - const struct sys_reg_desc *rd,
> > - u64 val)
> > -{
> > - u8 pmuver, host_pmuver;
> > - bool valid_pmu;
> > -
> > - host_pmuver = kvm_arm_pmu_get_pmuver_limit();
> > -
> > - /*
> > - * Allow AA64DFR0_EL1.PMUver to be set from userspace as long
> > - * as it doesn't promise more than what the HW gives us. We
> > - * allow an IMPDEF PMU though, only if no PMU is supported
> > - * (KVM backward compatibility handling).
> > - */
> > - pmuver = FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), val);
> > - if ((pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF && pmuver > host_pmuver))
> > - return -EINVAL;
> > -
> > - valid_pmu = (pmuver != 0 && pmuver != ID_AA64DFR0_EL1_PMUVer_IMP_DEF);
> > -
> > - /* Make sure view register and PMU support do match */
> > - if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
> > - return -EINVAL;
> > -
> > - /* We can only differ with PMUver, and anything else is an error */
> > - val ^= read_id_reg(vcpu, rd);
> > - val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> > - if (val)
> > - return -EINVAL;
> > -
> > - if (valid_pmu)
> > - vcpu->kvm->arch.dfr0_pmuver.imp = pmuver;
> > - else
> > - vcpu->kvm->arch.dfr0_pmuver.unimp = pmuver;
> > -
> > - return 0;
> > -}
> > -
> > -static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > - const struct sys_reg_desc *rd,
> > - u64 val)
> > -{
> > - u8 perfmon, host_perfmon;
> > - bool valid_pmu;
> > -
> > - host_perfmon = pmuver_to_perfmon(kvm_arm_pmu_get_pmuver_limit());
> > -
> > - /*
> > - * Allow DFR0_EL1.PerfMon to be set from userspace as long as
> > - * it doesn't promise more than what the HW gives us on the
> > - * AArch64 side (as everything is emulated with that), and
> > - * that this is a PMUv3.
> > - */
> > - perfmon = FIELD_GET(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), val);
> > - if ((perfmon != ID_DFR0_EL1_PerfMon_IMPDEF && perfmon > host_perfmon) ||
> > - (perfmon != 0 && perfmon < ID_DFR0_EL1_PerfMon_PMUv3))
> > - return -EINVAL;
> > -
> > - valid_pmu = (perfmon != 0 && perfmon != ID_DFR0_EL1_PerfMon_IMPDEF);
> > -
> > - /* Make sure view register and PMU support do match */
> > - if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
> > - return -EINVAL;
> > -
> > - /* We can only differ with PerfMon, and anything else is an error */
> > - val ^= read_id_reg(vcpu, rd);
> > - val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> > - if (val)
> > - return -EINVAL;
> > -
> > - if (valid_pmu)
> > - vcpu->kvm->arch.dfr0_pmuver.imp = perfmon_to_pmuver(perfmon);
> > - else
> > - vcpu->kvm->arch.dfr0_pmuver.unimp = perfmon_to_pmuver(perfmon);
> > -
> > - return 0;
> > -}
> > -
> > -/*
> > - * cpufeature ID register user accessors
> > - *
> > - * For now, these registers are immutable for userspace, so no values
> > - * are stored, and for set_id_reg() we don't allow the effective value
> > - * to be changed.
> > - */
> > -static int get_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> > - u64 *val)
> > -{
> > - *val = read_id_reg(vcpu, rd);
> > - return 0;
> > -}
> > -
> > -static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> > - u64 val)
> > -{
> > - /* This is what we mean by invariant: you can't change it. */
> > - if (val != read_id_reg(vcpu, rd))
> > - return -EINVAL;
> > -
> > - return 0;
> > -}
> > -
> > static int get_raz_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
> > u64 *val)
> > {
> > @@ -1642,50 +1337,6 @@ static unsigned int elx2_visibility(const struct kvm_vcpu *vcpu,
> > .visibility = elx2_visibility, \
> > }
> >
> > -/* sys_reg_desc initialiser for known cpufeature ID registers */
> > -#define ID_SANITISED(name) { \
> > - SYS_DESC(SYS_##name), \
> > - .access = access_id_reg, \
> > - .get_user = get_id_reg, \
> > - .set_user = set_id_reg, \
> > - .visibility = id_visibility, \
> > -}
> > -
> > -/* sys_reg_desc initialiser for known cpufeature ID registers */
> > -#define AA32_ID_SANITISED(name) { \
> > - SYS_DESC(SYS_##name), \
> > - .access = access_id_reg, \
> > - .get_user = get_id_reg, \
> > - .set_user = set_id_reg, \
> > - .visibility = aa32_id_visibility, \
> > -}
> > -
> > -/*
> > - * sys_reg_desc initialiser for architecturally unallocated cpufeature ID
> > - * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
> > - * (1 <= crm < 8, 0 <= Op2 < 8).
> > - */
> > -#define ID_UNALLOCATED(crm, op2) { \
> > - Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> > - .access = access_id_reg, \
> > - .get_user = get_id_reg, \
> > - .set_user = set_id_reg, \
> > - .visibility = raz_visibility \
> > -}
> > -
> > -/*
> > - * sys_reg_desc initialiser for known ID registers that we hide from guests.
> > - * For now, these are exposed just like unallocated ID regs: they appear
> > - * RAZ for the guest.
> > - */
> > -#define ID_HIDDEN(name) { \
> > - SYS_DESC(SYS_##name), \
> > - .access = access_id_reg, \
> > - .get_user = get_id_reg, \
> > - .set_user = set_id_reg, \
> > - .visibility = raz_visibility, \
> > -}
> > -
> > static bool access_sp_el1(struct kvm_vcpu *vcpu,
> > struct sys_reg_params *p,
> > const struct sys_reg_desc *r)
> > @@ -1776,87 +1427,6 @@ static const struct sys_reg_desc sys_reg_descs[] = {
> >
> > { SYS_DESC(SYS_MPIDR_EL1), NULL, reset_mpidr, MPIDR_EL1 },
> >
> > - /*
> > - * ID regs: all ID_SANITISED() entries here must have corresponding
> > - * entries in arm64_ftr_regs[].
> > - */
> > -
> > - /* AArch64 mappings of the AArch32 ID registers */
> > - /* CRm=1 */
> > - AA32_ID_SANITISED(ID_PFR0_EL1),
> > - AA32_ID_SANITISED(ID_PFR1_EL1),
> > - { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
> > - .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
> > - .visibility = aa32_id_visibility, },
> > - ID_HIDDEN(ID_AFR0_EL1),
> > - AA32_ID_SANITISED(ID_MMFR0_EL1),
> > - AA32_ID_SANITISED(ID_MMFR1_EL1),
> > - AA32_ID_SANITISED(ID_MMFR2_EL1),
> > - AA32_ID_SANITISED(ID_MMFR3_EL1),
> > -
> > - /* CRm=2 */
> > - AA32_ID_SANITISED(ID_ISAR0_EL1),
> > - AA32_ID_SANITISED(ID_ISAR1_EL1),
> > - AA32_ID_SANITISED(ID_ISAR2_EL1),
> > - AA32_ID_SANITISED(ID_ISAR3_EL1),
> > - AA32_ID_SANITISED(ID_ISAR4_EL1),
> > - AA32_ID_SANITISED(ID_ISAR5_EL1),
> > - AA32_ID_SANITISED(ID_MMFR4_EL1),
> > - AA32_ID_SANITISED(ID_ISAR6_EL1),
> > -
> > - /* CRm=3 */
> > - AA32_ID_SANITISED(MVFR0_EL1),
> > - AA32_ID_SANITISED(MVFR1_EL1),
> > - AA32_ID_SANITISED(MVFR2_EL1),
> > - ID_UNALLOCATED(3,3),
> > - AA32_ID_SANITISED(ID_PFR2_EL1),
> > - ID_HIDDEN(ID_DFR1_EL1),
> > - AA32_ID_SANITISED(ID_MMFR5_EL1),
> > - ID_UNALLOCATED(3,7),
> > -
> > - /* AArch64 ID registers */
> > - /* CRm=4 */
> > - { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
> > - .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
> > - ID_SANITISED(ID_AA64PFR1_EL1),
> > - ID_UNALLOCATED(4,2),
> > - ID_UNALLOCATED(4,3),
> > - ID_SANITISED(ID_AA64ZFR0_EL1),
> > - ID_HIDDEN(ID_AA64SMFR0_EL1),
> > - ID_UNALLOCATED(4,6),
> > - ID_UNALLOCATED(4,7),
> > -
> > - /* CRm=5 */
> > - { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
> > - .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
> > - ID_SANITISED(ID_AA64DFR1_EL1),
> > - ID_UNALLOCATED(5,2),
> > - ID_UNALLOCATED(5,3),
> > - ID_HIDDEN(ID_AA64AFR0_EL1),
> > - ID_HIDDEN(ID_AA64AFR1_EL1),
> > - ID_UNALLOCATED(5,6),
> > - ID_UNALLOCATED(5,7),
> > -
> > - /* CRm=6 */
> > - ID_SANITISED(ID_AA64ISAR0_EL1),
> > - ID_SANITISED(ID_AA64ISAR1_EL1),
> > - ID_SANITISED(ID_AA64ISAR2_EL1),
> > - ID_UNALLOCATED(6,3),
> > - ID_UNALLOCATED(6,4),
> > - ID_UNALLOCATED(6,5),
> > - ID_UNALLOCATED(6,6),
> > - ID_UNALLOCATED(6,7),
> > -
> > - /* CRm=7 */
> > - ID_SANITISED(ID_AA64MMFR0_EL1),
> > - ID_SANITISED(ID_AA64MMFR1_EL1),
> > - ID_SANITISED(ID_AA64MMFR2_EL1),
> > - ID_UNALLOCATED(7,3),
> > - ID_UNALLOCATED(7,4),
> > - ID_UNALLOCATED(7,5),
> > - ID_UNALLOCATED(7,6),
> > - ID_UNALLOCATED(7,7),
> > -
> > { SYS_DESC(SYS_SCTLR_EL1), access_vm_reg, reset_val, SCTLR_EL1, 0x00C50078 },
> > { SYS_DESC(SYS_ACTLR_EL1), access_actlr, reset_actlr, ACTLR_EL1 },
> > { SYS_DESC(SYS_CPACR_EL1), NULL, reset_val, CPACR_EL1, 0 },
> > @@ -2531,8 +2101,8 @@ static const struct sys_reg_desc cp15_64_regs[] = {
> > { SYS_DESC(SYS_AARCH32_CNTP_CVAL), access_arch_timer },
> > };
> >
> > -static bool check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
> > - bool is_32)
> > +bool check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
> > + bool is_32)
> > {
> > unsigned int i;
> >
> > @@ -2883,7 +2453,9 @@ static bool emulate_sys_reg(struct kvm_vcpu *vcpu,
> > {
> > const struct sys_reg_desc *r;
> >
> > - r = find_reg(params, sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
> > + r = kvm_arm_find_id_reg(params);
>
> It appears that this is the only one code that enforces id_regs.c
> to expose sys_reg_desc of ID registers. Although I'm not sure your
> intention, you might want to create emulate_id_reg(), instead of
> exposing that unnecessarily ?
Sure, will use emulate_id_reg which would be used in kvm_handle_sys_reg.
>
> Thank you,
> Reiji
>
> > + if (!r)
> > + r = find_reg(params, sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
> >
> > if (likely(r)) {
> > perform_access(vcpu, params, r);
> > @@ -2912,6 +2484,8 @@ void kvm_reset_sys_regs(struct kvm_vcpu *vcpu)
> > {
> > unsigned long i;
> >
> > + kvm_arm_reset_id_regs(vcpu);
> > +
> > for (i = 0; i < ARRAY_SIZE(sys_reg_descs); i++)
> > if (sys_reg_descs[i].reset)
> > sys_reg_descs[i].reset(vcpu, &sys_reg_descs[i]);
> > @@ -3160,6 +2734,10 @@ int kvm_arm_sys_reg_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg
> > if (err != -ENOENT)
> > return err;
> >
> > + err = kvm_arm_get_id_reg(vcpu, reg);
> > + if (err != -ENOENT)
> > + return err;
> > +
> > return kvm_sys_reg_get_user(vcpu, reg,
> > sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
> > }
> > @@ -3204,6 +2782,10 @@ int kvm_arm_sys_reg_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg
> > if (err != -ENOENT)
> > return err;
> >
> > + err = kvm_arm_set_id_reg(vcpu, reg);
> > + if (err != -ENOENT)
> > + return err;
> > +
> > return kvm_sys_reg_set_user(vcpu, reg,
> > sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
> > }
> > @@ -3250,10 +2832,10 @@ static bool copy_reg_to_user(const struct sys_reg_desc *reg, u64 __user **uind)
> > return true;
> > }
> >
> > -static int walk_one_sys_reg(const struct kvm_vcpu *vcpu,
> > - const struct sys_reg_desc *rd,
> > - u64 __user **uind,
> > - unsigned int *total)
> > +int walk_one_sys_reg(const struct kvm_vcpu *vcpu,
> > + const struct sys_reg_desc *rd,
> > + u64 __user **uind,
> > + unsigned int *total)
> > {
> > /*
> > * Ignore registers we trap but don't save,
> > @@ -3294,6 +2876,7 @@ unsigned long kvm_arm_num_sys_reg_descs(struct kvm_vcpu *vcpu)
> > {
> > return ARRAY_SIZE(invariant_sys_regs)
> > + num_demux_regs()
> > + + kvm_arm_walk_id_regs(vcpu, (u64 __user *)NULL)
> > + walk_sys_regs(vcpu, (u64 __user *)NULL);
> > }
> >
> > @@ -3309,6 +2892,11 @@ int kvm_arm_copy_sys_reg_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
> > uindices++;
> > }
> >
> > + err = kvm_arm_walk_id_regs(vcpu, uindices);
> > + if (err < 0)
> > + return err;
> > + uindices += err;
> > +
> > err = walk_sys_regs(vcpu, uindices);
> > if (err < 0)
> > return err;
> > @@ -3323,6 +2911,7 @@ int __init kvm_sys_reg_table_init(void)
> > unsigned int i;
> >
> > /* Make sure tables are unique and in order. */
> > + valid &= kvm_arm_check_idreg_table();
> > valid &= check_sysreg_table(sys_reg_descs, ARRAY_SIZE(sys_reg_descs), false);
> > valid &= check_sysreg_table(cp14_regs, ARRAY_SIZE(cp14_regs), true);
> > valid &= check_sysreg_table(cp14_64_regs, ARRAY_SIZE(cp14_64_regs), true);
> > diff --git a/arch/arm64/kvm/sys_regs.h b/arch/arm64/kvm/sys_regs.h
> > index 6b11f2cc7146..96a52936d130 100644
> > --- a/arch/arm64/kvm/sys_regs.h
> > +++ b/arch/arm64/kvm/sys_regs.h
> > @@ -210,6 +210,22 @@ find_reg(const struct sys_reg_params *params, const struct sys_reg_desc table[],
> > return __inline_bsearch((void *)pval, table, num, sizeof(table[0]), match_sys_reg);
> > }
> >
> > +static inline unsigned int raz_visibility(const struct kvm_vcpu *vcpu,
> > + const struct sys_reg_desc *r)
> > +{
> > + return REG_RAZ;
> > +}
> > +
> > +static inline bool write_to_read_only(struct kvm_vcpu *vcpu,
> > + struct sys_reg_params *params,
> > + const struct sys_reg_desc *r)
> > +{
> > + WARN_ONCE(1, "Unexpected sys_reg write to read-only register\n");
> > + print_sys_reg_instr(params);
> > + kvm_inject_undefined(vcpu);
> > + return false;
> > +}
> > +
> > const struct sys_reg_desc *get_reg_by_id(u64 id,
> > const struct sys_reg_desc table[],
> > unsigned int num);
> > @@ -220,6 +236,18 @@ int kvm_sys_reg_get_user(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg,
> > const struct sys_reg_desc table[], unsigned int num);
> > int kvm_sys_reg_set_user(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg,
> > const struct sys_reg_desc table[], unsigned int num);
> > +bool check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
> > + bool is_32);
> > +int walk_one_sys_reg(const struct kvm_vcpu *vcpu,
> > + const struct sys_reg_desc *rd,
> > + u64 __user **uind,
> > + unsigned int *total);
> > +const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params);
> > +void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu);
> > +int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
> > +int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
> > +bool kvm_arm_check_idreg_table(void);
> > +int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind);
> >
> > #define AA32(_x) .aarch32_map = AA32_##_x
> > #define Op0(_x) .Op0 = _x
> > --
> > 2.39.1.581.gbfd45094c4-goog
> >
Thanks,
Jing
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 16+ messages in thread
* [PATCH v2 2/6] KVM: arm64: Save ID registers' sanitized value per guest
2023-02-12 21:58 [PATCH v2 0/6] Support writable CPU ID registers from userspace Jing Zhang
2023-02-12 21:58 ` [PATCH v2 1/6] KVM: arm64: Move CPU ID feature registers emulation into a separate file Jing Zhang
@ 2023-02-12 21:58 ` Jing Zhang
2023-02-12 21:58 ` [PATCH v2 3/6] KVM: arm64: Use per guest ID register for ID_AA64PFR0_EL1.[CSV2|CSV3] Jing Zhang
` (3 subsequent siblings)
5 siblings, 0 replies; 16+ messages in thread
From: Jing Zhang @ 2023-02-12 21:58 UTC (permalink / raw)
To: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton
Cc: Will Deacon, Paolo Bonzini, James Morse, Alexandru Elisei,
Suzuki K Poulose, Fuad Tabba, Reiji Watanabe, Ricardo Koller,
Raghavendra Rao Ananta, Jing Zhang
From: Reiji Watanabe <reijiw@google.com>
Introduce id_regs[] in kvm_arch as a storage of guest's ID registers,
and save ID registers' sanitized value in the array at KVM_CREATE_VM.
Use the saved ones when ID registers are read by the guest or
userspace (via KVM_GET_ONE_REG).
No functional change intended.
Signed-off-by: Reiji Watanabe <reijiw@google.com>
Co-developed-by: Jing Zhang <jingzhangos@google.com>
Signed-off-by: Jing Zhang <jingzhangos@google.com>
---
arch/arm64/include/asm/kvm_host.h | 12 +++++++
arch/arm64/kvm/arm.c | 1 +
arch/arm64/kvm/id_regs.c | 53 ++++++++++++++++++++++++++-----
arch/arm64/kvm/sys_regs.c | 2 +-
arch/arm64/kvm/sys_regs.h | 1 +
5 files changed, 60 insertions(+), 9 deletions(-)
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index a1892a8f6032..5c1cec4efa37 100644
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -245,6 +245,16 @@ struct kvm_arch {
* the associated pKVM instance in the hypervisor.
*/
struct kvm_protected_vm pkvm;
+
+ /*
+ * Save ID registers for the guest in id_regs[].
+ * (Op0, Op1, CRn, CRm, Op2) of the ID registers to be saved in it
+ * is (3, 0, 0, crm, op2), where 1<=crm<8, 0<=op2<8.
+ */
+#define KVM_ARM_ID_REG_NUM 56
+#define IDREG_IDX(id) (((sys_reg_CRm(id) - 1) << 3) | sys_reg_Op2(id))
+#define IDREG(kvm, id) kvm->arch.id_regs[IDREG_IDX(id)]
+ u64 id_regs[KVM_ARM_ID_REG_NUM];
};
struct kvm_vcpu_fault_info {
@@ -1005,6 +1015,8 @@ int kvm_arm_vcpu_arch_has_attr(struct kvm_vcpu *vcpu,
long kvm_vm_ioctl_mte_copy_tags(struct kvm *kvm,
struct kvm_arm_copy_mte_tags *copy_tags);
+void kvm_arm_set_default_id_regs(struct kvm *kvm);
+
/* Guest/host FPSIMD coordination helpers */
int kvm_arch_vcpu_run_map_fp(struct kvm_vcpu *vcpu);
void kvm_arch_vcpu_load_fp(struct kvm_vcpu *vcpu);
diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
index 3bd732eaf087..4579c878ab30 100644
--- a/arch/arm64/kvm/arm.c
+++ b/arch/arm64/kvm/arm.c
@@ -153,6 +153,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
set_default_spectre(kvm);
kvm_arm_init_hypercalls(kvm);
+ kvm_arm_set_default_id_regs(kvm);
/*
* Initialise the default PMUver before there is a chance to
diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
index 7f30d683de21..0302507abbce 100644
--- a/arch/arm64/kvm/id_regs.c
+++ b/arch/arm64/kvm/id_regs.c
@@ -52,16 +52,20 @@ static u8 pmuver_to_perfmon(u8 pmuver)
}
}
-/* Read a sanitised cpufeature ID register by sys_reg_desc */
-static u64 read_id_reg(const struct kvm_vcpu *vcpu, struct sys_reg_desc const *r)
+/*
+ * Return true if the register's (Op0, Op1, CRn, CRm, Op2) is
+ * (3, 0, 0, crm, op2), where 1<=crm<8, 0<=op2<8.
+ */
+static bool is_id_reg(u32 id)
{
- u32 id = reg_to_encoding(r);
- u64 val;
-
- if (sysreg_visible_as_raz(vcpu, r))
- return 0;
+ return (sys_reg_Op0(id) == 3 && sys_reg_Op1(id) == 0 &&
+ sys_reg_CRn(id) == 0 && sys_reg_CRm(id) >= 1 &&
+ sys_reg_CRm(id) < 8);
+}
- val = read_sanitised_ftr_reg(id);
+u64 kvm_arm_read_id_reg_with_encoding(const struct kvm_vcpu *vcpu, u32 id)
+{
+ u64 val = IDREG(vcpu->kvm, id);
switch (id) {
case SYS_ID_AA64PFR0_EL1:
@@ -126,6 +130,14 @@ static u64 read_id_reg(const struct kvm_vcpu *vcpu, struct sys_reg_desc const *r
return val;
}
+static u64 read_id_reg(const struct kvm_vcpu *vcpu, struct sys_reg_desc const *r)
+{
+ if (sysreg_visible_as_raz(vcpu, r))
+ return 0;
+
+ return kvm_arm_read_id_reg_with_encoding(vcpu, reg_to_encoding(r));
+}
+
/* cpufeature ID register access trap handlers */
static bool access_id_reg(struct kvm_vcpu *vcpu,
@@ -484,3 +496,28 @@ int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind)
}
return total;
}
+
+/*
+ * Set the guest's ID registers that are defined in id_reg_descs[]
+ * with ID_SANITISED() to the host's sanitized value.
+ */
+void kvm_arm_set_default_id_regs(struct kvm *kvm)
+{
+ int i;
+ u32 id;
+ u64 val;
+
+ for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
+ id = reg_to_encoding(&id_reg_descs[i]);
+ if (WARN_ON_ONCE(!is_id_reg(id)))
+ /* Shouldn't happen */
+ continue;
+
+ if (id_reg_descs[i].visibility == raz_visibility)
+ /* Hidden or reserved ID register */
+ continue;
+
+ val = read_sanitised_ftr_reg(id);
+ IDREG(kvm, id) = val;
+ }
+}
diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
index 3b23b7a67eb5..a4350f0737c3 100644
--- a/arch/arm64/kvm/sys_regs.c
+++ b/arch/arm64/kvm/sys_regs.c
@@ -354,7 +354,7 @@ static bool trap_loregion(struct kvm_vcpu *vcpu,
struct sys_reg_params *p,
const struct sys_reg_desc *r)
{
- u64 val = read_sanitised_ftr_reg(SYS_ID_AA64MMFR1_EL1);
+ u64 val = kvm_arm_read_id_reg_with_encoding(vcpu, SYS_ID_AA64MMFR1_EL1);
u32 sr = reg_to_encoding(r);
if (!(val & (0xfUL << ID_AA64MMFR1_EL1_LO_SHIFT))) {
diff --git a/arch/arm64/kvm/sys_regs.h b/arch/arm64/kvm/sys_regs.h
index 96a52936d130..5cfab83ce8b8 100644
--- a/arch/arm64/kvm/sys_regs.h
+++ b/arch/arm64/kvm/sys_regs.h
@@ -248,6 +248,7 @@ int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
bool kvm_arm_check_idreg_table(void);
int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind);
+u64 kvm_arm_read_id_reg_with_encoding(const struct kvm_vcpu *vcpu, u32 id);
#define AA32(_x) .aarch32_map = AA32_##_x
#define Op0(_x) .Op0 = _x
--
2.39.1.581.gbfd45094c4-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v2 3/6] KVM: arm64: Use per guest ID register for ID_AA64PFR0_EL1.[CSV2|CSV3]
2023-02-12 21:58 [PATCH v2 0/6] Support writable CPU ID registers from userspace Jing Zhang
2023-02-12 21:58 ` [PATCH v2 1/6] KVM: arm64: Move CPU ID feature registers emulation into a separate file Jing Zhang
2023-02-12 21:58 ` [PATCH v2 2/6] KVM: arm64: Save ID registers' sanitized value per guest Jing Zhang
@ 2023-02-12 21:58 ` Jing Zhang
2023-02-12 21:58 ` [PATCH v2 4/6] KVM: arm64: Use per guest ID register for ID_AA64DFR0_EL1.PMUVer Jing Zhang
` (2 subsequent siblings)
5 siblings, 0 replies; 16+ messages in thread
From: Jing Zhang @ 2023-02-12 21:58 UTC (permalink / raw)
To: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton
Cc: Will Deacon, Paolo Bonzini, James Morse, Alexandru Elisei,
Suzuki K Poulose, Fuad Tabba, Reiji Watanabe, Ricardo Koller,
Raghavendra Rao Ananta, Jing Zhang
With per guest ID registers, ID_AA64PFR0_EL1.[CSV2|CSV3] settings from
userspace can be stored in its corresponding ID register.
No functional change intended.
Signed-off-by: Jing Zhang <jingzhangos@google.com>
---
arch/arm64/include/asm/kvm_host.h | 3 +--
arch/arm64/kvm/arm.c | 19 +------------------
arch/arm64/kvm/hyp/nvhe/sys_regs.c | 7 +++----
arch/arm64/kvm/id_regs.c | 30 ++++++++++++++++++++++--------
4 files changed, 27 insertions(+), 32 deletions(-)
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index 5c1cec4efa37..f64347eb77c2 100644
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -230,8 +230,6 @@ struct kvm_arch {
cpumask_var_t supported_cpus;
- u8 pfr0_csv2;
- u8 pfr0_csv3;
struct {
u8 imp:4;
u8 unimp:4;
@@ -254,6 +252,7 @@ struct kvm_arch {
#define KVM_ARM_ID_REG_NUM 56
#define IDREG_IDX(id) (((sys_reg_CRm(id) - 1) << 3) | sys_reg_Op2(id))
#define IDREG(kvm, id) kvm->arch.id_regs[IDREG_IDX(id)]
+#define IDREG_RD(kvm, rd) IDREG(kvm, reg_to_encoding(rd))
u64 id_regs[KVM_ARM_ID_REG_NUM];
};
diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
index 4579c878ab30..c78d68d011cb 100644
--- a/arch/arm64/kvm/arm.c
+++ b/arch/arm64/kvm/arm.c
@@ -104,22 +104,6 @@ static int kvm_arm_default_max_vcpus(void)
return vgic_present ? kvm_vgic_get_max_vcpus() : KVM_MAX_VCPUS;
}
-static void set_default_spectre(struct kvm *kvm)
-{
- /*
- * The default is to expose CSV2 == 1 if the HW isn't affected.
- * Although this is a per-CPU feature, we make it global because
- * asymmetric systems are just a nuisance.
- *
- * Userspace can override this as long as it doesn't promise
- * the impossible.
- */
- if (arm64_get_spectre_v2_state() == SPECTRE_UNAFFECTED)
- kvm->arch.pfr0_csv2 = 1;
- if (arm64_get_meltdown_state() == SPECTRE_UNAFFECTED)
- kvm->arch.pfr0_csv3 = 1;
-}
-
/**
* kvm_arch_init_vm - initializes a VM data structure
* @kvm: pointer to the KVM struct
@@ -151,9 +135,8 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
/* The maximum number of VCPUs is limited by the host's GIC model */
kvm->max_vcpus = kvm_arm_default_max_vcpus();
- set_default_spectre(kvm);
- kvm_arm_init_hypercalls(kvm);
kvm_arm_set_default_id_regs(kvm);
+ kvm_arm_init_hypercalls(kvm);
/*
* Initialise the default PMUver before there is a chance to
diff --git a/arch/arm64/kvm/hyp/nvhe/sys_regs.c b/arch/arm64/kvm/hyp/nvhe/sys_regs.c
index 08d2b004f4b7..ff486e78b32b 100644
--- a/arch/arm64/kvm/hyp/nvhe/sys_regs.c
+++ b/arch/arm64/kvm/hyp/nvhe/sys_regs.c
@@ -93,10 +93,9 @@ static u64 get_pvm_id_aa64pfr0(const struct kvm_vcpu *vcpu)
PVM_ID_AA64PFR0_RESTRICT_UNSIGNED);
/* Spectre and Meltdown mitigation in KVM */
- set_mask |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2),
- (u64)kvm->arch.pfr0_csv2);
- set_mask |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3),
- (u64)kvm->arch.pfr0_csv3);
+ set_mask |= IDREG(kvm, SYS_ID_AA64PFR0_EL1) &
+ (ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2) |
+ ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3));
return (id_aa64pfr0_el1_sys_val & allow_mask) | set_mask;
}
diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
index 0302507abbce..bc4c408a43eb 100644
--- a/arch/arm64/kvm/id_regs.c
+++ b/arch/arm64/kvm/id_regs.c
@@ -72,12 +72,6 @@ u64 kvm_arm_read_id_reg_with_encoding(const struct kvm_vcpu *vcpu, u32 id)
if (!vcpu_has_sve(vcpu))
val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_SVE);
val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_AMU);
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2),
- (u64)vcpu->kvm->arch.pfr0_csv2);
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3),
- (u64)vcpu->kvm->arch.pfr0_csv3);
if (kvm_vgic_global_state.type == VGIC_V3) {
val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC);
val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC), 1);
@@ -212,6 +206,7 @@ static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
u64 val)
{
u8 csv2, csv3;
+ u64 sval = val;
/*
* Allow AA64PFR0_EL1.CSV2 to be set from userspace as long as
@@ -236,8 +231,7 @@ static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
if (val)
return -EINVAL;
- vcpu->kvm->arch.pfr0_csv2 = csv2;
- vcpu->kvm->arch.pfr0_csv3 = csv3;
+ IDREG_RD(vcpu->kvm, rd) = sval;
return 0;
}
@@ -520,4 +514,24 @@ void kvm_arm_set_default_id_regs(struct kvm *kvm)
val = read_sanitised_ftr_reg(id);
IDREG(kvm, id) = val;
}
+ /*
+ * The default is to expose CSV2 == 1 if the HW isn't affected.
+ * Although this is a per-CPU feature, we make it global because
+ * asymmetric systems are just a nuisance.
+ *
+ * Userspace can override this as long as it doesn't promise
+ * the impossible.
+ */
+ val = IDREG(kvm, SYS_ID_AA64PFR0_EL1);
+
+ if (arm64_get_spectre_v2_state() == SPECTRE_UNAFFECTED) {
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2), 1);
+ }
+ if (arm64_get_meltdown_state() == SPECTRE_UNAFFECTED) {
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3), 1);
+ }
+
+ IDREG(kvm, SYS_ID_AA64PFR0_EL1) = val;
}
--
2.39.1.581.gbfd45094c4-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 16+ messages in thread* [PATCH v2 4/6] KVM: arm64: Use per guest ID register for ID_AA64DFR0_EL1.PMUVer
2023-02-12 21:58 [PATCH v2 0/6] Support writable CPU ID registers from userspace Jing Zhang
` (2 preceding siblings ...)
2023-02-12 21:58 ` [PATCH v2 3/6] KVM: arm64: Use per guest ID register for ID_AA64PFR0_EL1.[CSV2|CSV3] Jing Zhang
@ 2023-02-12 21:58 ` Jing Zhang
2023-02-25 2:35 ` Reiji Watanabe
2023-02-12 21:58 ` [PATCH v2 5/6] KVM: arm64: Introduce ID register specific descriptor Jing Zhang
2023-02-12 21:58 ` [PATCH v2 6/6] KVM: arm64: Refactor writings for PMUVer/CSV2/CSV3 Jing Zhang
5 siblings, 1 reply; 16+ messages in thread
From: Jing Zhang @ 2023-02-12 21:58 UTC (permalink / raw)
To: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton
Cc: Will Deacon, Paolo Bonzini, James Morse, Alexandru Elisei,
Suzuki K Poulose, Fuad Tabba, Reiji Watanabe, Ricardo Koller,
Raghavendra Rao Ananta, Jing Zhang
With per guest ID registers, PMUver settings from userspace
can be stored in its corresponding ID register.
No functional change intended.
Signed-off-by: Jing Zhang <jingzhangos@google.com>
---
arch/arm64/include/asm/kvm_host.h | 11 ++++----
arch/arm64/kvm/arm.c | 6 -----
arch/arm64/kvm/id_regs.c | 44 +++++++++++++++++++++++--------
include/kvm/arm_pmu.h | 6 +++--
4 files changed, 43 insertions(+), 24 deletions(-)
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index f64347eb77c2..effb61a9a855 100644
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -218,6 +218,12 @@ struct kvm_arch {
#define KVM_ARCH_FLAG_EL1_32BIT 4
/* PSCI SYSTEM_SUSPEND enabled for the guest */
#define KVM_ARCH_FLAG_SYSTEM_SUSPEND_ENABLED 5
+ /*
+ * AA64DFR0_EL1.PMUver was set as ID_AA64DFR0_EL1_PMUVer_IMP_DEF
+ * or DFR0_EL1.PerfMon was set as ID_DFR0_EL1_PerfMon_IMPDEF from
+ * userspace for VCPUs without PMU.
+ */
+#define KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU 6
unsigned long flags;
@@ -230,11 +236,6 @@ struct kvm_arch {
cpumask_var_t supported_cpus;
- struct {
- u8 imp:4;
- u8 unimp:4;
- } dfr0_pmuver;
-
/* Hypercall features firmware registers' descriptor */
struct kvm_smccc_features smccc_feat;
diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
index c78d68d011cb..fb2de2cb98cb 100644
--- a/arch/arm64/kvm/arm.c
+++ b/arch/arm64/kvm/arm.c
@@ -138,12 +138,6 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
kvm_arm_set_default_id_regs(kvm);
kvm_arm_init_hypercalls(kvm);
- /*
- * Initialise the default PMUver before there is a chance to
- * create an actual PMU.
- */
- kvm->arch.dfr0_pmuver.imp = kvm_arm_pmu_get_pmuver_limit();
-
return 0;
err_free_cpumask:
diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
index bc4c408a43eb..14ae03a1d8d0 100644
--- a/arch/arm64/kvm/id_regs.c
+++ b/arch/arm64/kvm/id_regs.c
@@ -21,9 +21,12 @@
static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
{
if (kvm_vcpu_has_pmu(vcpu))
- return vcpu->kvm->arch.dfr0_pmuver.imp;
-
- return vcpu->kvm->arch.dfr0_pmuver.unimp;
+ return FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
+ IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1));
+ else if (test_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags))
+ return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
+ else
+ return 0;
}
static u8 perfmon_to_pmuver(u8 perfmon)
@@ -267,10 +270,15 @@ static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
if (val)
return -EINVAL;
- if (valid_pmu)
- vcpu->kvm->arch.dfr0_pmuver.imp = pmuver;
- else
- vcpu->kvm->arch.dfr0_pmuver.unimp = pmuver;
+ if (valid_pmu) {
+ IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
+ IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1) |=
+ FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), pmuver);
+ } else if (pmuver == ID_AA64DFR0_EL1_PMUVer_IMP_DEF) {
+ set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+ } else {
+ clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+ }
return 0;
}
@@ -307,10 +315,15 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
if (val)
return -EINVAL;
- if (valid_pmu)
- vcpu->kvm->arch.dfr0_pmuver.imp = perfmon_to_pmuver(perfmon);
- else
- vcpu->kvm->arch.dfr0_pmuver.unimp = perfmon_to_pmuver(perfmon);
+ if (valid_pmu) {
+ IDREG(vcpu->kvm, SYS_ID_DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
+ IDREG(vcpu->kvm, SYS_ID_DFR0_EL1) |=
+ FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), perfmon_to_pmuver(perfmon));
+ } else if (perfmon == ID_DFR0_EL1_PerfMon_IMPDEF) {
+ set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+ } else {
+ clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+ }
return 0;
}
@@ -534,4 +547,13 @@ void kvm_arm_set_default_id_regs(struct kvm *kvm)
}
IDREG(kvm, SYS_ID_AA64PFR0_EL1) = val;
+
+ /*
+ * Initialise the default PMUver before there is a chance to
+ * create an actual PMU.
+ */
+ IDREG(kvm, SYS_ID_AA64DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
+ IDREG(kvm, SYS_ID_AA64DFR0_EL1) |=
+ FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
+ kvm_arm_pmu_get_pmuver_limit());
}
diff --git a/include/kvm/arm_pmu.h b/include/kvm/arm_pmu.h
index 628775334d5e..eef67b7d9751 100644
--- a/include/kvm/arm_pmu.h
+++ b/include/kvm/arm_pmu.h
@@ -92,8 +92,10 @@ void kvm_vcpu_pmu_restore_host(struct kvm_vcpu *vcpu);
/*
* Evaluates as true when emulating PMUv3p5, and false otherwise.
*/
-#define kvm_pmu_is_3p5(vcpu) \
- (vcpu->kvm->arch.dfr0_pmuver.imp >= ID_AA64DFR0_EL1_PMUVer_V3P5)
+#define kvm_pmu_is_3p5(vcpu) \
+ (kvm_vcpu_has_pmu(vcpu) && \
+ FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), \
+ IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1)) >= ID_AA64DFR0_EL1_PMUVer_V3P5)
u8 kvm_arm_pmu_get_pmuver_limit(void);
--
2.39.1.581.gbfd45094c4-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 16+ messages in thread* Re: [PATCH v2 4/6] KVM: arm64: Use per guest ID register for ID_AA64DFR0_EL1.PMUVer
2023-02-12 21:58 ` [PATCH v2 4/6] KVM: arm64: Use per guest ID register for ID_AA64DFR0_EL1.PMUVer Jing Zhang
@ 2023-02-25 2:35 ` Reiji Watanabe
2023-02-27 2:57 ` Jing Zhang
0 siblings, 1 reply; 16+ messages in thread
From: Reiji Watanabe @ 2023-02-25 2:35 UTC (permalink / raw)
To: Jing Zhang
Cc: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton, Will Deacon,
Paolo Bonzini, James Morse, Alexandru Elisei, Suzuki K Poulose,
Fuad Tabba, Ricardo Koller, Raghavendra Rao Ananta
Hi Jing,
On Sun, Feb 12, 2023 at 1:58 PM Jing Zhang <jingzhangos@google.com> wrote:
>
> With per guest ID registers, PMUver settings from userspace
> can be stored in its corresponding ID register.
>
> No functional change intended.
>
> Signed-off-by: Jing Zhang <jingzhangos@google.com>
> ---
> arch/arm64/include/asm/kvm_host.h | 11 ++++----
> arch/arm64/kvm/arm.c | 6 -----
> arch/arm64/kvm/id_regs.c | 44 +++++++++++++++++++++++--------
> include/kvm/arm_pmu.h | 6 +++--
> 4 files changed, 43 insertions(+), 24 deletions(-)
>
> diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
> index f64347eb77c2..effb61a9a855 100644
> --- a/arch/arm64/include/asm/kvm_host.h
> +++ b/arch/arm64/include/asm/kvm_host.h
> @@ -218,6 +218,12 @@ struct kvm_arch {
> #define KVM_ARCH_FLAG_EL1_32BIT 4
> /* PSCI SYSTEM_SUSPEND enabled for the guest */
> #define KVM_ARCH_FLAG_SYSTEM_SUSPEND_ENABLED 5
> + /*
> + * AA64DFR0_EL1.PMUver was set as ID_AA64DFR0_EL1_PMUVer_IMP_DEF
> + * or DFR0_EL1.PerfMon was set as ID_DFR0_EL1_PerfMon_IMPDEF from
> + * userspace for VCPUs without PMU.
> + */
> +#define KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU
As Oliver suggested, it might be better to not expose IMPDEF PMU
(but expose as 0), since it is not effectively supported by KVM.
(We need to be careful not to have migration from old KVM fail though)
>
> unsigned long flags;
>
> @@ -230,11 +236,6 @@ struct kvm_arch {
>
> cpumask_var_t supported_cpus;
>
> - struct {
> - u8 imp:4;
> - u8 unimp:4;
> - } dfr0_pmuver;
> -
> /* Hypercall features firmware registers' descriptor */
> struct kvm_smccc_features smccc_feat;
>
> diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
> index c78d68d011cb..fb2de2cb98cb 100644
> --- a/arch/arm64/kvm/arm.c
> +++ b/arch/arm64/kvm/arm.c
> @@ -138,12 +138,6 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
> kvm_arm_set_default_id_regs(kvm);
> kvm_arm_init_hypercalls(kvm);
>
> - /*
> - * Initialise the default PMUver before there is a chance to
> - * create an actual PMU.
> - */
> - kvm->arch.dfr0_pmuver.imp = kvm_arm_pmu_get_pmuver_limit();
> -
> return 0;
>
> err_free_cpumask:
> diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
> index bc4c408a43eb..14ae03a1d8d0 100644
> --- a/arch/arm64/kvm/id_regs.c
> +++ b/arch/arm64/kvm/id_regs.c
> @@ -21,9 +21,12 @@
> static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> {
> if (kvm_vcpu_has_pmu(vcpu))
> - return vcpu->kvm->arch.dfr0_pmuver.imp;
> -
> - return vcpu->kvm->arch.dfr0_pmuver.unimp;
> + return FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
> + IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1));
> + else if (test_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags))
> + return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
> + else
> + return 0;
> }
>
> static u8 perfmon_to_pmuver(u8 perfmon)
> @@ -267,10 +270,15 @@ static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
> if (val)
> return -EINVAL;
>
> - if (valid_pmu)
> - vcpu->kvm->arch.dfr0_pmuver.imp = pmuver;
> - else
> - vcpu->kvm->arch.dfr0_pmuver.unimp = pmuver;
> + if (valid_pmu) {
> + IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> + IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1) |=
> + FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), pmuver);
The original code keeps ID_AA64DFR0_EL1.PMUVer and ID_DFR0_EL1.PerfMon
values consistent (if one of them is update, the other one is also
updated accordingly). To keep the same behavior, shouldn't we update
the other one as well when one of them is updated ?
Thank you,
Reiji
> + } else if (pmuver == ID_AA64DFR0_EL1_PMUVer_IMP_DEF) {
> + set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
> + } else {
> + clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
> + }
>
> return 0;
> }
> @@ -307,10 +315,15 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> if (val)
> return -EINVAL;
>
> - if (valid_pmu)
> - vcpu->kvm->arch.dfr0_pmuver.imp = perfmon_to_pmuver(perfmon);
> - else
> - vcpu->kvm->arch.dfr0_pmuver.unimp = perfmon_to_pmuver(perfmon);
> + if (valid_pmu) {
> + IDREG(vcpu->kvm, SYS_ID_DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> + IDREG(vcpu->kvm, SYS_ID_DFR0_EL1) |=
> + FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), perfmon_to_pmuver(perfmon));
> + } else if (perfmon == ID_DFR0_EL1_PerfMon_IMPDEF) {
> + set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
> + } else {
> + clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
> + }
>
> return 0;
> }
> @@ -534,4 +547,13 @@ void kvm_arm_set_default_id_regs(struct kvm *kvm)
> }
>
> IDREG(kvm, SYS_ID_AA64PFR0_EL1) = val;
> +
> + /*
> + * Initialise the default PMUver before there is a chance to
> + * create an actual PMU.
> + */
> + IDREG(kvm, SYS_ID_AA64DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> + IDREG(kvm, SYS_ID_AA64DFR0_EL1) |=
> + FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
> + kvm_arm_pmu_get_pmuver_limit());
> }
> diff --git a/include/kvm/arm_pmu.h b/include/kvm/arm_pmu.h
> index 628775334d5e..eef67b7d9751 100644
> --- a/include/kvm/arm_pmu.h
> +++ b/include/kvm/arm_pmu.h
> @@ -92,8 +92,10 @@ void kvm_vcpu_pmu_restore_host(struct kvm_vcpu *vcpu);
> /*
> * Evaluates as true when emulating PMUv3p5, and false otherwise.
> */
> -#define kvm_pmu_is_3p5(vcpu) \
> - (vcpu->kvm->arch.dfr0_pmuver.imp >= ID_AA64DFR0_EL1_PMUVer_V3P5)
> +#define kvm_pmu_is_3p5(vcpu) \
> + (kvm_vcpu_has_pmu(vcpu) && \
> + FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), \
> + IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1)) >= ID_AA64DFR0_EL1_PMUVer_V3P5)
>
> u8 kvm_arm_pmu_get_pmuver_limit(void);
>
> --
> 2.39.1.581.gbfd45094c4-goog
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [PATCH v2 4/6] KVM: arm64: Use per guest ID register for ID_AA64DFR0_EL1.PMUVer
2023-02-25 2:35 ` Reiji Watanabe
@ 2023-02-27 2:57 ` Jing Zhang
0 siblings, 0 replies; 16+ messages in thread
From: Jing Zhang @ 2023-02-27 2:57 UTC (permalink / raw)
To: Reiji Watanabe
Cc: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton, Will Deacon,
Paolo Bonzini, James Morse, Alexandru Elisei, Suzuki K Poulose,
Fuad Tabba, Ricardo Koller, Raghavendra Rao Ananta
Hi Reiji,
On Fri, Feb 24, 2023 at 6:36 PM Reiji Watanabe <reijiw@google.com> wrote:
>
> Hi Jing,
>
> On Sun, Feb 12, 2023 at 1:58 PM Jing Zhang <jingzhangos@google.com> wrote:
> >
> > With per guest ID registers, PMUver settings from userspace
> > can be stored in its corresponding ID register.
> >
> > No functional change intended.
> >
> > Signed-off-by: Jing Zhang <jingzhangos@google.com>
> > ---
> > arch/arm64/include/asm/kvm_host.h | 11 ++++----
> > arch/arm64/kvm/arm.c | 6 -----
> > arch/arm64/kvm/id_regs.c | 44 +++++++++++++++++++++++--------
> > include/kvm/arm_pmu.h | 6 +++--
> > 4 files changed, 43 insertions(+), 24 deletions(-)
> >
> > diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
> > index f64347eb77c2..effb61a9a855 100644
> > --- a/arch/arm64/include/asm/kvm_host.h
> > +++ b/arch/arm64/include/asm/kvm_host.h
> > @@ -218,6 +218,12 @@ struct kvm_arch {
> > #define KVM_ARCH_FLAG_EL1_32BIT 4
> > /* PSCI SYSTEM_SUSPEND enabled for the guest */
> > #define KVM_ARCH_FLAG_SYSTEM_SUSPEND_ENABLED 5
> > + /*
> > + * AA64DFR0_EL1.PMUver was set as ID_AA64DFR0_EL1_PMUVer_IMP_DEF
> > + * or DFR0_EL1.PerfMon was set as ID_DFR0_EL1_PerfMon_IMPDEF from
> > + * userspace for VCPUs without PMU.
> > + */
> > +#define KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU
>
> As Oliver suggested, it might be better to not expose IMPDEF PMU
> (but expose as 0), since it is not effectively supported by KVM.
> (We need to be careful not to have migration from old KVM fail though)
>
>
Since that change is not related to writable ID register change
itself, I'd prefer to have that change in a separate commit or post.
> >
> > unsigned long flags;
> >
> > @@ -230,11 +236,6 @@ struct kvm_arch {
> >
> > cpumask_var_t supported_cpus;
> >
> > - struct {
> > - u8 imp:4;
> > - u8 unimp:4;
> > - } dfr0_pmuver;
> > -
> > /* Hypercall features firmware registers' descriptor */
> > struct kvm_smccc_features smccc_feat;
> >
> > diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
> > index c78d68d011cb..fb2de2cb98cb 100644
> > --- a/arch/arm64/kvm/arm.c
> > +++ b/arch/arm64/kvm/arm.c
> > @@ -138,12 +138,6 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
> > kvm_arm_set_default_id_regs(kvm);
> > kvm_arm_init_hypercalls(kvm);
> >
> > - /*
> > - * Initialise the default PMUver before there is a chance to
> > - * create an actual PMU.
> > - */
> > - kvm->arch.dfr0_pmuver.imp = kvm_arm_pmu_get_pmuver_limit();
> > -
> > return 0;
> >
> > err_free_cpumask:
> > diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
> > index bc4c408a43eb..14ae03a1d8d0 100644
> > --- a/arch/arm64/kvm/id_regs.c
> > +++ b/arch/arm64/kvm/id_regs.c
> > @@ -21,9 +21,12 @@
> > static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> > {
> > if (kvm_vcpu_has_pmu(vcpu))
> > - return vcpu->kvm->arch.dfr0_pmuver.imp;
> > -
> > - return vcpu->kvm->arch.dfr0_pmuver.unimp;
> > + return FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
> > + IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1));
> > + else if (test_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags))
> > + return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
> > + else
> > + return 0;
> > }
> >
> > static u8 perfmon_to_pmuver(u8 perfmon)
> > @@ -267,10 +270,15 @@ static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
> > if (val)
> > return -EINVAL;
> >
> > - if (valid_pmu)
> > - vcpu->kvm->arch.dfr0_pmuver.imp = pmuver;
> > - else
> > - vcpu->kvm->arch.dfr0_pmuver.unimp = pmuver;
> > + if (valid_pmu) {
> > + IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> > + IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1) |=
> > + FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), pmuver);
>
> The original code keeps ID_AA64DFR0_EL1.PMUVer and ID_DFR0_EL1.PerfMon
> values consistent (if one of them is update, the other one is also
> updated accordingly). To keep the same behavior, shouldn't we update
> the other one as well when one of them is updated ?
>
Yes, will do that to keep the values consistent.
> Thank you,
> Reiji
>
>
> > + } else if (pmuver == ID_AA64DFR0_EL1_PMUVer_IMP_DEF) {
> > + set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
> > + } else {
> > + clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
> > + }
> >
> > return 0;
> > }
> > @@ -307,10 +315,15 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > if (val)
> > return -EINVAL;
> >
> > - if (valid_pmu)
> > - vcpu->kvm->arch.dfr0_pmuver.imp = perfmon_to_pmuver(perfmon);
> > - else
> > - vcpu->kvm->arch.dfr0_pmuver.unimp = perfmon_to_pmuver(perfmon);
> > + if (valid_pmu) {
> > + IDREG(vcpu->kvm, SYS_ID_DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
> > + IDREG(vcpu->kvm, SYS_ID_DFR0_EL1) |=
> > + FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), perfmon_to_pmuver(perfmon));
> > + } else if (perfmon == ID_DFR0_EL1_PerfMon_IMPDEF) {
> > + set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
> > + } else {
> > + clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
> > + }
> >
> > return 0;
> > }
> > @@ -534,4 +547,13 @@ void kvm_arm_set_default_id_regs(struct kvm *kvm)
> > }
> >
> > IDREG(kvm, SYS_ID_AA64PFR0_EL1) = val;
> > +
> > + /*
> > + * Initialise the default PMUver before there is a chance to
> > + * create an actual PMU.
> > + */
> > + IDREG(kvm, SYS_ID_AA64DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
> > + IDREG(kvm, SYS_ID_AA64DFR0_EL1) |=
> > + FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
> > + kvm_arm_pmu_get_pmuver_limit());
> > }
> > diff --git a/include/kvm/arm_pmu.h b/include/kvm/arm_pmu.h
> > index 628775334d5e..eef67b7d9751 100644
> > --- a/include/kvm/arm_pmu.h
> > +++ b/include/kvm/arm_pmu.h
> > @@ -92,8 +92,10 @@ void kvm_vcpu_pmu_restore_host(struct kvm_vcpu *vcpu);
> > /*
> > * Evaluates as true when emulating PMUv3p5, and false otherwise.
> > */
> > -#define kvm_pmu_is_3p5(vcpu) \
> > - (vcpu->kvm->arch.dfr0_pmuver.imp >= ID_AA64DFR0_EL1_PMUVer_V3P5)
> > +#define kvm_pmu_is_3p5(vcpu) \
> > + (kvm_vcpu_has_pmu(vcpu) && \
> > + FIELD_GET(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), \
> > + IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1)) >= ID_AA64DFR0_EL1_PMUVer_V3P5)
> >
> > u8 kvm_arm_pmu_get_pmuver_limit(void);
> >
> > --
> > 2.39.1.581.gbfd45094c4-goog
> >
Thanks,
Jing
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 16+ messages in thread
* [PATCH v2 5/6] KVM: arm64: Introduce ID register specific descriptor
2023-02-12 21:58 [PATCH v2 0/6] Support writable CPU ID registers from userspace Jing Zhang
` (3 preceding siblings ...)
2023-02-12 21:58 ` [PATCH v2 4/6] KVM: arm64: Use per guest ID register for ID_AA64DFR0_EL1.PMUVer Jing Zhang
@ 2023-02-12 21:58 ` Jing Zhang
2023-02-25 4:00 ` Reiji Watanabe
2023-02-12 21:58 ` [PATCH v2 6/6] KVM: arm64: Refactor writings for PMUVer/CSV2/CSV3 Jing Zhang
5 siblings, 1 reply; 16+ messages in thread
From: Jing Zhang @ 2023-02-12 21:58 UTC (permalink / raw)
To: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton
Cc: Will Deacon, Paolo Bonzini, James Morse, Alexandru Elisei,
Suzuki K Poulose, Fuad Tabba, Reiji Watanabe, Ricardo Koller,
Raghavendra Rao Ananta, Jing Zhang
Introduce an ID feature register specific descriptor to include ID
register specific fields and callbacks besides its corresponding
general system register descriptor.
New fields for ID register descriptor would be added later when it
is necessary to support a writable ID register.
No functional change intended.
Co-developed-by: Reiji Watanabe <reijiw@google.com>
Signed-off-by: Reiji Watanabe <reijiw@google.com>
Signed-off-by: Jing Zhang <jingzhangos@google.com>
---
arch/arm64/kvm/id_regs.c | 187 +++++++++++++++++++++++++++++---------
arch/arm64/kvm/sys_regs.c | 2 +-
arch/arm64/kvm/sys_regs.h | 1 +
3 files changed, 144 insertions(+), 46 deletions(-)
diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
index 14ae03a1d8d0..15d0338742b6 100644
--- a/arch/arm64/kvm/id_regs.c
+++ b/arch/arm64/kvm/id_regs.c
@@ -18,6 +18,10 @@
#include "sys_regs.h"
+struct id_reg_desc {
+ const struct sys_reg_desc reg_desc;
+};
+
static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
{
if (kvm_vcpu_has_pmu(vcpu))
@@ -329,21 +333,25 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
}
/* sys_reg_desc initialiser for known cpufeature ID registers */
-#define ID_SANITISED(name) { \
- SYS_DESC(SYS_##name), \
- .access = access_id_reg, \
- .get_user = get_id_reg, \
- .set_user = set_id_reg, \
- .visibility = id_visibility, \
+#define ID_SANITISED(name) { \
+ .reg_desc = { \
+ SYS_DESC(SYS_##name), \
+ .access = access_id_reg, \
+ .get_user = get_id_reg, \
+ .set_user = set_id_reg, \
+ .visibility = id_visibility, \
+ }, \
}
/* sys_reg_desc initialiser for known cpufeature ID registers */
-#define AA32_ID_SANITISED(name) { \
- SYS_DESC(SYS_##name), \
- .access = access_id_reg, \
- .get_user = get_id_reg, \
- .set_user = set_id_reg, \
- .visibility = aa32_id_visibility, \
+#define AA32_ID_SANITISED(name) { \
+ .reg_desc = { \
+ SYS_DESC(SYS_##name), \
+ .access = access_id_reg, \
+ .get_user = get_id_reg, \
+ .set_user = set_id_reg, \
+ .visibility = aa32_id_visibility, \
+ }, \
}
/*
@@ -351,12 +359,14 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
* register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
* (1 <= crm < 8, 0 <= Op2 < 8).
*/
-#define ID_UNALLOCATED(crm, op2) { \
- Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
- .access = access_id_reg, \
- .get_user = get_id_reg, \
- .set_user = set_id_reg, \
- .visibility = raz_visibility \
+#define ID_UNALLOCATED(crm, op2) { \
+ .reg_desc = { \
+ Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
+ .access = access_id_reg, \
+ .get_user = get_id_reg, \
+ .set_user = set_id_reg, \
+ .visibility = raz_visibility \
+ }, \
}
/*
@@ -364,15 +374,17 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
* For now, these are exposed just like unallocated ID regs: they appear
* RAZ for the guest.
*/
-#define ID_HIDDEN(name) { \
- SYS_DESC(SYS_##name), \
- .access = access_id_reg, \
- .get_user = get_id_reg, \
- .set_user = set_id_reg, \
- .visibility = raz_visibility, \
+#define ID_HIDDEN(name) { \
+ .reg_desc = { \
+ SYS_DESC(SYS_##name), \
+ .access = access_id_reg, \
+ .get_user = get_id_reg, \
+ .set_user = set_id_reg, \
+ .visibility = raz_visibility, \
+ }, \
}
-static const struct sys_reg_desc id_reg_descs[] = {
+static const struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
/*
* ID regs: all ID_SANITISED() entries here must have corresponding
* entries in arm64_ftr_regs[].
@@ -382,9 +394,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
/* CRm=1 */
AA32_ID_SANITISED(ID_PFR0_EL1),
AA32_ID_SANITISED(ID_PFR1_EL1),
- { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
- .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
- .visibility = aa32_id_visibility, },
+ { .reg_desc = {
+ SYS_DESC(SYS_ID_DFR0_EL1),
+ .access = access_id_reg,
+ .get_user = get_id_reg,
+ .set_user = set_id_dfr0_el1,
+ .visibility = aa32_id_visibility, },
+ },
ID_HIDDEN(ID_AFR0_EL1),
AA32_ID_SANITISED(ID_MMFR0_EL1),
AA32_ID_SANITISED(ID_MMFR1_EL1),
@@ -413,8 +429,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
/* AArch64 ID registers */
/* CRm=4 */
- { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
- .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
+ { .reg_desc = {
+ SYS_DESC(SYS_ID_AA64PFR0_EL1),
+ .access = access_id_reg,
+ .get_user = get_id_reg,
+ .set_user = set_id_aa64pfr0_el1, },
+ },
ID_SANITISED(ID_AA64PFR1_EL1),
ID_UNALLOCATED(4, 2),
ID_UNALLOCATED(4, 3),
@@ -424,8 +444,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
ID_UNALLOCATED(4, 7),
/* CRm=5 */
- { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
- .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
+ { .reg_desc = {
+ SYS_DESC(SYS_ID_AA64DFR0_EL1),
+ .access = access_id_reg,
+ .get_user = get_id_reg,
+ .set_user = set_id_aa64dfr0_el1, },
+ },
ID_SANITISED(ID_AA64DFR1_EL1),
ID_UNALLOCATED(5, 2),
ID_UNALLOCATED(5, 3),
@@ -457,7 +481,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params)
{
- return find_reg(params, id_reg_descs, ARRAY_SIZE(id_reg_descs));
+ u32 id;
+
+ id = reg_to_encoding(params);
+ if (!is_id_reg(id))
+ return NULL;
+
+ return &id_reg_descs[IDREG_IDX(id)].reg_desc;
}
void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
@@ -465,39 +495,106 @@ void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
unsigned long i;
for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++)
- if (id_reg_descs[i].reset)
- id_reg_descs[i].reset(vcpu, &id_reg_descs[i]);
+ if (id_reg_descs[i].reg_desc.reset)
+ id_reg_descs[i].reg_desc.reset(vcpu, &id_reg_descs[i].reg_desc);
}
int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
{
- return kvm_sys_reg_get_user(vcpu, reg,
- id_reg_descs, ARRAY_SIZE(id_reg_descs));
+ u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
+ const struct sys_reg_desc *r;
+ struct sys_reg_params params;
+ u64 val;
+ int ret;
+ u32 id;
+
+ if (!index_to_params(reg->id, ¶ms))
+ return -ENOENT;
+ id = reg_to_encoding(¶ms);
+
+ if (!is_id_reg(id))
+ return -ENOENT;
+
+ r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
+ if (r->get_user) {
+ ret = (r->get_user)(vcpu, r, &val);
+ } else {
+ ret = 0;
+ val = 0;
+ }
+
+ if (!ret)
+ ret = put_user(val, uaddr);
+
+ return ret;
}
int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
{
- return kvm_sys_reg_set_user(vcpu, reg,
- id_reg_descs, ARRAY_SIZE(id_reg_descs));
+ u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
+ const struct sys_reg_desc *r;
+ struct sys_reg_params params;
+ u64 val;
+ int ret;
+ u32 id;
+
+ if (!index_to_params(reg->id, ¶ms))
+ return -ENOENT;
+ id = reg_to_encoding(¶ms);
+
+ if (!is_id_reg(id))
+ return -ENOENT;
+
+ if (get_user(val, uaddr))
+ return -EFAULT;
+
+ r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
+
+ if (sysreg_user_write_ignore(vcpu, r))
+ return 0;
+
+ if (r->set_user)
+ ret = (r->set_user)(vcpu, r, val);
+ else
+ ret = 0;
+
+ return ret;
}
bool kvm_arm_check_idreg_table(void)
{
- return check_sysreg_table(id_reg_descs, ARRAY_SIZE(id_reg_descs), false);
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
+ const struct sys_reg_desc *r = &id_reg_descs[i].reg_desc;
+
+ if (r->reg && !r->reset) {
+ kvm_err("sys_reg table %pS entry %d lacks reset\n", r, i);
+ return false;
+ }
+
+ if (i && cmp_sys_reg(&id_reg_descs[i-1].reg_desc, r) >= 0) {
+ kvm_err("sys_reg table %pS entry %d out of order\n",
+ &id_reg_descs[i - 1].reg_desc, i - 1);
+ return false;
+ }
+ }
+
+ return true;
}
/* Assumed ordered tables, see kvm_sys_reg_table_init. */
int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind)
{
- const struct sys_reg_desc *i2, *end2;
+ const struct id_reg_desc *i2, *end2;
unsigned int total = 0;
int err;
i2 = id_reg_descs;
end2 = id_reg_descs + ARRAY_SIZE(id_reg_descs);
- while (i2 != end2) {
- err = walk_one_sys_reg(vcpu, i2++, &uind, &total);
+ for (; i2 != end2; i2++) {
+ err = walk_one_sys_reg(vcpu, &(i2->reg_desc), &uind, &total);
if (err)
return err;
}
@@ -515,12 +612,12 @@ void kvm_arm_set_default_id_regs(struct kvm *kvm)
u64 val;
for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
- id = reg_to_encoding(&id_reg_descs[i]);
+ id = reg_to_encoding(&id_reg_descs[i].reg_desc);
if (WARN_ON_ONCE(!is_id_reg(id)))
/* Shouldn't happen */
continue;
- if (id_reg_descs[i].visibility == raz_visibility)
+ if (id_reg_descs[i].reg_desc.visibility == raz_visibility)
/* Hidden or reserved ID register */
continue;
diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
index a4350f0737c3..cdcd61ac9868 100644
--- a/arch/arm64/kvm/sys_regs.c
+++ b/arch/arm64/kvm/sys_regs.c
@@ -2518,7 +2518,7 @@ int kvm_handle_sys_reg(struct kvm_vcpu *vcpu)
* Userspace API
*****************************************************************************/
-static bool index_to_params(u64 id, struct sys_reg_params *params)
+bool index_to_params(u64 id, struct sys_reg_params *params)
{
switch (id & KVM_REG_SIZE_MASK) {
case KVM_REG_SIZE_U64:
diff --git a/arch/arm64/kvm/sys_regs.h b/arch/arm64/kvm/sys_regs.h
index 5cfab83ce8b8..3797d1b494a2 100644
--- a/arch/arm64/kvm/sys_regs.h
+++ b/arch/arm64/kvm/sys_regs.h
@@ -226,6 +226,7 @@ static inline bool write_to_read_only(struct kvm_vcpu *vcpu,
return false;
}
+bool index_to_params(u64 id, struct sys_reg_params *params);
const struct sys_reg_desc *get_reg_by_id(u64 id,
const struct sys_reg_desc table[],
unsigned int num);
--
2.39.1.581.gbfd45094c4-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 16+ messages in thread* Re: [PATCH v2 5/6] KVM: arm64: Introduce ID register specific descriptor
2023-02-12 21:58 ` [PATCH v2 5/6] KVM: arm64: Introduce ID register specific descriptor Jing Zhang
@ 2023-02-25 4:00 ` Reiji Watanabe
2023-02-27 3:04 ` Jing Zhang
0 siblings, 1 reply; 16+ messages in thread
From: Reiji Watanabe @ 2023-02-25 4:00 UTC (permalink / raw)
To: Jing Zhang
Cc: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton, Will Deacon,
Paolo Bonzini, James Morse, Alexandru Elisei, Suzuki K Poulose,
Fuad Tabba, Ricardo Koller, Raghavendra Rao Ananta
Hi Jing,
On Sun, Feb 12, 2023 at 1:58 PM Jing Zhang <jingzhangos@google.com> wrote:
>
> Introduce an ID feature register specific descriptor to include ID
> register specific fields and callbacks besides its corresponding
> general system register descriptor.
> New fields for ID register descriptor would be added later when it
> is necessary to support a writable ID register.
>
> No functional change intended.
>
> Co-developed-by: Reiji Watanabe <reijiw@google.com>
> Signed-off-by: Reiji Watanabe <reijiw@google.com>
> Signed-off-by: Jing Zhang <jingzhangos@google.com>
> ---
> arch/arm64/kvm/id_regs.c | 187 +++++++++++++++++++++++++++++---------
> arch/arm64/kvm/sys_regs.c | 2 +-
> arch/arm64/kvm/sys_regs.h | 1 +
> 3 files changed, 144 insertions(+), 46 deletions(-)
>
> diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
> index 14ae03a1d8d0..15d0338742b6 100644
> --- a/arch/arm64/kvm/id_regs.c
> +++ b/arch/arm64/kvm/id_regs.c
> @@ -18,6 +18,10 @@
>
> #include "sys_regs.h"
>
> +struct id_reg_desc {
> + const struct sys_reg_desc reg_desc;
> +};
> +
> static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> {
> if (kvm_vcpu_has_pmu(vcpu))
> @@ -329,21 +333,25 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> }
>
> /* sys_reg_desc initialiser for known cpufeature ID registers */
> -#define ID_SANITISED(name) { \
> - SYS_DESC(SYS_##name), \
> - .access = access_id_reg, \
> - .get_user = get_id_reg, \
> - .set_user = set_id_reg, \
> - .visibility = id_visibility, \
> +#define ID_SANITISED(name) { \
> + .reg_desc = { \
> + SYS_DESC(SYS_##name), \
> + .access = access_id_reg, \
> + .get_user = get_id_reg, \
> + .set_user = set_id_reg, \
> + .visibility = id_visibility, \
> + }, \
> }
>
> /* sys_reg_desc initialiser for known cpufeature ID registers */
> -#define AA32_ID_SANITISED(name) { \
> - SYS_DESC(SYS_##name), \
> - .access = access_id_reg, \
> - .get_user = get_id_reg, \
> - .set_user = set_id_reg, \
> - .visibility = aa32_id_visibility, \
> +#define AA32_ID_SANITISED(name) { \
> + .reg_desc = { \
> + SYS_DESC(SYS_##name), \
> + .access = access_id_reg, \
> + .get_user = get_id_reg, \
> + .set_user = set_id_reg, \
> + .visibility = aa32_id_visibility, \
> + }, \
> }
>
> /*
> @@ -351,12 +359,14 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
> * (1 <= crm < 8, 0 <= Op2 < 8).
> */
> -#define ID_UNALLOCATED(crm, op2) { \
> - Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> - .access = access_id_reg, \
> - .get_user = get_id_reg, \
> - .set_user = set_id_reg, \
> - .visibility = raz_visibility \
> +#define ID_UNALLOCATED(crm, op2) { \
> + .reg_desc = { \
> + Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> + .access = access_id_reg, \
> + .get_user = get_id_reg, \
> + .set_user = set_id_reg, \
> + .visibility = raz_visibility \
> + }, \
> }
>
> /*
> @@ -364,15 +374,17 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> * For now, these are exposed just like unallocated ID regs: they appear
> * RAZ for the guest.
> */
> -#define ID_HIDDEN(name) { \
> - SYS_DESC(SYS_##name), \
> - .access = access_id_reg, \
> - .get_user = get_id_reg, \
> - .set_user = set_id_reg, \
> - .visibility = raz_visibility, \
> +#define ID_HIDDEN(name) { \
> + .reg_desc = { \
> + SYS_DESC(SYS_##name), \
> + .access = access_id_reg, \
> + .get_user = get_id_reg, \
> + .set_user = set_id_reg, \
> + .visibility = raz_visibility, \
> + }, \
> }
>
> -static const struct sys_reg_desc id_reg_descs[] = {
> +static const struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
> /*
> * ID regs: all ID_SANITISED() entries here must have corresponding
> * entries in arm64_ftr_regs[].
> @@ -382,9 +394,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
> /* CRm=1 */
> AA32_ID_SANITISED(ID_PFR0_EL1),
> AA32_ID_SANITISED(ID_PFR1_EL1),
> - { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
> - .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
> - .visibility = aa32_id_visibility, },
> + { .reg_desc = {
> + SYS_DESC(SYS_ID_DFR0_EL1),
> + .access = access_id_reg,
> + .get_user = get_id_reg,
> + .set_user = set_id_dfr0_el1,
> + .visibility = aa32_id_visibility, },
> + },
> ID_HIDDEN(ID_AFR0_EL1),
> AA32_ID_SANITISED(ID_MMFR0_EL1),
> AA32_ID_SANITISED(ID_MMFR1_EL1),
> @@ -413,8 +429,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
>
> /* AArch64 ID registers */
> /* CRm=4 */
> - { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
> - .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
> + { .reg_desc = {
> + SYS_DESC(SYS_ID_AA64PFR0_EL1),
> + .access = access_id_reg,
> + .get_user = get_id_reg,
> + .set_user = set_id_aa64pfr0_el1, },
> + },
> ID_SANITISED(ID_AA64PFR1_EL1),
> ID_UNALLOCATED(4, 2),
> ID_UNALLOCATED(4, 3),
> @@ -424,8 +444,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
> ID_UNALLOCATED(4, 7),
>
> /* CRm=5 */
> - { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
> - .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
> + { .reg_desc = {
> + SYS_DESC(SYS_ID_AA64DFR0_EL1),
> + .access = access_id_reg,
> + .get_user = get_id_reg,
> + .set_user = set_id_aa64dfr0_el1, },
> + },
> ID_SANITISED(ID_AA64DFR1_EL1),
> ID_UNALLOCATED(5, 2),
> ID_UNALLOCATED(5, 3),
> @@ -457,7 +481,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
>
> const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params)
> {
> - return find_reg(params, id_reg_descs, ARRAY_SIZE(id_reg_descs));
> + u32 id;
> +
> + id = reg_to_encoding(params);
> + if (!is_id_reg(id))
> + return NULL;
> +
> + return &id_reg_descs[IDREG_IDX(id)].reg_desc;
> }
>
> void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> @@ -465,39 +495,106 @@ void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> unsigned long i;
>
> for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++)
> - if (id_reg_descs[i].reset)
> - id_reg_descs[i].reset(vcpu, &id_reg_descs[i]);
> + if (id_reg_descs[i].reg_desc.reset)
> + id_reg_descs[i].reg_desc.reset(vcpu, &id_reg_descs[i].reg_desc);
> }
>
> int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> {
> - return kvm_sys_reg_get_user(vcpu, reg,
> - id_reg_descs, ARRAY_SIZE(id_reg_descs));
> + u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
> + const struct sys_reg_desc *r;
> + struct sys_reg_params params;
> + u64 val;
> + int ret;
> + u32 id;
> +
> + if (!index_to_params(reg->id, ¶ms))
> + return -ENOENT;
> + id = reg_to_encoding(¶ms);
> +
> + if (!is_id_reg(id))
> + return -ENOENT;
> +
> + r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
> + if (r->get_user) {
> + ret = (r->get_user)(vcpu, r, &val);
> + } else {
> + ret = 0;
> + val = 0;
When get_user is NULL, I wonder why you want to treat them RAZ.
It can be achieved by using visibility(), which I think might be
better to use before calling get_user.
Another option would be simply reading from IDREG(), which I would
guess might be useful(?) when no special handling is necessary.
> + }
> +
> + if (!ret)
> + ret = put_user(val, uaddr);
> +
> + return ret;
> }
>
> int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> {
> - return kvm_sys_reg_set_user(vcpu, reg,
> - id_reg_descs, ARRAY_SIZE(id_reg_descs));
> + u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
> + const struct sys_reg_desc *r;
> + struct sys_reg_params params;
> + u64 val;
> + int ret;
> + u32 id;
> +
> + if (!index_to_params(reg->id, ¶ms))
> + return -ENOENT;
> + id = reg_to_encoding(¶ms);
> +
> + if (!is_id_reg(id))
> + return -ENOENT;
> +
> + if (get_user(val, uaddr))
> + return -EFAULT;
> +
> + r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
> +
> + if (sysreg_user_write_ignore(vcpu, r))
> + return 0;
> +
> + if (r->set_user)
> + ret = (r->set_user)(vcpu, r, val);
> + else
> + ret = 0;
This appears to be the same handling as WI.
How do you plan to use this set_user == NULL case ?
I don't think this shouldn't happen with the current code.
You might want to use WARN_ONCE here ?
> +
> + return ret;
> }
>
> bool kvm_arm_check_idreg_table(void)
> {
> - return check_sysreg_table(id_reg_descs, ARRAY_SIZE(id_reg_descs), false);
> + unsigned int i;
> +
> + for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
> + const struct sys_reg_desc *r = &id_reg_descs[i].reg_desc;
> +
> + if (r->reg && !r->reset) {
I don't think we need to check "!r->reset".
If r->reg is not NULL, I believe the entry must be incorrect.
> + kvm_err("sys_reg table %pS entry %d lacks reset\n", r, i);
> + return false;
> + }
> +
> + if (i && cmp_sys_reg(&id_reg_descs[i-1].reg_desc, r) >= 0) {
In this table, each ID register needs to be in the proper place.
So, I would think what should be checked would be if each entry
in the table includes the right ID register.
(e.g. id_reg_descs[0] must be for ID_PFR0_EL1, etc)
Thank you,
Reiji
> + kvm_err("sys_reg table %pS entry %d out of order\n",
> + &id_reg_descs[i - 1].reg_desc, i - 1);
> + return false;
> + }
> + }
> +
> + return true;
> }
>
> /* Assumed ordered tables, see kvm_sys_reg_table_init. */
> int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind)
> {
> - const struct sys_reg_desc *i2, *end2;
> + const struct id_reg_desc *i2, *end2;
> unsigned int total = 0;
> int err;
>
> i2 = id_reg_descs;
> end2 = id_reg_descs + ARRAY_SIZE(id_reg_descs);
>
> - while (i2 != end2) {
> - err = walk_one_sys_reg(vcpu, i2++, &uind, &total);
> + for (; i2 != end2; i2++) {
> + err = walk_one_sys_reg(vcpu, &(i2->reg_desc), &uind, &total);
> if (err)
> return err;
> }
> @@ -515,12 +612,12 @@ void kvm_arm_set_default_id_regs(struct kvm *kvm)
> u64 val;
>
> for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
> - id = reg_to_encoding(&id_reg_descs[i]);
> + id = reg_to_encoding(&id_reg_descs[i].reg_desc);
> if (WARN_ON_ONCE(!is_id_reg(id)))
> /* Shouldn't happen */
> continue;
>
> - if (id_reg_descs[i].visibility == raz_visibility)
> + if (id_reg_descs[i].reg_desc.visibility == raz_visibility)
> /* Hidden or reserved ID register */
> continue;
>
> diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
> index a4350f0737c3..cdcd61ac9868 100644
> --- a/arch/arm64/kvm/sys_regs.c
> +++ b/arch/arm64/kvm/sys_regs.c
> @@ -2518,7 +2518,7 @@ int kvm_handle_sys_reg(struct kvm_vcpu *vcpu)
> * Userspace API
> *****************************************************************************/
>
> -static bool index_to_params(u64 id, struct sys_reg_params *params)
> +bool index_to_params(u64 id, struct sys_reg_params *params)
> {
> switch (id & KVM_REG_SIZE_MASK) {
> case KVM_REG_SIZE_U64:
> diff --git a/arch/arm64/kvm/sys_regs.h b/arch/arm64/kvm/sys_regs.h
> index 5cfab83ce8b8..3797d1b494a2 100644
> --- a/arch/arm64/kvm/sys_regs.h
> +++ b/arch/arm64/kvm/sys_regs.h
> @@ -226,6 +226,7 @@ static inline bool write_to_read_only(struct kvm_vcpu *vcpu,
> return false;
> }
>
> +bool index_to_params(u64 id, struct sys_reg_params *params);
> const struct sys_reg_desc *get_reg_by_id(u64 id,
> const struct sys_reg_desc table[],
> unsigned int num);
> --
> 2.39.1.581.gbfd45094c4-goog
>
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [PATCH v2 5/6] KVM: arm64: Introduce ID register specific descriptor
2023-02-25 4:00 ` Reiji Watanabe
@ 2023-02-27 3:04 ` Jing Zhang
2023-02-27 22:23 ` Reiji Watanabe
0 siblings, 1 reply; 16+ messages in thread
From: Jing Zhang @ 2023-02-27 3:04 UTC (permalink / raw)
To: Reiji Watanabe
Cc: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton, Will Deacon,
Paolo Bonzini, James Morse, Alexandru Elisei, Suzuki K Poulose,
Fuad Tabba, Ricardo Koller, Raghavendra Rao Ananta
Hi Reiji,
On Fri, Feb 24, 2023 at 8:00 PM Reiji Watanabe <reijiw@google.com> wrote:
>
> Hi Jing,
>
> On Sun, Feb 12, 2023 at 1:58 PM Jing Zhang <jingzhangos@google.com> wrote:
> >
> > Introduce an ID feature register specific descriptor to include ID
> > register specific fields and callbacks besides its corresponding
> > general system register descriptor.
> > New fields for ID register descriptor would be added later when it
> > is necessary to support a writable ID register.
> >
> > No functional change intended.
> >
> > Co-developed-by: Reiji Watanabe <reijiw@google.com>
> > Signed-off-by: Reiji Watanabe <reijiw@google.com>
> > Signed-off-by: Jing Zhang <jingzhangos@google.com>
> > ---
> > arch/arm64/kvm/id_regs.c | 187 +++++++++++++++++++++++++++++---------
> > arch/arm64/kvm/sys_regs.c | 2 +-
> > arch/arm64/kvm/sys_regs.h | 1 +
> > 3 files changed, 144 insertions(+), 46 deletions(-)
> >
> > diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
> > index 14ae03a1d8d0..15d0338742b6 100644
> > --- a/arch/arm64/kvm/id_regs.c
> > +++ b/arch/arm64/kvm/id_regs.c
> > @@ -18,6 +18,10 @@
> >
> > #include "sys_regs.h"
> >
> > +struct id_reg_desc {
> > + const struct sys_reg_desc reg_desc;
> > +};
> > +
> > static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> > {
> > if (kvm_vcpu_has_pmu(vcpu))
> > @@ -329,21 +333,25 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > }
> >
> > /* sys_reg_desc initialiser for known cpufeature ID registers */
> > -#define ID_SANITISED(name) { \
> > - SYS_DESC(SYS_##name), \
> > - .access = access_id_reg, \
> > - .get_user = get_id_reg, \
> > - .set_user = set_id_reg, \
> > - .visibility = id_visibility, \
> > +#define ID_SANITISED(name) { \
> > + .reg_desc = { \
> > + SYS_DESC(SYS_##name), \
> > + .access = access_id_reg, \
> > + .get_user = get_id_reg, \
> > + .set_user = set_id_reg, \
> > + .visibility = id_visibility, \
> > + }, \
> > }
> >
> > /* sys_reg_desc initialiser for known cpufeature ID registers */
> > -#define AA32_ID_SANITISED(name) { \
> > - SYS_DESC(SYS_##name), \
> > - .access = access_id_reg, \
> > - .get_user = get_id_reg, \
> > - .set_user = set_id_reg, \
> > - .visibility = aa32_id_visibility, \
> > +#define AA32_ID_SANITISED(name) { \
> > + .reg_desc = { \
> > + SYS_DESC(SYS_##name), \
> > + .access = access_id_reg, \
> > + .get_user = get_id_reg, \
> > + .set_user = set_id_reg, \
> > + .visibility = aa32_id_visibility, \
> > + }, \
> > }
> >
> > /*
> > @@ -351,12 +359,14 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
> > * (1 <= crm < 8, 0 <= Op2 < 8).
> > */
> > -#define ID_UNALLOCATED(crm, op2) { \
> > - Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> > - .access = access_id_reg, \
> > - .get_user = get_id_reg, \
> > - .set_user = set_id_reg, \
> > - .visibility = raz_visibility \
> > +#define ID_UNALLOCATED(crm, op2) { \
> > + .reg_desc = { \
> > + Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> > + .access = access_id_reg, \
> > + .get_user = get_id_reg, \
> > + .set_user = set_id_reg, \
> > + .visibility = raz_visibility \
> > + }, \
> > }
> >
> > /*
> > @@ -364,15 +374,17 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > * For now, these are exposed just like unallocated ID regs: they appear
> > * RAZ for the guest.
> > */
> > -#define ID_HIDDEN(name) { \
> > - SYS_DESC(SYS_##name), \
> > - .access = access_id_reg, \
> > - .get_user = get_id_reg, \
> > - .set_user = set_id_reg, \
> > - .visibility = raz_visibility, \
> > +#define ID_HIDDEN(name) { \
> > + .reg_desc = { \
> > + SYS_DESC(SYS_##name), \
> > + .access = access_id_reg, \
> > + .get_user = get_id_reg, \
> > + .set_user = set_id_reg, \
> > + .visibility = raz_visibility, \
> > + }, \
> > }
> >
> > -static const struct sys_reg_desc id_reg_descs[] = {
> > +static const struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
> > /*
> > * ID regs: all ID_SANITISED() entries here must have corresponding
> > * entries in arm64_ftr_regs[].
> > @@ -382,9 +394,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > /* CRm=1 */
> > AA32_ID_SANITISED(ID_PFR0_EL1),
> > AA32_ID_SANITISED(ID_PFR1_EL1),
> > - { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
> > - .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
> > - .visibility = aa32_id_visibility, },
> > + { .reg_desc = {
> > + SYS_DESC(SYS_ID_DFR0_EL1),
> > + .access = access_id_reg,
> > + .get_user = get_id_reg,
> > + .set_user = set_id_dfr0_el1,
> > + .visibility = aa32_id_visibility, },
> > + },
> > ID_HIDDEN(ID_AFR0_EL1),
> > AA32_ID_SANITISED(ID_MMFR0_EL1),
> > AA32_ID_SANITISED(ID_MMFR1_EL1),
> > @@ -413,8 +429,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
> >
> > /* AArch64 ID registers */
> > /* CRm=4 */
> > - { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
> > - .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
> > + { .reg_desc = {
> > + SYS_DESC(SYS_ID_AA64PFR0_EL1),
> > + .access = access_id_reg,
> > + .get_user = get_id_reg,
> > + .set_user = set_id_aa64pfr0_el1, },
> > + },
> > ID_SANITISED(ID_AA64PFR1_EL1),
> > ID_UNALLOCATED(4, 2),
> > ID_UNALLOCATED(4, 3),
> > @@ -424,8 +444,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > ID_UNALLOCATED(4, 7),
> >
> > /* CRm=5 */
> > - { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
> > - .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
> > + { .reg_desc = {
> > + SYS_DESC(SYS_ID_AA64DFR0_EL1),
> > + .access = access_id_reg,
> > + .get_user = get_id_reg,
> > + .set_user = set_id_aa64dfr0_el1, },
> > + },
> > ID_SANITISED(ID_AA64DFR1_EL1),
> > ID_UNALLOCATED(5, 2),
> > ID_UNALLOCATED(5, 3),
> > @@ -457,7 +481,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
> >
> > const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params)
> > {
> > - return find_reg(params, id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > + u32 id;
> > +
> > + id = reg_to_encoding(params);
> > + if (!is_id_reg(id))
> > + return NULL;
> > +
> > + return &id_reg_descs[IDREG_IDX(id)].reg_desc;
> > }
> >
> > void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> > @@ -465,39 +495,106 @@ void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> > unsigned long i;
> >
> > for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++)
> > - if (id_reg_descs[i].reset)
> > - id_reg_descs[i].reset(vcpu, &id_reg_descs[i]);
> > + if (id_reg_descs[i].reg_desc.reset)
> > + id_reg_descs[i].reg_desc.reset(vcpu, &id_reg_descs[i].reg_desc);
> > }
> >
> > int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > {
> > - return kvm_sys_reg_get_user(vcpu, reg,
> > - id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > + u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
> > + const struct sys_reg_desc *r;
> > + struct sys_reg_params params;
> > + u64 val;
> > + int ret;
> > + u32 id;
> > +
> > + if (!index_to_params(reg->id, ¶ms))
> > + return -ENOENT;
> > + id = reg_to_encoding(¶ms);
> > +
> > + if (!is_id_reg(id))
> > + return -ENOENT;
> > +
> > + r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
> > + if (r->get_user) {
> > + ret = (r->get_user)(vcpu, r, &val);
> > + } else {
> > + ret = 0;
> > + val = 0;
>
> When get_user is NULL, I wonder why you want to treat them RAZ.
> It can be achieved by using visibility(), which I think might be
> better to use before calling get_user.
> Another option would be simply reading from IDREG(), which I would
> guess might be useful(?) when no special handling is necessary.
>
Will simply use the value from IDREG().
>
> > + }
> > +
> > + if (!ret)
> > + ret = put_user(val, uaddr);
> > +
> > + return ret;
> > }
> >
> > int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > {
> > - return kvm_sys_reg_set_user(vcpu, reg,
> > - id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > + u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
> > + const struct sys_reg_desc *r;
> > + struct sys_reg_params params;
> > + u64 val;
> > + int ret;
> > + u32 id;
> > +
> > + if (!index_to_params(reg->id, ¶ms))
> > + return -ENOENT;
> > + id = reg_to_encoding(¶ms);
> > +
> > + if (!is_id_reg(id))
> > + return -ENOENT;
> > +
> > + if (get_user(val, uaddr))
> > + return -EFAULT;
> > +
> > + r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
> > +
> > + if (sysreg_user_write_ignore(vcpu, r))
> > + return 0;
> > +
> > + if (r->set_user)
> > + ret = (r->set_user)(vcpu, r, val);
> > + else
> > + ret = 0;
>
> This appears to be the same handling as WI.
> How do you plan to use this set_user == NULL case ?
> I don't think this shouldn't happen with the current code.
> You might want to use WARN_ONCE here ?
Yes, you are right. It won't happen with current code. WIll use WARN_ONCE here.
>
> > +
> > + return ret;
> > }
> >
> > bool kvm_arm_check_idreg_table(void)
> > {
> > - return check_sysreg_table(id_reg_descs, ARRAY_SIZE(id_reg_descs), false);
> > + unsigned int i;
> > +
> > + for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
> > + const struct sys_reg_desc *r = &id_reg_descs[i].reg_desc;
> > +
> > + if (r->reg && !r->reset) {
>
> I don't think we need to check "!r->reset".
> If r->reg is not NULL, I believe the entry must be incorrect.
I am not sure I got your idea here? r->reg usually should not be NULL.
>
> > + kvm_err("sys_reg table %pS entry %d lacks reset\n", r, i);
> > + return false;
> > + }
> > +
> > + if (i && cmp_sys_reg(&id_reg_descs[i-1].reg_desc, r) >= 0) {
>
> In this table, each ID register needs to be in the proper place.
> So, I would think what should be checked would be if each entry
> in the table includes the right ID register.
> (e.g. id_reg_descs[0] must be for ID_PFR0_EL1, etc)
This comparison does the work, I think. It can detect any duplicate or
non-ID entry, unless all entries are wrong and in the order.
>
> Thank you,
> Reiji
>
> > + kvm_err("sys_reg table %pS entry %d out of order\n",
> > + &id_reg_descs[i - 1].reg_desc, i - 1);
> > + return false;
> > + }
> > + }
> > +
> > + return true;
> > }
> >
> > /* Assumed ordered tables, see kvm_sys_reg_table_init. */
> > int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind)
> > {
> > - const struct sys_reg_desc *i2, *end2;
> > + const struct id_reg_desc *i2, *end2;
> > unsigned int total = 0;
> > int err;
> >
> > i2 = id_reg_descs;
> > end2 = id_reg_descs + ARRAY_SIZE(id_reg_descs);
> >
> > - while (i2 != end2) {
> > - err = walk_one_sys_reg(vcpu, i2++, &uind, &total);
> > + for (; i2 != end2; i2++) {
> > + err = walk_one_sys_reg(vcpu, &(i2->reg_desc), &uind, &total);
> > if (err)
> > return err;
> > }
> > @@ -515,12 +612,12 @@ void kvm_arm_set_default_id_regs(struct kvm *kvm)
> > u64 val;
> >
> > for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
> > - id = reg_to_encoding(&id_reg_descs[i]);
> > + id = reg_to_encoding(&id_reg_descs[i].reg_desc);
> > if (WARN_ON_ONCE(!is_id_reg(id)))
> > /* Shouldn't happen */
> > continue;
> >
> > - if (id_reg_descs[i].visibility == raz_visibility)
> > + if (id_reg_descs[i].reg_desc.visibility == raz_visibility)
> > /* Hidden or reserved ID register */
> > continue;
> >
> > diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
> > index a4350f0737c3..cdcd61ac9868 100644
> > --- a/arch/arm64/kvm/sys_regs.c
> > +++ b/arch/arm64/kvm/sys_regs.c
> > @@ -2518,7 +2518,7 @@ int kvm_handle_sys_reg(struct kvm_vcpu *vcpu)
> > * Userspace API
> > *****************************************************************************/
> >
> > -static bool index_to_params(u64 id, struct sys_reg_params *params)
> > +bool index_to_params(u64 id, struct sys_reg_params *params)
> > {
> > switch (id & KVM_REG_SIZE_MASK) {
> > case KVM_REG_SIZE_U64:
> > diff --git a/arch/arm64/kvm/sys_regs.h b/arch/arm64/kvm/sys_regs.h
> > index 5cfab83ce8b8..3797d1b494a2 100644
> > --- a/arch/arm64/kvm/sys_regs.h
> > +++ b/arch/arm64/kvm/sys_regs.h
> > @@ -226,6 +226,7 @@ static inline bool write_to_read_only(struct kvm_vcpu *vcpu,
> > return false;
> > }
> >
> > +bool index_to_params(u64 id, struct sys_reg_params *params);
> > const struct sys_reg_desc *get_reg_by_id(u64 id,
> > const struct sys_reg_desc table[],
> > unsigned int num);
> > --
> > 2.39.1.581.gbfd45094c4-goog
> >
Thanks,
Jing
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [PATCH v2 5/6] KVM: arm64: Introduce ID register specific descriptor
2023-02-27 3:04 ` Jing Zhang
@ 2023-02-27 22:23 ` Reiji Watanabe
2023-02-28 1:52 ` Jing Zhang
0 siblings, 1 reply; 16+ messages in thread
From: Reiji Watanabe @ 2023-02-27 22:23 UTC (permalink / raw)
To: Jing Zhang
Cc: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton, Will Deacon,
Paolo Bonzini, James Morse, Alexandru Elisei, Suzuki K Poulose,
Fuad Tabba, Ricardo Koller, Raghavendra Rao Ananta
Hi Jing,
On Sun, Feb 26, 2023 at 7:05 PM Jing Zhang <jingzhangos@google.com> wrote:
>
> Hi Reiji,
>
> On Fri, Feb 24, 2023 at 8:00 PM Reiji Watanabe <reijiw@google.com> wrote:
> >
> > Hi Jing,
> >
> > On Sun, Feb 12, 2023 at 1:58 PM Jing Zhang <jingzhangos@google.com> wrote:
> > >
> > > Introduce an ID feature register specific descriptor to include ID
> > > register specific fields and callbacks besides its corresponding
> > > general system register descriptor.
> > > New fields for ID register descriptor would be added later when it
> > > is necessary to support a writable ID register.
> > >
> > > No functional change intended.
> > >
> > > Co-developed-by: Reiji Watanabe <reijiw@google.com>
> > > Signed-off-by: Reiji Watanabe <reijiw@google.com>
> > > Signed-off-by: Jing Zhang <jingzhangos@google.com>
> > > ---
> > > arch/arm64/kvm/id_regs.c | 187 +++++++++++++++++++++++++++++---------
> > > arch/arm64/kvm/sys_regs.c | 2 +-
> > > arch/arm64/kvm/sys_regs.h | 1 +
> > > 3 files changed, 144 insertions(+), 46 deletions(-)
> > >
> > > diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
> > > index 14ae03a1d8d0..15d0338742b6 100644
> > > --- a/arch/arm64/kvm/id_regs.c
> > > +++ b/arch/arm64/kvm/id_regs.c
> > > @@ -18,6 +18,10 @@
> > >
> > > #include "sys_regs.h"
> > >
> > > +struct id_reg_desc {
> > > + const struct sys_reg_desc reg_desc;
> > > +};
> > > +
> > > static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> > > {
> > > if (kvm_vcpu_has_pmu(vcpu))
> > > @@ -329,21 +333,25 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > > }
> > >
> > > /* sys_reg_desc initialiser for known cpufeature ID registers */
> > > -#define ID_SANITISED(name) { \
> > > - SYS_DESC(SYS_##name), \
> > > - .access = access_id_reg, \
> > > - .get_user = get_id_reg, \
> > > - .set_user = set_id_reg, \
> > > - .visibility = id_visibility, \
> > > +#define ID_SANITISED(name) { \
> > > + .reg_desc = { \
> > > + SYS_DESC(SYS_##name), \
> > > + .access = access_id_reg, \
> > > + .get_user = get_id_reg, \
> > > + .set_user = set_id_reg, \
> > > + .visibility = id_visibility, \
> > > + }, \
> > > }
> > >
> > > /* sys_reg_desc initialiser for known cpufeature ID registers */
> > > -#define AA32_ID_SANITISED(name) { \
> > > - SYS_DESC(SYS_##name), \
> > > - .access = access_id_reg, \
> > > - .get_user = get_id_reg, \
> > > - .set_user = set_id_reg, \
> > > - .visibility = aa32_id_visibility, \
> > > +#define AA32_ID_SANITISED(name) { \
> > > + .reg_desc = { \
> > > + SYS_DESC(SYS_##name), \
> > > + .access = access_id_reg, \
> > > + .get_user = get_id_reg, \
> > > + .set_user = set_id_reg, \
> > > + .visibility = aa32_id_visibility, \
> > > + }, \
> > > }
> > >
> > > /*
> > > @@ -351,12 +359,14 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > > * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
> > > * (1 <= crm < 8, 0 <= Op2 < 8).
> > > */
> > > -#define ID_UNALLOCATED(crm, op2) { \
> > > - Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> > > - .access = access_id_reg, \
> > > - .get_user = get_id_reg, \
> > > - .set_user = set_id_reg, \
> > > - .visibility = raz_visibility \
> > > +#define ID_UNALLOCATED(crm, op2) { \
> > > + .reg_desc = { \
> > > + Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> > > + .access = access_id_reg, \
> > > + .get_user = get_id_reg, \
> > > + .set_user = set_id_reg, \
> > > + .visibility = raz_visibility \
> > > + }, \
> > > }
> > >
> > > /*
> > > @@ -364,15 +374,17 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > > * For now, these are exposed just like unallocated ID regs: they appear
> > > * RAZ for the guest.
> > > */
> > > -#define ID_HIDDEN(name) { \
> > > - SYS_DESC(SYS_##name), \
> > > - .access = access_id_reg, \
> > > - .get_user = get_id_reg, \
> > > - .set_user = set_id_reg, \
> > > - .visibility = raz_visibility, \
> > > +#define ID_HIDDEN(name) { \
> > > + .reg_desc = { \
> > > + SYS_DESC(SYS_##name), \
> > > + .access = access_id_reg, \
> > > + .get_user = get_id_reg, \
> > > + .set_user = set_id_reg, \
> > > + .visibility = raz_visibility, \
> > > + }, \
> > > }
> > >
> > > -static const struct sys_reg_desc id_reg_descs[] = {
> > > +static const struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
> > > /*
> > > * ID regs: all ID_SANITISED() entries here must have corresponding
> > > * entries in arm64_ftr_regs[].
> > > @@ -382,9 +394,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > > /* CRm=1 */
> > > AA32_ID_SANITISED(ID_PFR0_EL1),
> > > AA32_ID_SANITISED(ID_PFR1_EL1),
> > > - { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
> > > - .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
> > > - .visibility = aa32_id_visibility, },
> > > + { .reg_desc = {
> > > + SYS_DESC(SYS_ID_DFR0_EL1),
> > > + .access = access_id_reg,
> > > + .get_user = get_id_reg,
> > > + .set_user = set_id_dfr0_el1,
> > > + .visibility = aa32_id_visibility, },
> > > + },
> > > ID_HIDDEN(ID_AFR0_EL1),
> > > AA32_ID_SANITISED(ID_MMFR0_EL1),
> > > AA32_ID_SANITISED(ID_MMFR1_EL1),
> > > @@ -413,8 +429,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > >
> > > /* AArch64 ID registers */
> > > /* CRm=4 */
> > > - { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
> > > - .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
> > > + { .reg_desc = {
> > > + SYS_DESC(SYS_ID_AA64PFR0_EL1),
> > > + .access = access_id_reg,
> > > + .get_user = get_id_reg,
> > > + .set_user = set_id_aa64pfr0_el1, },
> > > + },
> > > ID_SANITISED(ID_AA64PFR1_EL1),
> > > ID_UNALLOCATED(4, 2),
> > > ID_UNALLOCATED(4, 3),
> > > @@ -424,8 +444,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > > ID_UNALLOCATED(4, 7),
> > >
> > > /* CRm=5 */
> > > - { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
> > > - .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
> > > + { .reg_desc = {
> > > + SYS_DESC(SYS_ID_AA64DFR0_EL1),
> > > + .access = access_id_reg,
> > > + .get_user = get_id_reg,
> > > + .set_user = set_id_aa64dfr0_el1, },
> > > + },
> > > ID_SANITISED(ID_AA64DFR1_EL1),
> > > ID_UNALLOCATED(5, 2),
> > > ID_UNALLOCATED(5, 3),
> > > @@ -457,7 +481,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > >
> > > const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params)
> > > {
> > > - return find_reg(params, id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > > + u32 id;
> > > +
> > > + id = reg_to_encoding(params);
> > > + if (!is_id_reg(id))
> > > + return NULL;
> > > +
> > > + return &id_reg_descs[IDREG_IDX(id)].reg_desc;
> > > }
> > >
> > > void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> > > @@ -465,39 +495,106 @@ void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> > > unsigned long i;
> > >
> > > for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++)
> > > - if (id_reg_descs[i].reset)
> > > - id_reg_descs[i].reset(vcpu, &id_reg_descs[i]);
> > > + if (id_reg_descs[i].reg_desc.reset)
> > > + id_reg_descs[i].reg_desc.reset(vcpu, &id_reg_descs[i].reg_desc);
> > > }
> > >
> > > int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > > {
> > > - return kvm_sys_reg_get_user(vcpu, reg,
> > > - id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > > + u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
> > > + const struct sys_reg_desc *r;
> > > + struct sys_reg_params params;
> > > + u64 val;
> > > + int ret;
> > > + u32 id;
> > > +
> > > + if (!index_to_params(reg->id, ¶ms))
> > > + return -ENOENT;
> > > + id = reg_to_encoding(¶ms);
> > > +
> > > + if (!is_id_reg(id))
> > > + return -ENOENT;
> > > +
> > > + r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
> > > + if (r->get_user) {
> > > + ret = (r->get_user)(vcpu, r, &val);
> > > + } else {
> > > + ret = 0;
> > > + val = 0;
> >
> > When get_user is NULL, I wonder why you want to treat them RAZ.
> > It can be achieved by using visibility(), which I think might be
> > better to use before calling get_user.
> > Another option would be simply reading from IDREG(), which I would
> > guess might be useful(?) when no special handling is necessary.
> >
> Will simply use the value from IDREG().
> >
> > > + }
> > > +
> > > + if (!ret)
> > > + ret = put_user(val, uaddr);
> > > +
> > > + return ret;
> > > }
> > >
> > > int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > > {
> > > - return kvm_sys_reg_set_user(vcpu, reg,
> > > - id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > > + u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
> > > + const struct sys_reg_desc *r;
> > > + struct sys_reg_params params;
> > > + u64 val;
> > > + int ret;
> > > + u32 id;
> > > +
> > > + if (!index_to_params(reg->id, ¶ms))
> > > + return -ENOENT;
> > > + id = reg_to_encoding(¶ms);
> > > +
> > > + if (!is_id_reg(id))
> > > + return -ENOENT;
> > > +
> > > + if (get_user(val, uaddr))
> > > + return -EFAULT;
> > > +
> > > + r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
> > > +
> > > + if (sysreg_user_write_ignore(vcpu, r))
> > > + return 0;
> > > +
> > > + if (r->set_user)
> > > + ret = (r->set_user)(vcpu, r, val);
> > > + else
> > > + ret = 0;
> >
> > This appears to be the same handling as WI.
> > How do you plan to use this set_user == NULL case ?
> > I don't think this shouldn't happen with the current code.
> > You might want to use WARN_ONCE here ?
> Yes, you are right. It won't happen with current code. WIll use WARN_ONCE here.
> >
> > > +
> > > + return ret;
> > > }
> > >
> > > bool kvm_arm_check_idreg_table(void)
> > > {
> > > - return check_sysreg_table(id_reg_descs, ARRAY_SIZE(id_reg_descs), false);
> > > + unsigned int i;
> > > +
> > > + for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
> > > + const struct sys_reg_desc *r = &id_reg_descs[i].reg_desc;
> > > +
> > > + if (r->reg && !r->reset) {
> >
> > I don't think we need to check "!r->reset".
> > If r->reg is not NULL, I believe the entry must be incorrect.
> I am not sure I got your idea here? r->reg usually should not be NULL.
In general (not for ID registers), the r->reg is used as an index of sys_reg[].
In this patch, ID registers are not saved in sys_regs[], but in kvm_arch's
id_regs[]. So, I think the r->reg should be NULL for the ID registers.
(In fact, it is NULL for all ID registers in the current patch, right ?)
Or am I missing something ?
> >
> > > + kvm_err("sys_reg table %pS entry %d lacks reset\n", r, i);
> > > + return false;
> > > + }
> > > +
> > > + if (i && cmp_sys_reg(&id_reg_descs[i-1].reg_desc, r) >= 0) {
> >
> > In this table, each ID register needs to be in the proper place.
> > So, I would think what should be checked would be if each entry
> > in the table includes the right ID register.
> > (e.g. id_reg_descs[0] must be for ID_PFR0_EL1, etc)
> This comparison does the work, I think. It can detect any duplicate or
> non-ID entry, unless all entries are wrong and in the order.
Yes, I agree it does some work. There are some more cases that the
checking can't detect though (e.g. if one ID register is missing
from the table, I don't think the check can detect that).
I would prefer to adjust the checking specifically for this table
(i.e. Instead of checking the ordering, make sure that the entry
is for an ID register, and it is located in the right position).
What do you think ?
Thank you,
Reiji
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [PATCH v2 5/6] KVM: arm64: Introduce ID register specific descriptor
2023-02-27 22:23 ` Reiji Watanabe
@ 2023-02-28 1:52 ` Jing Zhang
0 siblings, 0 replies; 16+ messages in thread
From: Jing Zhang @ 2023-02-28 1:52 UTC (permalink / raw)
To: Reiji Watanabe
Cc: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton, Will Deacon,
Paolo Bonzini, James Morse, Alexandru Elisei, Suzuki K Poulose,
Fuad Tabba, Ricardo Koller, Raghavendra Rao Ananta
Hi Reiji,
On Mon, Feb 27, 2023 at 2:24 PM Reiji Watanabe <reijiw@google.com> wrote:
>
> Hi Jing,
>
> On Sun, Feb 26, 2023 at 7:05 PM Jing Zhang <jingzhangos@google.com> wrote:
> >
> > Hi Reiji,
> >
> > On Fri, Feb 24, 2023 at 8:00 PM Reiji Watanabe <reijiw@google.com> wrote:
> > >
> > > Hi Jing,
> > >
> > > On Sun, Feb 12, 2023 at 1:58 PM Jing Zhang <jingzhangos@google.com> wrote:
> > > >
> > > > Introduce an ID feature register specific descriptor to include ID
> > > > register specific fields and callbacks besides its corresponding
> > > > general system register descriptor.
> > > > New fields for ID register descriptor would be added later when it
> > > > is necessary to support a writable ID register.
> > > >
> > > > No functional change intended.
> > > >
> > > > Co-developed-by: Reiji Watanabe <reijiw@google.com>
> > > > Signed-off-by: Reiji Watanabe <reijiw@google.com>
> > > > Signed-off-by: Jing Zhang <jingzhangos@google.com>
> > > > ---
> > > > arch/arm64/kvm/id_regs.c | 187 +++++++++++++++++++++++++++++---------
> > > > arch/arm64/kvm/sys_regs.c | 2 +-
> > > > arch/arm64/kvm/sys_regs.h | 1 +
> > > > 3 files changed, 144 insertions(+), 46 deletions(-)
> > > >
> > > > diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
> > > > index 14ae03a1d8d0..15d0338742b6 100644
> > > > --- a/arch/arm64/kvm/id_regs.c
> > > > +++ b/arch/arm64/kvm/id_regs.c
> > > > @@ -18,6 +18,10 @@
> > > >
> > > > #include "sys_regs.h"
> > > >
> > > > +struct id_reg_desc {
> > > > + const struct sys_reg_desc reg_desc;
> > > > +};
> > > > +
> > > > static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
> > > > {
> > > > if (kvm_vcpu_has_pmu(vcpu))
> > > > @@ -329,21 +333,25 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > > > }
> > > >
> > > > /* sys_reg_desc initialiser for known cpufeature ID registers */
> > > > -#define ID_SANITISED(name) { \
> > > > - SYS_DESC(SYS_##name), \
> > > > - .access = access_id_reg, \
> > > > - .get_user = get_id_reg, \
> > > > - .set_user = set_id_reg, \
> > > > - .visibility = id_visibility, \
> > > > +#define ID_SANITISED(name) { \
> > > > + .reg_desc = { \
> > > > + SYS_DESC(SYS_##name), \
> > > > + .access = access_id_reg, \
> > > > + .get_user = get_id_reg, \
> > > > + .set_user = set_id_reg, \
> > > > + .visibility = id_visibility, \
> > > > + }, \
> > > > }
> > > >
> > > > /* sys_reg_desc initialiser for known cpufeature ID registers */
> > > > -#define AA32_ID_SANITISED(name) { \
> > > > - SYS_DESC(SYS_##name), \
> > > > - .access = access_id_reg, \
> > > > - .get_user = get_id_reg, \
> > > > - .set_user = set_id_reg, \
> > > > - .visibility = aa32_id_visibility, \
> > > > +#define AA32_ID_SANITISED(name) { \
> > > > + .reg_desc = { \
> > > > + SYS_DESC(SYS_##name), \
> > > > + .access = access_id_reg, \
> > > > + .get_user = get_id_reg, \
> > > > + .set_user = set_id_reg, \
> > > > + .visibility = aa32_id_visibility, \
> > > > + }, \
> > > > }
> > > >
> > > > /*
> > > > @@ -351,12 +359,14 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > > > * register with encoding Op0=3, Op1=0, CRn=0, CRm=crm, Op2=op2
> > > > * (1 <= crm < 8, 0 <= Op2 < 8).
> > > > */
> > > > -#define ID_UNALLOCATED(crm, op2) { \
> > > > - Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> > > > - .access = access_id_reg, \
> > > > - .get_user = get_id_reg, \
> > > > - .set_user = set_id_reg, \
> > > > - .visibility = raz_visibility \
> > > > +#define ID_UNALLOCATED(crm, op2) { \
> > > > + .reg_desc = { \
> > > > + Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \
> > > > + .access = access_id_reg, \
> > > > + .get_user = get_id_reg, \
> > > > + .set_user = set_id_reg, \
> > > > + .visibility = raz_visibility \
> > > > + }, \
> > > > }
> > > >
> > > > /*
> > > > @@ -364,15 +374,17 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
> > > > * For now, these are exposed just like unallocated ID regs: they appear
> > > > * RAZ for the guest.
> > > > */
> > > > -#define ID_HIDDEN(name) { \
> > > > - SYS_DESC(SYS_##name), \
> > > > - .access = access_id_reg, \
> > > > - .get_user = get_id_reg, \
> > > > - .set_user = set_id_reg, \
> > > > - .visibility = raz_visibility, \
> > > > +#define ID_HIDDEN(name) { \
> > > > + .reg_desc = { \
> > > > + SYS_DESC(SYS_##name), \
> > > > + .access = access_id_reg, \
> > > > + .get_user = get_id_reg, \
> > > > + .set_user = set_id_reg, \
> > > > + .visibility = raz_visibility, \
> > > > + }, \
> > > > }
> > > >
> > > > -static const struct sys_reg_desc id_reg_descs[] = {
> > > > +static const struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
> > > > /*
> > > > * ID regs: all ID_SANITISED() entries here must have corresponding
> > > > * entries in arm64_ftr_regs[].
> > > > @@ -382,9 +394,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > > > /* CRm=1 */
> > > > AA32_ID_SANITISED(ID_PFR0_EL1),
> > > > AA32_ID_SANITISED(ID_PFR1_EL1),
> > > > - { SYS_DESC(SYS_ID_DFR0_EL1), .access = access_id_reg,
> > > > - .get_user = get_id_reg, .set_user = set_id_dfr0_el1,
> > > > - .visibility = aa32_id_visibility, },
> > > > + { .reg_desc = {
> > > > + SYS_DESC(SYS_ID_DFR0_EL1),
> > > > + .access = access_id_reg,
> > > > + .get_user = get_id_reg,
> > > > + .set_user = set_id_dfr0_el1,
> > > > + .visibility = aa32_id_visibility, },
> > > > + },
> > > > ID_HIDDEN(ID_AFR0_EL1),
> > > > AA32_ID_SANITISED(ID_MMFR0_EL1),
> > > > AA32_ID_SANITISED(ID_MMFR1_EL1),
> > > > @@ -413,8 +429,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > > >
> > > > /* AArch64 ID registers */
> > > > /* CRm=4 */
> > > > - { SYS_DESC(SYS_ID_AA64PFR0_EL1), .access = access_id_reg,
> > > > - .get_user = get_id_reg, .set_user = set_id_aa64pfr0_el1, },
> > > > + { .reg_desc = {
> > > > + SYS_DESC(SYS_ID_AA64PFR0_EL1),
> > > > + .access = access_id_reg,
> > > > + .get_user = get_id_reg,
> > > > + .set_user = set_id_aa64pfr0_el1, },
> > > > + },
> > > > ID_SANITISED(ID_AA64PFR1_EL1),
> > > > ID_UNALLOCATED(4, 2),
> > > > ID_UNALLOCATED(4, 3),
> > > > @@ -424,8 +444,12 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > > > ID_UNALLOCATED(4, 7),
> > > >
> > > > /* CRm=5 */
> > > > - { SYS_DESC(SYS_ID_AA64DFR0_EL1), .access = access_id_reg,
> > > > - .get_user = get_id_reg, .set_user = set_id_aa64dfr0_el1, },
> > > > + { .reg_desc = {
> > > > + SYS_DESC(SYS_ID_AA64DFR0_EL1),
> > > > + .access = access_id_reg,
> > > > + .get_user = get_id_reg,
> > > > + .set_user = set_id_aa64dfr0_el1, },
> > > > + },
> > > > ID_SANITISED(ID_AA64DFR1_EL1),
> > > > ID_UNALLOCATED(5, 2),
> > > > ID_UNALLOCATED(5, 3),
> > > > @@ -457,7 +481,13 @@ static const struct sys_reg_desc id_reg_descs[] = {
> > > >
> > > > const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *params)
> > > > {
> > > > - return find_reg(params, id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > > > + u32 id;
> > > > +
> > > > + id = reg_to_encoding(params);
> > > > + if (!is_id_reg(id))
> > > > + return NULL;
> > > > +
> > > > + return &id_reg_descs[IDREG_IDX(id)].reg_desc;
> > > > }
> > > >
> > > > void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> > > > @@ -465,39 +495,106 @@ void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu)
> > > > unsigned long i;
> > > >
> > > > for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++)
> > > > - if (id_reg_descs[i].reset)
> > > > - id_reg_descs[i].reset(vcpu, &id_reg_descs[i]);
> > > > + if (id_reg_descs[i].reg_desc.reset)
> > > > + id_reg_descs[i].reg_desc.reset(vcpu, &id_reg_descs[i].reg_desc);
> > > > }
> > > >
> > > > int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > > > {
> > > > - return kvm_sys_reg_get_user(vcpu, reg,
> > > > - id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > > > + u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
> > > > + const struct sys_reg_desc *r;
> > > > + struct sys_reg_params params;
> > > > + u64 val;
> > > > + int ret;
> > > > + u32 id;
> > > > +
> > > > + if (!index_to_params(reg->id, ¶ms))
> > > > + return -ENOENT;
> > > > + id = reg_to_encoding(¶ms);
> > > > +
> > > > + if (!is_id_reg(id))
> > > > + return -ENOENT;
> > > > +
> > > > + r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
> > > > + if (r->get_user) {
> > > > + ret = (r->get_user)(vcpu, r, &val);
> > > > + } else {
> > > > + ret = 0;
> > > > + val = 0;
> > >
> > > When get_user is NULL, I wonder why you want to treat them RAZ.
> > > It can be achieved by using visibility(), which I think might be
> > > better to use before calling get_user.
> > > Another option would be simply reading from IDREG(), which I would
> > > guess might be useful(?) when no special handling is necessary.
> > >
> > Will simply use the value from IDREG().
> > >
> > > > + }
> > > > +
> > > > + if (!ret)
> > > > + ret = put_user(val, uaddr);
> > > > +
> > > > + return ret;
> > > > }
> > > >
> > > > int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
> > > > {
> > > > - return kvm_sys_reg_set_user(vcpu, reg,
> > > > - id_reg_descs, ARRAY_SIZE(id_reg_descs));
> > > > + u64 __user *uaddr = (u64 __user *)(unsigned long)reg->addr;
> > > > + const struct sys_reg_desc *r;
> > > > + struct sys_reg_params params;
> > > > + u64 val;
> > > > + int ret;
> > > > + u32 id;
> > > > +
> > > > + if (!index_to_params(reg->id, ¶ms))
> > > > + return -ENOENT;
> > > > + id = reg_to_encoding(¶ms);
> > > > +
> > > > + if (!is_id_reg(id))
> > > > + return -ENOENT;
> > > > +
> > > > + if (get_user(val, uaddr))
> > > > + return -EFAULT;
> > > > +
> > > > + r = &id_reg_descs[IDREG_IDX(id)].reg_desc;
> > > > +
> > > > + if (sysreg_user_write_ignore(vcpu, r))
> > > > + return 0;
> > > > +
> > > > + if (r->set_user)
> > > > + ret = (r->set_user)(vcpu, r, val);
> > > > + else
> > > > + ret = 0;
> > >
> > > This appears to be the same handling as WI.
> > > How do you plan to use this set_user == NULL case ?
> > > I don't think this shouldn't happen with the current code.
> > > You might want to use WARN_ONCE here ?
> > Yes, you are right. It won't happen with current code. WIll use WARN_ONCE here.
> > >
> > > > +
> > > > + return ret;
> > > > }
> > > >
> > > > bool kvm_arm_check_idreg_table(void)
> > > > {
> > > > - return check_sysreg_table(id_reg_descs, ARRAY_SIZE(id_reg_descs), false);
> > > > + unsigned int i;
> > > > +
> > > > + for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
> > > > + const struct sys_reg_desc *r = &id_reg_descs[i].reg_desc;
> > > > +
> > > > + if (r->reg && !r->reset) {
> > >
> > > I don't think we need to check "!r->reset".
> > > If r->reg is not NULL, I believe the entry must be incorrect.
> > I am not sure I got your idea here? r->reg usually should not be NULL.
>
> In general (not for ID registers), the r->reg is used as an index of sys_reg[].
> In this patch, ID registers are not saved in sys_regs[], but in kvm_arch's
> id_regs[]. So, I think the r->reg should be NULL for the ID registers.
> (In fact, it is NULL for all ID registers in the current patch, right ?)
>
> Or am I missing something ?
Got it. Thanks. Will remove the lines for checking reset callback.
> > >
> > > > + kvm_err("sys_reg table %pS entry %d lacks reset\n", r, i);
> > > > + return false;
> > > > + }
> > > > +
> > > > + if (i && cmp_sys_reg(&id_reg_descs[i-1].reg_desc, r) >= 0) {
> > >
> > > In this table, each ID register needs to be in the proper place.
> > > So, I would think what should be checked would be if each entry
> > > in the table includes the right ID register.
> > > (e.g. id_reg_descs[0] must be for ID_PFR0_EL1, etc)
> > This comparison does the work, I think. It can detect any duplicate or
> > non-ID entry, unless all entries are wrong and in the order.
>
> Yes, I agree it does some work. There are some more cases that the
> checking can't detect though (e.g. if one ID register is missing
> from the table, I don't think the check can detect that).
> I would prefer to adjust the checking specifically for this table
> (i.e. Instead of checking the ordering, make sure that the entry
> is for an ID register, and it is located in the right position).
> What do you think ?
Agreed. Will improve the checking.
>
> Thank you,
> Reiji
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply [flat|nested] 16+ messages in thread
* [PATCH v2 6/6] KVM: arm64: Refactor writings for PMUVer/CSV2/CSV3
2023-02-12 21:58 [PATCH v2 0/6] Support writable CPU ID registers from userspace Jing Zhang
` (4 preceding siblings ...)
2023-02-12 21:58 ` [PATCH v2 5/6] KVM: arm64: Introduce ID register specific descriptor Jing Zhang
@ 2023-02-12 21:58 ` Jing Zhang
5 siblings, 0 replies; 16+ messages in thread
From: Jing Zhang @ 2023-02-12 21:58 UTC (permalink / raw)
To: KVM, KVMARM, ARMLinux, Marc Zyngier, Oliver Upton
Cc: Will Deacon, Paolo Bonzini, James Morse, Alexandru Elisei,
Suzuki K Poulose, Fuad Tabba, Reiji Watanabe, Ricardo Koller,
Raghavendra Rao Ananta, Jing Zhang
Save KVM sanitised ID register value in ID descriptor (kvm_sys_val).
Add an init callback for every ID register to setup kvm_sys_val.
All per VCPU sanitizations are still handled on the fly during ID
register read and write from userspace.
An arm64_ftr_bits array is used to indicate writable feature fields.
Refactor writings for ID_AA64PFR0_EL1.[CSV2|CSV3],
ID_AA64DFR0_EL1.PMUVer and ID_DFR0_ELF.PerfMon based on utilities
introduced by ID register descriptor.
No functional change intended.
Co-developed-by: Reiji Watanabe <reijiw@google.com>
Signed-off-by: Reiji Watanabe <reijiw@google.com>
Signed-off-by: Jing Zhang <jingzhangos@google.com>
---
arch/arm64/include/asm/cpufeature.h | 25 +++
arch/arm64/include/asm/kvm_host.h | 2 +-
arch/arm64/kernel/cpufeature.c | 26 +--
arch/arm64/kvm/arm.c | 2 +-
arch/arm64/kvm/id_regs.c | 337 +++++++++++++++++++---------
arch/arm64/kvm/sys_regs.c | 3 +-
arch/arm64/kvm/sys_regs.h | 2 +-
7 files changed, 257 insertions(+), 140 deletions(-)
diff --git a/arch/arm64/include/asm/cpufeature.h b/arch/arm64/include/asm/cpufeature.h
index fc2c739f48f1..493ec530eefc 100644
--- a/arch/arm64/include/asm/cpufeature.h
+++ b/arch/arm64/include/asm/cpufeature.h
@@ -64,6 +64,30 @@ struct arm64_ftr_bits {
s64 safe_val; /* safe value for FTR_EXACT features */
};
+#define __ARM64_FTR_BITS(SIGNED, VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL) \
+ { \
+ .sign = SIGNED, \
+ .visible = VISIBLE, \
+ .strict = STRICT, \
+ .type = TYPE, \
+ .shift = SHIFT, \
+ .width = WIDTH, \
+ .safe_val = SAFE_VAL, \
+ }
+
+/* Define a feature with unsigned values */
+#define ARM64_FTR_BITS(VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL) \
+ __ARM64_FTR_BITS(FTR_UNSIGNED, VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL)
+
+/* Define a feature with a signed value */
+#define S_ARM64_FTR_BITS(VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL) \
+ __ARM64_FTR_BITS(FTR_SIGNED, VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL)
+
+#define ARM64_FTR_END \
+ { \
+ .width = 0, \
+ }
+
/*
* Describe the early feature override to the core override code:
*
@@ -911,6 +935,7 @@ static inline unsigned int get_vmid_bits(u64 mmfr1)
return 8;
}
+s64 arm64_ftr_safe_value(const struct arm64_ftr_bits *ftrp, s64 new, s64 cur);
struct arm64_ftr_reg *get_arm64_ftr_reg(u32 sys_id);
extern struct arm64_ftr_override id_aa64mmfr1_override;
diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index effb61a9a855..4795f81b31b4 100644
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -1015,7 +1015,7 @@ int kvm_arm_vcpu_arch_has_attr(struct kvm_vcpu *vcpu,
long kvm_vm_ioctl_mte_copy_tags(struct kvm *kvm,
struct kvm_arm_copy_mte_tags *copy_tags);
-void kvm_arm_set_default_id_regs(struct kvm *kvm);
+void kvm_arm_init_id_regs(struct kvm *kvm);
/* Guest/host FPSIMD coordination helpers */
int kvm_arch_vcpu_run_map_fp(struct kvm_vcpu *vcpu);
diff --git a/arch/arm64/kernel/cpufeature.c b/arch/arm64/kernel/cpufeature.c
index 23bd2a926b74..e18848ee4b98 100644
--- a/arch/arm64/kernel/cpufeature.c
+++ b/arch/arm64/kernel/cpufeature.c
@@ -139,30 +139,6 @@ void dump_cpu_features(void)
pr_emerg("0x%*pb\n", ARM64_NCAPS, &cpu_hwcaps);
}
-#define __ARM64_FTR_BITS(SIGNED, VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL) \
- { \
- .sign = SIGNED, \
- .visible = VISIBLE, \
- .strict = STRICT, \
- .type = TYPE, \
- .shift = SHIFT, \
- .width = WIDTH, \
- .safe_val = SAFE_VAL, \
- }
-
-/* Define a feature with unsigned values */
-#define ARM64_FTR_BITS(VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL) \
- __ARM64_FTR_BITS(FTR_UNSIGNED, VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL)
-
-/* Define a feature with a signed value */
-#define S_ARM64_FTR_BITS(VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL) \
- __ARM64_FTR_BITS(FTR_SIGNED, VISIBLE, STRICT, TYPE, SHIFT, WIDTH, SAFE_VAL)
-
-#define ARM64_FTR_END \
- { \
- .width = 0, \
- }
-
static void cpu_enable_cnp(struct arm64_cpu_capabilities const *cap);
static bool __system_matches_cap(unsigned int n);
@@ -790,7 +766,7 @@ static u64 arm64_ftr_set_value(const struct arm64_ftr_bits *ftrp, s64 reg,
return reg;
}
-static s64 arm64_ftr_safe_value(const struct arm64_ftr_bits *ftrp, s64 new,
+s64 arm64_ftr_safe_value(const struct arm64_ftr_bits *ftrp, s64 new,
s64 cur)
{
s64 ret = 0;
diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
index fb2de2cb98cb..e539d9ca9d01 100644
--- a/arch/arm64/kvm/arm.c
+++ b/arch/arm64/kvm/arm.c
@@ -135,7 +135,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
/* The maximum number of VCPUs is limited by the host's GIC model */
kvm->max_vcpus = kvm_arm_default_max_vcpus();
- kvm_arm_set_default_id_regs(kvm);
+ kvm_arm_init_id_regs(kvm);
kvm_arm_init_hypercalls(kvm);
return 0;
diff --git a/arch/arm64/kvm/id_regs.c b/arch/arm64/kvm/id_regs.c
index 15d0338742b6..6d0a3b200abd 100644
--- a/arch/arm64/kvm/id_regs.c
+++ b/arch/arm64/kvm/id_regs.c
@@ -18,10 +18,88 @@
#include "sys_regs.h"
+/*
+ * Number of entries in id_reg_desc's ftr_bits[] (Number of 4 bits fields
+ * in 64 bit register + 1 entry for a terminator entry).
+ */
+#define FTR_FIELDS_NUM 17
+
struct id_reg_desc {
const struct sys_reg_desc reg_desc;
+ /*
+ * KVM sanitised ID register value.
+ * It is the default value for per VM emulated ID register.
+ */
+ u64 kvm_sys_val;
+ /*
+ * Used to validate the ID register values with arm64_check_features().
+ * The last item in the array must be terminated by an item whose
+ * width field is zero as that is expected by arm64_check_features().
+ * Only feature bits defined in this array are writable.
+ */
+ struct arm64_ftr_bits ftr_bits[FTR_FIELDS_NUM];
+
+ /*
+ * Basically init() is used to setup the KVM sanitised value
+ * stored in kvm_sys_val.
+ */
+ void (*init)(struct id_reg_desc *idr);
};
+static struct id_reg_desc id_reg_descs[];
+
+/**
+ * arm64_check_features() - Check if a feature register value constitutes
+ * a subset of features indicated by @limit.
+ *
+ * @ftrp: Pointer to an array of arm64_ftr_bits. It must be terminated by
+ * an item whose width field is zero.
+ * @val: The feature register value to check
+ * @limit: The limit value of the feature register
+ *
+ * This function will check if each feature field of @val is the "safe" value
+ * against @limit based on @ftrp[], each of which specifies the target field
+ * (shift, width), whether or not the field is for a signed value (sign),
+ * how the field is determined to be "safe" (type), and the safe value
+ * (safe_val) when type == FTR_EXACT (safe_val won't be used by this
+ * function when type != FTR_EXACT). Any other fields in arm64_ftr_bits
+ * won't be used by this function. If a field value in @val is the same
+ * as the one in @limit, it is always considered the safe value regardless
+ * of the type. For register fields that are not in @ftrp[], only the value
+ * in @limit is considered the safe value.
+ *
+ * Return: 0 if all the fields are safe. Otherwise, return negative errno.
+ */
+static int arm64_check_features(const struct arm64_ftr_bits *ftrp, u64 val, u64 limit)
+{
+ u64 mask = 0;
+
+ for (; ftrp->width; ftrp++) {
+ s64 f_val, f_lim, safe_val;
+
+ f_val = arm64_ftr_value(ftrp, val);
+ f_lim = arm64_ftr_value(ftrp, limit);
+ mask |= arm64_ftr_mask(ftrp);
+
+ if (f_val == f_lim)
+ safe_val = f_val;
+ else
+ safe_val = arm64_ftr_safe_value(ftrp, f_val, f_lim);
+
+ if (safe_val != f_val)
+ return -E2BIG;
+ }
+
+ /*
+ * For fields that are not indicated in ftrp, values in limit are the
+ * safe values.
+ */
+ if ((val & ~mask) != (limit & ~mask))
+ return -E2BIG;
+
+ return 0;
+}
+
static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
{
if (kvm_vcpu_has_pmu(vcpu))
@@ -33,19 +111,6 @@ static u8 vcpu_pmuver(const struct kvm_vcpu *vcpu)
return 0;
}
-static u8 perfmon_to_pmuver(u8 perfmon)
-{
- switch (perfmon) {
- case ID_DFR0_EL1_PerfMon_PMUv3:
- return ID_AA64DFR0_EL1_PMUVer_IMP;
- case ID_DFR0_EL1_PerfMon_IMPDEF:
- return ID_AA64DFR0_EL1_PMUVer_IMP_DEF;
- default:
- /* Anything ARMv8.1+ and NI have the same value. For now. */
- return perfmon;
- }
-}
-
static u8 pmuver_to_perfmon(u8 pmuver)
{
switch (pmuver) {
@@ -78,7 +143,6 @@ u64 kvm_arm_read_id_reg_with_encoding(const struct kvm_vcpu *vcpu, u32 id)
case SYS_ID_AA64PFR0_EL1:
if (!vcpu_has_sve(vcpu))
val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_SVE);
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_AMU);
if (kvm_vgic_global_state.type == VGIC_V3) {
val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC);
val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC), 1);
@@ -105,15 +169,10 @@ u64 kvm_arm_read_id_reg_with_encoding(const struct kvm_vcpu *vcpu, u32 id)
val &= ~ARM64_FEATURE_MASK(ID_AA64ISAR2_EL1_WFxT);
break;
case SYS_ID_AA64DFR0_EL1:
- /* Limit debug to ARMv8.0 */
- val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer), 6);
/* Set PMUver to the required version */
val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
vcpu_pmuver(vcpu));
- /* Hide SPE from guests */
- val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMSVer);
break;
case SYS_ID_DFR0_EL1:
val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
@@ -172,9 +231,15 @@ static int get_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *rd,
u64 val)
{
- /* This is what we mean by invariant: you can't change it. */
- if (val != read_id_reg(vcpu, rd))
- return -EINVAL;
+ int ret;
+ int id = reg_to_encoding(rd);
+
+ ret = arm64_check_features(id_reg_descs[IDREG_IDX(id)].ftr_bits, val,
+ id_reg_descs[IDREG_IDX(id)].kvm_sys_val);
+ if (ret)
+ return ret;
+
+ IDREG(vcpu->kvm, id) = val;
return 0;
}
@@ -208,12 +273,47 @@ static unsigned int aa32_id_visibility(const struct kvm_vcpu *vcpu,
return id_visibility(vcpu, r);
}
+static void init_id_reg(struct id_reg_desc *idr)
+{
+ idr->kvm_sys_val = read_sanitised_ftr_reg(reg_to_encoding(&idr->reg_desc));
+}
+
+static void init_id_aa64pfr0_el1(struct id_reg_desc *idr)
+{
+ u64 val;
+ u32 id = reg_to_encoding(&idr->reg_desc);
+
+ val = read_sanitised_ftr_reg(id);
+ /*
+ * The default is to expose CSV2 == 1 if the HW isn't affected.
+ * Although this is a per-CPU feature, we make it global because
+ * asymmetric systems are just a nuisance.
+ *
+ * Userspace can override this as long as it doesn't promise
+ * the impossible.
+ */
+ if (arm64_get_spectre_v2_state() == SPECTRE_UNAFFECTED) {
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2), 1);
+ }
+ if (arm64_get_meltdown_state() == SPECTRE_UNAFFECTED) {
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3), 1);
+ }
+
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_AMU);
+
+ val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_GIC), 1);
+
+ idr->kvm_sys_val = val;
+}
+
static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
const struct sys_reg_desc *rd,
u64 val)
{
u8 csv2, csv3;
- u64 sval = val;
/*
* Allow AA64PFR0_EL1.CSV2 to be set from userspace as long as
@@ -231,16 +331,29 @@ static int set_id_aa64pfr0_el1(struct kvm_vcpu *vcpu,
(csv3 && arm64_get_meltdown_state() != SPECTRE_UNAFFECTED))
return -EINVAL;
- /* We can only differ with CSV[23], and anything else is an error */
- val ^= read_id_reg(vcpu, rd);
- val &= ~(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2) |
- ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3));
- if (val)
- return -EINVAL;
+ return set_id_reg(vcpu, rd, val);
+}
- IDREG_RD(vcpu->kvm, rd) = sval;
+static void init_id_aa64dfr0_el1(struct id_reg_desc *idr)
+{
+ u64 val;
+ u32 id = reg_to_encoding(&idr->reg_desc);
- return 0;
+ val = read_sanitised_ftr_reg(id);
+ /* Limit debug to ARMv8.0 */
+ val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_DebugVer), 6);
+ /*
+ * Initialise the default PMUver before there is a chance to
+ * create an actual PMU.
+ */
+ val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
+ kvm_arm_pmu_get_pmuver_limit());
+ /* Hide SPE from guests */
+ val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMSVer);
+
+ idr->kvm_sys_val = val;
}
static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
@@ -268,23 +381,39 @@ static int set_id_aa64dfr0_el1(struct kvm_vcpu *vcpu,
if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
return -EINVAL;
- /* We can only differ with PMUver, and anything else is an error */
- val ^= read_id_reg(vcpu, rd);
- val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
- if (val)
- return -EINVAL;
-
if (valid_pmu) {
- IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
- IDREG(vcpu->kvm, SYS_ID_AA64DFR0_EL1) |=
- FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer), pmuver);
- } else if (pmuver == ID_AA64DFR0_EL1_PMUVer_IMP_DEF) {
- set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+ return set_id_reg(vcpu, rd, val);
} else {
- clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+ /* We can only differ with PMUver, and anything else is an error */
+ val ^= read_id_reg(vcpu, rd);
+ val &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
+ if (val)
+ return -EINVAL;
+
+ if (pmuver == ID_AA64DFR0_EL1_PMUVer_IMP_DEF)
+ set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+ else
+ clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+
+ return 0;
}
+}
- return 0;
+static void init_id_dfr0_el1(struct id_reg_desc *idr)
+{
+ u64 val;
+ u32 id = reg_to_encoding(&idr->reg_desc);
+
+ val = read_sanitised_ftr_reg(id);
+ /*
+ * Initialise the default PMUver before there is a chance to
+ * create an actual PMU.
+ */
+ val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
+ val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon),
+ kvm_arm_pmu_get_pmuver_limit());
+
+ idr->kvm_sys_val = val;
}
static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
@@ -313,34 +442,37 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
if (kvm_vcpu_has_pmu(vcpu) != valid_pmu)
return -EINVAL;
- /* We can only differ with PerfMon, and anything else is an error */
- val ^= read_id_reg(vcpu, rd);
- val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
- if (val)
- return -EINVAL;
-
if (valid_pmu) {
- IDREG(vcpu->kvm, SYS_ID_DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
- IDREG(vcpu->kvm, SYS_ID_DFR0_EL1) |=
- FIELD_PREP(ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon), perfmon_to_pmuver(perfmon));
- } else if (perfmon == ID_DFR0_EL1_PerfMon_IMPDEF) {
- set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+ return set_id_reg(vcpu, rd, val);
} else {
- clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
- }
+ /* We can only differ with PerfMon, and anything else is an error */
+ val ^= read_id_reg(vcpu, rd);
+ val &= ~ARM64_FEATURE_MASK(ID_DFR0_EL1_PerfMon);
+ if (val)
+ return -EINVAL;
- return 0;
+ if (perfmon == ID_DFR0_EL1_PerfMon_IMPDEF)
+ set_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+ else
+ clear_bit(KVM_ARCH_FLAG_VCPU_HAS_IMP_DEF_PMU, &vcpu->kvm->arch.flags);
+
+ return 0;
+ }
}
/* sys_reg_desc initialiser for known cpufeature ID registers */
+#define SYS_DESC_SANITISED(name) { \
+ SYS_DESC(SYS_##name), \
+ .access = access_id_reg, \
+ .get_user = get_id_reg, \
+ .set_user = set_id_reg, \
+ .visibility = id_visibility, \
+}
+
#define ID_SANITISED(name) { \
- .reg_desc = { \
- SYS_DESC(SYS_##name), \
- .access = access_id_reg, \
- .get_user = get_id_reg, \
- .set_user = set_id_reg, \
- .visibility = id_visibility, \
- }, \
+ .reg_desc = SYS_DESC_SANITISED(name), \
+ .ftr_bits = { ARM64_FTR_END, }, \
+ .init = init_id_reg, \
}
/* sys_reg_desc initialiser for known cpufeature ID registers */
@@ -352,6 +484,8 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
.set_user = set_id_reg, \
.visibility = aa32_id_visibility, \
}, \
+ .ftr_bits = { ARM64_FTR_END, }, \
+ .init = init_id_reg, \
}
/*
@@ -367,6 +501,7 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
.set_user = set_id_reg, \
.visibility = raz_visibility \
}, \
+ .ftr_bits = { ARM64_FTR_END, }, \
}
/*
@@ -382,9 +517,10 @@ static int set_id_dfr0_el1(struct kvm_vcpu *vcpu,
.set_user = set_id_reg, \
.visibility = raz_visibility, \
}, \
+ .ftr_bits = { ARM64_FTR_END, }, \
}
-static const struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
+static struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
/*
* ID regs: all ID_SANITISED() entries here must have corresponding
* entries in arm64_ftr_regs[].
@@ -400,6 +536,11 @@ static const struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
.get_user = get_id_reg,
.set_user = set_id_dfr0_el1,
.visibility = aa32_id_visibility, },
+ .ftr_bits = {
+ ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE,
+ ID_DFR0_EL1_PerfMon_SHIFT, ID_DFR0_EL1_PerfMon_WIDTH, 0),
+ ARM64_FTR_END, },
+ .init = init_id_dfr0_el1,
},
ID_HIDDEN(ID_AFR0_EL1),
AA32_ID_SANITISED(ID_MMFR0_EL1),
@@ -434,6 +575,13 @@ static const struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
.access = access_id_reg,
.get_user = get_id_reg,
.set_user = set_id_aa64pfr0_el1, },
+ .ftr_bits = {
+ ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE,
+ ID_AA64PFR0_EL1_CSV2_SHIFT, ID_AA64PFR0_EL1_CSV2_WIDTH, 0),
+ ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE,
+ ID_AA64PFR0_EL1_CSV3_SHIFT, ID_AA64PFR0_EL1_CSV3_WIDTH, 0),
+ ARM64_FTR_END, },
+ .init = init_id_aa64pfr0_el1,
},
ID_SANITISED(ID_AA64PFR1_EL1),
ID_UNALLOCATED(4, 2),
@@ -449,6 +597,11 @@ static const struct id_reg_desc id_reg_descs[KVM_ARM_ID_REG_NUM] = {
.access = access_id_reg,
.get_user = get_id_reg,
.set_user = set_id_aa64dfr0_el1, },
+ .ftr_bits = {
+ ARM64_FTR_BITS(FTR_VISIBLE, FTR_STRICT, FTR_LOWER_SAFE,
+ ID_AA64DFR0_EL1_PMUVer_SHIFT, ID_AA64DFR0_EL1_PMUVer_WIDTH, 0),
+ ARM64_FTR_END, },
+ .init = init_id_aa64dfr0_el1,
},
ID_SANITISED(ID_AA64DFR1_EL1),
ID_UNALLOCATED(5, 2),
@@ -561,7 +714,7 @@ int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
return ret;
}
-bool kvm_arm_check_idreg_table(void)
+bool kvm_arm_idreg_table_init(void)
{
unsigned int i;
@@ -578,6 +731,9 @@ bool kvm_arm_check_idreg_table(void)
&id_reg_descs[i - 1].reg_desc, i - 1);
return false;
}
+
+ if (id_reg_descs[i].init)
+ id_reg_descs[i].init(&id_reg_descs[i]);
}
return true;
@@ -602,55 +758,16 @@ int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind)
}
/*
- * Set the guest's ID registers that are defined in id_reg_descs[]
- * with ID_SANITISED() to the host's sanitized value.
+ * Initialize the guest's ID registers with KVM sanitised values that were setup
+ * during ID register descriptors initialization.
*/
-void kvm_arm_set_default_id_regs(struct kvm *kvm)
+void kvm_arm_init_id_regs(struct kvm *kvm)
{
int i;
u32 id;
- u64 val;
for (i = 0; i < ARRAY_SIZE(id_reg_descs); i++) {
id = reg_to_encoding(&id_reg_descs[i].reg_desc);
- if (WARN_ON_ONCE(!is_id_reg(id)))
- /* Shouldn't happen */
- continue;
-
- if (id_reg_descs[i].reg_desc.visibility == raz_visibility)
- /* Hidden or reserved ID register */
- continue;
-
- val = read_sanitised_ftr_reg(id);
- IDREG(kvm, id) = val;
- }
- /*
- * The default is to expose CSV2 == 1 if the HW isn't affected.
- * Although this is a per-CPU feature, we make it global because
- * asymmetric systems are just a nuisance.
- *
- * Userspace can override this as long as it doesn't promise
- * the impossible.
- */
- val = IDREG(kvm, SYS_ID_AA64PFR0_EL1);
-
- if (arm64_get_spectre_v2_state() == SPECTRE_UNAFFECTED) {
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV2), 1);
+ IDREG(kvm, id) = id_reg_descs[i].kvm_sys_val;
}
- if (arm64_get_meltdown_state() == SPECTRE_UNAFFECTED) {
- val &= ~ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3);
- val |= FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64PFR0_EL1_CSV3), 1);
- }
-
- IDREG(kvm, SYS_ID_AA64PFR0_EL1) = val;
-
- /*
- * Initialise the default PMUver before there is a chance to
- * create an actual PMU.
- */
- IDREG(kvm, SYS_ID_AA64DFR0_EL1) &= ~ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer);
- IDREG(kvm, SYS_ID_AA64DFR0_EL1) |=
- FIELD_PREP(ARM64_FEATURE_MASK(ID_AA64DFR0_EL1_PMUVer),
- kvm_arm_pmu_get_pmuver_limit());
}
diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
index cdcd61ac9868..c377f4a3e3bf 100644
--- a/arch/arm64/kvm/sys_regs.c
+++ b/arch/arm64/kvm/sys_regs.c
@@ -2911,14 +2911,13 @@ int __init kvm_sys_reg_table_init(void)
unsigned int i;
/* Make sure tables are unique and in order. */
- valid &= kvm_arm_check_idreg_table();
valid &= check_sysreg_table(sys_reg_descs, ARRAY_SIZE(sys_reg_descs), false);
valid &= check_sysreg_table(cp14_regs, ARRAY_SIZE(cp14_regs), true);
valid &= check_sysreg_table(cp14_64_regs, ARRAY_SIZE(cp14_64_regs), true);
valid &= check_sysreg_table(cp15_regs, ARRAY_SIZE(cp15_regs), true);
valid &= check_sysreg_table(cp15_64_regs, ARRAY_SIZE(cp15_64_regs), true);
valid &= check_sysreg_table(invariant_sys_regs, ARRAY_SIZE(invariant_sys_regs), false);
-
+ valid &= kvm_arm_idreg_table_init();
if (!valid)
return -EINVAL;
diff --git a/arch/arm64/kvm/sys_regs.h b/arch/arm64/kvm/sys_regs.h
index 3797d1b494a2..0b22955d233b 100644
--- a/arch/arm64/kvm/sys_regs.h
+++ b/arch/arm64/kvm/sys_regs.h
@@ -247,7 +247,7 @@ const struct sys_reg_desc *kvm_arm_find_id_reg(const struct sys_reg_params *para
void kvm_arm_reset_id_regs(struct kvm_vcpu *vcpu);
int kvm_arm_get_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
int kvm_arm_set_id_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);
-bool kvm_arm_check_idreg_table(void);
+bool kvm_arm_idreg_table_init(void);
int kvm_arm_walk_id_regs(struct kvm_vcpu *vcpu, u64 __user *uind);
u64 kvm_arm_read_id_reg_with_encoding(const struct kvm_vcpu *vcpu, u32 id);
--
2.39.1.581.gbfd45094c4-goog
_______________________________________________
linux-arm-kernel mailing list
linux-arm-kernel@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
^ permalink raw reply related [flat|nested] 16+ messages in thread