x86/fpu: Disable MPX when eagerfpu is off

This issue is a fallout from the command-line parsing move.

When "eagerfpu=off" is given as a command-line input, the kernel
should disable MPX support. The decision for turning off MPX was
made in fpu__init_system_ctx_switch(), which is after the
selection of the XSAVE format. This patch fixes it by getting
that decision done earlier in fpu__init_system_xstate().

Signed-off-by: Yu-cheng Yu <[email protected]>
Cc: Andy Lutomirski <[email protected]>
Cc: Borislav Petkov <[email protected]>
Cc: Borislav Petkov <[email protected]>
Cc: Dave Hansen <[email protected]>
Cc: Fenghua Yu <[email protected]>
Cc: H. Peter Anvin <[email protected]>
Cc: Linus Torvalds <[email protected]>
Cc: Oleg Nesterov <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Quentin Casasnovas <[email protected]>
Cc: Ravi V. Shankar <[email protected]>
Cc: Sai Praneeth Prakhya <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: yu-cheng yu <[email protected]>
Link: http://lkml.kernel.org/r/[email protected]
Signed-off-by: Ingo Molnar <[email protected]>

diff --git a/arch/x86/include/asm/fpu/internal.h b/arch/x86/include/asm/fpu/internal.h
index eadcdd5bb9464af38645499004fee0755d6b071f..0fd440df63f18d77c040f8683f34018ed426b4b2 100644 (file)
--- a/arch/x86/include/asm/fpu/internal.h
+++ b/arch/x86/include/asm/fpu/internal.h
@@ -42,6 +42,7 @@ extern void fpu__init_cpu_xstate(void);
 extern void fpu__init_system(struct cpuinfo_x86 *c);
 extern void fpu__init_check_bugs(void);
 extern void fpu__resume_cpu(void);
+extern u64 fpu__get_supported_xfeatures_mask(void);
 
 /*
  * Debugging facility:

diff --git a/arch/x86/kernel/fpu/init.c b/arch/x86/kernel/fpu/init.c
index 3a45fcd0b924c42f7a25c19fbf4ff984eabad975..f0ab36844a6ddce7489888a8d7e81fa660cb3ec9 100644 (file)
--- a/arch/x86/kernel/fpu/init.c
+++ b/arch/x86/kernel/fpu/init.c
@@ -273,8 +273,46 @@ static void __init fpu__init_system_xstate_size_legacy(void)
  */
 static enum { AUTO, ENABLE, DISABLE } eagerfpu = AUTO;
 
+/*
+ * Find supported xfeatures based on cpu features and command-line input.
+ * This must be called after fpu__init_parse_early_param() is called and
+ * xfeatures_mask is enumerated.
+ */
+u64 __init fpu__get_supported_xfeatures_mask(void)
+{
+       /* Support all xfeatures known to us */
+       if (eagerfpu != DISABLE)
+               return XCNTXT_MASK;
+
+       /* Warning of xfeatures being disabled for no eagerfpu mode */
+       if (xfeatures_mask & XFEATURE_MASK_EAGER) {
+               pr_err("x86/fpu: eagerfpu switching disabled, disabling the following xstate features: 0x%llx.\n",
+                       xfeatures_mask & XFEATURE_MASK_EAGER);
+       }
+
+       /* Return a mask that masks out all features requiring eagerfpu mode */
+       return ~XFEATURE_MASK_EAGER;
+}
+
+/*
+ * Disable features dependent on eagerfpu.
+ */
+static void __init fpu__clear_eager_fpu_features(void)
+{
+       setup_clear_cpu_cap(X86_FEATURE_MPX);
+}
+
 /*
  * Pick the FPU context switching strategy:
+ *
+ * When eagerfpu is AUTO or ENABLE, we ensure it is ENABLE if either of
+ * the following is true:
+ *
+ * (1) the cpu has xsaveopt, as it has the optimization and doing eager
+ *     FPU switching has a relatively low cost compared to a plain xsave;
+ * (2) the cpu has xsave features (e.g. MPX) that depend on eager FPU
+ *     switching. Should the kernel boot with noxsaveopt, we support MPX
+ *     with eager FPU switching at a higher cost.
  */
 static void __init fpu__init_system_ctx_switch(void)
 {
@@ -286,19 +324,11 @@ static void __init fpu__init_system_ctx_switch(void)
        WARN_ON_FPU(current->thread.fpu.fpstate_active);
        current_thread_info()->status = 0;
 
-       /* Auto enable eagerfpu for xsaveopt */
        if (boot_cpu_has(X86_FEATURE_XSAVEOPT) && eagerfpu != DISABLE)
                eagerfpu = ENABLE;
 
-       if (xfeatures_mask & XFEATURE_MASK_EAGER) {
-               if (eagerfpu == DISABLE) {
-                       pr_err("x86/fpu: eagerfpu switching disabled, disabling the following xstate features: 0x%llx.\n",
-                              xfeatures_mask & XFEATURE_MASK_EAGER);
-                       xfeatures_mask &= ~XFEATURE_MASK_EAGER;
-               } else {
-                       eagerfpu = ENABLE;
-               }
-       }
+       if (xfeatures_mask & XFEATURE_MASK_EAGER)
+               eagerfpu = ENABLE;
 
        if (eagerfpu == ENABLE)
                setup_force_cpu_cap(X86_FEATURE_EAGER_FPU);
@@ -316,10 +346,12 @@ static void __init fpu__init_parse_early_param(void)
         * No need to check "eagerfpu=auto" again, since it is the
         * initial default.
         */
-       if (cmdline_find_option_bool(boot_command_line, "eagerfpu=off"))
+       if (cmdline_find_option_bool(boot_command_line, "eagerfpu=off")) {
                eagerfpu = DISABLE;
-       else if (cmdline_find_option_bool(boot_command_line, "eagerfpu=on"))
+               fpu__clear_eager_fpu_features();
+       } else if (cmdline_find_option_bool(boot_command_line, "eagerfpu=on")) {
                eagerfpu = ENABLE;
+       }
 
        if (cmdline_find_option_bool(boot_command_line, "no387"))
                setup_clear_cpu_cap(X86_FEATURE_FPU);

diff --git a/arch/x86/kernel/fpu/xstate.c b/arch/x86/kernel/fpu/xstate.c
index d489f277a8a0cc6b9820a0bcf099ccc5f332e63f..d425cda5ae6d0f1544c5d8decdb14d8682d7f7dd 100644 (file)
--- a/arch/x86/kernel/fpu/xstate.c
+++ b/arch/x86/kernel/fpu/xstate.c
@@ -633,8 +633,7 @@ void __init fpu__init_system_xstate(void)
                BUG();
        }
 
-       /* Support only the state known to the OS: */
-       xfeatures_mask = xfeatures_mask & XCNTXT_MASK;
+       xfeatures_mask &= fpu__get_supported_xfeatures_mask();
 
        /* Enable xstate instructions to be able to continue with initialization: */
        fpu__init_cpu_xstate();