[LTP] [PATCH v4] hugetlb/hugemmap: add hugemmap33 to test hugetlbfs quota accounting
Pavithra
pavrampu@linux.ibm.com
Sun Aug 9 19:49:00 CEST 2026
Test hugetlbfs quota accounting with filesystem size limits to check
for regressions in quota handling for MAP_PRIVATE and MAP_SHARED pages.
Signed-off-by: Pavithra <pavrampu@linux.ibm.com>
---
v3 -> v4:
- Check only ENOMEM for quota exhaustion in mmap() and COW mmap()
error paths;
- Use TESTPTR() for both mmap() calls to capture return value and
errno consistently via TST_RET_PTR and TST_ERR
- Use PATH_MAX instead of PATH_MAX + 32 for the path buffer
Link to v3: https://lore.kernel.org/ltp/20260809162202.1811452-1-pavrampu@linux.ibm.com/
---
runtest/hugetlb | 1 +
testcases/kernel/mem/.gitignore | 1 +
.../kernel/mem/hugetlb/hugemmap/hugemmap33.c | 222 ++++++++++++++++++
3 files changed, 224 insertions(+)
create mode 100644 testcases/kernel/mem/hugetlb/hugemmap/hugemmap33.c
diff --git a/runtest/hugetlb b/runtest/hugetlb
index 6b35c1f42..c83955987 100644
--- a/runtest/hugetlb
+++ b/runtest/hugetlb
@@ -35,6 +35,7 @@ hugemmap29 hugemmap29
hugemmap30 hugemmap30
hugemmap31 hugemmap31
hugemmap32 hugemmap32
+hugemmap33 hugemmap33
hugemmap34 hugemmap34
hugemmap35 hugemmap35
hugemmap36 hugemmap36
diff --git a/testcases/kernel/mem/.gitignore b/testcases/kernel/mem/.gitignore
index e63a6dde7..f4c3dd1b0 100644
--- a/testcases/kernel/mem/.gitignore
+++ b/testcases/kernel/mem/.gitignore
@@ -35,6 +35,7 @@
/hugetlb/hugemmap/hugemmap30
/hugetlb/hugemmap/hugemmap31
/hugetlb/hugemmap/hugemmap32
+/hugetlb/hugemmap/hugemmap33
/hugetlb/hugemmap/hugemmap34
/hugetlb/hugemmap/hugemmap35
/hugetlb/hugemmap/hugemmap36
diff --git a/testcases/kernel/mem/hugetlb/hugemmap/hugemmap33.c b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap33.c
new file mode 100644
index 000000000..6a242575c
--- /dev/null
+++ b/testcases/kernel/mem/hugetlb/hugemmap/hugemmap33.c
@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: LGPL-2.1-or-later
+/*
+ * Copyright (C) 2005-2007 David Gibson & Adam Litke, IBM Corporation.
+ * Copyright (c) Linux Test Project, 2024
+ * Copyright (C) 2025-2026 Naveed & Pavithra, IBM Corporation.
+ * Assisted with AI tools
+ */
+
+/*\
+ * Test hugetlbfs quota accounting with filesystem size limits.
+ *
+ * The number of global huge pages available to a mounted hugetlbfs filesystem
+ * can be limited using a quota mechanism by setting the size attribute at
+ * mount time. Older kernels did not properly handle quota accounting for
+ * MAP_PRIVATE pages and MAP_SHARED reservations.
+ *
+ * Commit a1e78772d72b introduced MAP_PRIVATE reservations at mmap() time,
+ * so quota is checked upfront and mmap() fails with ENOMEM when over quota.
+ * Before this, quota was only checked at fault time resulting in SIGBUS.
+ *
+ * Root is required to mount the quota-limited hugetlbfs instance.
+ */
+
+#define _GNU_SOURCE
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/vfs.h>
+#include <sys/statfs.h>
+#include <sys/mount.h>
+
+#include "hugetlb.h"
+
+#define MNTPOINT "hugetlbfs/"
+
+static long hpage_size;
+static int quota_mounted;
+
+/* map action flags */
+#define ACTION_COW 0x0001
+#define ACTION_TOUCH 0x0002
+
+/* Expected outcome for a quota test */
+#define QUOTA_OK 0
+#define QUOTA_FAIL 1
+#define QUOTA_COW_FAIL 2
+
+static void verify_quota_stat(long tot, long free, long avail)
+{
+ struct statfs s;
+
+ SAFE_STATFS(MNTPOINT, &s);
+
+ if ((long)s.f_blocks != tot || (long)s.f_bfree != free || (long)s.f_bavail != avail) {
+ tst_res(TFAIL, "Bad quota counters: total=%li free=%li avail=%li, expected %li %li %li",
+ (long)s.f_blocks, (long)s.f_bfree, (long)s.f_bavail,
+ tot, free, avail);
+ return;
+ }
+ tst_res(TPASS, "Quota counters are correct: total=%li free=%li avail=%li",
+ tot, free, avail);
+}
+
+static void do_map(unsigned long size, int mmap_flags, int action_flags,
+ int expected)
+{
+ int fd;
+ char *a = MAP_FAILED, *b, *c = MAP_FAILED;
+ char path[PATH_MAX];
+
+ snprintf(path, sizeof(path), "%s/test_file_%d", MNTPOINT, getpid());
+ fd = SAFE_OPEN(path, O_CREAT | O_RDWR, 0600);
+ SAFE_UNLINK(path);
+
+ TESTPTR(mmap(NULL, size, PROT_READ | PROT_WRITE, mmap_flags, fd, 0));
+ a = TST_RET_PTR;
+ if (a == MAP_FAILED) {
+ if (expected == QUOTA_FAIL && TST_ERR == ENOMEM) {
+ tst_res(TPASS | TERRNO, "mmap failed as expected due to quota");
+ SAFE_CLOSE(fd);
+ return;
+ }
+ tst_res(TFAIL | TERRNO, "mmap failed unexpectedly");
+ SAFE_CLOSE(fd);
+ return;
+ }
+
+ if (expected == QUOTA_FAIL) {
+ tst_res(TFAIL, "mmap succeeded but quota exhaustion was expected");
+ goto cleanup_a;
+ }
+
+ if (action_flags & ACTION_TOUCH) {
+ for (b = a; b < a + size; b += hpage_size)
+ *b = 1;
+ }
+
+ if (action_flags & ACTION_COW) {
+ TESTPTR(mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0));
+ c = TST_RET_PTR;
+ if (c == MAP_FAILED) {
+ if (expected == QUOTA_COW_FAIL && TST_ERR == ENOMEM) {
+ tst_res(TPASS | TERRNO, "COW mmap failed as expected due to quota");
+ goto cleanup_a;
+ }
+ tst_res(TFAIL | TERRNO, "COW mmap failed unexpectedly");
+ goto cleanup_a;
+ }
+
+ if (expected == QUOTA_COW_FAIL) {
+ tst_res(TFAIL, "COW mmap succeeded but quota exhaustion was expected");
+ goto cleanup_c;
+ }
+
+ if (*c != 1) {
+ tst_res(TFAIL, "Data mismatch when setting up COW");
+ goto cleanup_c;
+ }
+ *c = 0;
+ SAFE_MUNMAP(c, size);
+ }
+
+ if (expected == QUOTA_OK)
+ tst_res(TPASS, "Quota test passed as expected");
+
+ SAFE_MUNMAP(a, size);
+ SAFE_CLOSE(fd);
+ return;
+
+cleanup_c:
+ SAFE_MUNMAP(c, size);
+cleanup_a:
+ SAFE_MUNMAP(a, size);
+ SAFE_CLOSE(fd);
+}
+
+static void run_quota_test(int expected,
+ unsigned long size, int mmap_flags,
+ int action_flags)
+{
+ pid_t pid;
+ int status;
+
+ pid = SAFE_FORK();
+ if (pid == 0) {
+ do_map(size, mmap_flags, action_flags, expected);
+ exit(0);
+ }
+
+ SAFE_WAITPID(pid, &status, 0);
+
+ if (WIFSIGNALED(status))
+ tst_res(TFAIL, "Child killed by unexpected signal %d", WTERMSIG(status));
+}
+
+static void run_test(void)
+{
+ tst_res(TINFO, "Testing unused quota cleanup for untouched mappings");
+ run_quota_test(QUOTA_OK, hpage_size, MAP_PRIVATE, 0);
+ verify_quota_stat(1, 1, 1);
+ run_quota_test(QUOTA_OK, hpage_size, MAP_SHARED, 0);
+ verify_quota_stat(1, 1, 1);
+
+ tst_res(TINFO, "Testing page instantiation within quota limits");
+ run_quota_test(QUOTA_OK, hpage_size, MAP_PRIVATE, ACTION_TOUCH);
+ run_quota_test(QUOTA_OK, hpage_size, MAP_SHARED, ACTION_TOUCH);
+
+ tst_res(TINFO, "Testing page instantiation over quota");
+ run_quota_test(QUOTA_FAIL, 2 * hpage_size, MAP_SHARED, ACTION_TOUCH);
+
+ tst_res(TINFO, "Testing private mapping quota check");
+ run_quota_test(QUOTA_FAIL, 2 * hpage_size, MAP_PRIVATE, ACTION_TOUCH);
+
+ tst_res(TINFO, "Testing COW over quota");
+ run_quota_test(QUOTA_COW_FAIL, hpage_size, MAP_SHARED,
+ ACTION_TOUCH | ACTION_COW);
+ run_quota_test(QUOTA_COW_FAIL, hpage_size, MAP_PRIVATE,
+ ACTION_TOUCH | ACTION_COW);
+
+ tst_res(TINFO, "Testing operations within quota after failures");
+ run_quota_test(QUOTA_OK, hpage_size, MAP_SHARED, ACTION_TOUCH);
+ run_quota_test(QUOTA_OK, hpage_size, MAP_PRIVATE, ACTION_TOUCH);
+}
+
+static void setup(void)
+{
+ char mount_opts[BUFSIZ];
+
+ hpage_size = tst_get_hugepage_size();
+
+ snprintf(mount_opts, sizeof(mount_opts), "size=%luK",
+ hpage_size / 1024);
+
+ if (mount("none", MNTPOINT, "hugetlbfs", 0, mount_opts) == -1) {
+ if (errno == ENODEV)
+ tst_brk(TCONF, "hugetlbfs not supported");
+ tst_brk(TBROK | TERRNO, "mount() failed");
+ }
+ quota_mounted = 1;
+
+ tst_res(TINFO, "Mounted hugetlbfs with quota at %s (size=%luK)",
+ MNTPOINT, hpage_size / 1024);
+}
+
+static void cleanup(void)
+{
+ if (quota_mounted)
+ SAFE_UMOUNT(MNTPOINT);
+}
+
+static struct tst_test test = {
+ .tags = (struct tst_tag[]) {
+ {"linux-git", "a1e78772d72b"},
+ {}
+ },
+ .needs_root = 1,
+ .mntpoint = MNTPOINT,
+ .forks_child = 1,
+ .setup = setup,
+ .cleanup = cleanup,
+ .test_all = run_test,
+ .hugepages = {2, TST_NEEDS},
+};
--
2.55.0
More information about the ltp
mailing list