selftests/mm: use sys_pkey helpers consistently

sys_pkey_alloc, sys_pkey_free and sys_mprotect_pkey are currently used in
protections_keys.c, while pkey_sighandler_tests.c calls the libc wrappers
directly (e.g.  pkey_mprotect()).  This is probably ok when using glibc
(those symbols appeared a while ago), but Musl does not currently provide
them.  The logging in the helpers from pkey-helpers.h can also come in
handy.

Make things more consistent by using the sys_pkey helpers in
pkey_sighandler_tests.c too.  To that end their implementation is moved to
a common .c file (pkey_util.c).  This also enables calling
is_pkeys_supported() outside of protections_keys.c, since it relies on
sys_pkey_{alloc,free}.

[kevin.brodsky@arm.com: fix dependency on pkey_util.c]
Link: https://lkml.kernel.org/r/20241216092849.2140850-1-kevin.brodsky@arm.com
Link: https://lkml.kernel.org/r/20241209095019.1732120-12-kevin.brodsky@arm.com
Signed-off-by: Kevin Brodsky <kevin.brodsky@arm.com>
Cc: Aruna Ramakrishna <aruna.ramakrishna@oracle.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Joey Gouly <joey.gouly@arm.com>
Cc: Keith Lucas <keith.lucas@oracle.com>
Cc: Ryan Roberts <ryan.roberts@arm.com>
Cc: Shuah Khan <shuah@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/tools/testing/selftests/mm/Makefile b/tools/testing/selftests/mm/Makefile
index 0d5d8f2f865246622ff7caf2c2ba327b0c373ed2..f430c4303c0d64670755f03859eec66157a1fa2b 100644 (file)
--- a/tools/testing/selftests/mm/Makefile
+++ b/tools/testing/selftests/mm/Makefile
@@ -158,11 +158,15 @@ $(TEST_GEN_FILES): vm_util.c thp_settings.c
 
 $(OUTPUT)/uffd-stress: uffd-common.c
 $(OUTPUT)/uffd-unit-tests: uffd-common.c
+$(OUTPUT)/protection_keys: pkey_util.c
+$(OUTPUT)/pkey_sighandler_tests: pkey_util.c
 
 ifeq ($(ARCH),x86_64)
 BINARIES_32 := $(patsubst %,$(OUTPUT)/%,$(BINARIES_32))
 BINARIES_64 := $(patsubst %,$(OUTPUT)/%,$(BINARIES_64))
 
+$(BINARIES_32) $(BINARIES_64): pkey_util.c
+
 define gen-target-rule-32
 $(1) $(1)_32: $(OUTPUT)/$(1)_32
 .PHONY: $(1) $(1)_32

diff --git a/tools/testing/selftests/mm/pkey-helpers.h b/tools/testing/selftests/mm/pkey-helpers.h
index 6f0ab7b42738a93fc01517eacc5ce006f484fabe..f080e97b39bea9ef214f4ff238d38c3e4437efe7 100644 (file)
--- a/tools/testing/selftests/mm/pkey-helpers.h
+++ b/tools/testing/selftests/mm/pkey-helpers.h
@@ -89,6 +89,8 @@ extern void abort_hooks(void);
 
 int sys_pkey_alloc(unsigned long flags, unsigned long init_val);
 int sys_pkey_free(unsigned long pkey);
+int sys_mprotect_pkey(void *ptr, size_t size, unsigned long orig_prot,
+               unsigned long pkey);
 
 /* For functions called from protection_keys.c only */
 noinline int read_ptr(int *ptr);

diff --git a/tools/testing/selftests/mm/pkey_sighandler_tests.c b/tools/testing/selftests/mm/pkey_sighandler_tests.c
index 425da955686737d2e226bd0b373ac5deb9f2b0bd..63443b75f49e031e3b39fc3c5cc96303b5de1fc2 100644 (file)
--- a/tools/testing/selftests/mm/pkey_sighandler_tests.c
+++ b/tools/testing/selftests/mm/pkey_sighandler_tests.c
@@ -311,8 +311,8 @@ static void test_sigsegv_handler_with_different_pkey_for_stack(void)
        __write_pkey_reg(pkey_reg);
 
        /* Protect the new stack with MPK 1 */
-       pkey = pkey_alloc(0, 0);
-       pkey_mprotect(stack, STACK_SIZE, PROT_READ | PROT_WRITE, pkey);
+       pkey = sys_pkey_alloc(0, 0);
+       sys_mprotect_pkey(stack, STACK_SIZE, PROT_READ | PROT_WRITE, pkey);
 
        /* Set up alternate signal stack that will use the default MPK */
        sigstack.ss_sp = mmap(0, STACK_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
@@ -484,8 +484,8 @@ static void test_pkru_sigreturn(void)
        __write_pkey_reg(pkey_reg);
 
        /* Protect the stack with MPK 2 */
-       pkey = pkey_alloc(0, 0);
-       pkey_mprotect(stack, STACK_SIZE, PROT_READ | PROT_WRITE, pkey);
+       pkey = sys_pkey_alloc(0, 0);
+       sys_mprotect_pkey(stack, STACK_SIZE, PROT_READ | PROT_WRITE, pkey);
 
        /* Set up alternate signal stack that will use the default MPK */
        sigstack.ss_sp = mmap(0, STACK_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,

diff --git a/tools/testing/selftests/mm/pkey_util.c b/tools/testing/selftests/mm/pkey_util.c
new file mode 100644 (file)
index 0000000..ca4ad0d
--- /dev/null
+++ b/tools/testing/selftests/mm/pkey_util.c
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-2.0-only
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#include "pkey-helpers.h"
+
+int sys_pkey_alloc(unsigned long flags, unsigned long init_val)
+{
+       int ret = syscall(SYS_pkey_alloc, flags, init_val);
+       dprintf1("%s(flags=%lx, init_val=%lx) syscall ret: %d errno: %d\n",
+                       __func__, flags, init_val, ret, errno);
+       return ret;
+}
+
+int sys_pkey_free(unsigned long pkey)
+{
+       int ret = syscall(SYS_pkey_free, pkey);
+       dprintf1("%s(pkey=%ld) syscall ret: %d\n", __func__, pkey, ret);
+       return ret;
+}
+
+int sys_mprotect_pkey(void *ptr, size_t size, unsigned long orig_prot,
+               unsigned long pkey)
+{
+       int sret;
+
+       dprintf2("%s(0x%p, %zx, prot=%lx, pkey=%lx)\n", __func__,
+                       ptr, size, orig_prot, pkey);
+
+       errno = 0;
+       sret = syscall(__NR_pkey_mprotect, ptr, size, orig_prot, pkey);
+       if (errno) {
+               dprintf2("SYS_mprotect_key sret: %d\n", sret);
+               dprintf2("SYS_mprotect_key prot: 0x%lx\n", orig_prot);
+               dprintf2("SYS_mprotect_key failed, errno: %d\n", errno);
+               if (DEBUG_LEVEL >= 2)
+                       perror("SYS_mprotect_pkey");
+       }
+       return sret;
+}

diff --git a/tools/testing/selftests/mm/protection_keys.c b/tools/testing/selftests/mm/protection_keys.c
index f43cf3b75d8e6c80f80cb33c1119ec9abf657b6b..3688571e6b39ec23c8adc741f4d5defe94dbad2b 100644 (file)
--- a/tools/testing/selftests/mm/protection_keys.c
+++ b/tools/testing/selftests/mm/protection_keys.c
@@ -460,34 +460,6 @@ static pid_t fork_lazy_child(void)
        return forkret;
 }
 
-int sys_mprotect_pkey(void *ptr, size_t size, unsigned long orig_prot,
-               unsigned long pkey)
-{
-       int sret;
-
-       dprintf2("%s(0x%p, %zx, prot=%lx, pkey=%lx)\n", __func__,
-                       ptr, size, orig_prot, pkey);
-
-       errno = 0;
-       sret = syscall(__NR_pkey_mprotect, ptr, size, orig_prot, pkey);
-       if (errno) {
-               dprintf2("SYS_mprotect_key sret: %d\n", sret);
-               dprintf2("SYS_mprotect_key prot: 0x%lx\n", orig_prot);
-               dprintf2("SYS_mprotect_key failed, errno: %d\n", errno);
-               if (DEBUG_LEVEL >= 2)
-                       perror("SYS_mprotect_pkey");
-       }
-       return sret;
-}
-
-int sys_pkey_alloc(unsigned long flags, unsigned long init_val)
-{
-       int ret = syscall(SYS_pkey_alloc, flags, init_val);
-       dprintf1("%s(flags=%lx, init_val=%lx) syscall ret: %d errno: %d\n",
-                       __func__, flags, init_val, ret, errno);
-       return ret;
-}
-
 static int alloc_pkey(void)
 {
        int ret;
@@ -534,13 +506,6 @@ static int alloc_pkey(void)
        return ret;
 }
 
-int sys_pkey_free(unsigned long pkey)
-{
-       int ret = syscall(SYS_pkey_free, pkey);
-       dprintf1("%s(pkey=%ld) syscall ret: %d\n", __func__, pkey, ret);
-       return ret;
-}
-
 /*
  * I had a bug where pkey bits could be set by mprotect() but
  * not cleared.  This ensures we get lots of random bit sets