KVM: arm64: nv: Turn encoding ranges into discrete XArray stores

In order to be able to store different values for member of an
encoding range, replace xa_store_range() calls with discrete
xa_store() calls and an encoding iterator.

We end-up using a bit more memory, but we gain some flexibility
that we will make use of shortly.

Take this opportunity to tidy up the error handling path.

Signed-off-by: Marc Zyngier <maz@kernel.org>
Reviewed-by: Joey Gouly <joey.gouly@arm.com>
Link: https://lore.kernel.org/r/20240214131827.2856277-11-maz@kernel.org
Signed-off-by: Oliver Upton <oliver.upton@linux.dev>

diff --git a/arch/arm64/kvm/emulate-nested.c b/arch/arm64/kvm/emulate-nested.c
index ef46c2e4530700262b62f43a1c5809a2c6e95b79..42f5b4483c806b2548d4103496b41f8642d6f807 100644 (file)
--- a/arch/arm64/kvm/emulate-nested.c
+++ b/arch/arm64/kvm/emulate-nested.c
@@ -1757,6 +1757,28 @@ static __init void print_nv_trap_error(const struct encoding_to_trap_config *tc,
                err);
 }
 
+static u32 encoding_next(u32 encoding)
+{
+       u8 op0, op1, crn, crm, op2;
+
+       op0 = sys_reg_Op0(encoding);
+       op1 = sys_reg_Op1(encoding);
+       crn = sys_reg_CRn(encoding);
+       crm = sys_reg_CRm(encoding);
+       op2 = sys_reg_Op2(encoding);
+
+       if (op2 < Op2_mask)
+               return sys_reg(op0, op1, crn, crm, op2 + 1);
+       if (crm < CRm_mask)
+               return sys_reg(op0, op1, crn, crm + 1, 0);
+       if (crn < CRn_mask)
+               return sys_reg(op0, op1, crn + 1, 0, 0);
+       if (op1 < Op1_mask)
+               return sys_reg(op0, op1 + 1, 0, 0, 0);
+
+       return sys_reg(op0 + 1, 0, 0, 0, 0);
+}
+
 int __init populate_nv_trap_config(void)
 {
        int ret = 0;
@@ -1775,23 +1797,18 @@ int __init populate_nv_trap_config(void)
                        ret = -EINVAL;
                }
 
-               if (cgt->encoding != cgt->end) {
-                       prev = xa_store_range(&sr_forward_xa,
-                                             cgt->encoding, cgt->end,
-                                             xa_mk_value(cgt->tc.val),
-                                             GFP_KERNEL);
-               } else {
-                       prev = xa_store(&sr_forward_xa, cgt->encoding,
+               for (u32 enc = cgt->encoding; enc <= cgt->end; enc = encoding_next(enc)) {
+                       prev = xa_store(&sr_forward_xa, enc,
                                        xa_mk_value(cgt->tc.val), GFP_KERNEL);
                        if (prev && !xa_is_err(prev)) {
                                ret = -EINVAL;
                                print_nv_trap_error(cgt, "Duplicate CGT", ret);
                        }
-               }
 
-               if (xa_is_err(prev)) {
-                       ret = xa_err(prev);
-                       print_nv_trap_error(cgt, "Failed CGT insertion", ret);
+                       if (xa_is_err(prev)) {
+                               ret = xa_err(prev);
+                               print_nv_trap_error(cgt, "Failed CGT insertion", ret);
+                       }
                }
        }
 
@@ -1804,6 +1821,7 @@ int __init populate_nv_trap_config(void)
        for (int i = 0; i < ARRAY_SIZE(encoding_to_fgt); i++) {
                const struct encoding_to_trap_config *fgt = &encoding_to_fgt[i];
                union trap_config tc;
+               void *prev;
 
                if (fgt->tc.fgt >= __NR_FGT_GROUP_IDS__) {
                        ret = -EINVAL;
@@ -1818,8 +1836,13 @@ int __init populate_nv_trap_config(void)
                }
 
                tc.val |= fgt->tc.val;
-               xa_store(&sr_forward_xa, fgt->encoding,
-                        xa_mk_value(tc.val), GFP_KERNEL);
+               prev = xa_store(&sr_forward_xa, fgt->encoding,
+                               xa_mk_value(tc.val), GFP_KERNEL);
+
+               if (xa_is_err(prev)) {
+                       ret = xa_err(prev);
+                       print_nv_trap_error(fgt, "Failed FGT insertion", ret);
+               }
        }
 
        kvm_info("nv: %ld fine grained trap handlers\n",