1 files changed, 98 insertions, 36 deletions

diff --git a/arch/x86/kernel/cpu/bugs.c b/arch/x86/kernel/cpu/bugs.c
index 390b3dc3d438..71949bf2de5a 100644
--- a/arch/x86/kernel/cpu/bugs.c
+++ b/arch/x86/kernel/cpu/bugs.c
@@ -11,6 +11,7 @@
 #include <linux/init.h>
 #include <linux/utsname.h>
 #include <linux/cpu.h>
+#include <linux/module.h>
 
 #include <asm/nospec-branch.h>
 #include <asm/cmdline.h>
@@ -90,20 +91,41 @@ static const char *spectre_v2_strings[] = {
 };
 
 #undef pr_fmt
-#define pr_fmt(fmt)     "Spectre V2 mitigation: " fmt
+#define pr_fmt(fmt)     "Spectre V2 : " fmt
 
 static enum spectre_v2_mitigation spectre_v2_enabled = SPECTRE_V2_NONE;
 
+#ifdef RETPOLINE
+static bool spectre_v2_bad_module;
+
+bool retpoline_module_ok(bool has_retpoline)
+{
+        if (spectre_v2_enabled == SPECTRE_V2_NONE || has_retpoline)
+                return true;
+
+        pr_err("System may be vulnerable to spectre v2\n");
+        spectre_v2_bad_module = true;
+        return false;
+}
+
+static inline const char *spectre_v2_module_string(void)
+{
+        return spectre_v2_bad_module ? " - vulnerable module loaded" : "";
+}
+#else
+static inline const char *spectre_v2_module_string(void) { return ""; }
+#endif
+
 static void __init spec2_print_if_insecure(const char *reason)
 {
         if (boot_cpu_has_bug(X86_BUG_SPECTRE_V2))
-                pr_info("%s\n", reason);
+                pr_info("%s selected on command line.\n", reason);
 }
 
 static void __init spec2_print_if_secure(const char *reason)
 {
         if (!boot_cpu_has_bug(X86_BUG_SPECTRE_V2))
-                pr_info("%s\n", reason);
+                pr_info("%s selected on command line.\n", reason);
 }
 
 static inline bool retp_compiler(void)
@@ -118,42 +140,68 @@ static inline bool match_option(const char *arg, int arglen, const char *opt)
         return len == arglen && !strncmp(arg, opt, len);
 }
 
+static const struct {
+        const char *option;
+        enum spectre_v2_mitigation_cmd cmd;
+        bool secure;
+} mitigation_options[] = {
+        { "off",               SPECTRE_V2_CMD_NONE,              false },
+        { "on",                SPECTRE_V2_CMD_FORCE,             true },
+        { "retpoline",         SPECTRE_V2_CMD_RETPOLINE,         false },
+        { "retpoline,amd",     SPECTRE_V2_CMD_RETPOLINE_AMD,     false },
+        { "retpoline,generic", SPECTRE_V2_CMD_RETPOLINE_GENERIC, false },
+        { "auto",              SPECTRE_V2_CMD_AUTO,              false },
+};
+
 static enum spectre_v2_mitigation_cmd __init spectre_v2_parse_cmdline(void)
 {
         char arg[20];
-        int ret;
-
-        ret = cmdline_find_option(boot_command_line, "spectre_v2", arg,
-                                  sizeof(arg));
-        if (ret > 0)  {
-                if (match_option(arg, ret, "off")) {
-                        goto disable;
-                } else if (match_option(arg, ret, "on")) {
-                        spec2_print_if_secure("force enabled on command line.");
-                        return SPECTRE_V2_CMD_FORCE;
-                } else if (match_option(arg, ret, "retpoline")) {
-                        spec2_print_if_insecure("retpoline selected on command line.");
-                        return SPECTRE_V2_CMD_RETPOLINE;
-                } else if (match_option(arg, ret, "retpoline,amd")) {
-                        if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD) {
-                                pr_err("retpoline,amd selected but CPU is not AMD. Switching to AUTO select\n");
-                                return SPECTRE_V2_CMD_AUTO;
-                        }
-                        spec2_print_if_insecure("AMD retpoline selected on command line.");
-                        return SPECTRE_V2_CMD_RETPOLINE_AMD;
-                } else if (match_option(arg, ret, "retpoline,generic")) {
-                        spec2_print_if_insecure("generic retpoline selected on command line.");
-                        return SPECTRE_V2_CMD_RETPOLINE_GENERIC;
-                } else if (match_option(arg, ret, "auto")) {
+        int ret, i;
+        enum spectre_v2_mitigation_cmd cmd = SPECTRE_V2_CMD_AUTO;
+
+        if (cmdline_find_option_bool(boot_command_line, "nospectre_v2"))
+                return SPECTRE_V2_CMD_NONE;
+        else {
+                ret = cmdline_find_option(boot_command_line, "spectre_v2", arg,
+                                          sizeof(arg));
+                if (ret < 0)
+                        return SPECTRE_V2_CMD_AUTO;
+
+                for (i = 0; i < ARRAY_SIZE(mitigation_options); i++) {
+                        if (!match_option(arg, ret, mitigation_options[i].option))
+                                continue;
+                        cmd = mitigation_options[i].cmd;
+                        break;
+                }
+
+                if (i >= ARRAY_SIZE(mitigation_options)) {
+                        pr_err("unknown option (%s). Switching to AUTO select\n",
+                               mitigation_options[i].option);
                         return SPECTRE_V2_CMD_AUTO;
                 }
         }
 
-        if (!cmdline_find_option_bool(boot_command_line, "nospectre_v2"))
+        if ((cmd == SPECTRE_V2_CMD_RETPOLINE ||
+             cmd == SPECTRE_V2_CMD_RETPOLINE_AMD ||
+             cmd == SPECTRE_V2_CMD_RETPOLINE_GENERIC) &&
+            !IS_ENABLED(CONFIG_RETPOLINE)) {
+                pr_err("%s selected but not compiled in. Switching to AUTO select\n",
+                       mitigation_options[i].option);
                 return SPECTRE_V2_CMD_AUTO;
-disable:
-        spec2_print_if_insecure("disabled on command line.");
-        return SPECTRE_V2_CMD_NONE;
+        }
+
+        if (cmd == SPECTRE_V2_CMD_RETPOLINE_AMD &&
+            boot_cpu_data.x86_vendor != X86_VENDOR_AMD) {
+                pr_err("retpoline,amd selected but CPU is not AMD. Switching to AUTO select\n");
+                return SPECTRE_V2_CMD_AUTO;
+        }
+
+        if (mitigation_options[i].secure)
+                spec2_print_if_secure(mitigation_options[i].option);
+        else
+                spec2_print_if_insecure(mitigation_options[i].option);
+
+        return cmd;
 }
 
 /* Check for Skylake-like CPUs (for RSB handling) */
@@ -191,10 +239,10 @@ static void __init spectre_v2_select_mitigation(void)
                 return;
 
         case SPECTRE_V2_CMD_FORCE:
-                /* FALLTRHU */
         case SPECTRE_V2_CMD_AUTO:
-                goto retpoline_auto;
-
+                if (IS_ENABLED(CONFIG_RETPOLINE))
+                        goto retpoline_auto;
+                break;
         case SPECTRE_V2_CMD_RETPOLINE_AMD:
                 if (IS_ENABLED(CONFIG_RETPOLINE))
                         goto retpoline_amd;
@@ -249,6 +297,12 @@ retpoline_auto:
                 setup_force_cpu_cap(X86_FEATURE_RSB_CTXSW);
                 pr_info("Filling RSB on context switch\n");
         }
+
+        /* Initialize Indirect Branch Prediction Barrier if supported */
+        if (boot_cpu_has(X86_FEATURE_IBPB)) {
+                setup_force_cpu_cap(X86_FEATURE_USE_IBPB);
+                pr_info("Enabling Indirect Branch Prediction Barrier\n");
+        }
 }
 
 #undef pr_fmt
@@ -269,7 +323,7 @@ ssize_t cpu_show_spectre_v1(struct device *dev,
 {
         if (!boot_cpu_has_bug(X86_BUG_SPECTRE_V1))
                 return sprintf(buf, "Not affected\n");
-        return sprintf(buf, "Vulnerable\n");
+        return sprintf(buf, "Mitigation: __user pointer sanitization\n");
 }
 
 ssize_t cpu_show_spectre_v2(struct device *dev,
@@ -278,6 +332,14 @@ ssize_t cpu_show_spectre_v2(struct device *dev,
         if (!boot_cpu_has_bug(X86_BUG_SPECTRE_V2))
                 return sprintf(buf, "Not affected\n");
 
-        return sprintf(buf, "%s\n", spectre_v2_strings[spectre_v2_enabled]);
+        return sprintf(buf, "%s%s%s\n", spectre_v2_strings[spectre_v2_enabled],
+                       boot_cpu_has(X86_FEATURE_USE_IBPB) ? ", IBPB" : "",
+                       spectre_v2_module_string());
 }
 #endif
+
+void __ibp_barrier(void)
+{
+        __wrmsr(MSR_IA32_PRED_CMD, PRED_CMD_IBPB, 0);
+}
+EXPORT_SYMBOL_GPL(__ibp_barrier);