powerpc/64: Make meltdown reporting Book3S 64 specific

[mirror_ubuntu-bionic-kernel.git] / arch / powerpc / kernel / security.c

diff --git a/arch/powerpc/kernel/security.c b/arch/powerpc/kernel/security.c
index b98a722da9151bd41351de9448b21bfbc417cd6b..206488603b664d3e9922adb2fe4c067e3ccdea97 100644 (file)
--- a/arch/powerpc/kernel/security.c
+++ b/arch/powerpc/kernel/security.c
@@ -10,10 +10,89 @@
 
 #include <asm/debugfs.h>
 #include <asm/security_features.h>
+#include <asm/setup.h>
 
 
 unsigned long powerpc_security_features __read_mostly = SEC_FTR_DEFAULT;
 
+bool barrier_nospec_enabled;
+static bool no_nospec;
+
+static void enable_barrier_nospec(bool enable)
+{
+       barrier_nospec_enabled = enable;
+       do_barrier_nospec_fixups(enable);
+}
+
+void setup_barrier_nospec(void)
+{
+       bool enable;
+
+       /*
+        * It would make sense to check SEC_FTR_SPEC_BAR_ORI31 below as well.
+        * But there's a good reason not to. The two flags we check below are
+        * both are enabled by default in the kernel, so if the hcall is not
+        * functional they will be enabled.
+        * On a system where the host firmware has been updated (so the ori
+        * functions as a barrier), but on which the hypervisor (KVM/Qemu) has
+        * not been updated, we would like to enable the barrier. Dropping the
+        * check for SEC_FTR_SPEC_BAR_ORI31 achieves that. The only downside is
+        * we potentially enable the barrier on systems where the host firmware
+        * is not updated, but that's harmless as it's a no-op.
+        */
+       enable = security_ftr_enabled(SEC_FTR_FAVOUR_SECURITY) &&
+                security_ftr_enabled(SEC_FTR_BNDS_CHK_SPEC_BAR);
+
+       if (!no_nospec)
+               enable_barrier_nospec(enable);
+}
+
+static int __init handle_nospectre_v1(char *p)
+{
+       no_nospec = true;
+
+       return 0;
+}
+early_param("nospectre_v1", handle_nospectre_v1);
+
+#ifdef CONFIG_DEBUG_FS
+static int barrier_nospec_set(void *data, u64 val)
+{
+       switch (val) {
+       case 0:
+       case 1:
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       if (!!val == !!barrier_nospec_enabled)
+               return 0;
+
+       enable_barrier_nospec(!!val);
+
+       return 0;
+}
+
+static int barrier_nospec_get(void *data, u64 *val)
+{
+       *val = barrier_nospec_enabled ? 1 : 0;
+       return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(fops_barrier_nospec,
+                       barrier_nospec_get, barrier_nospec_set, "%llu\n");
+
+static __init int barrier_nospec_debugfs_init(void)
+{
+       debugfs_create_file("barrier_nospec", 0600, powerpc_debugfs_root, NULL,
+                           &fops_barrier_nospec);
+       return 0;
+}
+device_initcall(barrier_nospec_debugfs_init);
+#endif /* CONFIG_DEBUG_FS */
+
+#ifdef CONFIG_PPC_BOOK3S_64
 ssize_t cpu_show_meltdown(struct device *dev, struct device_attribute *attr, char *buf)
 {
        bool thread_priv;
@@ -46,25 +125,39 @@ ssize_t cpu_show_meltdown(struct device *dev, struct device_attribute *attr, cha
 
        return sprintf(buf, "Vulnerable\n");
 }
+#endif
 
 ssize_t cpu_show_spectre_v1(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       if (!security_ftr_enabled(SEC_FTR_BNDS_CHK_SPEC_BAR))
-               return sprintf(buf, "Not affected\n");
+       struct seq_buf s;
 
-       return sprintf(buf, "Vulnerable\n");
+       seq_buf_init(&s, buf, PAGE_SIZE - 1);
+
+       if (security_ftr_enabled(SEC_FTR_BNDS_CHK_SPEC_BAR)) {
+               if (barrier_nospec_enabled)
+                       seq_buf_printf(&s, "Mitigation: __user pointer sanitization");
+               else
+                       seq_buf_printf(&s, "Vulnerable");
+
+               if (security_ftr_enabled(SEC_FTR_SPEC_BAR_ORI31))
+                       seq_buf_printf(&s, ", ori31 speculation barrier enabled");
+
+               seq_buf_printf(&s, "\n");
+       } else
+               seq_buf_printf(&s, "Not affected\n");
+
+       return s.len;
 }
 
 ssize_t cpu_show_spectre_v2(struct device *dev, struct device_attribute *attr, char *buf)
 {
-       bool bcs, ccd, ori;
        struct seq_buf s;
+       bool bcs, ccd;
 
        seq_buf_init(&s, buf, PAGE_SIZE - 1);
 
        bcs = security_ftr_enabled(SEC_FTR_BCCTRL_SERIALISED);
        ccd = security_ftr_enabled(SEC_FTR_COUNT_CACHE_DISABLED);
-       ori = security_ftr_enabled(SEC_FTR_SPEC_BAR_ORI31);
 
        if (bcs || ccd) {
                seq_buf_printf(&s, "Mitigation: ");
@@ -80,14 +173,12 @@ ssize_t cpu_show_spectre_v2(struct device *dev, struct device_attribute *attr, c
        } else
                seq_buf_printf(&s, "Vulnerable");
 
-       if (ori)
-               seq_buf_printf(&s, ", ori31 speculation barrier enabled");
-
        seq_buf_printf(&s, "\n");
 
        return s.len;
 }
 
+#ifdef CONFIG_PPC_BOOK3S_64
 /*
  * Store-forwarding barrier support.
  */
@@ -235,3 +326,4 @@ static __init int stf_barrier_debugfs_init(void)
 }
 device_initcall(stf_barrier_debugfs_init);
 #endif /* CONFIG_DEBUG_FS */
+#endif /* CONFIG_PPC_BOOK3S_64 */