Test for memfd_create() syscall with MFD_HUGETLB flag.

* memfd_create03: Tests the syscall for the flag MFD_HUGETLB.

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

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

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

+static int hugepages_enabled;
+static long og_total_pages;
+
+static void test_write_protect(int fd)

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

+}
+
+static void test_def_pagesize(int fd)
+{
+	unsigned int i;
+	int unmap_size;
+	int ret;
+	long hps;
+	void *mem;
+
+	SAFE_FILE_LINES_SCANF(MEMINFO_PATH, DEFAULT_HPS, &hps);
+	hps = hps << 10;
+	unmap_size = hps / 4;
+	mem = CHECK_HUGE_MMAPABLE(fd, hps);
+
+	for (i = unmap_size; i < hps; i += unmap_size) {
+		ret = munmap(mem, i);
+		if (ret == -1) {
+			tst_res(TINFO,
+				"munmap(%p, %dkb) failed as expected",
+				mem, i/1024);
+		} else {
+			tst_res(TFAIL,
+				"munmap(%p, %d) suceeded unexpectedly\n",
+				mem, i);
+			return;
+		}
+	}
+
+	SAFE_MUNMAP(mem, hps);
+
+	tst_res(TPASS, "File created in default pagesize %ldkB\n", hps/1024);
+}
+
+static void test_max_hugepages(int fd)
+{
+	int res;
+	int new_fd;
+	long hps;
+	long free_pages;

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

+	tst_res(TINFO, "memfd_create() succeeded");
+
+	res = CHECK_HUGE_NON_MMAPABLE(new_fd, hps);
+	if (res == 0)
+		tst_res(TPASS, "Hugepages creation is limited as expected\n");
+	else
+		tst_res(TFAIL, "Hugepages exceeded the allocation limit\n");
+
+	SAFE_CLOSE(new_fd);
+
+	SAFE_MUNMAP(mem, free_pages * hps);
+}
+
+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 HUGEPAGE ALLOCATION LIMIT--"},
+};
+
+static void memfd_huge_controller(unsigned int n)
+{

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

+
+	tst_res(TINFO, "memfd_create() succeeded");
+
+	tc->func(fd);
+
+	SAFE_CLOSE(fd);
+}
+
+static void setup(void)
+{
+	char buf[8];
+	int fd;
+	long free_pages;
+	long total_pages;
+
+	if (access("/sys/kernel/mm/hugepages", F_OK))
+		tst_brk(TCONF, "Huge page is not supported");
+
+	SAFE_FILE_LINES_SCANF(MEMINFO_PATH, FREE_HP, &free_pages);

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

+}
+
+static void cleanup(void)
+{
+	char buf[8];
+	int fd;
+	long total_pages;
+
+	if (hugepages_enabled == 0)
+		return;
+
+	sprintf(buf, "%ld", og_total_pages);
+
+	fd = open(TOTAL_HP_PATH, O_RDWR | O_TRUNC);
+
+	if (write(fd, buf, strlen(buf)) == -1)
+		tst_brk(TCONF, "Clean-up failed: write() failed");
+
+	SAFE_CLOSE(fd);
+
+	SAFE_FILE_LINES_SCANF(TOTAL_HP_PATH, "%ld", &total_pages);
+	if (og_total_pages != total_pages)
+		tst_brk(TCONF, "Clean-up failed");
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test = memfd_huge_controller,
+	.tcnt = ARRAY_SIZE(tcases),
+	.needs_root = 1,
+	.min_kver = "4.14",
+	.cleanup = cleanup,
+};

testcases/kernel/syscalls/memfd_create/memfd_create04.c new file +51 -0

new file mode 100644
index 000000000..f10f3d2bc
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+/*
+ *  Copyright (c) Zilogic Systems Pvt. Ltd., 2018
+ *  Email: [email protected]
+ *
+ * This program is free software;  you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY;  without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+ * the GNU General Public License for more details.
+ */
+
+/*
+ * Test: Validating memfd_create() with MFD_HUGETLB and MFD_HUGE_x flags.
+ *
+ * Test cases: Attempt to create hugepages of different sizes.
+ *
+ * Test logic:	memfd_create() should return non-negative value (fd)
+ *		if the system supports that particular hugepage size.
+ *		On success, fd is returned.
+ *              On failure, -1 is returned with ENODEV error.
+ */
+
+#define _GNU_SOURCE
+
+#include "tst_test.h"
+#include "memfd_create_common.h"
+
+#include <errno.h>
+#include <stdio.h>
+
+static  struct test_flag {
+	int flag;
+	char *h_size;
+	int exp_err;
+} test_flags[] =  {
+	{.flag = MFD_HUGE_64KB,   .h_size = "64kB"},
+	{.flag = MFD_HUGE_512KB, .h_size = "512kB"},
+	{.flag = MFD_HUGE_2MB,     .h_size = "2MB"},
+	{.flag = MFD_HUGE_8MB,     .h_size = "8MB"},
+	{.flag = MFD_HUGE_16MB,   .h_size = "16MB"},
+	{.flag = MFD_HUGE_256MB, .h_size = "256MB"},
+	{.flag = MFD_HUGE_1GB,     .h_size = "1GB"},
+	{.flag = MFD_HUGE_2GB,     .h_size = "2GB"},
+	{.flag = MFD_HUGE_16GB,   .h_size = "16GB"},
+};

testcases/kernel/syscalls/memfd_create/memfd_create04.c new file +4 -0

+}
+
+static void memfd_huge_x_controller(unsigned int n)
+{

testcases/kernel/syscalls/memfd_create/memfd_create04.c new file +20 -0

+
+		return;
+	}
+
+	tst_res(TPASS, "memfd_create succeeded for %s page size\n",
+		tflag.h_size);
+}
+
+static void setup(void)
+{
+	if (access("/sys/kernel/mm/hugepages", F_OK))
+		tst_brk(TCONF, "Huge page is not supported");
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test = memfd_huge_x_controller,
+	.tcnt = ARRAY_SIZE(test_flags),
+	.min_kver = "4.14",
+};

testcases/kernel/syscalls/memfd_create/memfd_create_hugetlb.c new file +48 -0

new file mode 100644
index 000000000..3ce7ad9e4
@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+/*
+ *  Copyright (c) Zilogic Systems Pvt. Ltd., 2018
+ *  Email: [email protected]
+ *
+ * This program is free software;  you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY;  without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+ * the GNU General Public License for more details.
+ */
+
+#define _GNU_SOURCE
+
+#include "memfd_create_hugetlb.h"
+#include "lapi/syscalls.h"
+
+#include <sys/mman.h>
+#include <string.h>
+
+#define TST_NO_DEFAULT_MAIN
+#include "tst_test.h"
+
+void *check_huge_mmapable(const char *filename, const int lineno,
+			  int fd, unsigned long size)
+{
+	void *mem;
+
+	mem = SAFE_MMAP(NULL, size, PROT_WRITE, MAP_PRIVATE, fd, 0);
+
+	memset((char *)mem, 0, 1);
+	tst_res_(filename, lineno, TINFO,
+		 "mmap(%p, %lu, %d, %d, %d, %d) succeeded",
+		 NULL, size, PROT_WRITE, MAP_PRIVATE, fd, 0);
+
+	return mem;
+}
+
+int check_huge_non_mmapable(const char *filename, const int lineno,
+			    int fd, unsigned long size)
+{
+	void *mem;
+

Hi,

Thanks for your code review. We will make the changes in next patch.

In set-up(), we are using SAFE_FILE_LINES_SCANF(). Do we need to go for FILE_LINES_SCANF() with tst_brk-> TCONF on error?

Regards,
Vishnu K

----- Original Message -----

I don't have strong opinion either way. You can do that - the only way I see it failing now is if /proc was not mounted, which seems unlikely.

Regards,
Jan