kselftest/arm64: Add simple hwcap validation

Add some trivial hwcap validation which checks that /proc/cpuinfo and
AT_HWCAP agree with each other and can verify that for extensions that can
generate a SIGILL due to adding new instructions one appears or doesn't
appear as expected. I've added SVE and SME, other capabilities can be
added later if this gets merged.

This isn't super exciting but on the other hand took very little time to
write and should be handy when verifying that you wired up AT_HWCAP
properly.

Signed-off-by: Mark Brown <broonie@kernel.org>
Link: https://lore.kernel.org/r/20220829154602.827275-1-broonie@kernel.org
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>

diff --git a/tools/testing/selftests/arm64/abi/.gitignore b/tools/testing/selftests/arm64/abi/.gitignore
index b9e54417250d811cba6b0183b4ab683856f5290b..c31d34d48a30d996bfa8b8f5133656c5f2983125 100644 (file)
--- a/tools/testing/selftests/arm64/abi/.gitignore
+++ b/tools/testing/selftests/arm64/abi/.gitignore
@@ -1,2 +1,3 @@
+hwcap
 syscall-abi
 tpidr2

diff --git a/tools/testing/selftests/arm64/abi/Makefile b/tools/testing/selftests/arm64/abi/Makefile
index c8d7f2495eb21c3fbcc348701a3e2ec4f14b19f7..e60752eb833421d07709970d0b897d516e361c6f 100644 (file)
--- a/tools/testing/selftests/arm64/abi/Makefile
+++ b/tools/testing/selftests/arm64/abi/Makefile
@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: GPL-2.0
 # Copyright (C) 2021 ARM Limited
 
-TEST_GEN_PROGS := syscall-abi tpidr2
+TEST_GEN_PROGS := hwcap syscall-abi tpidr2
 
 include ../../lib.mk
 

diff --git a/tools/testing/selftests/arm64/abi/hwcap.c b/tools/testing/selftests/arm64/abi/hwcap.c
new file mode 100644 (file)
index 0000000..8b5c646
--- /dev/null
+++ b/tools/testing/selftests/arm64/abi/hwcap.c
@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2022 ARM Limited.
+ */
+
+#include <errno.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/auxv.h>
+#include <sys/prctl.h>
+#include <asm/hwcap.h>
+#include <asm/sigcontext.h>
+#include <asm/unistd.h>
+
+#include "../../kselftest.h"
+
+#define TESTS_PER_HWCAP 2
+
+/*
+ * Function expected to generate SIGILL when the feature is not
+ * supported and return when it is supported. If SIGILL is generated
+ * then the handler must be able to skip over the instruction safely.
+ *
+ * Note that it is expected that for many architecture extensions
+ * there are no specific traps due to no architecture state being
+ * added so we may not fault if running on a kernel which doesn't know
+ * to add the hwcap.
+ */
+typedef void (*sigill_fn)(void);
+
+static void sme_sigill(void)
+{
+       /* RDSVL x0, #0 */
+       asm volatile(".inst 0x04bf5800" : : : "x0");
+}
+
+static void sve_sigill(void)
+{
+       /* RDVL x0, #0 */
+       asm volatile(".inst 0x04bf5000" : : : "x0");
+}
+
+static const struct hwcap_data {
+       const char *name;
+       unsigned long at_hwcap;
+       unsigned long hwcap_bit;
+       const char *cpuinfo;
+       sigill_fn sigill_fn;
+       bool sigill_reliable;
+} hwcaps[] = {
+       {
+               .name = "SME",
+               .at_hwcap = AT_HWCAP2,
+               .hwcap_bit = HWCAP2_SME,
+               .cpuinfo = "sme",
+               .sigill_fn = sme_sigill,
+               .sigill_reliable = true,
+       },
+       {
+               .name = "SVE",
+               .at_hwcap = AT_HWCAP,
+               .hwcap_bit = HWCAP_SVE,
+               .cpuinfo = "sve",
+               .sigill_fn = sve_sigill,
+               .sigill_reliable = true,
+       },
+};
+
+static bool seen_sigill;
+
+static void handle_sigill(int sig, siginfo_t *info, void *context)
+{
+       ucontext_t *uc = context;
+
+       seen_sigill = true;
+
+       /* Skip over the offending instruction */
+       uc->uc_mcontext.pc += 4;
+}
+
+bool cpuinfo_present(const char *name)
+{
+       FILE *f;
+       char buf[2048], name_space[30], name_newline[30];
+       char *s;
+
+       /*
+        * The feature should appear with a leading space and either a
+        * trailing space or a newline.
+        */
+       snprintf(name_space, sizeof(name_space), " %s ", name);
+       snprintf(name_newline, sizeof(name_newline), " %s\n", name);
+
+       f = fopen("/proc/cpuinfo", "r");
+       if (!f) {
+               ksft_print_msg("Failed to open /proc/cpuinfo\n");
+               return false;
+       }
+
+       while (fgets(buf, sizeof(buf), f)) {
+               /* Features: line? */
+               if (strncmp(buf, "Features\t:", strlen("Features\t:")) != 0)
+                       continue;
+
+               /* All CPUs should be symmetric, don't read any more */
+               fclose(f);
+
+               s = strstr(buf, name_space);
+               if (s)
+                       return true;
+               s = strstr(buf, name_newline);
+               if (s)
+                       return true;
+
+               return false;
+       }
+
+       ksft_print_msg("Failed to find Features in /proc/cpuinfo\n");
+       fclose(f);
+       return false;
+}
+
+int main(void)
+{
+       const struct hwcap_data *hwcap;
+       int i, ret;
+       bool have_cpuinfo, have_hwcap;
+       struct sigaction sa;
+
+       ksft_print_header();
+       ksft_set_plan(ARRAY_SIZE(hwcaps) * TESTS_PER_HWCAP);
+
+       memset(&sa, 0, sizeof(sa));
+       sa.sa_sigaction = handle_sigill;
+       sa.sa_flags = SA_RESTART | SA_SIGINFO;
+       sigemptyset(&sa.sa_mask);
+       ret = sigaction(SIGILL, &sa, NULL);
+       if (ret < 0)
+               ksft_exit_fail_msg("Failed to install SIGILL handler: %s (%d)\n",
+                                  strerror(errno), errno);
+
+       for (i = 0; i < ARRAY_SIZE(hwcaps); i++) {
+               hwcap = &hwcaps[i];
+
+               have_hwcap = getauxval(hwcaps->at_hwcap) & hwcap->hwcap_bit;
+               have_cpuinfo = cpuinfo_present(hwcap->cpuinfo);
+
+               if (have_hwcap)
+                       ksft_print_msg("%s present", hwcap->name);
+
+               ksft_test_result(have_hwcap == have_cpuinfo,
+                                "cpuinfo_match_%s\n", hwcap->name);
+
+               if (hwcap->sigill_fn) {
+                       seen_sigill = false;
+                       hwcap->sigill_fn();
+
+                       if (have_hwcap) {
+                               /* Should be able to use the extension */
+                               ksft_test_result(!seen_sigill, "sigill_%s\n",
+                                                hwcap->name);
+                       } else if (hwcap->sigill_reliable) {
+                               /* Guaranteed a SIGILL */
+                               ksft_test_result(seen_sigill, "sigill_%s\n",
+                                                hwcap->name);
+                       } else {
+                               /* Missing SIGILL might be fine */
+                               ksft_print_msg("SIGILL %sreported for %s\n",
+                                              seen_sigill ? "" : "not ",
+                                              hwcap->name);
+                               ksft_test_result_skip("sigill_%s\n",
+                                                     hwcap->name);
+                       }
+               } else {
+                       ksft_test_result_skip("sigill_%s\n",
+                                             hwcap->name);
+               }
+       }
+
+       ksft_print_cnts();
+
+       return 0;
+}