arm64: ssbd: Restore mitigation status on CPU resume

commit 647d0519b53f440a55df163de21c52a8205431cc upstream.

On a system where firmware can dynamically change the state of the
mitigation, the CPU will always come up with the mitigation enabled,
including when coming back from suspend.

If the user has requested "no mitigation" via a command line option,
let's enforce it by calling into the firmware again to disable it.

Similarily, for a resume from hibernate, the mitigation could have
been disabled by the boot kernel. Let's ensure that it is set
back on in that case.

Acked-by: Will Deacon <will.deacon@arm.com>
Reviewed-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/arch/arm64/include/asm/cpufeature.h b/arch/arm64/include/asm/cpufeature.h
index 0c1529e020a7c1cee9fa49a055e2e44b403b8c85..15868eca58de03ea6a0f28654c122edf0ae54326 100644 (file)
--- a/arch/arm64/include/asm/cpufeature.h
+++ b/arch/arm64/include/asm/cpufeature.h
@@ -237,6 +237,12 @@ static inline int arm64_get_ssbd_state(void)
 #endif
 }
 
+#ifdef CONFIG_ARM64_SSBD
+void arm64_set_ssbd_mitigation(bool state);
+#else
+static inline void arm64_set_ssbd_mitigation(bool state) {}
+#endif
+
 #endif /* __ASSEMBLY__ */
 
 #endif

diff --git a/arch/arm64/kernel/cpu_errata.c b/arch/arm64/kernel/cpu_errata.c
index 9e0b311873ef92b068e92a8b6f612dbfbe1a01e6..1db97ad7b58b37e9c838b3c030bfe2e0aa981c4c 100644 (file)
--- a/arch/arm64/kernel/cpu_errata.c
+++ b/arch/arm64/kernel/cpu_errata.c
@@ -258,7 +258,7 @@ void __init arm64_enable_wa2_handling(struct alt_instr *alt,
                *updptr = cpu_to_le32(aarch64_insn_gen_nop());
 }
 
-static void arm64_set_ssbd_mitigation(bool state)
+void arm64_set_ssbd_mitigation(bool state)
 {
        switch (psci_ops.conduit) {
        case PSCI_CONDUIT_HVC:

diff --git a/arch/arm64/kernel/hibernate.c b/arch/arm64/kernel/hibernate.c
index d55a7b09959b4d3f725ee6400a21fbc963d31b61..f6e71c73cceba9b693c5613710eb4c85f9882b76 100644 (file)
--- a/arch/arm64/kernel/hibernate.c
+++ b/arch/arm64/kernel/hibernate.c
@@ -308,6 +308,17 @@ int swsusp_arch_suspend(void)
 
                sleep_cpu = -EINVAL;
                __cpu_suspend_exit();
+
+               /*
+                * Just in case the boot kernel did turn the SSBD
+                * mitigation off behind our back, let's set the state
+                * to what we expect it to be.
+                */
+               switch (arm64_get_ssbd_state()) {
+               case ARM64_SSBD_FORCE_ENABLE:
+               case ARM64_SSBD_KERNEL:
+                       arm64_set_ssbd_mitigation(true);
+               }
        }
 
        local_dbg_restore(flags);

diff --git a/arch/arm64/kernel/suspend.c b/arch/arm64/kernel/suspend.c
index bb0cd787a9d31dc4762d3a98257b3e11d8afe6f0..1dbf6099e2a56a94626604a55d8ae933ae0434c6 100644 (file)
--- a/arch/arm64/kernel/suspend.c
+++ b/arch/arm64/kernel/suspend.c
@@ -67,6 +67,14 @@ void notrace __cpu_suspend_exit(void)
         */
        if (hw_breakpoint_restore)
                hw_breakpoint_restore(cpu);
+
+       /*
+        * On resume, firmware implementing dynamic mitigation will
+        * have turned the mitigation on. If the user has forcefully
+        * disabled it, make sure their wishes are obeyed.
+        */
+       if (arm64_get_ssbd_state() == ARM64_SSBD_FORCE_DISABLE)
+               arm64_set_ssbd_mitigation(false);
 }
 
 /*