x86/speculation: Prepare entry code for Spectre v1 swapgs mitigations [Linux 4.9.189]

This Linux kernel change "x86/speculation: Prepare entry code for Spectre v1 swapgs mitigations" is included in the Linux 4.9.189 release. This change is authored by Josh Poimboeuf <jpoimboe [at] redhat.com> on Mon Jul 8 11:52:25 2019 -0500. The commit for this change in Linux stable tree is e90ec5e (patch) which is from upstream commit 18ec54f. The same Linux upstream change may have been applied to various maintained Linux releases and you can find all Linux releases containing changes from upstream 18ec54f.

x86/speculation: Prepare entry code for Spectre v1 swapgs mitigations

commit 18ec54fdd6d18d92025af097cd042a75cf0ea24c upstream.

Spectre v1 isn't only about array bounds checks.  It can affect any
conditional checks.  The kernel entry code interrupt, exception, and NMI
handlers all have conditional swapgs checks.  Those may be problematic in
the context of Spectre v1, as kernel code can speculatively run with a user
GS.

For example:

    if (coming from user space)
        swapgs
    mov %gs:<percpu_offset>, %reg
    mov (%reg), %reg1

When coming from user space, the CPU can speculatively skip the swapgs, and
then do a speculative percpu load using the user GS value.  So the user can
speculatively force a read of any kernel value.  If a gadget exists which
uses the percpu value as an address in another load/store, then the
contents of the kernel value may become visible via an L1 side channel
attack.

A similar attack exists when coming from kernel space.  The CPU can
speculatively do the swapgs, causing the user GS to get used for the rest
of the speculative window.

The mitigation is similar to a traditional Spectre v1 mitigation, except:

  a) index masking isn't possible; because the index (percpu offset)
     isn't user-controlled; and

  b) an lfence is needed in both the "from user" swapgs path and the
     "from kernel" non-swapgs path (because of the two attacks described
     above).

The user entry swapgs paths already have SWITCH_TO_KERNEL_CR3, which has a
CR3 write when PTI is enabled.  Since CR3 writes are serializing, the
lfences can be skipped in those cases.

On the other hand, the kernel entry swapgs paths don't depend on PTI.

To avoid unnecessary lfences for the user entry case, create two separate
features for alternative patching:

  X86_FEATURE_FENCE_SWAPGS_USER
  X86_FEATURE_FENCE_SWAPGS_KERNEL

Use these features in entry code to patch in lfences where needed.

The features aren't enabled yet, so there's no functional change.

Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Dave Hansen <dave.hansen@intel.com>
[bwh: Backported to 4.9:
 - Assign the CPU feature bits from word 7
 - Add FENCE_SWAPGS_KERNEL_ENTRY to NMI entry, since it does not
   use paranoid_entry
 - Include <asm/cpufeatures.h> in calling.h
 - Adjust context]
Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

There are 42 lines of Linux source code added/deleted in this change. Code changes to Linux kernel are as follows.

 arch/x86/entry/calling.h           | 18 ++++++++++++++++++
 arch/x86/entry/entry_64.S          | 21 +++++++++++++++++++--
 arch/x86/include/asm/cpufeatures.h |  3 ++-
 3 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/arch/x86/entry/calling.h b/arch/x86/entry/calling.h
index 9a9e588..8af8c07 100644
--- a/arch/x86/entry/calling.h
+++ b/arch/x86/entry/calling.h
@@ -1,4 +1,5 @@
 #include <linux/jump_label.h>
+#include <asm/cpufeatures.h>

 /*

@@ -201,6 +202,23 @@
    .byte 0xf1
    .endm

+/*
+ * Mitigate Spectre v1 for conditional swapgs code paths.
+ *
+ * FENCE_SWAPGS_USER_ENTRY is used in the user entry swapgs code path, to
+ * prevent a speculative swapgs when coming from kernel space.
+ *
+ * FENCE_SWAPGS_KERNEL_ENTRY is used in the kernel entry non-swapgs code path,
+ * to prevent the swapgs from getting speculatively skipped when coming from
+ * user space.
+ */
+.macro FENCE_SWAPGS_USER_ENTRY
+   ALTERNATIVE "", "lfence", X86_FEATURE_FENCE_SWAPGS_USER
+.endm
+.macro FENCE_SWAPGS_KERNEL_ENTRY
+   ALTERNATIVE "", "lfence", X86_FEATURE_FENCE_SWAPGS_KERNEL
+.endm
+
 #endif /* CONFIG_X86_64 */

 /*
diff --git a/arch/x86/entry/entry_64.S b/arch/x86/entry/entry_64.S
index 8252d9d..592f62f 100644
--- a/arch/x86/entry/entry_64.S
+++ b/arch/x86/entry/entry_64.S
@@ -420,6 +420,7 @@ END(irq_entries_start)
     * tracking that we're in kernel mode.
     */
    SWAPGS
+   FENCE_SWAPGS_USER_ENTRY
    SWITCH_KERNEL_CR3

    /*
@@ -433,8 +434,10 @@ END(irq_entries_start)
    TRACE_IRQS_OFF

    CALL_enter_from_user_mode
-
+   jmpq    2f
 1:
+   FENCE_SWAPGS_KERNEL_ENTRY
+2:
    /*
     * Save previous stack pointer, optionally switch to interrupt stack.
     * irq_count is used to check if a CPU is already on an interrupt stack
@@ -1004,6 +1007,13 @@ ENTRY(paranoid_entry)
    movq    %rax, %cr3
 2:
 #endif
+   /*
+    * The above doesn't do an unconditional CR3 write, even in the PTI
+    * case.  So do an lfence to prevent GS speculation, regardless of
+    * whether PTI is enabled.
+    */
+   FENCE_SWAPGS_KERNEL_ENTRY
+
    ret
 END(paranoid_entry)

@@ -1065,6 +1075,7 @@ ENTRY(error_entry)
     * from user mode due to an IRET fault.
     */
    SWAPGS
+   FENCE_SWAPGS_USER_ENTRY

 .Lerror_entry_from_usermode_after_swapgs:
    /*
@@ -1076,6 +1087,8 @@ ENTRY(error_entry)
    CALL_enter_from_user_mode
    ret

+.Lerror_entry_done_lfence:
+   FENCE_SWAPGS_KERNEL_ENTRY
 .Lerror_entry_done:
    TRACE_IRQS_OFF
    ret
@@ -1094,7 +1107,7 @@ ENTRY(error_entry)
    cmpq    %rax, RIP+8(%rsp)
    je  .Lbstep_iret
    cmpq    $.Lgs_change, RIP+8(%rsp)
-   jne .Lerror_entry_done
+   jne .Lerror_entry_done_lfence

    /*
     * hack: .Lgs_change can fail with user gsbase.  If this happens, fix up
@@ -1102,6 +1115,7 @@ ENTRY(error_entry)
     * .Lgs_change's error handler with kernel gsbase.
     */
    SWAPGS
+   FENCE_SWAPGS_USER_ENTRY
    jmp .Lerror_entry_done

 .Lbstep_iret:
@@ -1115,6 +1129,7 @@ ENTRY(error_entry)
     * Switch to kernel gsbase:
     */
    SWAPGS
+   FENCE_SWAPGS_USER_ENTRY

    /*
     * Pretend that the exception came from user mode: set up pt_regs
@@ -1211,6 +1226,7 @@ ENTRY(nmi)
     * to switch CR3 here.
     */
    cld
+   FENCE_SWAPGS_USER_ENTRY
    movq    %rsp, %rdx
    movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp
    pushq   5*8(%rdx)   /* pt_regs->ss */
@@ -1499,6 +1515,7 @@ end_repeat_nmi:
    movq    %rax, %cr3
 2:
 #endif
+   FENCE_SWAPGS_KERNEL_ENTRY

    /* paranoidentry do_nmi, 0; without TRACE_IRQS_OFF */
    call    do_nmi
diff --git a/arch/x86/include/asm/cpufeatures.h b/arch/x86/include/asm/cpufeatures.h
index 26031c9..7c47614 100644
--- a/arch/x86/include/asm/cpufeatures.h
+++ b/arch/x86/include/asm/cpufeatures.h
@@ -192,7 +192,8 @@

 #define X86_FEATURE_HW_PSTATE  ( 7*32+ 8) /* AMD HW-PState */
 #define X86_FEATURE_PROC_FEEDBACK ( 7*32+ 9) /* AMD ProcFeedbackInterface */
-
+#define X86_FEATURE_FENCE_SWAPGS_USER  ( 7*32+10) /* "" LFENCE in user entry SWAPGS path */
+#define X86_FEATURE_FENCE_SWAPGS_KERNEL    ( 7*32+11) /* "" LFENCE in kernel entry SWAPGS path */
 #define X86_FEATURE_RETPOLINE  ( 7*32+12) /* "" Generic Retpoline mitigation for Spectre variant 2 */
 #define X86_FEATURE_RETPOLINE_AMD ( 7*32+13) /* "" AMD Retpoline mitigation for Spectre variant 2 */

Leave a Reply

Your email address will not be published. Required fields are marked *