powerpc: Add self-tests of the feature fixup code

This commit adds tests of the feature fixup code, they are run during
boot if CONFIG_FTR_FIXUP_SELFTEST=y. Some of the tests manually invoke
the patching routines to check their behaviour, and others use the
macros and so are patched during the normal patching done during boot.

Because we have two sets of macros with different names, we use a macro
to generate the test of the macros, very niiiice.

Signed-off-by: Michael Ellerman <michael@ellerman.id.au>
Signed-off-by: Paul Mackerras <paulus@samba.org>

1 files changed, 206 insertions, 0 deletions

diff --git a/arch/powerpc/lib/feature-fixups.c b/arch/powerpc/lib/feature-fixups.c
index 174c1eba9ac8..48e1ed89052d 100644
--- a/arch/powerpc/lib/feature-fixups.c
+++ b/arch/powerpc/lib/feature-fixups.c
@@ -13,6 +13,8 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/init.h>
 #include <asm/cputable.h>
 #include <asm/code-patching.h>
 
@@ -107,3 +109,207 @@ void do_feature_fixups(unsigned long value, void *fixup_start, void *fixup_end)
                 }
         }
 }
+
+#ifdef CONFIG_FTR_FIXUP_SELFTEST
+
+#define check(x)        \
+        if (!(x)) printk("feature-fixups: test failed at line %d\n", __LINE__);
+
+/* This must be after the text it fixes up, vmlinux.lds.S enforces that atm */
+static struct fixup_entry fixup;
+
+static long calc_offset(struct fixup_entry *entry, unsigned int *p)
+{
+        return (unsigned long)p - (unsigned long)entry;
+}
+
+void test_basic_patching(void)
+{
+        extern unsigned int ftr_fixup_test1;
+        extern unsigned int end_ftr_fixup_test1;
+        extern unsigned int ftr_fixup_test1_orig;
+        extern unsigned int ftr_fixup_test1_expected;
+        int size = &end_ftr_fixup_test1 - &ftr_fixup_test1;
+
+        fixup.value = fixup.mask = 8;
+        fixup.start_off = calc_offset(&fixup, &ftr_fixup_test1 + 1);
+        fixup.end_off = calc_offset(&fixup, &ftr_fixup_test1 + 2);
+        fixup.alt_start_off = fixup.alt_end_off = 0;
+
+        /* Sanity check */
+        check(memcmp(&ftr_fixup_test1, &ftr_fixup_test1_orig, size) == 0);
+
+        /* Check we don't patch if the value matches */
+        patch_feature_section(8, &fixup);
+        check(memcmp(&ftr_fixup_test1, &ftr_fixup_test1_orig, size) == 0);
+
+        /* Check we do patch if the value doesn't match */
+        patch_feature_section(0, &fixup);
+        check(memcmp(&ftr_fixup_test1, &ftr_fixup_test1_expected, size) == 0);
+
+        /* Check we do patch if the mask doesn't match */
+        memcpy(&ftr_fixup_test1, &ftr_fixup_test1_orig, size);
+        check(memcmp(&ftr_fixup_test1, &ftr_fixup_test1_orig, size) == 0);
+        patch_feature_section(~8, &fixup);
+        check(memcmp(&ftr_fixup_test1, &ftr_fixup_test1_expected, size) == 0);
+}
+
+static void test_alternative_patching(void)
+{
+        extern unsigned int ftr_fixup_test2;
+        extern unsigned int end_ftr_fixup_test2;
+        extern unsigned int ftr_fixup_test2_orig;
+        extern unsigned int ftr_fixup_test2_alt;
+        extern unsigned int ftr_fixup_test2_expected;
+        int size = &end_ftr_fixup_test2 - &ftr_fixup_test2;
+
+        fixup.value = fixup.mask = 0xF;
+        fixup.start_off = calc_offset(&fixup, &ftr_fixup_test2 + 1);
+        fixup.end_off = calc_offset(&fixup, &ftr_fixup_test2 + 2);
+        fixup.alt_start_off = calc_offset(&fixup, &ftr_fixup_test2_alt);
+        fixup.alt_end_off = calc_offset(&fixup, &ftr_fixup_test2_alt + 1);
+
+        /* Sanity check */
+        check(memcmp(&ftr_fixup_test2, &ftr_fixup_test2_orig, size) == 0);
+
+        /* Check we don't patch if the value matches */
+        patch_feature_section(0xF, &fixup);
+        check(memcmp(&ftr_fixup_test2, &ftr_fixup_test2_orig, size) == 0);
+
+        /* Check we do patch if the value doesn't match */
+        patch_feature_section(0, &fixup);
+        check(memcmp(&ftr_fixup_test2, &ftr_fixup_test2_expected, size) == 0);
+
+        /* Check we do patch if the mask doesn't match */
+        memcpy(&ftr_fixup_test2, &ftr_fixup_test2_orig, size);
+        check(memcmp(&ftr_fixup_test2, &ftr_fixup_test2_orig, size) == 0);
+        patch_feature_section(~0xF, &fixup);
+        check(memcmp(&ftr_fixup_test2, &ftr_fixup_test2_expected, size) == 0);
+}
+
+static void test_alternative_case_too_big(void)
+{
+        extern unsigned int ftr_fixup_test3;
+        extern unsigned int end_ftr_fixup_test3;
+        extern unsigned int ftr_fixup_test3_orig;
+        extern unsigned int ftr_fixup_test3_alt;
+        int size = &end_ftr_fixup_test3 - &ftr_fixup_test3;
+
+        fixup.value = fixup.mask = 0xC;
+        fixup.start_off = calc_offset(&fixup, &ftr_fixup_test3 + 1);
+        fixup.end_off = calc_offset(&fixup, &ftr_fixup_test3 + 2);
+        fixup.alt_start_off = calc_offset(&fixup, &ftr_fixup_test3_alt);
+        fixup.alt_end_off = calc_offset(&fixup, &ftr_fixup_test3_alt + 2);
+
+        /* Sanity check */
+        check(memcmp(&ftr_fixup_test3, &ftr_fixup_test3_orig, size) == 0);
+
+        /* Expect nothing to be patched, and the error returned to us */
+        check(patch_feature_section(0xF, &fixup) == 1);
+        check(memcmp(&ftr_fixup_test3, &ftr_fixup_test3_orig, size) == 0);
+        check(patch_feature_section(0, &fixup) == 1);
+        check(memcmp(&ftr_fixup_test3, &ftr_fixup_test3_orig, size) == 0);
+        check(patch_feature_section(~0xF, &fixup) == 1);
+        check(memcmp(&ftr_fixup_test3, &ftr_fixup_test3_orig, size) == 0);
+}
+
+static void test_alternative_case_too_small(void)
+{
+        extern unsigned int ftr_fixup_test4;
+        extern unsigned int end_ftr_fixup_test4;
+        extern unsigned int ftr_fixup_test4_orig;
+        extern unsigned int ftr_fixup_test4_alt;
+        extern unsigned int ftr_fixup_test4_expected;
+        int size = &end_ftr_fixup_test4 - &ftr_fixup_test4;
+        unsigned long flag;
+
+        /* Check a high-bit flag */
+        flag = 1UL << ((sizeof(unsigned long) - 1) * 8);
+        fixup.value = fixup.mask = flag;
+        fixup.start_off = calc_offset(&fixup, &ftr_fixup_test4 + 1);
+        fixup.end_off = calc_offset(&fixup, &ftr_fixup_test4 + 5);
+        fixup.alt_start_off = calc_offset(&fixup, &ftr_fixup_test4_alt);
+        fixup.alt_end_off = calc_offset(&fixup, &ftr_fixup_test4_alt + 2);
+
+        /* Sanity check */
+        check(memcmp(&ftr_fixup_test4, &ftr_fixup_test4_orig, size) == 0);
+
+        /* Check we don't patch if the value matches */
+        patch_feature_section(flag, &fixup);
+        check(memcmp(&ftr_fixup_test4, &ftr_fixup_test4_orig, size) == 0);
+
+        /* Check we do patch if the value doesn't match */
+        patch_feature_section(0, &fixup);
+        check(memcmp(&ftr_fixup_test4, &ftr_fixup_test4_expected, size) == 0);
+
+        /* Check we do patch if the mask doesn't match */
+        memcpy(&ftr_fixup_test4, &ftr_fixup_test4_orig, size);
+        check(memcmp(&ftr_fixup_test4, &ftr_fixup_test4_orig, size) == 0);
+        patch_feature_section(~flag, &fixup);
+        check(memcmp(&ftr_fixup_test4, &ftr_fixup_test4_expected, size) == 0);
+}
+
+static void test_alternative_case_with_branch(void)
+{
+        extern unsigned int ftr_fixup_test5;
+        extern unsigned int end_ftr_fixup_test5;
+        extern unsigned int ftr_fixup_test5_expected;
+        int size = &end_ftr_fixup_test5 - &ftr_fixup_test5;
+
+        check(memcmp(&ftr_fixup_test5, &ftr_fixup_test5_expected, size) == 0);
+}
+
+static void test_alternative_case_with_external_branch(void)
+{
+        extern unsigned int ftr_fixup_test6;
+        extern unsigned int end_ftr_fixup_test6;
+        extern unsigned int ftr_fixup_test6_expected;
+        int size = &end_ftr_fixup_test6 - &ftr_fixup_test6;
+
+        check(memcmp(&ftr_fixup_test6, &ftr_fixup_test6_expected, size) == 0);
+}
+
+static void test_cpu_macros(void)
+{
+        extern void ftr_fixup_test_FTR_macros;
+        extern void ftr_fixup_test_FTR_macros_expected;
+        unsigned long size = &ftr_fixup_test_FTR_macros_expected -
+                             &ftr_fixup_test_FTR_macros;
+
+        /* The fixups have already been done for us during boot */
+        check(memcmp(&ftr_fixup_test_FTR_macros,
+                     &ftr_fixup_test_FTR_macros_expected, size) == 0);
+}
+
+static void test_fw_macros(void)
+{
+#ifdef CONFIG_PPC64
+        extern void ftr_fixup_test_FW_FTR_macros;
+        extern void ftr_fixup_test_FW_FTR_macros_expected;
+        unsigned long size = &ftr_fixup_test_FW_FTR_macros_expected -
+                             &ftr_fixup_test_FW_FTR_macros;
+
+        /* The fixups have already been done for us during boot */
+        check(memcmp(&ftr_fixup_test_FW_FTR_macros,
+                     &ftr_fixup_test_FW_FTR_macros_expected, size) == 0);
+#endif
+}
+
+static int __init test_feature_fixups(void)
+{
+        printk(KERN_DEBUG "Running feature fixup self-tests ...\n");
+
+        test_basic_patching();
+        test_alternative_patching();
+        test_alternative_case_too_big();
+        test_alternative_case_too_small();
+        test_alternative_case_with_branch();
+        test_alternative_case_with_external_branch();
+        test_cpu_macros();
+        test_fw_macros();
+
+        return 0;
+}
+late_initcall(test_feature_fixups);
+
+#endif /* CONFIG_FTR_FIXUP_SELFTEST */