KVM: arm/arm64: Add VCPU workarounds firmware register
Subsystems (5)
v3 cover KVM: arm/arm64: Add VCPU workarounds firmware register
Hi,
Aside from a rebase against kvm-arm/next, this update introduces a new UNAFFECTED value for WORKAROUND_1, which is not used at the moment, but will become useful with some patches extending the host kernel workaround code [1]. We add the value to the ABI already.
Also we now require an exact match for the two WORKAROUND_1 levels, as we can't allow a guest to migrate from a system with an effectively unknown workaround state to a system which requires an active guest workaround.
Now tested with actual migration, see below.
Cheers,
Andre
-----------------------------
Workarounds for Spectre variant 2 or 4 vulnerabilities require some help from the firmware, so KVM implements an interface to provide that for guests. When such a guest is migrated, we want to make sure we don't loose the protection the guest relies on.
This introduces two new firmware registers in KVM's GET/SET_ONE_REG interface, so userland can save the level of protection implemented by the hypervisor and used by the guest. Upon restoring these registers, we make sure we don't downgrade and reject any values that would mean weaker protection.
The protection level is encoding in the lower 4 bits, with smaller values indicating weaker protection.
Patch 1 implements the two firmware registers, patch 2 adds the documentation.
ARM(32) is a bit of a pain (again), as the firmware register interface is shared, but 32-bit does not implement all the workarounds. For now I stuffed two wrappers into kvm_emulate.h, which doesn't sound like the best solution. Happy to hear about better solutions.
This has been tested with migration between two Juno systems. Out of the box they advertise identical workaround levels, and migration succeeds. However when disabling the A57 cluster on one system, WORKAROUND_1 is not needed and the host kernel disables this. Migration between the two now fails, as expected.
Please have a look and comment!
Cheers,
Andre
[1] http://lists.infradead.org/pipermail/linux-arm-kernel/2019-January/627791.html
Changelog:
v1 .. v2:
- complete rework of WORKAROUND_2 presentation to use a linear scale, dropping the complicated comparison routine
v2 .. v3:
- rebase against latest kvm-arm/next
- introduce UNAFFECTED value for WORKAROUND_1
- require exact match for WORKAROUND_1 levels
Andre Przywara (2):
KVM: arm/arm64: Add save/restore support for firmware workaround state
KVM: doc: add API documentation on the KVM_REG_ARM_WORKAROUNDS
register
Documentation/virtual/kvm/arm/psci.txt | 24 +++++ arch/arm/include/asm/kvm_emulate.h | 10 +++ arch/arm/include/uapi/asm/kvm.h | 10 +++ arch/arm64/include/asm/kvm_emulate.h | 14 +++ arch/arm64/include/uapi/asm/kvm.h | 9 ++ virt/kvm/arm/psci.c | 119 +++++++++++++++++++++---- 6 files changed, 170 insertions(+), 16 deletions(-)
Signature · 1 line
2.17.1
PATCH v3 1/2 KVM: arm/arm64: Add save/restore support for firmware workaround state
KVM implements the firmware interface for mitigating cache speculation vulnerabilities. Guests may use this interface to ensure mitigation is active.
If we want to migrate such a guest to a host with a different support level for those workarounds, migration might need to fail, to ensure that critical guests don't loose their protection.
Introduce a way for userland to save and restore the workarounds state. On restoring we do checks that make sure we don't downgrade our mitigation level.
--- arch/arm/include/asm/kvm_emulate.h | 10 +++ arch/arm/include/uapi/asm/kvm.h | 10 +++ arch/arm64/include/asm/kvm_emulate.h | 14 ++++ arch/arm64/include/uapi/asm/kvm.h | 9 ++ virt/kvm/arm/psci.c | 119 +++++++++++++++++++++++---- 5 files changed, 146 insertions(+), 16 deletions(-)
arch/arm/include/asm/kvm_emulate.h +10 -0
@@ -283,6 +283,16 @@ static inline unsigned long kvm_vcpu_get_mpidr_aff(struct kvm_vcpu *vcpu)return vcpu_cp15 (vcpu, c0_MPIDR) &MPIDR_HWID_BITMASK ; } +static inline bool kvm_arm_get_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu) +{ +return false; +} + +static inline void kvm_arm_set_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu, +bool flag) +{ +} +static inline void kvm_vcpu_set_be (struct kvm_vcpu *vcpu) { *vcpu_cpsr (vcpu) |=PSR_E_BIT ;
arch/arm/include/uapi/asm/kvm.h +10 -0
@@ -214,6 +214,16 @@ struct kvm_vcpu_events {#define KVM_REG_ARM_FW_REG (r) (KVM_REG_ARM | KVM_REG_SIZE_U64 | \ KVM_REG_ARM_FW | ((r) & 0xffff))#define KVM_REG_ARM_PSCI_VERSION KVM_REG_ARM_FW_REG(0) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 KVM_REG_ARM_FW_REG(1) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_UNAFFECTED 2 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 KVM_REG_ARM_FW_REG(2) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL 2 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED 3 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED (1U << 4)/* Device Control API: ARM VGIC */ #define KVM_DEV_ARM_VGIC_GRP_ADDR 0
arch/arm64/include/asm/kvm_emulate.h +14 -0
@@ -348,6 +348,20 @@ static inline unsigned long kvm_vcpu_get_mpidr_aff(struct kvm_vcpu *vcpu)return vcpu_read_sys_reg (vcpu,MPIDR_EL1 ) &MPIDR_HWID_BITMASK ; } +static inline bool kvm_arm_get_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu) +{ +return vcpu->arch.workaround_flags &VCPU_WORKAROUND_2_FLAG ; +} + +static inline void kvm_arm_set_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu, +bool flag) +{ +if (flag) + vcpu->arch.workaround_flags |=VCPU_WORKAROUND_2_FLAG ; +else + vcpu->arch.workaround_flags &= ~VCPU_WORKAROUND_2_FLAG ; +} +static inline void kvm_vcpu_set_be (struct kvm_vcpu *vcpu) {if (vcpu_mode_is_32bit (vcpu)) {
arch/arm64/include/uapi/asm/kvm.h +9 -0
@@ -225,6 +225,15 @@ struct kvm_vcpu_events {#define KVM_REG_ARM_FW_REG (r) (KVM_REG_ARM64 | KVM_REG_SIZE_U64 | \ KVM_REG_ARM_FW | ((r) & 0xffff))#define KVM_REG_ARM_PSCI_VERSION KVM_REG_ARM_FW_REG(0) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 KVM_REG_ARM_FW_REG(1) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 KVM_REG_ARM_FW_REG(2) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL 2 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED 3 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED (1U << 4)/* Device Control API: ARM VGIC */ #define KVM_DEV_ARM_VGIC_GRP_ADDR 0
virt/kvm/arm/psci.c +103 -16
151 lines not on this page · raw message
Signature · 1 line
2.17.1
Re: [PATCH v3 1/2] KVM: arm/arm64: Add save/restore support for firmware workaround state
Quoted 46 lines · Andre Przywara
KVM implements the firmware interface for mitigating cache speculation vulnerabilities. Guests may use this interface to ensure mitigation is active.
If we want to migrate such a guest to a host with a different support level for those workarounds, migration might need to fail, to ensure that critical guests don't loose their protection.Introduce a way for userland to save and restore the workarounds state. On restoring we do checks that make sure we don't downgrade our mitigation level.
Signed-off-by Andre Przywara <[email protected]>--- arch/arm/include/asm/kvm_emulate.h | 10 +++ arch/arm/include/uapi/asm/kvm.h | 10 +++ arch/arm64/include/asm/kvm_emulate.h | 14 ++++ arch/arm64/include/uapi/asm/kvm.h | 9 ++ virt/kvm/arm/psci.c | 119 +++++++++++++++++++++++---- 5 files changed, 146 insertions(+), 16 deletions(-)arch/arm/include/asm/kvm_emulate.h +10
-0@@ -283,6 +283,16 @@ static inline unsigned long kvm_vcpu_get_mpidr_aff(struct kvm_vcpu *vcpu)return vcpu_cp15 (vcpu, c0_MPIDR) &MPIDR_HWID_BITMASK ; } +static inline bool kvm_arm_get_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu) +{ +return false; +} + +static inline void kvm_arm_set_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu, +bool flag) +{ +} +static inline void kvm_vcpu_set_be (struct kvm_vcpu *vcpu) { *vcpu_cpsr (vcpu) |=PSR_E_BIT ;arch/arm/include/uapi/asm/kvm.h +0
-0
arch/arm/include/uapi/asm/kvm.h struct kvm_vcpu_events { · line 220
Quoted 7 lines
arch/arm/include/uapi/asm/kvm.h +4
-0@@ -214,6 +214,16 @@ struct kvm_vcpu_events {#define KVM_REG_ARM_FW_REG (r) (KVM_REG_ARM | KVM_REG_SIZE_U64 | \ KVM_REG_ARM_FW | ((r) & 0xffff))#define KVM_REG_ARM_PSCI_VERSION KVM_REG_ARM_FW_REG(0) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 KVM_REG_ARM_FW_REG(1) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_UNAFFECTED 2
Thanks for adding the UNAFFECTED state for WORKAROUND_1 - this means the ABI at least can deal with migration to a host which supports but doesn't need the workaround. I'm happy for the actual support for this to be added later if/when it's needed.
Re: [PATCH v3 1/2] KVM: arm/arm64: Add save/restore support for firmware workaround state
Quoted 51 lines · On Fri, 22 Feb 2019 17:16:12 +0000 Steven Price <[email protected]> wrote:
Quoted 50 lines · Andre Przywara
KVM implements the firmware interface for mitigating cache speculation vulnerabilities. Guests may use this interface to ensure mitigation is active.
If we want to migrate such a guest to a host with a different support level for those workarounds, migration might need to fail, to ensure that critical guests don't loose their protection.Introduce a way for userland to save and restore the workarounds state. On restoring we do checks that make sure we don't downgrade our mitigation level.
Signed-off-by Andre Przywara <[email protected]>--- arch/arm/include/asm/kvm_emulate.h | 10 +++ arch/arm/include/uapi/asm/kvm.h | 10 +++ arch/arm64/include/asm/kvm_emulate.h | 14 ++++ arch/arm64/include/uapi/asm/kvm.h | 9 ++ virt/kvm/arm/psci.c | 119 +++++++++++++++++++++++---- 5 files changed, 146 insertions(+), 16 deletions(-)arch/arm/include/asm/kvm_emulate.h +10
-0@@ -283,6 +283,16 @@ static inline unsigned long kvm_vcpu_get_mpidr_aff(struct kvm_vcpu *vcpu)return vcpu_cp15 (vcpu, c0_MPIDR) &MPIDR_HWID_BITMASK ; } +static inline bool kvm_arm_get_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu) +{ +return false; +} + +static inline void kvm_arm_set_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu, +bool flag) +{ +} +static inline void kvm_vcpu_set_be (struct kvm_vcpu *vcpu) { *vcpu_cpsr (vcpu) |=PSR_E_BIT ;arch/arm/include/uapi/asm/kvm.h +1
-0@@ -214,6 +214,16 @@ struct kvm_vcpu_events {#define KVM_REG_ARM_FW_REG (r) (KVM_REG_ARM | KVM_REG_SIZE_U64 | \ KVM_REG_ARM_FW | ((r) & 0xffff))#define KVM_REG_ARM_PSCI_VERSION KVM_REG_ARM_FW_REG(0) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 KVM_REG_ARM_FW_REG(1)
Quoted 8 lines
arch/arm/include/uapi/asm/kvm.h struct kvm_vcpu_events { · line 220
Quoted 3 lines
arch/arm/include/uapi/asm/kvm.h +3
-0+#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_UNAFFECTED 2Thanks for adding the UNAFFECTED state for
WORKAROUND_1- this means the ABI at least can deal with migration to a host which supports but doesn't need the workaround. I'm happy for the actual support for this to be added later if/when it's needed.
Thanks. Actually we *can't* do anything right now, because the host kernel only provides this "requires w/a or not" state, so for the current kernel we will never see UNAFFECTED. If QEMU wants to set UNAFFECTED because the source kernel had it, we naturally deny it, as future code would do as well. So I think this solution is forward compatible.
Quoted 1 line
Reviewed-by Steven Price <[email protected]>
Thanks for that!
Andre.
Re: [PATCH v3 1/2] KVM: arm/arm64: Add save/restore support for firmware workaround state
In reply to Andre PrzywaraQuoted 49 lines · Andre Przywara
KVM implements the firmware interface for mitigating cache speculation vulnerabilities. Guests may use this interface to ensure mitigation is active.
If we want to migrate such a guest to a host with a different support level for those workarounds, migration might need to fail, to ensure that critical guests don't loose their protection.Introduce a way for userland to save and restore the workarounds state. On restoring we do checks that make sure we don't downgrade our mitigation level.
Signed-off-by Andre Przywara <[email protected]>--- arch/arm/include/asm/kvm_emulate.h | 10 +++ arch/arm/include/uapi/asm/kvm.h | 10 +++ arch/arm64/include/asm/kvm_emulate.h | 14 ++++ arch/arm64/include/uapi/asm/kvm.h | 9 ++ virt/kvm/arm/psci.c | 119 +++++++++++++++++++++++---- 5 files changed, 146 insertions(+), 16 deletions(-)arch/arm/include/asm/kvm_emulate.h +10
-0@@ -283,6 +283,16 @@ static inline unsigned long kvm_vcpu_get_mpidr_aff(struct kvm_vcpu *vcpu)return vcpu_cp15 (vcpu, c0_MPIDR) &MPIDR_HWID_BITMASK ; } +static inline bool kvm_arm_get_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu) +{ +return false; +} + +static inline void kvm_arm_set_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu, +bool flag) +{ +} +static inline void kvm_vcpu_set_be (struct kvm_vcpu *vcpu) { *vcpu_cpsr (vcpu) |=PSR_E_BIT ;arch/arm/include/uapi/asm/kvm.h +0
-0@@ -214,6 +214,16 @@ struct kvm_vcpu_events {#define KVM_REG_ARM_FW_REG (r) (KVM_REG_ARM | KVM_REG_SIZE_U64 | \ KVM_REG_ARM_FW | ((r) & 0xffff))#define KVM_REG_ARM_PSCI_VERSION KVM_REG_ARM_FW_REG(0)
arch/arm/include/uapi/asm/kvm.h struct kvm_vcpu_events { · line 226
Quoted 10 lines
arch/arm/include/uapi/asm/kvm.h +10
-0+#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 KVM_REG_ARM_FW_REG(1) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_UNAFFECTED 2 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 KVM_REG_ARM_FW_REG(2) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL 2 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED 3 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED (1U << 4)
Why 4? How could the system be less affected than "UNAFFECTED"? (And if not, why do we need space to insert extra values?) Mixing read-only system-description info with mutable guest state in this register feels a bit odd, but we probably don't win much by making it a separate register either.
Possibly we could drop the _REG from the #defines that are not reg IDs, since KVM_REG_* are all reg IDs today.
But it works either way.
Without a clear definition of what these values mean, I worry about ABI drift. But if we don't expect these to evolve it's probably low-risk.
Quoted 52 lines
arch/arm/include/uapi/asm/kvm.h +0
-0/* Device Control API: ARM VGIC */ #define KVM_DEV_ARM_VGIC_GRP_ADDR 0arch/arm64/include/asm/kvm_emulate.h +14
-0@@ -348,6 +348,20 @@ static inline unsigned long kvm_vcpu_get_mpidr_aff(struct kvm_vcpu *vcpu)return vcpu_read_sys_reg (vcpu,MPIDR_EL1 ) &MPIDR_HWID_BITMASK ; } +static inline bool kvm_arm_get_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu) +{ +return vcpu->arch.workaround_flags &VCPU_WORKAROUND_2_FLAG ; +} + +static inline void kvm_arm_set_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu, +bool flag) +{ +if (flag) + vcpu->arch.workaround_flags |=VCPU_WORKAROUND_2_FLAG ; +else + vcpu->arch.workaround_flags &= ~VCPU_WORKAROUND_2_FLAG ; +} +static inline void kvm_vcpu_set_be (struct kvm_vcpu *vcpu) {if (vcpu_mode_is_32bit (vcpu)) {arch/arm64/include/uapi/asm/kvm.h +9
-0@@ -225,6 +225,15 @@ struct kvm_vcpu_events {#define KVM_REG_ARM_FW_REG (r) (KVM_REG_ARM64 | KVM_REG_SIZE_U64 | \ KVM_REG_ARM_FW | ((r) & 0xffff))#define KVM_REG_ARM_PSCI_VERSION KVM_REG_ARM_FW_REG(0) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 KVM_REG_ARM_FW_REG(1) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 KVM_REG_ARM_FW_REG(2) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL 2 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED 3 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED (1U << 4)/* Device Control API: ARM VGIC */ #define KVM_DEV_ARM_VGIC_GRP_ADDR 0virt/kvm/arm/psci.c +0
-0
virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 448
Quoted 5 lines
virt/kvm/arm/psci.c +1
-1@@ -445,42 +445,97 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)int kvm_arm_get_fw_num_regs (struct kvm_vcpu *vcpu) { -return 1 ;/* PSCI version */ +return 3 ;/* PSCI version and two workaround registers */
Meh. But this is no worse than the way we do it elsewhere.
Quoted 9 lines
virt/kvm/arm/psci.c +2
-1}int kvm_arm_copy_fw_reg_indices (struct kvm_vcpu *vcpu,u64 __user *uindices) { -if (put_user (KVM_REG_ARM_PSCI_VERSION , uindices)) +if (put_user (KVM_REG_ARM_PSCI_VERSION , uindices++))return -EFAULT ; +if (put_user (KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 , uindices++))
virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 466
Quoted 10 lines
virt/kvm/arm/psci.c +10
-0+return -EFAULT ; + +if (put_user (KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 , uindices++)) +return -EFAULT ; + +return 0 ; +} + +#define KVM_REG_FEATURE_LEVEL_WIDTH 4 +#define KVM_REG_FEATURE_LEVEL_MASK (BIT(KVM_REG_FEATURE_LEVEL_WIDTH) - 1)
Nit: Maybe use GENMASK?
Quoted 27 lines
virt/kvm/arm/psci.c +27
-0+ +/* +* Convert the workaround level into an easy-to-compare number, where higher +* values mean better protection. +*/ +static int get_kernel_wa_level (u64 regid) +{ +switch (regid) { +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 : +if (kvm_arm_harden_branch_predictor ()) +return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL ; +else +return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL ; +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 : +switch (kvm_arm_have_ssbd ()) { +case KVM_SSBD_FORCE_DISABLE : +return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL ; +case KVM_SSBD_KERNEL : +return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL ; +case KVM_SSBD_FORCE_ENABLE : +case KVM_SSBD_MITIGATED : +return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED ; +case KVM_SSBD_UNKNOWN : +default : +return KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN ; + } + }
virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 500
Quoted 10 lines
virt/kvm/arm/psci.c +2
-3+return 0 ; }int kvm_arm_get_fw_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg) { -if (reg->id ==KVM_REG_ARM_PSCI_VERSION ) { -void __user *uaddr = (void __user *)(long )reg->addr; -u64 val; +void __user *uaddr = (void __user *)(long )reg->addr;
(Why (long), I wonder? Anyway, no bother.)
Quoted 11 lines
virt/kvm/arm/psci.c +5
-4+u64 val; +switch (reg->id) { +case KVM_REG_ARM_PSCI_VERSION : val =kvm_psci_version (vcpu, vcpu->kvm); -if (copy_to_user (uaddr, &val,KVM_REG_SIZE (reg->id))) -return -EFAULT ; - -return 0 ; +break ; +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 :
virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 517
Quoted 10 lines
virt/kvm/arm/psci.c +10
-0+ val =get_kernel_wa_level (reg->id) &KVM_REG_FEATURE_LEVEL_MASK ; +break ; +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 : + val =get_kernel_wa_level (reg->id) &KVM_REG_FEATURE_LEVEL_MASK ; +if (kvm_arm_have_ssbd () ==KVM_SSBD_KERNEL && +kvm_arm_get_vcpu_workaround_2_flag (vcpu)) + val |=KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED ; +break ; +default : +return -EINVAL ;
Hmmm, it could be more reasonable to return -ENOENT. But this precedent may be established now.
Anyway, userspace is unlikely to make any useful distinction between these two errors.
virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 472
Quoted 3 lines
virt/kvm/arm/psci.c +0
-1} -return -EINVAL ;
You could try a BUILD_BUG_ON(KVM_REG_SIZE(reg->id) == sizeof(val)).
I suspect gcc may not be quite bright enough to spot that condition is compiletime-constant, but if it does then so much the better.
Not sure it's worth a runtime check though.
Quoted 29 lines
virt/kvm/arm/psci.c +14
-6+if (copy_to_user (uaddr, &val,KVM_REG_SIZE (reg->id))) +return -EFAULT ; + +return 0 ; }int kvm_arm_set_fw_reg (struct kvm_vcpu *vcpu,const struct kvm_one_reg *reg) { -if (reg->id ==KVM_REG_ARM_PSCI_VERSION ) { -void __user *uaddr = (void __user *)(long )reg->addr; -bool wants_02; -u64 val; +void __user *uaddr = (void __user *)(long )reg->addr; +u64 val; +int wa_level; + +if (copy_from_user (&val, uaddr,KVM_REG_SIZE (reg->id))) +return -EFAULT ; -if (copy_from_user (&val, uaddr,KVM_REG_SIZE (reg->id))) -return -EFAULT ; +switch (reg->id) { +case KVM_REG_ARM_PSCI_VERSION : + { +bool wants_02; wants_02 =test_bit (KVM_ARM_VCPU_PSCI_0_2 , vcpu->arch.features);
virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) · line 559
Quoted 8 lines
virt/kvm/arm/psci.c +5
-0@@ -497,6 +552,38 @@ int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) vcpu->kvm->arch.psci_version = val;return 0 ; } +break ; + } + +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 : + wa_level = val &KVM_REG_FEATURE_LEVEL_MASK ;
Should we require the other bits to be zero?
Providing we never add anything else to this register we will get away with it, but it would be cleaner to police the extra bits here and in similar places.
virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) · line 568
Quoted 9 lines
virt/kvm/arm/psci.c +9
-0+ +/* For now we only accept the very same workaround level. */ +if (get_kernel_wa_level (reg->id) != wa_level) +return -EINVAL ; + +return 0 ; + +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 : + wa_level = val &KVM_REG_FEATURE_LEVEL_MASK ;
Ditto...
virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) · line 571
Quoted 3 lines
virt/kvm/arm/psci.c +3
-0+ +if (get_kernel_wa_level (reg->id) < wa_level) +return -EINVAL ;
Is the SMCCC_ARCH_WORKAROUND_2 interface definitely always available to the guest even when in the get_kernel_wa_level() == _UNAFFECTED case?
With wa_level == _AVAIL, the guest assumes that the interface is there.
(This may be fine; I'm just not so aware of the history.)
virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) · line 574
Quoted 3 lines
virt/kvm/arm/psci.c +3
-0+ +if (kvm_arm_have_ssbd () !=KVM_SSBD_KERNEL ) +return 0 ;
(val & KVM_REG_FEATURE_LEVEL_MASK) could still be _NOT_AVAIL or _UNKNOWN here, yet we still attempt to call kvm_arm_set_vcpu_workaround_2_flag() based on the user's KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED bit.
Should we? I'm not clear on what the sematics should be for this case.
virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) · line 584
Quoted 10 lines
virt/kvm/arm/psci.c +10
-0+ +switch (wa_level) { +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL : +kvm_arm_set_vcpu_workaround_2_flag (vcpu, + val &KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED ); +break ; +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED : +kvm_arm_set_vcpu_workaround_2_flag (vcpu, true); +break ; + }
This has the odd effect that userspace can bypass PSCI/SMCCC and twiddle this bit directly via KVM_SET_ONE_REG. I'm not sure this matters, and it may even be useful. A bit unexpected though. Are there any pitfalls here I've not thought of?
virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) · line 586
Quoted 2 lines
virt/kvm/arm/psci.c +2
-0+ +return 0 ;
The logic overall feels a bit fragile and arbitrary, though given what it is describing, we may not be able to do a whole lot better.
Do we trust the user-supplied val more than we should?
[...]
Overall, the code looks reasonable; my comments are pretty much nits.
Cheers
---Dave
Re: [PATCH v3 1/2] KVM: arm/arm64: Add save/restore support for firmware workaround state
On Fri, 22 Feb 2019 17:22:37 +0000
Dave Martin <[email protected]> wrote:
Hi Dave,
thanks for having a look!
Quoted 58 lines · Andre Przywara
Quoted 57 lines
KVM implements the firmware interface for mitigating cache speculation vulnerabilities. Guests may use this interface to ensure mitigation is active.
If we want to migrate such a guest to a host with a different support level for those workarounds, migration might need to fail, to ensure that critical guests don't loose their protection.Introduce a way for userland to save and restore the workarounds state. On restoring we do checks that make sure we don't downgrade our mitigation level.
Signed-off-by Andre Przywara <[email protected]>--- arch/arm/include/asm/kvm_emulate.h | 10 +++ arch/arm/include/uapi/asm/kvm.h | 10 +++ arch/arm64/include/asm/kvm_emulate.h | 14 ++++ arch/arm64/include/uapi/asm/kvm.h | 9 ++ virt/kvm/arm/psci.c | 119 +++++++++++++++++++++++---- 5 files changed, 146 insertions(+), 16 deletions(-)arch/arm/include/asm/kvm_emulate.h +10
-0@@ -283,6 +283,16 @@ static inline unsigned long kvm_vcpu_get_mpidr_aff(struct kvm_vcpu *vcpu)return vcpu_cp15 (vcpu, c0_MPIDR) &MPIDR_HWID_BITMASK ; } +static inline bool kvm_arm_get_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu) +{ +return false; +} + +static inline void kvm_arm_set_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu, +bool flag) +{ +} +static inline void kvm_vcpu_set_be (struct kvm_vcpu *vcpu) { *vcpu_cpsr (vcpu) |=PSR_E_BIT ;arch/arm/include/uapi/asm/kvm.h +8
-0@@ -214,6 +214,16 @@ struct kvm_vcpu_events {#define KVM_REG_ARM_FW_REG (r) (KVM_REG_ARM | KVM_REG_SIZE_U64 | \ KVM_REG_ARM_FW | ((r) & 0xffff))#define KVM_REG_ARM_PSCI_VERSION KVM_REG_ARM_FW_REG(0) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 KVM_REG_ARM_FW_REG(1) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_UNAFFECTED 2 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 KVM_REG_ARM_FW_REG(2) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL 2
Quoted 8 lines
arch/arm/include/uapi/asm/kvm.h struct kvm_vcpu_events { · line 226
Quoted 2 lines
arch/arm/include/uapi/asm/kvm.h +2
-0+#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED 3 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED (1U << 4)Why 4? How could the system be less affected than "UNAFFECTED"? (And if not, why do we need space to insert extra values?) Mixing read-only system-description info with mutable guest state in this register feels a bit odd, but we probably don't win much by making it a separate register either.
For workaround 2 the guest has the ability to opt out of the (costly)
mitigation. This bit 4 holds that state for the VCPU. As this is somewhat orthogonal to the *level*, I didn't want to fiddle this bit into the encoding.
Quoted 8 lines
Possibly we could drop the
_REGfrom the #defines that are not reg IDs, since KVM_REG_* are all reg IDs today.But it works either way.
Without a clear definition of what these values mean, I worry about ABI drift. But if we don't expect these to evolve it's probably low-risk.
See the Documentation patch. I found it odd to have it first in the series, describing something that is not yet implemented.
Quoted 68 lines
Quoted 52 lines
arch/arm/include/uapi/asm/kvm.h +0
-0/* Device Control API: ARM VGIC */ #define KVM_DEV_ARM_VGIC_GRP_ADDR 0arch/arm64/include/asm/kvm_emulate.h +14
-0@@ -348,6 +348,20 @@ static inline unsigned long kvm_vcpu_get_mpidr_aff(struct kvm_vcpu *vcpu)return vcpu_read_sys_reg (vcpu,MPIDR_EL1 ) &MPIDR_HWID_BITMASK ; } +static inline bool kvm_arm_get_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu) +{ +return vcpu->arch.workaround_flags &VCPU_WORKAROUND_2_FLAG ; +} + +static inline void kvm_arm_set_vcpu_workaround_2_flag (struct kvm_vcpu *vcpu, +bool flag) +{ +if (flag) + vcpu->arch.workaround_flags |=VCPU_WORKAROUND_2_FLAG ; +else + vcpu->arch.workaround_flags &= ~VCPU_WORKAROUND_2_FLAG ; +} +static inline void kvm_vcpu_set_be (struct kvm_vcpu *vcpu) {if (vcpu_mode_is_32bit (vcpu)) {arch/arm64/include/uapi/asm/kvm.h +9
-0@@ -225,6 +225,15 @@ struct kvm_vcpu_events {#define KVM_REG_ARM_FW_REG (r) (KVM_REG_ARM64 | KVM_REG_SIZE_U64 | \ KVM_REG_ARM_FW | ((r) & 0xffff))#define KVM_REG_ARM_PSCI_VERSION KVM_REG_ARM_FW_REG(0) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 KVM_REG_ARM_FW_REG(1) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 KVM_REG_ARM_FW_REG(2) +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL 0 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN 1 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL 2 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED 3 +#define KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED (1U << 4)/* Device Control API: ARM VGIC */ #define KVM_DEV_ARM_VGIC_GRP_ADDR 0virt/kvm/arm/psci.c +0
-0virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 448
Quoted 5 lines
virt/kvm/arm/psci.c +1
-1@@ -445,42 +445,97 @@ int kvm_hvc_call_handler(struct kvm_vcpu *vcpu)int kvm_arm_get_fw_num_regs (struct kvm_vcpu *vcpu) { -return 1 ;/* PSCI version */ +return 3 ;/* PSCI version and two workaround registers */ Meh. But this is no worse than the way we do it elsewhere.
Quoted 8 lines
virt/kvm/arm/psci.c +1
-1}int kvm_arm_copy_fw_reg_indices (struct kvm_vcpu *vcpu,u64 __user *uindices) { -if (put_user (KVM_REG_ARM_PSCI_VERSION , uindices)) +if (put_user (KVM_REG_ARM_PSCI_VERSION , uindices++))return -EFAULT ;
Quoted 13 lines
virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 466
Quoted 11 lines
virt/kvm/arm/psci.c +11
-0+if (put_user (KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 , uindices++)) +return -EFAULT ; + +if (put_user (KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 , uindices++)) +return -EFAULT ; + +return 0 ; +} + +#define KVM_REG_FEATURE_LEVEL_WIDTH 4 +#define KVM_REG_FEATURE_LEVEL_MASK (BIT(KVM_REG_FEATURE_LEVEL_WIDTH) - 1)Nit: Maybe use GENMASK?
Yeah, but it would need to be GENMASK(KVM_REG_FEATURE_LEVEL_WIDTH - 1, 0), which is not really more readable, also breaks 80 columns ;-)
Quoted 38 lines
Quoted 38 lines
virt/kvm/arm/psci.c +3
-0+ +/* +* Convert the workaround level into an easy-to-compare number, where higher
+ * values mean better protection.
+ */virt/kvm/arm/psci.c +6
-0+static int get_kernel_wa_level (u64 regid) +{ +switch (regid) { +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 : +if (kvm_arm_harden_branch_predictor ()) +return
KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL;virt/kvm/arm/psci.c +2
-0+else +return
KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL;virt/kvm/arm/psci.c +4
-0+case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 : +switch (kvm_arm_have_ssbd ()) { +case KVM_SSBD_FORCE_DISABLE : +return
KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL;virt/kvm/arm/psci.c +2
-0+case KVM_SSBD_KERNEL : +return
KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL;virt/kvm/arm/psci.c +3
-0+case KVM_SSBD_FORCE_ENABLE : +case KVM_SSBD_MITIGATED : +return
KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED;virt/kvm/arm/psci.c +3
-0+case KVM_SSBD_UNKNOWN : +default : +return
KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN;virt/kvm/arm/psci.c +3
-0+ } + } +return 0 ; }
Quoted 8 lines
virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 500
Quoted 6 lines
int kvm_arm_get_fw_reg(struct
kvm_vcpu*vcpu, const structkvm_one_reg*reg) {virt/kvm/arm/psci.c +1
-3-if (reg->id ==KVM_REG_ARM_PSCI_VERSION ) { -void __user *uaddr = (void __user *)(long )reg->addr; -u64 val; +void __user *uaddr = (void __user *)(long )reg->addr;(Why (long), I wonder? Anyway, no bother.)
Just copied from above. You need some cast to a pointer-sized integer for 32-bit. uintptr_t doesn't seem too popular in the kernel.
Quoted 19 lines
Quoted 19 lines
virt/kvm/arm/psci.c +6
-4+u64 val; +switch (reg->id) { +case KVM_REG_ARM_PSCI_VERSION : val =kvm_psci_version (vcpu, vcpu->kvm); -if (copy_to_user (uaddr, &val,KVM_REG_SIZE (reg->id))) -return -EFAULT ; - -return 0 ; +break ; +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 : + val = get_kernel_wa_level(reg->id) &
KVM_REG_FEATURE_LEVEL_MASK;virt/kvm/arm/psci.c +3
-0+break ; +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 : + val = get_kernel_wa_level(reg->id) &
KVM_REG_FEATURE_LEVEL_MASK;virt/kvm/arm/psci.c +2
-0+if (kvm_arm_have_ssbd () ==KVM_SSBD_KERNEL && +kvm_arm_get_vcpu_workaround_2_flag (vcpu))
Quoted 8 lines
virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 517
Quoted 5 lines
virt/kvm/arm/psci.c +1
-0+ val |=
KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED;virt/kvm/arm/psci.c +3
-0+break ; +default : +return -EINVAL ;Hmmm, it could be more reasonable to return
-ENOENT. But this precedent may be established now.
Good point. For non-existent sysregs we return -ENOENT, indeed. So I think we should follow this here as well. Don't think it's a regression to switch now.
Quoted 5 lines
Anyway, userspace is unlikely to make any useful distinction between these two errors.
Quoted 2 lines
}
Quoted 8 lines
virt/kvm/arm/psci.c int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) · line 472
Quoted 1 line
virt/kvm/arm/psci.c +0
-1-return -EINVAL ;You could try a
BUILD_BUG_ON(KVM_REG_SIZE(reg->id) == sizeof(val)).I suspect gcc may not be quite bright enough to spot that condition is compiletime-constant, but if it does then so much the better.
Not sure it's worth a runtime check though.
Do we rely on them being 64 bit, actually? Not sure we would be checking something useful here.
Quoted 41 lines
Quoted 30 lines
virt/kvm/arm/psci.c +4
-0+if (copy_to_user (uaddr, &val,KVM_REG_SIZE (reg->id))) +return -EFAULT ; + +return 0 ; } int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct
kvm_one_reg*reg) {virt/kvm/arm/psci.c +6
-5-if (reg->id ==KVM_REG_ARM_PSCI_VERSION ) { -void __user *uaddr = (void __user *)(long )reg->addr; -bool wants_02; -u64 val; +void __user *uaddr = (void __user *)(long )reg->addr; +u64 val; +int wa_level; + +if (copy_from_user (&val, uaddr,KVM_REG_SIZE (reg->id))) +return -EFAULT ; - if (copy_from_user(&val, uaddr,
KVM_REG_SIZE(reg->id)))virt/kvm/arm/psci.c +4
-1-return -EFAULT ; +switch (reg->id) { +case KVM_REG_ARM_PSCI_VERSION : + { +bool wants_02; wants_02 = test_bit(KVM_ARM_VCPU_PSCI_0_2,
vcpu->arch.features);virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, · line 559
Quoted 8 lines
virt/kvm/arm/psci.c +5
-0@@ -497,6 +552,38 @@ int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) vcpu->kvm->arch.psci_version = val;return 0 ; } +break ; + } + +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1 : + wa_level = val &KVM_REG_FEATURE_LEVEL_MASK ;Should we require the other bits to be zero?
Quoted 3 lines
Providing we never add anything else to this register we will get away with it, but it would be cleaner to police the extra bits here and in similar places.
Mmh, I remember we are strict about this in other places, and I think I had some check in an earlier version, so might indeed be useful to have.
Quoted 20 lines
virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) · line 568
Quoted 10 lines
virt/kvm/arm/psci.c +2
-0+ +/* For now we only accept the very same workaround level. */
virt/kvm/arm/psci.c +7
-0+if (get_kernel_wa_level (reg->id) != wa_level) +return -EINVAL ; + +return 0 ; + +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2 : + wa_level = val &KVM_REG_FEATURE_LEVEL_MASK ;Ditto...
virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) · line 571
Quoted 3 lines
virt/kvm/arm/psci.c +3
-0+ +if (get_kernel_wa_level (reg->id) < wa_level) +return -EINVAL ;Is the
SMCCC_ARCH_WORKAROUND_2interface definitely always available to the guest even when in theget_kernel_wa_level()==_UNAFFECTEDcase?
Quoted 3 lines
With
wa_level==_AVAIL, the guest assumes that the interface is there.(This may be fine; I'm just not so aware of the history.)
If I understand arch/arm64/kvm/hyp/hyp-entry.S:el1_hvc_guest correctly, we do.
Quoted 7 lines
virt/kvm/arm/psci.c int kvm_arm_set_fw_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg) · line 574
Quoted 3 lines
virt/kvm/arm/psci.c +3
-0+ +if (kvm_arm_have_ssbd () !=KVM_SSBD_KERNEL ) +return 0 ;(val &
KVM_REG_FEATURE_LEVEL_MASK) could still be_NOT_AVAILor_UNKNOWNhere, yet we still attempt to callkvm_arm_set_vcpu_workaround_2_flag()based on the user'sKVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLEDbit.
Not sure I understand. If wa_level is not _AVAIL or _UNAFFECTED, we just fall through the switch/case below without doing anything. So what do I miss here?
Quoted 11 lines
Should we? I'm not clear on what the sematics should be for this case.
Quoted 9 lines
virt/kvm/arm/psci.c +5
-0+ +switch (wa_level) { +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL : + kvm_arm_set_vcpu_workaround_2_flag(vcpu, + val &
KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED);virt/kvm/arm/psci.c +3
-0+break ; +case KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED : + kvm_arm_set_vcpu_workaround_2_flag(vcpu,
Quoted 8 lines
virt/kvm/arm/psci.c
Quoted 3 lines
true);
virt/kvm/arm/psci.c +2
-0+break ; + }This has the odd effect that userspace can bypass PSCI/SMCCC and twiddle this bit directly via
KVM_SET_ONE_REG. I'm not sure this matters, and it may even be useful. A bit unexpected though. Are there any pitfalls here I've not thought of?
I think that userland can generally have more "power" than the guest, which is fine, since it's under the host's admin control. Is there any threat scenario would should be worried about? And what could be the solution?
Quoted 5 lines
virt/kvm/arm/psci.c
Quoted 2 lines
virt/kvm/arm/psci.c +2
-0+ +return 0 ;The logic overall feels a bit fragile and arbitrary, though given what it is describing, we may not be able to do a whole lot better.
Given that it was a lot worse before, I am now quite happy with it ;-)
Quoted 1 line
Do we trust the user-supplied val more than we should?
I think we allow QEMU to treat its guest badly ...
Quoted 3 lines
[...]
Overall, the code looks reasonable; my comments are pretty much nits.
Thanks,
Andre.
PATCH v3 2/2 KVM: doc: add API documentation on the KVM_REG_ARM_WORKAROUNDS register
In reply to Andre PrzywaraAdd documentation for the newly defined firmware registers to save and restore any vulnerability migitation status.
--- Documentation/virtual/kvm/arm/psci.txt | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
Documentation/virtual/kvm/arm/psci.txt +24 -0
@@ -28,3 +28,27 @@ The following register is defined: - Allows any PSCI version implemented by KVM and compatible with v0.2 to be set with SET_ONE_REG - Affects the whole VM (even if the register view is per-vcpu) + +* KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1: + Holds the state of the firmware controlled workaround to mitigate + CVE-2017-5715, as described under SMCCC_ARCH_WORKAROUND_1 in [1]. + Accepted values are: + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL: Workaround not available. + The mitigation status for the guest is unknown. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL: Workaround active for the guest. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_UNAFFECTED: The workaround is not + available and not needed. + +* KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2: + Holds the state of the firmware controlled workaround to mitigate + CVE-2018-3639, as described under SMCCC_ARCH_WORKAROUND_2 in [1]. + Accepted values are: + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL: Workaround not available. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN: Workaround state unknown. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL: Workaround available, and can + be disabled by a vCPU. If KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED is + set, it is active for this vCPU. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED: Workaround always active + or not needed. + +[1] https://developer.arm.com/-/media/developer/pdf/ARM_DEN_0070A_Firmware_interfaces_for_mitigating_CVE-2017-5715.pdf
Signature · 1 line
2.17.1
Re: [PATCH v3 2/2] KVM: doc: add API documentation on the KVM_REG_ARM_WORKAROUNDS register
Quoted 16 lines · Andre Przywara
Add documentation for the newly defined firmware registers to save and restore any vulnerability migitation status.
Signed-off-by Andre Przywara <[email protected]>--- Documentation/virtual/kvm/arm/psci.txt | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)Documentation/virtual/kvm/arm/psci.txt +0
-0@@ -28,3 +28,27 @@ The following register is defined: - Allows any PSCI version implemented by KVM and compatible with v0.2 to be set with SET_ONE_REG - Affects the whole VM (even if the register view is per-vcpu)
Documentation/virtual/kvm/arm/psci.txt The following register is defined: · line 40
Quoted 10 lines
Documentation/virtual/kvm/arm/psci.txt +10
-0+ +* KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1: + Holds the state of the firmware controlled workaround to mitigate + CVE-2017-5715, as described under SMCCC_ARCH_WORKAROUND_1 in [1]. + Accepted values are: + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL: Workaround not available. + The mitigation status for the guest is unknown. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL: Workaround active for the guest. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_UNAFFECTED: The workaround is not + available and not needed.
This definition of "unaffected" doesn't match the definition in ARM DEN-0070A - specifically a value of "1" means:
SMCCC_ARCH_WORKAROUND_1 can be invoked safely on all PEs in the system.
The PE on which SMCCC_ARCH_FEATURES is called does not require firmware mitigation for CVE-2017-5715.
i.e. the workaround *is* available - just not needed.
This difference is important if/when we allow migration from an "AVAIL" host to an "UNAFFECTED" host - the workaround calls can still be made even though they are redundant.
Steve
Quoted 15 lines
Documentation/virtual/kvm/arm/psci.txt +14
-0+ +* KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2: + Holds the state of the firmware controlled workaround to mitigate + CVE-2018-3639, as described under SMCCC_ARCH_WORKAROUND_2 in [1]. + Accepted values are: + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL: Workaround not available. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN: Workaround state unknown. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL: Workaround available, and can + be disabled by a vCPU. If KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED is + set, it is active for this vCPU. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED: Workaround always active + or not needed. + +[1] https://developer.arm.com/-/media/developer/pdf/ARM_DEN_0070A_Firmware_interfaces_for_mitigating_CVE-2017-5715.pdf
Re: [PATCH v3 2/2] KVM: doc: add API documentation on the KVM_REG_ARM_WORKAROUNDS register
In reply to Andre PrzywaraQuoted 13 lines · Andre Przywara
Add documentation for the newly defined firmware registers to save and restore any vulnerability migitation status.
Signed-off-by Andre Przywara <[email protected]>--- Documentation/virtual/kvm/arm/psci.txt | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)Documentation/virtual/kvm/arm/psci.txt +0
-0
Documentation/virtual/kvm/arm/psci.txt The following register is defined: · line 30
Quoted 3 lines
Documentation/virtual/kvm/arm/psci.txt +0
-0@@ -28,3 +28,27 @@ The following register is defined: - Allows any PSCI version implemented by KVM and compatible with v0.2 to be set with SET_ONE_REG - Affects the whole VM (even if the register view is per-vcpu)
Doh, ignore my comments about undescribed semantics in the last patch.
Quoted 10 lines
Documentation/virtual/kvm/arm/psci.txt +10
-0+ +* KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1: + Holds the state of the firmware controlled workaround to mitigate + CVE-2017-5715, as described under SMCCC_ARCH_WORKAROUND_1 in [1]. + Accepted values are: + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL: Workaround not available. + The mitigation status for the guest is unknown. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL: Workaround active for the guest. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_UNAFFECTED: The workaround is not + available and not needed.
Documentation/virtual/kvm/arm/psci.txt The following register is defined: · line 50
Quoted 10 lines
Documentation/virtual/kvm/arm/psci.txt +10
-0+ +* KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2: + Holds the state of the firmware controlled workaround to mitigate + CVE-2018-3639, as described under SMCCC_ARCH_WORKAROUND_2 in [1]. + Accepted values are: + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL: Workaround not available. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN: Workaround state unknown. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL: Workaround available, and can + be disabled by a vCPU. If KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED is + set, it is active for this vCPU.
Ah, so this is really not supposed to be set except for _AVAIL?
Documentation/virtual/kvm/arm/psci.txt The following register is defined: · line 52
Quoted 2 lines
Documentation/virtual/kvm/arm/psci.txt +2
-0+ KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED: Workaround always active + or not needed.
But is the workaround available (i.e., SMCCC interface implemented?)
The code assumes it is, IIUC -- i.e., it will happily upgrade _AVAIL to _UNAFFECTED. That's bad if it means the SMCCC call disappears under the guest's feet.
(Not saying it does, just that I'm not sure.)
For KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1, we apply an == check, avoiding this subtlety.
Cheers
---Dave
Re: [PATCH v3 2/2] KVM: doc: add API documentation on the KVM_REG_ARM_WORKAROUNDS register
Quoted 34 lines · On Fri, 22 Feb 2019 17:27:44 +0000 Dave Martin <[email protected]> wrote:
Quoted 13 lines · Andre Przywara
Add documentation for the newly defined firmware registers to save and restore any vulnerability migitation status.
Signed-off-by Andre Przywara <[email protected]>--- Documentation/virtual/kvm/arm/psci.txt | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)Documentation/virtual/kvm/arm/psci.txt +0
-0Documentation/virtual/kvm/arm/psci.txt The following register is defined: · line 30
Quoted 3 lines
Documentation/virtual/kvm/arm/psci.txt +0
-0@@ -28,3 +28,27 @@ The following register is defined: - Allows any PSCI version implemented by KVM and compatible with v0.2 to be set with SET_ONE_REG - Affects the whole VM (even if the register view is per-vcpu)Doh, ignore my comments about undescribed semantics in the last patch.
Quoted 14 lines
Documentation/virtual/kvm/arm/psci.txt +14
-0+ +* KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1: + Holds the state of the firmware controlled workaround to mitigate + CVE-2017-5715, as described under SMCCC_ARCH_WORKAROUND_1 in [1]. + Accepted values are: + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_NOT_AVAIL: Workaround not available. + The mitigation status for the guest is unknown. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_AVAIL: Workaround active for the guest. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1_UNAFFECTED: The workaround is not + available and not needed. + +* KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2: + Holds the state of the firmware controlled workaround to mitigate + CVE-2018-3639, as described under SMCCC_ARCH_WORKAROUND_2 in [1].
Quoted 8 lines
Documentation/virtual/kvm/arm/psci.txt The following register is defined: · line 50
Quoted 6 lines
Documentation/virtual/kvm/arm/psci.txt +6
-0+ Accepted values are: + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_NOT_AVAIL: Workaround not available. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNKNOWN: Workaround state unknown. + KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_AVAIL: Workaround available, and can + be disabled by a vCPU. If KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_ENABLED is + set, it is active for this vCPU.Ah, so this is really not supposed to be set except for
_AVAIL?
Yes, it's only used if the kernel offers the switch. The reason is to allow the guest to turn it *off*, actually.
Quoted 4 lines
Documentation/virtual/kvm/arm/psci.txt The following register is defined: · line 52
Quoted 2 lines
Documentation/virtual/kvm/arm/psci.txt +2
-0+ KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_2_UNAFFECTED: Workaround always active + or not needed.But is the workaround available (i.e., SMCCC interface implemented?)
Yes, that mirrors return value 1 of the actual firmware interface permanently enable or not require, but safe to call the firmware).
Quoted 3 lines
The code assumes it is, IIUC -- i.e., it will happily upgrade
_AVAILto_UNAFFECTED. That's bad if it means the SMCCC call disappears under the guest's feet.
I think migrating to a "better" system is an important use case, so we should make it possible.
Quoted 5 lines
(Not saying it does, just that I'm not sure.)
For
KVM_REG_ARM_SMCCC_ARCH_WORKAROUND_1, we apply an == check, avoiding this subtlety.
Because we only have two cases there at the moment, and NOT_AVAIL could mean not protected. Since we require guest interaction for WORKAROUND_1, we can't allow any change at the moment. This will change with the introduction of UNAFFECTED.
Cheers,
Andre