KVM: arm64: Move sysreg reset check to boot time

Our sysreg reset check has become a bit silly, as it only checks whether
a reset callback actually exists for a given sysreg entry, and apply the
method if available. Doing the check at each vcpu reset is pretty dumb,
as the tables never change. It is thus perfectly possible to do the same
checks at boot time.

This also allows us to introduce a sparse sys_regs[] array, something
that will be required with ARMv8.4-NV.

Signed-off-by: Marc Zyngier <maz@kernel.org>

diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c
index 9d28eabbdf9758c0cd65f56c7996fc36e40afc7d..ad1d57501d6d8e7fc20fbf1d7cee241736c8da51 100644 (file)
--- a/arch/arm64/kvm/sys_regs.c
+++ b/arch/arm64/kvm/sys_regs.c
@@ -2087,12 +2087,37 @@ static const struct sys_reg_desc cp15_64_regs[] = {
        { SYS_DESC(SYS_AARCH32_CNTP_CVAL),    access_arch_timer },
 };
 
+static int check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,
+                             bool is_32)
+{
+       unsigned int i;
+
+       for (i = 0; i < n; i++) {
+               if (!is_32 && table[i].reg && !table[i].reset) {
+                       kvm_err("sys_reg table %p entry %d has lacks reset\n",
+                               table, i);
+                       return 1;
+               }
+
+               if (i && cmp_sys_reg(&table[i-1], &table[i]) >= 0) {
+                       kvm_err("sys_reg table %p out of order (%d)\n", table, i - 1);
+                       return 1;
+               }
+       }
+
+       return 0;
+}
+
 /* Target specific emulation tables */
 static struct kvm_sys_reg_target_table *target_tables[KVM_ARM_NUM_TARGETS];
 
 void kvm_register_target_sys_reg_table(unsigned int target,
                                       struct kvm_sys_reg_target_table *table)
 {
+       if (check_sysreg_table(table->table64.table, table->table64.num, false) ||
+           check_sysreg_table(table->table32.table, table->table32.num, true))
+               return;
+
        target_tables[target] = table;
 }
 
@@ -2378,19 +2403,13 @@ static int emulate_sys_reg(struct kvm_vcpu *vcpu,
 }
 
 static void reset_sys_reg_descs(struct kvm_vcpu *vcpu,
-                               const struct sys_reg_desc *table, size_t num,
-                               unsigned long *bmap)
+                               const struct sys_reg_desc *table, size_t num)
 {
        unsigned long i;
 
        for (i = 0; i < num; i++)
-               if (table[i].reset) {
-                       int reg = table[i].reg;
-
+               if (table[i].reset)
                        table[i].reset(vcpu, &table[i]);
-                       if (reg > 0 && reg < NR_SYS_REGS)
-                               set_bit(reg, bmap);
-               }
 }
 
 /**
@@ -2846,32 +2865,18 @@ int kvm_arm_copy_sys_reg_indices(struct kvm_vcpu *vcpu, u64 __user *uindices)
        return write_demux_regids(uindices);
 }
 
-static int check_sysreg_table(const struct sys_reg_desc *table, unsigned int n)
-{
-       unsigned int i;
-
-       for (i = 1; i < n; i++) {
-               if (cmp_sys_reg(&table[i-1], &table[i]) >= 0) {
-                       kvm_err("sys_reg table %p out of order (%d)\n", table, i - 1);
-                       return 1;
-               }
-       }
-
-       return 0;
-}
-
 void kvm_sys_reg_table_init(void)
 {
        unsigned int i;
        struct sys_reg_desc clidr;
 
        /* Make sure tables are unique and in order. */
-       BUG_ON(check_sysreg_table(sys_reg_descs, ARRAY_SIZE(sys_reg_descs)));
-       BUG_ON(check_sysreg_table(cp14_regs, ARRAY_SIZE(cp14_regs)));
-       BUG_ON(check_sysreg_table(cp14_64_regs, ARRAY_SIZE(cp14_64_regs)));
-       BUG_ON(check_sysreg_table(cp15_regs, ARRAY_SIZE(cp15_regs)));
-       BUG_ON(check_sysreg_table(cp15_64_regs, ARRAY_SIZE(cp15_64_regs)));
-       BUG_ON(check_sysreg_table(invariant_sys_regs, ARRAY_SIZE(invariant_sys_regs)));
+       BUG_ON(check_sysreg_table(sys_reg_descs, ARRAY_SIZE(sys_reg_descs), false));
+       BUG_ON(check_sysreg_table(cp14_regs, ARRAY_SIZE(cp14_regs), true));
+       BUG_ON(check_sysreg_table(cp14_64_regs, ARRAY_SIZE(cp14_64_regs), true));
+       BUG_ON(check_sysreg_table(cp15_regs, ARRAY_SIZE(cp15_regs), true));
+       BUG_ON(check_sysreg_table(cp15_64_regs, ARRAY_SIZE(cp15_64_regs), true));
+       BUG_ON(check_sysreg_table(invariant_sys_regs, ARRAY_SIZE(invariant_sys_regs), false));
 
        /* We abuse the reset function to overwrite the table itself. */
        for (i = 0; i < ARRAY_SIZE(invariant_sys_regs); i++)
@@ -2907,17 +2912,10 @@ void kvm_reset_sys_regs(struct kvm_vcpu *vcpu)
 {
        size_t num;
        const struct sys_reg_desc *table;
-       DECLARE_BITMAP(bmap, NR_SYS_REGS) = { 0, };
 
        /* Generic chip reset first (so target could override). */
-       reset_sys_reg_descs(vcpu, sys_reg_descs, ARRAY_SIZE(sys_reg_descs), bmap);
+       reset_sys_reg_descs(vcpu, sys_reg_descs, ARRAY_SIZE(sys_reg_descs));
 
        table = get_target_table(vcpu->arch.target, true, &num);
-       reset_sys_reg_descs(vcpu, table, num, bmap);
-
-       for (num = 1; num < NR_SYS_REGS; num++) {
-               if (WARN(!test_bit(num, bmap),
-                        "Didn't reset __vcpu_sys_reg(%zi)\n", num))
-                       break;
-       }
+       reset_sys_reg_descs(vcpu, table, num);
 }