[LTP] [PATCH 20/29] Hugetlb: Migrating libhugetlbfs mprotect
Tarun Sahu
tsahu@linux.ibm.com
Sun Oct 16 14:57:22 CEST 2022
Migrating the libhugetlbfs/testcases/mprotect.c test
Test Description: This test uses mprotect to change protection of
hugepage mapping and perform read/write operation. It checks if the
operation results in expected behaviour as per the protection.
Signed-off-by: Tarun Sahu <tsahu@linux.ibm.com>
---
runtest/hugetlb | 1 +
testcases/kernel/mem/.gitignore | 1 +
.../kernel/mem/hugetlb/hugemmap/hugemmap23.c | 283 ++++++++++++++++++
3 files changed, 285 insertions(+)
create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap23.c
diff --git a/runtest/hugetlb b/runtest/hugetlb
index 5d06c8679..2e8d58857 100644
--- a/runtest/hugetlb
+++ b/runtest/hugetlb
@@ -24,6 +24,7 @@ hugemmap19 hugemmap19
hugemmap20 hugemmap20
hugemmap21 hugemmap21 -T 2 -s 5
hugemmap22 hugemmap22 -T 2 -s 5
+hugemmap23 hugemmap23
hugemmap05_1 hugemmap05 -m
hugemmap05_2 hugemmap05 -s
hugemmap05_3 hugemmap05 -s -m
diff --git a/testcases/kernel/mem/.gitignore b/testcases/kernel/mem/.gitignore
index 0fd01dbce..ffd831f2e 100644
--- a/testcases/kernel/mem/.gitignore
+++ b/testcases/kernel/mem/.gitignore
@@ -23,6 +23,7 @@
/hugetlb/hugemmap/hugemmap20
/hugetlb/hugemmap/hugemmap21
/hugetlb/hugemmap/hugemmap22
+/hugetlb/hugemmap/hugemmap23
/hugetlb/hugeshmat/hugeshmat01
/hugetlb/hugeshmat/hugeshmat02
/hugetlb/hugeshmat/hugeshmat03
diff --git a/testcases/kernel/mem/hugetlb/hugemmap/hugemmap23.c b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap23.c
new file mode 100644
index 000000000..e93f85669
--- /dev/null
+++ b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap23.c
@@ -0,0 +1,283 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * Copyright (C) 2005-2006 David Gibson & Adam Litke, IBM Corporation.
+ *
+ * Test Name: mprotect
+ *
+ * Test Description: This test uses mprotect to change protection of hugepage
+ * mapping and perform read/write operation. It checks if the operation results
+ * in expected behaviour as per the protection.
+ *
+ * HISTORY
+ * Written by David Gibson & Adam Litke
+ *
+ */
+
+/* TODO: resolve mmap ENOMEM failure on more iteration */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <sys/mount.h>
+#include <limits.h>
+#include <sys/param.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <setjmp.h>
+#include <signal.h>
+
+#include "hugetlb.h"
+
+#ifndef barrier
+# ifdef mb
+ /* Redefining the mb() */
+# define barrier() mb()
+# else
+# define barrier() __asm__ __volatile__ ("" : : : "memory")
+# endif
+#endif
+
+static char *verbose;
+static int fd = -1;
+static char hfile[MAXPATHLEN];
+static sigjmp_buf sig_escape;
+static void *sig_expected = MAP_FAILED;
+static long hpage_size;
+
+static void sig_handler(int signum, siginfo_t *si, void *uc)
+{
+ (void)uc;
+ if (signum == SIGSEGV) {
+ if (verbose)
+ tst_res(TINFO, "SIGSEGV at %p (sig_expected=%p)\n", si->si_addr,
+ sig_expected);
+ if (si->si_addr == sig_expected)
+ siglongjmp(sig_escape, 1);
+ tst_res(TFAIL, "SIGSEGV somewhere unexpected");
+ goto fail;
+ }
+ tst_res(TFAIL, "Unexpected signal %s", strsignal(signum));
+fail:
+ tst_brk(TBROK, "Once failed, No point in continue the test.");
+}
+
+static int test_read(void *p)
+{
+ volatile unsigned long *pl = p;
+ unsigned long x;
+
+ if (sigsetjmp(sig_escape, 1)) {
+ /* We got a SEGV */
+ sig_expected = MAP_FAILED;
+ return -1;
+ }
+
+ sig_expected = p;
+ barrier();
+ x = *pl;
+ if (verbose)
+ tst_res(TINFO, "Read back %lu", x);
+ barrier();
+ sig_expected = MAP_FAILED;
+ /*
+ * gcc 5 complains about x not ever being used, the following
+ * statement is solely here to shut it up
+ */
+ pl = (unsigned long *)x;
+
+ return 0;
+}
+
+static int test_write(void *p, unsigned long val)
+{
+ volatile unsigned long *pl = p;
+ unsigned long x;
+
+ if (sigsetjmp(sig_escape, 1)) {
+ /* We got a SEGV */
+ sig_expected = MAP_FAILED;
+ return -1;
+ }
+
+ sig_expected = p;
+ barrier();
+ *pl = val;
+ x = *pl;
+ barrier();
+ sig_expected = MAP_FAILED;
+
+ return (x != val);
+}
+
+#define RANDOM_CONSTANT 0x1234ABCD
+
+static void test_prot(void *p, int prot)
+{
+ int r, w;
+
+ r = test_read(p);
+ if (verbose)
+ tst_res(TINFO, "On Read: %d\n", r);
+ w = test_write(p, RANDOM_CONSTANT);
+ if (verbose)
+ tst_res(TINFO, "On Write: %d\n", w);
+
+ if (prot & PROT_READ) {
+ if (r != 0) {
+ tst_res(TFAIL, "read failed on mmap(prot=%x)", prot);
+ goto fail;
+ }
+
+ } else {
+ if (r != -1) {
+ tst_res(TFAIL, "read succeeded on mmap(prot=%x)", prot);
+ goto fail;
+ }
+ }
+
+ if (prot & PROT_WRITE) {
+ switch (w) {
+ case -1:
+ tst_res(TFAIL, "write failed on mmap(prot=%x)", prot);
+ goto fail;
+ case 0:
+ break;
+ case 1:
+ tst_res(TFAIL, "write mismatch on mmap(prot=%x)", prot);
+ goto fail;
+ default:
+ tst_res(TWARN, "Bug in test");
+ goto fail;
+ }
+ } else {
+ switch (w) {
+ case -1:
+ break;
+ case 0:
+ tst_res(TFAIL, "write succeeded on mmap(prot=%x)", prot);
+ goto fail;
+ case 1:
+ tst_res(TFAIL, "write mismatch on mmap(prot=%x)", prot);
+ goto fail;
+ default:
+ tst_res(TWARN, "Bug in test");
+ break;
+ }
+ }
+ return;
+fail:
+ tst_brk(TBROK, "Once failed, No point in continue to the test");
+}
+
+static void test_mprotect(int fd, char *testname,
+ unsigned long len1, int prot1,
+ unsigned long len2, int prot2)
+{
+ void *p;
+ int err;
+
+ if (verbose) {
+ tst_res(TINFO, "Testing %s\n", testname);
+ tst_res(TINFO, "Mapping with prot=%x\n", prot1);
+ }
+ p = SAFE_MMAP(NULL, len1, prot1, MAP_SHARED, fd, 0);
+
+ test_prot(p, prot1);
+
+ if (verbose)
+ tst_res(TINFO, "mprotect()ing to prot=%x\n", prot2);
+ err = mprotect(p, len2, prot2);
+ if (err != 0) {
+ tst_res(TFAIL|TERRNO, "%s: mprotect(prot=%x)", testname, prot2);
+ goto fail;
+ }
+
+ test_prot(p, prot2);
+
+ if (len2 < len1)
+ test_prot(p + len2, prot1);
+
+ SAFE_MUNMAP(p, len1);
+ return;
+fail:
+ tst_brk(TBROK, "Once failed, No point in continue the test");
+}
+
+static void run_test(void)
+{
+ void *p;
+
+ struct sigaction sa = {
+ .sa_sigaction = sig_handler,
+ .sa_flags = SA_SIGINFO,
+ };
+
+ SAFE_SIGACTION(SIGSEGV, &sa, NULL);
+
+ fd = SAFE_OPEN(hfile, O_RDWR | O_CREAT, 0600);
+ SAFE_UNLINK(hfile);
+
+ p = SAFE_MMAP(NULL, 2*hpage_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+ memset(p, 0, hpage_size);
+ SAFE_MUNMAP(p, hpage_size);
+
+ /* Basic protection change tests */
+ test_mprotect(fd, "R->RW", hpage_size, PROT_READ,
+ hpage_size, PROT_READ|PROT_WRITE);
+ test_mprotect(fd, "RW->R", hpage_size, PROT_READ|PROT_WRITE,
+ hpage_size, PROT_READ);
+
+ /* Tests which require VMA splitting */
+ test_mprotect(fd, "R->RW 1/2", 2*hpage_size, PROT_READ,
+ hpage_size, PROT_READ|PROT_WRITE);
+ test_mprotect(fd, "RW->R 1/2", 2*hpage_size, PROT_READ|PROT_WRITE,
+ hpage_size, PROT_READ);
+
+ /* PROT_NONE tests */
+ test_mprotect(fd, "NONE->R", hpage_size, PROT_NONE,
+ hpage_size, PROT_READ);
+ test_mprotect(fd, "NONE->RW", hpage_size, PROT_NONE,
+ hpage_size, PROT_READ|PROT_WRITE);
+
+ tst_res(TPASS, "Successful");
+ SAFE_CLOSE(fd);
+}
+
+static void setup(void)
+{
+ if (tst_hugepages < 2)
+ tst_brk(TCONF, "Not enough hugepages for testing.");
+
+ if (!Hopt)
+ Hopt = tst_get_tmpdir();
+ SAFE_MOUNT("none", Hopt, "hugetlbfs", 0, NULL);
+
+ snprintf(hfile, sizeof(hfile), "%s/ltp_hugetlbfile%d", Hopt, getpid());
+
+ hpage_size = SAFE_READ_MEMINFO("Hugepagesize:")*1024;
+}
+
+static void cleanup(void)
+{
+ if (fd >= 0)
+ SAFE_CLOSE(fd);
+ umount2(Hopt, MNT_DETACH);
+}
+
+static struct tst_test test = {
+ .needs_root = 1,
+ .needs_tmpdir = 1,
+ .options = (struct tst_option[]) {
+ {"v", &verbose, "Run test with verbose"},
+ {"H:", &Hopt, "Location of hugetlbfs, i.e. -H /var/hugetlbfs"},
+ {"s:", &nr_opt, "Set the number of the been allocated hugepages"},
+ {}
+ },
+ .setup = setup,
+ .cleanup = cleanup,
+ .test_all = run_test,
+ .hugepages = {2, TST_REQUEST},
+};
--
2.31.1
More information about the ltp
mailing list