[LTP] [PATCH 09/29] Hugetlb: Migrating libhugetlbfs fork-cow
Tarun Sahu
tsahu@linux.ibm.com
Sun Oct 16 14:57:11 CEST 2022
Migrating the libhugetlbfs/testcases/fork-cow.c test
Test Description: This checks copy-on-write semantics, specifically the
semantics of a MAP_PRIVATE mapping across a fork(). Some versions of the
powerpc kernel had a bug in huge_ptep_set_wrprotect() which would fail to
flush the hash table after setting the write protect bit in the parent's
page tables, thus allowing the parent to pollute the child's mapping.
Signed-off-by: Tarun Sahu <tsahu@linux.ibm.com>
---
runtest/hugetlb | 2 +
testcases/kernel/mem/.gitignore | 1 +
.../kernel/mem/hugetlb/hugefork/Makefile | 10 +
.../kernel/mem/hugetlb/hugefork/hugefork01.c | 220 ++++++++++++++++++
4 files changed, 233 insertions(+)
create mode 100644 testcases/kernel/mem/hugetlb/hugefork/Makefile
create mode 100644 testcases/kernel/mem/hugetlb/hugefork/hugefork01.c
diff --git a/runtest/hugetlb b/runtest/hugetlb
index ec1fc2515..4c16e1e7c 100644
--- a/runtest/hugetlb
+++ b/runtest/hugetlb
@@ -1,6 +1,8 @@
hugefallocate01 hugefallocate01
hugefallocate02 hugefallocate02
+hugefork01 hugefork01
+
hugemmap01 hugemmap01
hugemmap02 hugemmap02
hugemmap04 hugemmap04
diff --git a/testcases/kernel/mem/.gitignore b/testcases/kernel/mem/.gitignore
index c0906f3d3..adea760c7 100644
--- a/testcases/kernel/mem/.gitignore
+++ b/testcases/kernel/mem/.gitignore
@@ -1,6 +1,7 @@
/cpuset/cpuset01
/hugetlb/hugefallocate/hugefallocate01
/hugetlb/hugefallocate/hugefallocate02
+/hugetlb/hugefork/hugefork01
/hugetlb/hugemmap/hugemmap01
/hugetlb/hugemmap/hugemmap02
/hugetlb/hugemmap/hugemmap04
diff --git a/testcases/kernel/mem/hugetlb/hugefork/Makefile b/testcases/kernel/mem/hugetlb/hugefork/Makefile
new file mode 100644
index 000000000..77ebb0aef
--- /dev/null
+++ b/testcases/kernel/mem/hugetlb/hugefork/Makefile
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+# Copyright (C) 2009, Cisco Systems Inc.
+# Ngie Cooper, July 2009
+
+top_srcdir ?= ../../../../..
+
+include $(top_srcdir)/include/mk/testcases.mk
+include $(abs_srcdir)/../Makefile.inc
+include $(top_srcdir)/include/mk/generic_leaf_target.mk
+
diff --git a/testcases/kernel/mem/hugetlb/hugefork/hugefork01.c b/testcases/kernel/mem/hugetlb/hugefork/hugefork01.c
new file mode 100644
index 000000000..096ff0c4d
--- /dev/null
+++ b/testcases/kernel/mem/hugetlb/hugefork/hugefork01.c
@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * Copyright (C) 2008 David Gibson, IBM Corporation.
+ *
+ * Test Name: fork COW
+ *
+ * Test Description: This checks copy-on-write semantics, specifically the
+ * semantics of a MAP_PRIVATE mapping across a fork(). Some versions of the
+ * powerpc kernel had a bug in huge_ptep_set_wrprotect() which would fail to
+ * flush the hash table after setting the write protect bit in the parent's
+ * page tables, thus allowing the parent to pollute the child's mapping.
+ *
+ * HISTORY
+ * Written by David Gibson
+ *
+ */
+
+#define _GNU_SOURCE
+
+
+#include <sys/shm.h>
+#include <sys/wait.h>
+#include <sys/mman.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/mount.h>
+#include <limits.h>
+#include <sys/param.h>
+#include <sys/types.h>
+
+#include "hugetlb.h"
+
+#define RANDOM_CONSTANT 0x1234ABCD
+#define OTHER_CONSTANT 0xfeef5678
+
+static int fd = -1;
+static char hfile[MAXPATHLEN];
+static long hpage_size;
+static char *verbose;
+
+/*
+ * The parent uses this to check if the child terminated badly.
+ */
+static void sigchld_handler(int signum, siginfo_t *si, void *uc)
+{
+ (void)signum;
+ (void)uc;
+ if (WEXITSTATUS(si->si_status) != 0) {
+ tst_res(TFAIL, "Child failed: %d", WEXITSTATUS(si->si_status));
+ goto fail;
+ }
+ if (WIFSIGNALED(si->si_status)) {
+ tst_res(TFAIL, "Child recived signal %s",
+ strsignal(WTERMSIG(si->si_status)));
+ goto fail;
+ }
+ return;
+fail:
+ tst_brk(TBROK, "Once failed, No point in continuing the test");
+}
+
+static void run_test(void)
+{
+ int status;
+ void *syncarea;
+ volatile unsigned int *p;
+ volatile unsigned int *trigger, *child_readback;
+ int parent_readback;
+ pid_t pid;
+ struct sigaction sa = {
+ .sa_sigaction = sigchld_handler,
+ .sa_flags = SA_SIGINFO,
+ };
+
+ /* Get a shared normal page for synchronization */
+ if (verbose)
+ tst_res(TINFO, "Mapping synchronization area..");
+ syncarea = SAFE_MMAP(NULL, getpagesize(), PROT_READ|PROT_WRITE,
+ MAP_SHARED|MAP_ANONYMOUS, -1, 0);
+ if (verbose)
+ tst_res(TINFO, "done");
+
+ trigger = syncarea;
+ *trigger = 0;
+
+ child_readback = trigger + 1;
+ *child_readback = 0;
+
+ fd = SAFE_OPEN(hfile, O_RDWR | O_CREAT, 0600);
+ SAFE_UNLINK(hfile);
+
+ if (verbose)
+ tst_res(TINFO, "Mapping hugepage area...");
+ p = SAFE_MMAP(NULL, hpage_size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
+ if (verbose)
+ tst_res(TINFO, "mapped at %p", p);
+ /* Touch the page for write in parent */
+ if (verbose)
+ tst_res(TINFO, "Parent writes pre-fork...");
+ *p = RANDOM_CONSTANT;
+ if (verbose)
+ tst_res(TINFO, "%x", RANDOM_CONSTANT);
+
+ SAFE_SIGACTION(SIGCHLD, &sa, NULL);
+
+ pid = SAFE_FORK();
+
+ if (pid != 0) {
+ /* Parent */
+ if (verbose)
+ tst_res(TINFO, "Parent writes post-fork...");
+ *p = ~RANDOM_CONSTANT;
+ if (verbose)
+ tst_res(TINFO, "~RANDOM_CONSTANT: %x", ~RANDOM_CONSTANT);
+ *trigger = 1;
+
+ while (*trigger != 2)
+ ;
+
+ if (verbose)
+ tst_res(TINFO, "Parent reads..");
+ parent_readback = *p;
+ if (verbose)
+ tst_res(TINFO, "Parent readback: %x", parent_readback);
+ *trigger = 3;
+ } else {
+ /* Child */
+ if (verbose)
+ tst_res(TINFO, "Child starts..");
+ while (*trigger != 1)
+ ;
+
+ if (verbose)
+ tst_res(TINFO, "Child reads...");
+ *child_readback = *p;
+ if (verbose) {
+ tst_res(TINFO, "child readback: %x", *child_readback);
+ tst_res(TINFO, "Child writes...");
+ }
+ *p = OTHER_CONSTANT;
+ if (verbose)
+ tst_res(TINFO, "OTHER_CONSTANT: %x", OTHER_CONSTANT);
+
+ *trigger = 2;
+
+ while (*trigger != 3)
+ ;
+ if (verbose)
+ tst_res(TINFO, "Child exits...");
+ exit(0);
+ }
+
+ if (verbose)
+ tst_res(TINFO, "child_readback = 0x%x, parent_readback = 0x%x\n",
+ *child_readback, parent_readback);
+
+ if (*child_readback != RANDOM_CONSTANT) {
+ tst_res(TFAIL, "Child read back 0x%x instead of 0x%x",
+ *child_readback, RANDOM_CONSTANT);
+ goto fail;
+ }
+ if (parent_readback != ~RANDOM_CONSTANT) {
+ tst_res(TFAIL, "Parent read back 0x%x instead of 0x%x",
+ parent_readback, RANDOM_CONSTANT);
+ goto fail;
+ }
+
+ SAFE_WAITPID(pid, &status, 0);
+
+ tst_res(TPASS, "Successful");
+ SAFE_MUNMAP((void *)p, hpage_size);
+ SAFE_MUNMAP(syncarea, getpagesize());
+ SAFE_CLOSE(fd);
+ return;
+fail:
+ tst_brk(TBROK, "Once failed, No point in continuing the test");
+}
+
+static void setup(void)
+{
+ int free_pages = SAFE_READ_MEMINFO("HugePages_Free:");
+
+ if (tst_hugepages < 2 || free_pages < 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, "Turns on verbose mode"},
+ {"H:", &Hopt, "Location of hugetlbfs, i.e. -H /var/hugetlbfs"},
+ {"s:", &nr_opt, "Set the number of the been allocated hugepages"},
+ {}
+ },
+ .forks_child = 1,
+ .setup = setup,
+ .cleanup = cleanup,
+ .test_all = run_test,
+ .hugepages = {2, TST_REQUEST},
+};
--
2.31.1
More information about the ltp
mailing list