[LTP] [PATCH 29/29] Hugetlb: Migrating libhugetlbfs shm-fork

[Tarun Sahu <tsahu@linux.ibm.com>]

Migrating the libhugetlbfs/testcases/shm-fork.c test

Test Description: Test shared memory behavior when multiple threads are
Test shared memory behavior when multiple threads are attached
to a segment.  A segment is created and then children are
spawned which attach, write, read (verify), and detach from the
shared memory segment.

Signed-off-by: Tarun Sahu <tsahu@linux.ibm.com>
---
 runtest/hugetlb                               |   1 +
 testcases/kernel/mem/.gitignore               |   1 +
 .../kernel/mem/hugetlb/hugefork/hugefork02.c  | 196 ++++++++++++++++++
 3 files changed, 198 insertions(+)
 create mode 100644 testcases/kernel/mem/hugetlb/hugefork/hugefork02.c

diff --git a/runtest/hugetlb b/runtest/hugetlb
index 2088df636..28dc487a4 100644
--- a/runtest/hugetlb
+++ b/runtest/hugetlb
@@ -2,6 +2,7 @@ hugefallocate01 hugefallocate01
 hugefallocate02 hugefallocate02
 
 hugefork01 hugefork01
+hugefork02 hugefork02 -P 3 -s 5
 
 hugemmap01 hugemmap01
 hugemmap02 hugemmap02
diff --git a/testcases/kernel/mem/.gitignore b/testcases/kernel/mem/.gitignore
index 81b9f547c..20b60b1a1 100644
--- a/testcases/kernel/mem/.gitignore
+++ b/testcases/kernel/mem/.gitignore
@@ -2,6 +2,7 @@
 /hugetlb/hugefallocate/hugefallocate01
 /hugetlb/hugefallocate/hugefallocate02
 /hugetlb/hugefork/hugefork01
+/hugetlb/hugefork/hugefork02
 /hugetlb/hugemmap/hugemmap01
 /hugetlb/hugemmap/hugemmap02
 /hugetlb/hugemmap/hugemmap04
diff --git a/testcases/kernel/mem/hugetlb/hugefork/hugefork02.c b/testcases/kernel/mem/hugetlb/hugefork/hugefork02.c
new file mode 100644
index 000000000..16e41486b
--- /dev/null
+++ b/testcases/kernel/mem/hugetlb/hugefork/hugefork02.c
@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * Copyright (C) 2005-2006 David Gibson & Adam Litke, IBM Corporation.
+ *
+ * Test Name: Private Mapping
+ *
+ * Test Description: Test shared memory behavior when multiple threads are
+ * Test shared memory behavior when multiple threads are attached
+ * to a segment.  A segment is created and then children are
+ * spawned which attach, write, read (verify), and detach from the
+ * shared memory segment.
+ *
+ * HISTORY
+ *  Written by David Gibson & Adam Litke
+ *
+ */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <sys/mount.h>
+#include <limits.h>
+#include <sys/param.h>
+#include <setjmp.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/shm.h>
+
+#include "tst_safe_sysv_ipc.h"
+#include "hugetlb.h"
+
+static int nr_hugepages;
+static int numprocs;
+static int shmid = -1;
+
+#define MAX_PROCS 200
+#define BUF_SZ 256
+
+#define CHILD_FAIL(thread, fmt, ...) \
+	do { \
+		if (verbose) \
+			tst_res(TINFO, "Thread %d (pid=%d) FAIL: " fmt, \
+			       thread, getpid(), ##__VA_ARGS__); \
+		exit(1); \
+	} while (0)
+
+static char *verbose;
+static char hfile[MAXPATHLEN];
+static long hpage_size;
+static int numprocs;
+static char *numprocs_opt;
+
+static void do_child(int thread, unsigned long size)
+{
+	volatile char *shmaddr;
+	int j;
+	unsigned long k;
+
+	for (j = 0; j < 5; j++) {
+		shmaddr = shmat(shmid, 0, SHM_RND);
+		if (shmaddr == MAP_FAILED)
+			CHILD_FAIL(thread, "shmat() failed");
+
+		for (k = 0; k < size; k++)
+			shmaddr[k] = (char) (k);
+		for (k = 0; k < size; k++)
+			if (shmaddr[k] != (char)k)
+				CHILD_FAIL(thread, "Index %lu mismatch", k);
+
+		if (shmdt((const void *)shmaddr) != 0)
+			CHILD_FAIL(thread, "shmdt() failed: %s",
+				   strerror(errno));
+	}
+	exit(0);
+}
+
+static void check_hugetlb_shm_group(void)
+{
+	int fd;
+	char gid_buffer[64] = {0};
+	gid_t hugetlb_shm_group;
+	gid_t gid = getgid();
+	uid_t uid = getuid();
+
+	/* root is an exception */
+	if (uid == 0)
+		return;
+
+	fd = SAFE_OPEN("/proc/sys/vm/hugetlb_shm_group", O_RDONLY);
+	SAFE_READ(0, fd, &gid_buffer, sizeof(gid_buffer));
+	hugetlb_shm_group = atoi(gid_buffer);
+	SAFE_CLOSE(fd);
+	if (hugetlb_shm_group != gid)
+		tst_brk(TCONF, "Do not have permission to use SHM_HUGETLB");
+}
+
+static void run_test(void)
+{
+	unsigned long size;
+	int pid, status;
+	int i;
+	int wait_list[MAX_PROCS];
+
+	check_hugetlb_shm_group();
+
+	size = hpage_size * nr_hugepages;
+	if (verbose)
+		tst_res(TINFO, "Requesting %lu bytes\n", size);
+
+	shmid = shmget(2, size, SHM_HUGETLB|IPC_CREAT|SHM_R|SHM_W);
+	if (shmid < 0) {
+		tst_res(TFAIL|TERRNO, "shmget()");
+		goto fail;
+	}
+
+	if (verbose) {
+		tst_res(TINFO, "shmid: %d\n", shmid);
+		tst_res(TINFO, "Spawning children:\n");
+	}
+	for (i = 0; i < numprocs; i++) {
+		pid = SAFE_FORK();
+
+		if (pid == 0)
+			do_child(i, size);
+
+		wait_list[i] = pid;
+	}
+
+	for (i = 0; i < numprocs; i++) {
+		SAFE_WAITPID(wait_list[i], &status, 0);
+		if (WEXITSTATUS(status) != 0) {
+			tst_res(TFAIL, "Thread %d (pid=%d) failed", i, wait_list[i]);
+			goto fail;
+		}
+		if (WIFSIGNALED(status)) {
+			tst_res(TFAIL, "Thread %d (pid=%d) received unhandled signal",
+			     i, wait_list[i]);
+			goto fail;
+		}
+	}
+
+	tst_res(TPASS, "Successful");
+	return;
+
+fail:
+	tst_brk(TBROK, "Once failed, No point in continuing the test");
+}
+
+static void setup(void)
+{
+	if (!Hopt)
+		Hopt = tst_get_tmpdir();
+	SAFE_MOUNT("none", Hopt, "hugetlbfs", 0, NULL);
+
+	snprintf(hfile, sizeof(hfile), "%s/ltp_mmapfile%d", Hopt, getpid());
+
+	hpage_size = SAFE_READ_MEMINFO("Hugepagesize:")*1024;
+
+	if (!(numprocs_opt) || !(nr_opt))
+		tst_brk(TCONF, "Usage: -P  <# procs> -s <# pages>");
+
+	tst_parse_int(numprocs_opt, &numprocs, 1, INT_MAX);
+	tst_parse_int(nr_opt, &nr_hugepages, 1, INT_MAX);
+
+	if (numprocs > MAX_PROCS)
+		tst_brk(TCONF, "Cannot spawn more than %d processes", MAX_PROCS);
+
+	if ((unsigned long)nr_hugepages > tst_hugepages)
+		tst_brk(TCONF, "Not enough hugepages available only %lu max",
+				tst_hugepages);
+}
+
+static void cleanup(void)
+{
+	if (shmid >= 0)
+		SAFE_SHMCTL(shmid, IPC_RMID, NULL);
+	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"},
+		{"P:", &numprocs_opt, "Num of process to run in parallel"},
+		{"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 = {5, TST_REQUEST},
+};
-- 
2.31.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp