Test for memfd_create() syscall with MFD_HUGETLB flag.

memfd_create03.c: Tests the syscall for the flag MFD_HUGETLB.

memfd_create04.c: Tests the syscall for the flags MFD_HUGE_2MB, MFD_HUGE_1GB,... used in conjunction with MFD_HUGETLB flag.

memfd_create_hugetlb.c: Contains helper functions for memfd_create03.c and memfd_create04.c.

-- major changes from v1 to v2 --

Restore the original number of hugepages in cleanup().

Modify check_mfd_new() from memfd_create_common and replace safe_huge_new() + safe_huge_x_new() from memfd_create_hugetlb with it.

Modify get_from_file() from memfd_create_hugetlb to use FILE_LINES_SCANF in code logic.

Move test dependent flags to include/lapi

testcases/kernel/syscalls/memfd_create/memfd_create03.c new file +6 -0

+
+static void test_def_pagesize(int fd)
+{
+	int ret;
+	long hps;
+	void *mem;

testcases/kernel/syscalls/memfd_create/memfd_create03.c new file +54 -0

+
+static void test_max_hugepages(int fd)
+{
+	int res;
+	int new_fd;
+	int dummy_fd;
+	long hps;
+	long free_pages;
+	void *mem;
+
+	free_pages = GET_HUGE_FREE_PAGES();
+	hps = GET_HUGE_DEF_PAGESIZE();
+	mem = CHECK_HUGE_MMAPABLE(fd, free_pages * hps);
+
+	new_fd = CHECK_MFD_NEW("new_file", 0, MFD_HUGETLB);
+	if (fd < 0)
+		tst_brk(TBROK | TERRNO, "memfd_create() failed");
+	res = CHECK_HUGE_NON_MMAPABLE(new_fd, hps);
+	dummy_fd = new_fd;
+	SAFE_CLOSE(new_fd);
+	tst_res(TINFO, "close(%d) succeeded", dummy_fd);
+
+	SAFE_MUNMAP(mem, free_pages * hps);
+
+	if (res == 0)
+		tst_res(TPASS, "Hugepages creation is limited as expected");
+	else
+		tst_res(TFAIL, "Hugepages creation limit failed");
+}
+
+static const struct tcase {
+	void (*func)(int fd);
+	const char *desc;
+} tcases[] = {
+	{&test_write_protect, "--TESTING WRITE CALL IN HUGEPAGES--"},
+	{&test_def_pagesize, "--TESTING PAGE SIZE OF CREATED FILE--"},
+	{&test_max_hugepages, "--TESTING THE NUMBER OF HUGEPAGES--"},
+};
+
+static void memfd_huge_controller(unsigned int n)
+{
+	int fd;
+	int dummy_fd;
+	const struct tcase *tc;
+
+	tc = &tcases[n];
+
+	tst_res(TINFO, "%s", tc->desc);
+
+	fd = CHECK_MFD_NEW("test_file", 0, MFD_HUGETLB);
+	if (fd < 0)
+		tst_brk(TBROK | TERRNO, "memfd_create() failed");
+
+	tc->func(fd);

testcases/kernel/syscalls/memfd_create/memfd_create_common.c +12 -3

index f22e3d345..186eafa51 100644
@@ -144,21 +144,33 @@ int mfd_flags_available(const char *filename, const int
 lineno,
 }
 
 int check_mfd_new(const char *filename, const int lineno,
-			const char *name, loff_t sz, int flags)
+		  const char *name, loff_t sz, int flags)
 {
 	int fd;
 
 	fd = sys_memfd_create(name, flags);
 	if (fd < 0) {
+		if ((flags & MFD_HUGETLB) == MFD_HUGETLB)
+			goto end;
+
 		tst_brk_(filename, lineno, TBROK | TERRNO,
-			"memfd_create(%s, %d) failed", name, flags);
+			 "memfd_create(%s, %d) failed", name, flags);
+	}
+
+	if ((flags & MFD_HUGETLB) == MFD_HUGETLB) {
+		tst_res_(filename, lineno, TINFO,
+			 "memfd_create(%s, %d) succeeded",
+			 name, flags);
+		goto end;
 	}
 
-	tst_res_(filename, lineno, TPASS, "memfd_create(%s, %d) succeeded",

testcases/kernel/syscalls/memfd_create/memfd_create_common.c +19 -0

+int check_huge_non_writeable(const char *filename, const int lineno, int fd)
+{
+	ssize_t ret;
+	char test_str[] = "data";
+
+	ret = write(fd, test_str, sizeof(test_str));
+
+	if (ret < 0) {
+		if (errno != EINVAL) {
+			tst_res_(filename, lineno, TINFO,
+				 "write(%d, \"%s\", %zu) didn't fail as expected",
+				 fd, test_str, strlen(test_str));
+
+			return -1;
+		}
+	} else {
+		tst_res_(filename, lineno, TINFO,
+			 "write(%d, \"%s\", %zu) succeeded unexpectedly",
+			 fd, test_str, strlen(test_str));

testcases/kernel/syscalls/memfd_create/memfd_create03.c new file +7 -0

+static void test_write_protect(int fd)
+{
+        if (CHECK_HUGE_NON_WRITEABLE(fd) == 0)
+                tst_res(TPASS, "write call failed as expected");
+        else
+                tst_res(TFAIL, "write call passed unexpectedly");
+}

Why not report PASS/FAIL directly? Or why not put the test

testcases/kernel/syscalls/memfd_create/memfd_create03.c new file +5 -0

+        hugepages_enabled = 1;
+        SAFE_CLOSE(fd);
+
+        if (GET_HUGE_TOTAL_PAGES() == 0)
+                tst_brk(TCONF, "Enable Hugepages manually");

I thought you need 4 huge pages for the test. This skips setup

If you need 4 huge pages for test, then shouldn't this check you have at

This looks like a guaranteed warning on some systems.