KVM: arm64: Handle SME host state when running guests

While we don't currently support SME in guests we do currently support it
for the host system so we need to take care of SME's impact, including
the floating point register state, when running guests. Simiarly to SVE
we need to manage the traps in CPACR_RL1, what is new is the handling of
streaming mode and ZA.

Normally we defer any handling of the floating point register state until
the guest first uses it however if the system is in streaming mode FPSIMD
and SVE operations may generate SME traps which we would need to distinguish
from actual attempts by the guest to use SME. Rather than do this for the
time being if we are in streaming mode when entering the guest we force
the floating point state to be saved immediately and exit streaming mode,
meaning that the guest won't generate SME traps for supported operations.

We could handle ZA in the access trap similarly to the FPSIMD/SVE state
without the disruption caused by streaming mode but for simplicity
handle it the same way as streaming mode for now.

This will be revisited when we support SME for guests (hopefully before SME
hardware becomes available), for now it will only incur additional cost on
systems with SME and even there only if streaming mode or ZA are enabled.

Signed-off-by: Mark Brown <broonie@kernel.org>
Reviewed-by: Catalin Marinas <catalin.marinas@arm.com>
Reviewed-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/20220419112247.711548-27-broonie@kernel.org
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>

diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h
index 8a7c442d5b57719fe85555e389cb09b5dec34ffb..f8f0d30dd1a28e72eb29bc0e9a92fedf534ddb3b 100644 (file)
--- a/arch/arm64/include/asm/kvm_host.h
+++ b/arch/arm64/include/asm/kvm_host.h
@@ -454,6 +454,7 @@ struct kvm_vcpu_arch {
 #define KVM_ARM64_DEBUG_STATE_SAVE_TRBE        (1 << 13) /* Save TRBE context if active  */
 #define KVM_ARM64_FP_FOREIGN_FPSTATE   (1 << 14)
 #define KVM_ARM64_ON_UNSUPPORTED_CPU   (1 << 15) /* Physical CPU not in supported_cpus */
+#define KVM_ARM64_HOST_SME_ENABLED     (1 << 16) /* SME enabled for EL0 */
 
 #define KVM_GUESTDBG_VALID_MASK (KVM_GUESTDBG_ENABLE | \
                                 KVM_GUESTDBG_USE_SW_BP | \

diff --git a/arch/arm64/kvm/fpsimd.c b/arch/arm64/kvm/fpsimd.c
index 57d7ac3cfa0c8d92cfa18b04534eaa3a43ffbe80..441edb9c398c95a089ddc7c777f6bc4001e8e7f8 100644 (file)
--- a/arch/arm64/kvm/fpsimd.c
+++ b/arch/arm64/kvm/fpsimd.c
@@ -82,6 +82,26 @@ void kvm_arch_vcpu_load_fp(struct kvm_vcpu *vcpu)
 
        if (read_sysreg(cpacr_el1) & CPACR_EL1_ZEN_EL0EN)
                vcpu->arch.flags |= KVM_ARM64_HOST_SVE_ENABLED;
+
+       /*
+        * We don't currently support SME guests but if we leave
+        * things in streaming mode then when the guest starts running
+        * FPSIMD or SVE code it may generate SME traps so as a
+        * special case if we are in streaming mode we force the host
+        * state to be saved now and exit streaming mode so that we
+        * don't have to handle any SME traps for valid guest
+        * operations. Do this for ZA as well for now for simplicity.
+        */
+       if (system_supports_sme()) {
+               if (read_sysreg(cpacr_el1) & CPACR_EL1_SMEN_EL0EN)
+                       vcpu->arch.flags |= KVM_ARM64_HOST_SME_ENABLED;
+
+               if (read_sysreg_s(SYS_SVCR_EL0) &
+                   (SYS_SVCR_EL0_SM_MASK | SYS_SVCR_EL0_ZA_MASK)) {
+                       vcpu->arch.flags &= ~KVM_ARM64_FP_HOST;
+                       fpsimd_save_and_flush_cpu_state();
+               }
+       }
 }
 
 /*
@@ -135,6 +155,22 @@ void kvm_arch_vcpu_put_fp(struct kvm_vcpu *vcpu)
 
        local_irq_save(flags);
 
+       /*
+        * If we have VHE then the Hyp code will reset CPACR_EL1 to
+        * CPACR_EL1_DEFAULT and we need to reenable SME.
+        */
+       if (has_vhe() && system_supports_sme()) {
+               /* Also restore EL0 state seen on entry */
+               if (vcpu->arch.flags & KVM_ARM64_HOST_SME_ENABLED)
+                       sysreg_clear_set(CPACR_EL1, 0,
+                                        CPACR_EL1_SMEN_EL0EN |
+                                        CPACR_EL1_SMEN_EL1EN);
+               else
+                       sysreg_clear_set(CPACR_EL1,
+                                        CPACR_EL1_SMEN_EL0EN,
+                                        CPACR_EL1_SMEN_EL1EN);
+       }
+
        if (vcpu->arch.flags & KVM_ARM64_FP_ENABLED) {
                if (vcpu_has_sve(vcpu)) {
                        __vcpu_sys_reg(vcpu, ZCR_EL1) = read_sysreg_el1(SYS_ZCR);