KVM: arm64: Setup a framework for hypercall bitmap firmware registers

KVM regularly introduces new hypercall services to the guests without
any consent from the userspace. This means, the guests can observe
hypercall services in and out as they migrate across various host
kernel versions. This could be a major problem if the guest
discovered a hypercall, started using it, and after getting migrated
to an older kernel realizes that it's no longer available. Depending
on how the guest handles the change, there's a potential chance that
the guest would just panic.

As a result, there's a need for the userspace to elect the services
that it wishes the guest to discover. It can elect these services
based on the kernels spread across its (migration) fleet. To remedy
this, extend the existing firmware pseudo-registers, such as
KVM_REG_ARM_PSCI_VERSION, but by creating a new COPROC register space
for all the hypercall services available.

These firmware registers are categorized based on the service call
owners, but unlike the existing firmware pseudo-registers, they hold
the features supported in the form of a bitmap.

During the VM initialization, the registers are set to upper-limit of
the features supported by the corresponding registers. It's expected
that the VMMs discover the features provided by each register via
GET_ONE_REG, and write back the desired values using SET_ONE_REG.
KVM allows this modification only until the VM has started.

Some of the standard features are not mapped to any bits of the
registers. But since they can recreate the original problem of
making it available without userspace's consent, they need to
be explicitly added to the case-list in
kvm_hvc_call_default_allowed(). Any function-id that's not enabled
via the bitmap, or not listed in kvm_hvc_call_default_allowed, will
be returned as SMCCC_RET_NOT_SUPPORTED to the guest.

Older userspace code can simply ignore the feature and the
hypercall services will be exposed unconditionally to the guests,
thus ensuring backward compatibility.

In this patch, the framework adds the register only for ARM's standard
secure services (owner value 4). Currently, this includes support only
for ARM True Random Number Generator (TRNG) service, with bit-0 of the
register representing mandatory features of v1.0. Other services are
momentarily added in the upcoming patches.

Signed-off-by: Raghavendra Rao Ananta <rananta@google.com>
Reviewed-by: Gavin Shan <gshan@redhat.com>
[maz: reduced the scope of some helpers, tidy-up bitmap max values,
 dropped error-only fast path]
Signed-off-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/20220502233853.1233742-3-rananta@google.com

diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index 94a27a7520f4740e64e202599c11fa75441b4e44..fef597af0beb75b3b50894be05b9318b4f122814 100644 (file)
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -101,6 +101,15 @@ struct kvm_s2_mmu {
 struct kvm_arch_memory_slot {
 };
 
+/**
+ * struct kvm_smccc_features: Descriptor of the hypercall services exposed to the guests
+ *
+ * @std_bmap: Bitmap of standard secure service calls
+ */
+struct kvm_smccc_features {
+       unsigned long std_bmap;
+};
+
 struct kvm_arch {
        struct kvm_s2_mmu mmu;
 
@@ -150,6 +159,9 @@ struct kvm_arch {
 
        u8 pfr0_csv2;
        u8 pfr0_csv3;
+
+       /* Hypercall features firmware registers' descriptor */
+       struct kvm_smccc_features smccc_feat;
 };
 
 struct kvm_vcpu_fault_info {

diff --git a/arch/arm64/include/uapi/asm/kvm.h b/arch/arm64/include/uapi/asm/kvm.h
index c1b6ddc02d2ff96eac2248ad47f1e9191d3e85be..b0be5ec196b9eb4897892f8a639e604bc46292e0 100644 (file)
--- a/arch/arm64/include/uapi/asm/kvm.h
+++ b/arch/arm64/include/uapi/asm/kvm.h
@@ -332,6 +332,19 @@ struct kvm_arm_copy_mte_tags {
 #define KVM_ARM64_SVE_VLS_WORDS        \
        ((KVM_ARM64_SVE_VQ_MAX - KVM_ARM64_SVE_VQ_MIN) / 64 + 1)
 
+/* Bitmap feature firmware registers */
+#define KVM_REG_ARM_FW_FEAT_BMAP               (0x0016 << KVM_REG_ARM_COPROC_SHIFT)
+#define KVM_REG_ARM_FW_FEAT_BMAP_REG(r)                (KVM_REG_ARM64 | KVM_REG_SIZE_U64 | \
+                                               KVM_REG_ARM_FW_FEAT_BMAP |      \
+                                               ((r) & 0xffff))
+
+#define KVM_REG_ARM_STD_BMAP                   KVM_REG_ARM_FW_FEAT_BMAP_REG(0)
+
+enum {
+       KVM_REG_ARM_STD_BIT_TRNG_V1_0   = 0,
+       KVM_REG_ARM_STD_BMAP_BIT_COUNT,
+};
+
 /* Device Control API: ARM VGIC */
 #define KVM_DEV_ARM_VGIC_GRP_ADDR      0
 #define KVM_DEV_ARM_VGIC_GRP_DIST_REGS 1

diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c
index 523bc934fe2f66687b2bb605776f4b239b6114d3..a37fadbd617efd0792ef0d01eb45d7a3fbcfbc33 100644 (file)
--- a/arch/arm64/kvm/arm.c
+++ b/arch/arm64/kvm/arm.c
@@ -156,6 +156,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
        kvm->arch.max_vcpus = kvm_arm_default_max_vcpus();
 
        set_default_spectre(kvm);
+       kvm_arm_init_hypercalls(kvm);
 
        return ret;
 out_free_stage2_pgd:

diff --git a/arch/arm64/kvm/guest.c b/arch/arm64/kvm/guest.c
index 0d5cca56cbdada170208e927789c4f02c95ac5b7..8c607199cad14d4dee8320d8847dc3ab9dab52ce 100644 (file)
--- a/arch/arm64/kvm/guest.c
+++ b/arch/arm64/kvm/guest.c
@@ -756,7 +756,9 @@ int kvm_arm_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 
        switch (reg->id & KVM_REG_ARM_COPROC_MASK) {
        case KVM_REG_ARM_CORE:  return get_core_reg(vcpu, reg);
-       case KVM_REG_ARM_FW:    return kvm_arm_get_fw_reg(vcpu, reg);
+       case KVM_REG_ARM_FW:
+       case KVM_REG_ARM_FW_FEAT_BMAP:
+               return kvm_arm_get_fw_reg(vcpu, reg);
        case KVM_REG_ARM64_SVE: return get_sve_reg(vcpu, reg);
        }
 
@@ -774,7 +776,9 @@ int kvm_arm_set_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 
        switch (reg->id & KVM_REG_ARM_COPROC_MASK) {
        case KVM_REG_ARM_CORE:  return set_core_reg(vcpu, reg);
-       case KVM_REG_ARM_FW:    return kvm_arm_set_fw_reg(vcpu, reg);
+       case KVM_REG_ARM_FW:
+       case KVM_REG_ARM_FW_FEAT_BMAP:
+               return kvm_arm_set_fw_reg(vcpu, reg);
        case KVM_REG_ARM64_SVE: return set_sve_reg(vcpu, reg);
        }
 

diff --git a/arch/arm64/kvm/hypercalls.c b/arch/arm64/kvm/hypercalls.c
index dd4e20b8d656529c58bc5f870af9d36896414f4a..22f3a919e699ac69b05fe4a64b615f3cb7a63379 100644 (file)
--- a/arch/arm64/kvm/hypercalls.c
+++ b/arch/arm64/kvm/hypercalls.c
@@ -9,6 +9,9 @@
 #include <kvm/arm_hypercalls.h>
 #include <kvm/arm_psci.h>
 
+#define KVM_ARM_SMCCC_STD_FEATURES                             \
+       GENMASK(KVM_REG_ARM_STD_BMAP_BIT_COUNT - 1, 0)
+
 static void kvm_ptp_get_time(struct kvm_vcpu *vcpu, u64 *val)
 {
        struct system_time_snapshot systime_snapshot;
@@ -58,6 +61,56 @@ static void kvm_ptp_get_time(struct kvm_vcpu *vcpu, u64 *val)
        val[3] = lower_32_bits(cycles);
 }
 
+static bool kvm_hvc_call_default_allowed(u32 func_id)
+{
+       switch (func_id) {
+       /*
+        * List of function-ids that are not gated with the bitmapped
+        * feature firmware registers, and are to be allowed for
+        * servicing the call by default.
+        */
+       case ARM_SMCCC_VERSION_FUNC_ID:
+       case ARM_SMCCC_ARCH_FEATURES_FUNC_ID:
+       case ARM_SMCCC_HV_PV_TIME_FEATURES:
+       case ARM_SMCCC_HV_PV_TIME_ST:
+       case ARM_SMCCC_VENDOR_HYP_CALL_UID_FUNC_ID:
+       case ARM_SMCCC_VENDOR_HYP_KVM_FEATURES_FUNC_ID:
+       case ARM_SMCCC_VENDOR_HYP_KVM_PTP_FUNC_ID:
+               return true;
+       default:
+               /* PSCI 0.2 and up is in the 0:0x1f range */
+               if (ARM_SMCCC_OWNER_NUM(func_id) == ARM_SMCCC_OWNER_STANDARD &&
+                   ARM_SMCCC_FUNC_NUM(func_id) <= 0x1f)
+                       return true;
+
+               /*
+                * KVM's PSCI 0.1 doesn't comply with SMCCC, and has
+                * its own function-id base and range
+                */
+               if (func_id >= KVM_PSCI_FN(0) && func_id <= KVM_PSCI_FN(3))
+                       return true;
+
+               return false;
+       }
+}
+
+static bool kvm_hvc_call_allowed(struct kvm_vcpu *vcpu, u32 func_id)
+{
+       struct kvm_smccc_features *smccc_feat = &vcpu->kvm->arch.smccc_feat;
+
+       switch (func_id) {
+       case ARM_SMCCC_TRNG_VERSION:
+       case ARM_SMCCC_TRNG_FEATURES:
+       case ARM_SMCCC_TRNG_GET_UUID:
+       case ARM_SMCCC_TRNG_RND32:
+       case ARM_SMCCC_TRNG_RND64:
+               return test_bit(KVM_REG_ARM_STD_BIT_TRNG_V1_0,
+                               &smccc_feat->std_bmap);
+       default:
+               return kvm_hvc_call_default_allowed(func_id);
+       }
+}
+
 int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)
 {
        u32 func_id = smccc_get_function(vcpu);
@@ -65,6 +118,9 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)
        u32 feature;
        gpa_t gpa;
 
+       if (!kvm_hvc_call_allowed(vcpu, func_id))
+               goto out;
+
        switch (func_id) {
        case ARM_SMCCC_VERSION_FUNC_ID:
                val[0] = ARM_SMCCC_VERSION_1_1;
@@ -155,6 +211,7 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)
                return kvm_psci_call(vcpu);
        }
 
+out:
        smccc_set_retval(vcpu, val[0], val[1], val[2], val[3]);
        return 1;
 }
@@ -164,8 +221,16 @@ static const u64 kvm_arm_fw_reg_ids[] = {
        KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1,
        KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2,
        KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3,
+       KVM_REG_ARM_STD_BMAP,
 };
 
+void kvm_arm_init_hypercalls(struct kvm *kvm)
+{
+       struct kvm_smccc_features *smccc_feat = &kvm->arch.smccc_feat;
+
+       smccc_feat->std_bmap = KVM_ARM_SMCCC_STD_FEATURES;
+}
+
 int kvm_arm_get_fw_num_regs(struct kvm_vcpu *vcpu)
 {
        return ARRAY_SIZE(kvm_arm_fw_reg_ids);
@@ -236,6 +301,7 @@ static int get_kernel_wa_level(u64 regid)
 
 int kvm_arm_get_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 {
+       struct kvm_smccc_features *smccc_feat = &vcpu->kvm->arch.smccc_feat;
        void __user *uaddr = (void __user *)(long)reg->addr;
        u64 val;
 
@@ -248,6 +314,9 @@ int kvm_arm_get_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
        case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_3:
                val = get_kernel_wa_level(reg->id) & KVM_REG_FEATURE_LEVEL_MASK;
                break;
+       case KVM_REG_ARM_STD_BMAP:
+               val = READ_ONCE(smccc_feat->std_bmap);
+               break;
        default:
                return -ENOENT;
        }
@@ -258,6 +327,39 @@ int kvm_arm_get_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
        return 0;
 }
 
+static int kvm_arm_set_fw_reg_bmap(struct kvm_vcpu *vcpu, u64 reg_id, u64 val)
+{
+       int ret = 0;
+       struct kvm *kvm = vcpu->kvm;
+       struct kvm_smccc_features *smccc_feat = &kvm->arch.smccc_feat;
+       unsigned long *fw_reg_bmap, fw_reg_features;
+
+       switch (reg_id) {
+       case KVM_REG_ARM_STD_BMAP:
+               fw_reg_bmap = &smccc_feat->std_bmap;
+               fw_reg_features = KVM_ARM_SMCCC_STD_FEATURES;
+               break;
+       default:
+               return -ENOENT;
+       }
+
+       /* Check for unsupported bit */
+       if (val & ~fw_reg_features)
+               return -EINVAL;
+
+       mutex_lock(&kvm->lock);
+
+       if (test_bit(KVM_ARCH_FLAG_HAS_RAN_ONCE, &kvm->arch.flags)) {
+               ret = -EBUSY;
+               goto out;
+       }
+
+       WRITE_ONCE(*fw_reg_bmap, val);
+out:
+       mutex_unlock(&kvm->lock);
+       return ret;
+}
+
 int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
 {
        void __user *uaddr = (void __user *)(long)reg->addr;
@@ -336,6 +438,8 @@ int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
                        return -EINVAL;
 
                return 0;
+       case KVM_REG_ARM_STD_BMAP:
+               return kvm_arm_set_fw_reg_bmap(vcpu, reg->id, val);
        default:
                return -ENOENT;
        }

diff --git a/include/kvm/arm_hypercalls.h b/include/kvm/arm_hypercalls.h
index 5d38628a8d048c1895e9763f4df5a9945976144f..1188f116cf4e9dafbde939eac6d17cc5235d9650 100644 (file)
--- a/include/kvm/arm_hypercalls.h
+++ b/include/kvm/arm_hypercalls.h
@@ -42,6 +42,7 @@ static inline void smccc_set_retval(struct kvm_vcpu *vcpu,
 
 struct kvm_one_reg;
 
+void kvm_arm_init_hypercalls(struct kvm *kvm);
 int kvm_arm_get_fw_num_regs(struct kvm_vcpu *vcpu);
 int kvm_arm_copy_fw_reg_indices(struct kvm_vcpu *vcpu, u64 __user *uindices);
 int kvm_arm_get_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg);