[Devel] [PATCH hci-8.1 1/7] selftests/mm: cover the MADV_DOEXEC interface and VMA attributes
Konstantin Khorenko
khorenko at virtuozzo.com
Wed Oct 14 20:14:59 MSK 2026
Add cases for what madvise accepts and what the copy of a preserved VMA
keeps:
- /proc/sys/vm/madv_doexec_flag reports MADV_DOEXEC, and a kernel
without the sysctl does not accept MADV_DOEXEC either.
- Shared anonymous, private file, executable, MAP_GROWSDOWN and stack
mappings are refused with EINVAL, and so is a hugetlb mapping when
huge pages are available.
- A range unmarked with MADV_DONTEXEC (twice, the second a no-op) is
not preserved.
- Marking the middle page of a mapping preserves that page only.
- An mlocked range is preserved without VM_LOCKED.
- MADV_DONTFORK and MADV_WIPEONFORK carry over, so a fork in the new
image leaves the range out or wipes it.
- A userfaultfd registration does not carry over.
- The memory policy of the range carries over.
A flag expected to disappear is checked in smaps before the exec as
well, so that a failed lookup cannot pass for its absence. EINVAL from
MADV_DOEXEC fails a case on a 64-bit kernel with the madv_doexec_flag
sysctl, in the existing cases too; the cases skip only when something
they need is missing: the feature, free huge pages, the mlock limit,
userfaultfd, mbind. A failing case prints what failed, and the
children running the cases, old and new, exit with exit(), so that the
message reaches a pipe.
New cases go to a table, and the checks run in the new image to a
second one, so that main() stays small.
https://virtuozzo.atlassian.net/browse/VSTOR-150234
Feature: oracle/mm: MADV_DOEXEC madvise() flag
Assisted-by: LLM
Signed-off-by: Konstantin Khorenko <khorenko at virtuozzo.com>
---
tools/testing/selftests/mm/doexec.c | 424 +++++++++++++++++++++++++++++++++---
1 file changed, 392 insertions(+), 32 deletions(-)
diff --git a/tools/testing/selftests/mm/doexec.c b/tools/testing/selftests/mm/doexec.c
index a89fe2f067df5..850b498e3d1dc 100644
--- a/tools/testing/selftests/mm/doexec.c
+++ b/tools/testing/selftests/mm/doexec.c
@@ -1,10 +1,12 @@
// SPDX-License-Identifier: GPL-2.0-only
-/* Verify that exec preserves the memory backing long-term DMA pins. */
+/* Verify what MADV_DOEXEC preserves across exec, long-term DMA pins first. */
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <grp.h>
#include <limits.h>
+#include <linux/mempolicy.h>
+#include <linux/userfaultfd.h>
#include <linux/vfio.h>
#include <linux/vhost.h>
#include <poll.h>
@@ -25,12 +27,16 @@
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/sysmacros.h>
+#include <sys/utsname.h>
#include <sys/wait.h>
#include <unistd.h>
#include "../../../../mm/gup_test.h"
#include "../kselftest.h"
+#ifndef UFFD_USER_MODE_ONLY
+#define UFFD_USER_MODE_ONLY 1
+#endif
#ifndef MADV_DOEXEC
#define MADV_DOEXEC 201
#endif
@@ -40,6 +46,9 @@
#ifndef MADV_COLLAPSE
#define MADV_COLLAPSE 25
#endif
+#ifndef MADV_WIPEONFORK
+#define MADV_WIPEONFORK 18
+#endif
/* The downstream ELF loader requires this opt-in in a PT_NOTE segment. */
asm(".pushsection .note.doexec,\"a\",%note\n"
@@ -117,6 +126,38 @@ static int check_bytes(char *ram, size_t size, unsigned char value)
return KSFT_PASS;
}
+/*
+ * EINVAL from MADV_DOEXEC means no feature only on a kernel without the
+ * sysctl, or on a 32-bit one, which has no VM_EXEC_KEEP.
+ */
+static int unsupported(void)
+{
+ int err = errno;
+ struct utsname uts;
+
+ if (err == EINVAL &&
+ (access("/proc/sys/vm/madv_doexec_flag", F_OK) ||
+ (!uname(&uts) && !strstr(uts.machine, "64") &&
+ strcmp(uts.machine, "s390x") && strcmp(uts.machine, "alpha"))))
+ return KSFT_SKIP;
+ ksft_print_msg("MADV_DOEXEC: %s\n", strerror(err));
+ fflush(stdout);
+ errno = err;
+ return KSFT_FAIL;
+}
+
+static int fail(const char *what)
+{
+ ksft_print_msg("%s\n", what);
+ fflush(stdout);
+ return KSFT_FAIL;
+}
+
+static int check_contents(char *ram, size_t size, unsigned char value)
+{
+ return check_bytes(ram, size, value) ? fail("contents lost") : KSFT_PASS;
+}
+
static int after_cow_exec(char *ram, size_t size, pid_t sibling, int pipe_fd)
{
char ready = 1;
@@ -146,7 +187,7 @@ static int before_cow_exec(void)
return KSFT_FAIL;
memset(ram, 0x31, size);
if (madvise(ram, size, MADV_DOEXEC))
- return errno == EINVAL ? KSFT_SKIP : KSFT_FAIL;
+ return unsupported();
if (pipe(pipe_fd))
return KSFT_FAIL;
pid = fork();
@@ -272,10 +313,8 @@ static int before_exec(int kind)
return KSFT_SKIP;
if (kind == LOCKED && mlock(ram, size))
return KSFT_SKIP;
- if (madvise(ram, size, MADV_DOEXEC)) {
- ksft_print_msg("MADV_DOEXEC: %s\n", strerror(errno));
- return errno == EINVAL ? KSFT_SKIP : KSFT_FAIL;
- }
+ if (madvise(ram, size, MADV_DOEXEC))
+ return unsupported();
pin = (struct pin_longterm_test) {
.addr = (uintptr_t)ram,
.size = size,
@@ -358,7 +397,7 @@ static int shared_mm_exec(bool own_thread)
pid_t pid;
if (!ram)
- return errno == EINVAL ? KSFT_SKIP : KSFT_FAIL;
+ return unsupported();
if (pipe(pipe_fd))
return KSFT_FAIL;
if (own_thread) {
@@ -403,7 +442,7 @@ static int vhost_owner_exec(void)
return KSFT_SKIP;
ram = preserved_ram(size);
if (!ram)
- return errno == EINVAL ? KSFT_SKIP : KSFT_FAIL;
+ return unsupported();
if (ioctl(fd, VHOST_SET_OWNER))
return KSFT_SKIP;
if (ioctl(fd, VHOST_RESET_OWNER))
@@ -473,7 +512,7 @@ static int unprivileged_exec(const char *path, bool preserve)
}
ram = preserved_ram(size);
if (!ram)
- _exit(errno == EINVAL ? KSFT_SKIP : KSFT_FAIL);
+ _exit(unsupported());
err = exec_path(path, ram, size, 1, true);
/* Exec must return EPERM with the old mapping intact. */
if (err != EPERM || check_bytes(ram, size, 0x31))
@@ -520,7 +559,7 @@ static int devzero_exec(void)
return KSFT_FAIL;
memset(ram, 0x31, size);
if (madvise(ram, size, MADV_DOEXEC))
- return errno == EINVAL ? KSFT_SKIP : KSFT_FAIL;
+ return unsupported();
check_exec(ram, size, 1, false);
return KSFT_FAIL;
}
@@ -558,7 +597,7 @@ static int noexec_dontexec(void)
goto out;
}
if (madvise(ram, size, MADV_DOEXEC)) {
- ret = errno == EINVAL ? KSFT_SKIP : KSFT_FAIL;
+ ret = unsupported();
goto out;
}
if (!madvise(ram, size, MADV_DONTEXEC) && exec_refused(ram, size))
@@ -577,7 +616,7 @@ static int doexec_noexec(void)
int ret;
if (!ram)
- return errno == EINVAL ? KSFT_SKIP : KSFT_FAIL;
+ return unsupported();
if (!exec_refused(ram, size) || madvise(ram, size, MADV_DONTEXEC) ||
mprotect(ram, size, PROT_READ | PROT_EXEC))
return KSFT_FAIL;
@@ -631,7 +670,7 @@ static int devmem_refused(void)
int fd;
if (!preserved_ram(size))
- return errno == EINVAL ? KSFT_SKIP : KSFT_FAIL;
+ return unsupported();
/* Without FMODE_WRITE, do_mmap() drops VM_SHARED from the mapping. */
fd = open("/dev/mem", O_RDWR);
if (fd < 0)
@@ -681,8 +720,10 @@ static int vfio_bar_exec(void)
uintptr_t aligned;
int dev;
- if (!bdf || !preserved_ram(page))
+ if (!bdf)
return KSFT_SKIP;
+ if (!preserved_ram(page))
+ return unsupported();
dev = vfio_device_fd(bdf);
if (dev < 0 || ioctl(dev, VFIO_DEVICE_GET_REGION_INFO, &info) ||
!(info.flags & VFIO_REGION_INFO_FLAG_MMAP) || info.size < page) {
@@ -725,7 +766,7 @@ static int nonleader_exec(void)
pthread_t thread;
if (!ram)
- return errno == EINVAL ? KSFT_SKIP : KSFT_FAIL;
+ return unsupported();
if (pthread_create(&thread, NULL, exec_thread, ram))
return KSFT_FAIL;
pthread_join(thread, NULL);
@@ -773,7 +814,7 @@ static int proc_readers_exec(void)
close(ready[0]);
close(go[1]);
if (!ram)
- _exit(errno == EINVAL ? KSFT_SKIP : KSFT_FAIL);
+ _exit(unsupported());
if (write(ready[1], "x", 1) != 1 || read(go[0], buffer, 1) != 1)
_exit(KSFT_FAIL);
close(ready[1]);
@@ -910,7 +951,7 @@ static int clone_exec_race(void)
close(report[0]);
race.ram = preserved_ram(size);
if (!race.ram)
- _exit(errno == EINVAL ? KSFT_SKIP : KSFT_FAIL);
+ _exit(unsupported());
if (pthread_create(&thread, NULL, clone_race_thread, &race))
_exit(KSFT_FAIL);
while (atomic_load(&race.rounds) < 4)
@@ -985,7 +1026,7 @@ static int allocation_failures(void)
for (i = 0; i < size; i += stride)
ram[i] = 0x31;
if (madvise(ram, size, MADV_DOEXEC))
- _exit(errno == EINVAL ? KSFT_SKIP : KSFT_FAIL);
+ _exit(unsupported());
/* Keep the path lookup, which /proc fails with ENOENT, out of the sweep. */
exe = open("/proc/self/exe", O_RDONLY | O_CLOEXEC);
fd = open("/proc/self/fail-nth", O_WRONLY | O_CLOEXEC);
@@ -1034,6 +1075,308 @@ static int allocation_failures(void)
return early && fatal ? KSFT_PASS : KSFT_SKIP;
}
+static void exec_mode(const char *exe, const char *mode, void *addr, size_t size)
+{
+ char addr_arg[32], size_arg[32];
+
+ snprintf(addr_arg, sizeof(addr_arg), "%llu",
+ (unsigned long long)(uintptr_t)addr);
+ snprintf(size_arg, sizeof(size_arg), "%zu", size);
+ execl(exe, "doexec", mode, addr_arg, size_arg, NULL);
+ ksft_print_msg("exec: %s\n", strerror(errno));
+ fflush(stdout);
+}
+
+static bool range_mapped(char *addr, size_t size)
+{
+ return !msync(addr, size, MS_ASYNC);
+}
+
+static int sysctl_flag(void)
+{
+ FILE *file = fopen("/proc/sys/vm/madv_doexec_flag", "r");
+ int flag = -1;
+
+ if (!file) {
+ if (access("/proc/sys/vm", F_OK) || !preserved_ram(sysconf(_SC_PAGESIZE)))
+ return KSFT_SKIP;
+ return fail("MADV_DOEXEC works without the sysctl");
+ }
+ if (fscanf(file, "%d", &flag) != 1)
+ flag = -1;
+ fclose(file);
+ return flag == MADV_DOEXEC ? KSFT_PASS : fail("unexpected madv_doexec_flag");
+}
+
+static bool doexec_refused(char *addr, size_t size, const char *what)
+{
+ if (addr == MAP_FAILED) {
+ ksft_print_msg("%s: mmap: %s\n", what, strerror(errno));
+ /* A security policy may forbid the mapping itself. */
+ return errno == EACCES || errno == EPERM;
+ }
+ if (madvise(addr, size, MADV_DOEXEC) && errno == EINVAL)
+ return true;
+ ksft_print_msg("%s not refused\n", what);
+ return false;
+}
+
+/* Apart from VFIO PFN maps, only private non-stack anonymous memory can be marked. */
+static int refused_mappings(void)
+{
+ size_t size = sysconf(_SC_PAGESIZE);
+ int fd = open("/proc/self/exe", O_RDONLY);
+ char stack_var = 0;
+ bool ok = true;
+
+ if (!preserved_ram(size))
+ return unsupported();
+ ok &= doexec_refused(mmap(NULL, size, PROT_READ | PROT_WRITE,
+ MAP_SHARED | MAP_ANONYMOUS, -1, 0), size, "shared anon");
+ ok &= doexec_refused(mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0), size,
+ "private file");
+ ok &= doexec_refused(mmap(NULL, size, PROT_READ | PROT_EXEC,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0), size, "executable");
+ ok &= doexec_refused(mmap(NULL, size, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS | MAP_GROWSDOWN, -1, 0), size,
+ "MAP_GROWSDOWN");
+ ok &= doexec_refused((char *)((uintptr_t)&stack_var & ~(size - 1)), size, "stack");
+ close(fd);
+ return ok ? KSFT_PASS : KSFT_FAIL;
+}
+
+static int hugetlb_refused(void)
+{
+ size_t size = 2ul << 20;
+ char *addr;
+
+ if (!preserved_ram(sysconf(_SC_PAGESIZE)))
+ return unsupported();
+ addr = mmap(NULL, size, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
+ if (addr == MAP_FAILED)
+ return KSFT_SKIP;
+ return doexec_refused(addr, size, "hugetlb") ? KSFT_PASS : KSFT_FAIL;
+}
+
+static int unmarked_exec(void)
+{
+ size_t size = sysconf(_SC_PAGESIZE);
+ char *ram = preserved_ram(size);
+
+ if (!ram)
+ return unsupported();
+ if (madvise(ram, size, MADV_DONTEXEC) || madvise(ram, size, MADV_DONTEXEC))
+ return fail("MADV_DONTEXEC failed");
+ exec_mode("/proc/self/exe", "--absent", ram, size);
+ return KSFT_FAIL;
+}
+
+static int after_absent(char *ram, size_t size)
+{
+ return range_mapped(ram, size) ? fail("range still mapped") : KSFT_PASS;
+}
+
+/* Marking the middle page splits the VMA; only that page carries over. */
+static int partial_exec(void)
+{
+ size_t page = sysconf(_SC_PAGESIZE);
+ char *ram = mmap(NULL, 3 * page, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+ if (ram == MAP_FAILED)
+ return KSFT_FAIL;
+ memset(ram, 0x31, 3 * page);
+ if (madvise(ram + page, page, MADV_DOEXEC))
+ return unsupported();
+ exec_mode("/proc/self/exe", "--partial", ram, 3 * page);
+ return KSFT_FAIL;
+}
+
+static int after_partial(char *ram, size_t size)
+{
+ size_t page = size / 3;
+
+ if (range_mapped(ram, page) || range_mapped(ram + 2 * page, page))
+ return fail("unmarked page preserved");
+ if (!range_mapped(ram + page, page))
+ return fail("marked page not preserved");
+ return check_contents(ram + page, page, 0x31);
+}
+
+/* The flag is checked before exec too, so that its absence after is meaningful. */
+static int exec_with_flag(char *ram, size_t size, const char *mode, const char *flag)
+{
+ if (!smaps_has_flag(ram, flag))
+ return fail("flag missing before exec");
+ exec_mode("/proc/self/exe", mode, ram, size);
+ return KSFT_FAIL;
+}
+
+static int flagged_exec(const char *mode, int advice, const char *flag)
+{
+ size_t size = sysconf(_SC_PAGESIZE);
+ char *ram = preserved_ram(size);
+
+ if (!ram)
+ return unsupported();
+ if (madvise(ram, size, advice))
+ return fail("madvise failed");
+ return exec_with_flag(ram, size, mode, flag);
+}
+
+static int locked_exec(void)
+{
+ size_t size = sysconf(_SC_PAGESIZE);
+ char *ram = preserved_ram(size);
+
+ if (!ram)
+ return unsupported();
+ if (mlock(ram, size))
+ return KSFT_SKIP;
+ return exec_with_flag(ram, size, "--unlocked", " lo ");
+}
+
+static int after_unlocked(char *ram, size_t size)
+{
+ if (smaps_has_flag(ram, " lo "))
+ return fail("VM_LOCKED preserved");
+ return check_contents(ram, size, 0x31);
+}
+
+static int dontfork_exec(void)
+{
+ return flagged_exec("--dontfork", MADV_DONTFORK, " dc ");
+}
+
+static int wipeonfork_exec(void)
+{
+ return flagged_exec("--wipeonfork", MADV_WIPEONFORK, " wf ");
+}
+
+/* The fork flags carry over: a child of the new image sees what they say. */
+static int after_fork_flag(char *ram, size_t size, const char *flag, bool wipe)
+{
+ pid_t pid;
+
+ if (!smaps_has_flag(ram, flag))
+ return fail("fork flag lost");
+ if (check_bytes(ram, size, 0x31))
+ return fail("contents lost");
+ pid = fork();
+ if (pid < 0)
+ return KSFT_FAIL;
+ if (!pid) {
+ if (wipe)
+ _exit(range_mapped(ram, size) ? check_bytes(ram, size, 0) : KSFT_FAIL);
+ _exit(range_mapped(ram, size) ? KSFT_FAIL : KSFT_PASS);
+ }
+ return wait_child(pid);
+}
+
+static int after_dontfork(char *ram, size_t size)
+{
+ return after_fork_flag(ram, size, " dc ", false);
+}
+
+static int after_wipeonfork(char *ram, size_t size)
+{
+ return after_fork_flag(ram, size, " wf ", true);
+}
+
+/* The userfaultfd context belongs to the old mm and must not carry over. */
+static int uffd_exec(void)
+{
+ size_t size = sysconf(_SC_PAGESIZE);
+ char *ram = preserved_ram(size);
+ struct uffdio_api api = { .api = UFFD_API };
+ struct uffdio_register reg = {
+ .mode = UFFDIO_REGISTER_MODE_MISSING,
+ };
+ int uffd;
+
+ if (!ram)
+ return unsupported();
+ uffd = syscall(__NR_userfaultfd, O_CLOEXEC | UFFD_USER_MODE_ONLY);
+ if (uffd < 0 || ioctl(uffd, UFFDIO_API, &api))
+ return KSFT_SKIP;
+ reg.range.start = (uintptr_t)ram;
+ reg.range.len = size;
+ if (ioctl(uffd, UFFDIO_REGISTER, ®))
+ return KSFT_SKIP;
+ if (!smaps_has_flag(ram, " um "))
+ return fail("userfaultfd registration not in smaps");
+ exec_mode("/proc/self/exe", "--no-uffd", ram, size);
+ return KSFT_FAIL;
+}
+
+static int after_no_uffd(char *ram, size_t size)
+{
+ if (smaps_has_flag(ram, " um "))
+ return fail("userfaultfd registration preserved");
+ return check_contents(ram, size, 0x31);
+}
+
+/* vma_dup_policy() carries the memory policy of the range over. */
+static int mempolicy_exec(void)
+{
+ size_t size = sysconf(_SC_PAGESIZE);
+ char *ram = preserved_ram(size);
+ unsigned long nodes = 1;
+
+ if (!ram)
+ return unsupported();
+ if (syscall(__NR_mbind, ram, size, MPOL_PREFERRED, &nodes, 2, 0))
+ return KSFT_SKIP;
+ exec_mode("/proc/self/exe", "--mempolicy", ram, size);
+ return KSFT_FAIL;
+}
+
+static int after_mempolicy(char *ram, size_t size)
+{
+ unsigned long nodes[16] = { 0 };
+ int mode = -1;
+
+ if (syscall(__NR_get_mempolicy, &mode, nodes, 8 * sizeof(nodes), ram, MPOL_F_ADDR))
+ return fail("get_mempolicy failed");
+ if (mode != MPOL_PREFERRED || nodes[0] != 1)
+ return fail("memory policy lost");
+ return check_contents(ram, size, 0x31);
+}
+
+struct after_mode {
+ const char *mode;
+ int (*fn)(char *ram, size_t size);
+};
+
+static const struct after_mode after_modes[] = {
+ { "--absent", after_absent },
+ { "--partial", after_partial },
+ { "--unlocked", after_unlocked },
+ { "--dontfork", after_dontfork },
+ { "--wipeonfork", after_wipeonfork },
+ { "--no-uffd", after_no_uffd },
+ { "--mempolicy", after_mempolicy },
+};
+
+struct more_case {
+ const char *name;
+ int (*fn)(void);
+};
+
+static const struct more_case more_cases[] = {
+ { "madv_doexec_flag sysctl matches MADV_DOEXEC", sysctl_flag },
+ { "shared, file, executable and stack mappings refused", refused_mappings },
+ { "hugetlb mapping refused", hugetlb_refused },
+ { "MADV_DONTEXEC: range not preserved", unmarked_exec },
+ { "partially marked VMA: only the marked part preserved", partial_exec },
+ { "mlocked range: preserved unlocked", locked_exec },
+ { "MADV_DONTFORK range: preserved, not given to a child", dontfork_exec },
+ { "MADV_WIPEONFORK range: preserved, wiped in a child", wipeonfork_exec },
+ { "userfaultfd registration: not preserved", uffd_exec },
+ { "memory policy: preserved", mempolicy_exec },
+};
+
int main(int argc, char **argv)
{
pid_t pid;
@@ -1052,6 +1395,10 @@ int main(int argc, char **argv)
strtoull(argv[3], NULL, 10), atoi(argv[4]), atoi(argv[5]));
if (argc == 5 && !strcmp(argv[1], "--reject"))
return KSFT_FAIL;
+ for (kind = 0; argc == 4 && kind < (int)ARRAY_SIZE(after_modes); kind++)
+ if (!strcmp(argv[1], after_modes[kind].mode))
+ return after_modes[kind].fn((char *)(uintptr_t)strtoull(argv[2], NULL, 10),
+ strtoull(argv[3], NULL, 10));
if (argc == 2 && !strcmp(argv[1], "--euid"))
return geteuid() ? KSFT_SKIP : KSFT_PASS;
if (argc == 4 && !strcmp(argv[1], "--pfnmap"))
@@ -1070,18 +1417,20 @@ int main(int argc, char **argv)
write(fd, "0", 1);
close(fd);
}
+ if (!range_mapped(ram, size))
+ return fail("range not preserved");
for (i = 0; i < size; i += stride)
if (ram[i] != 0x31)
return KSFT_FAIL;
return KSFT_PASS;
}
ksft_print_header();
- ksft_set_plan(NR_TESTS + 13);
+ ksft_set_plan(NR_TESTS + 13 + ARRAY_SIZE(more_cases));
for (kind = 0; kind < NR_TESTS; kind++) {
fflush(stdout);
pid = fork();
if (!pid)
- _exit(before_exec(kind));
+ exit(before_exec(kind));
ret = pid < 0 ? KSFT_FAIL : wait_child(pid);
if (ret == KSFT_SKIP)
ksft_test_result_skip("%s: DOEXEC, GUP test or mapping unavailable\n",
@@ -1093,7 +1442,7 @@ int main(int argc, char **argv)
fflush(stdout);
pid = fork();
if (!pid)
- _exit(before_cow_exec());
+ exit(before_cow_exec());
ret = pid < 0 ? KSFT_FAIL : wait_child(pid);
if (ret == KSFT_SKIP)
ksft_test_result_skip("pre-existing COW: DOEXEC unavailable\n");
@@ -1121,27 +1470,27 @@ int main(int argc, char **argv)
switch (kind) {
case 0:
case 1:
- _exit(shared_mm_exec(kind));
+ exit(shared_mm_exec(kind));
case 2:
- _exit(vhost_owner_exec());
+ exit(vhost_owner_exec());
case 3:
- _exit(allocation_failures());
+ exit(allocation_failures());
case 4:
- _exit(nonleader_exec());
+ exit(nonleader_exec());
case 5:
- _exit(proc_readers_exec());
+ exit(proc_readers_exec());
case 6:
- _exit(clone_exec_race());
+ exit(clone_exec_race());
case 7:
- _exit(setuid_exec());
+ exit(setuid_exec());
case 8:
- _exit(devzero_exec());
+ exit(devzero_exec());
case 9:
- _exit(doexec_noexec());
+ exit(doexec_noexec());
case 10:
- _exit(devmem_refused());
+ exit(devmem_refused());
case 11:
- _exit(vfio_bar_exec());
+ exit(vfio_bar_exec());
}
}
ret = pid < 0 ? KSFT_FAIL : wait_child(pid);
@@ -1150,5 +1499,16 @@ int main(int argc, char **argv)
else
ksft_test_result(ret == KSFT_PASS, "%s\n", extra_names[kind]);
}
+ for (kind = 0; kind < (int)ARRAY_SIZE(more_cases); kind++) {
+ fflush(stdout);
+ pid = fork();
+ if (!pid)
+ exit(more_cases[kind].fn());
+ ret = pid < 0 ? KSFT_FAIL : wait_child(pid);
+ if (ret == KSFT_SKIP)
+ ksft_test_result_skip("%s: unavailable\n", more_cases[kind].name);
+ else
+ ksft_test_result(ret == KSFT_PASS, "%s\n", more_cases[kind].name);
+ }
ksft_finished();
}
--
2.43.0
More information about the Devel
mailing list