Skip to contentSkip to conversation

selftests/mm: hugetlb cgroup charging: robustness fixes

PATCH Applied Li Wang 5 participants 21 messages Dec 21, 2025 – Dec 23, 2025

Subsystems (3)
lore
Share & tools
lore

Li Wang

author
#0 lore raw

v3 cover selftests/mm: hugetlb cgroup charging: robustness fixes

Changes in v3:
- 1/3: no changes.
- 2/3: reorder with 3/3, and drop the 'size=' mount args.
- 3/3: add $path check, improve varible declaration, sleep 1s for 60 tryies.

Changes in v2:
- 1/3: Parse -s using sscanf("%zu", ...) instead of strtoull().
- 2/3: Fix typo in charge_reserved_hugetlb.sh ("reseravation" -> "reservation").
- 3/3: No changes.

This series fixes a few issues in the hugetlb cgroup charging selftests (write_to_hugetlbfs.c + charge_reserved_hugetlb.sh) that show up on systems with large hugepages (e.g. 512MB) and when failures cause the test to wait indefinitely.

On an aarch64 64k page kernel with 512MB hugepages, the test consistently fails in write_to_hugetlbfs with ENOMEM and then hangs waiting for the expected usage values. The root cause is that charge_reserved_hugetlb.sh mounts hugetlbfs with a fixed size=256M, which is smaller than a single hugepage, resulting in a mount with size=0 capacity.

In addition, write_to_hugetlbfs previously parsed -s via atoi() into an int, which can overflow and print negative sizes.

Reproducer / environment:
- Kernel: 6.12.0-xxx.el10.aarch64+64k
- Hugepagesize: 524288 kB (512MB)
- ./charge_reserved_hugetlb.sh -cgroup-v2
- Observed mount: pagesize=512M,size=0 before this series

After applying the series, the test completes successfully on the above setup.

Li Wang (3):
selftests/mm/write_to_hugetlbfs: parse -s as size_t selftests/mm/charge_reserved_hugetlb: drop mount size for hugetlbfs selftests/mm/charge_reserved_hugetlb.sh: add waits with timeout helper

 .../selftests/mm/charge_reserved_hugetlb.sh   | 55 +++++++++++--------
 .../testing/selftests/mm/write_to_hugetlbfs.c |  9 ++-
 2 files changed, 38 insertions(+), 26 deletions(-)
Signature · 1 line
2.49.0
author
#1 lore raw

PATCH v3 1/3 selftests/mm/write_to_hugetlbfs: parse -s as size_t

write_to_hugetlbfs currently parses the -s size argument with atoi() into an int. This silently accepts malformed input, cannot report overflow, and can truncate large sizes.

--- Error log ---

 # uname -r
 6.12.0-xxx.el10.aarch64+64k
 # ls /sys/kernel/mm/hugepages/hugepages-*
 hugepages-16777216kB/  hugepages-2048kB/  hugepages-524288kB/

#./charge_reserved_hugetlb.sh -cgroup-v2
# -----------------------------------------
...

 # nr hugepages = 10
 # writing cgroup limit: 5368709120
 # writing reseravation limit: 5368709120
 ...
 # Writing to this path: /mnt/huge/test
 # Writing this size: -1610612736        <--------

Switch the size variable to size_t and parse -s with sscanf("%zu", ...). Also print the size using %zu.

This avoids incorrect behavior with large -s values and makes the utility more robust.

---
 tools/testing/selftests/mm/write_to_hugetlbfs.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)
tools/testing/selftests/mm/write_to_hugetlbfs.c +6 -3
index 34c91f7e6128..ecb5f7619960 100644
@@ -68,7 +68,7 @@ int main(int argc, char **argv)
 	int key = 0;
 	int *ptr = NULL;
 	int c = 0;
-	int size = 0;
+	size_t size = 0;
 	char path[256] = "";
 	enum method method = MAX_METHOD;
 	int want_sleep = 0, private = 0;
@@ -86,7 +86,10 @@ int main(int argc, char **argv)
 	while ((c = getopt(argc, argv, "s:p:m:owlrn")) != -1) {
 		switch (c) {
 		case 's':
-			size = atoi(optarg);
+			if (sscanf(optarg, "%zu", &size) != 1) {
+				perror("Invalid -s.");
+				exit_usage();
+			}
 			break;
 		case 'p':
 			strncpy(path, optarg, sizeof(path) - 1);
@@ -131,7 +134,7 @@ int main(int argc, char **argv)
 	}
 
 	if (size != 0) {
-		printf("Writing this size: %d\n", size);
+		printf("Writing this size: %zu\n", size);
 	} else {
 		errno = EINVAL;
 		perror("size not found");
Signature · 1 line
2.49.0
Acked-by on v3 1/3
#2 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

Quoted 63 lines · Li Wang

write_to_hugetlbfs currently parses the -s size argument with atoi() into an int. This silently accepts malformed input, cannot report overflow, and can truncate large sizes.

--- Error log ---

  # uname -r
  6.12.0-xxx.el10.aarch64+64k
  # ls /sys/kernel/mm/hugepages/hugepages-*
  hugepages-16777216kB/  hugepages-2048kB/  hugepages-524288kB/

#./charge_reserved_hugetlb.sh -cgroup-v2
# -----------------------------------------
...

  # nr hugepages = 10
  # writing cgroup limit: 5368709120
  # writing reseravation limit: 5368709120
  ...
  # Writing to this path: /mnt/huge/test
  # Writing this size: -1610612736        <--------

Switch the size variable to size_t and parse -s with sscanf("%zu", ...). Also print the size using %zu.

This avoids incorrect behavior with large -s values and makes the utility more robust.

---
  tools/testing/selftests/mm/write_to_hugetlbfs.c | 9 ++++++---
  1 file changed, 6 insertions(+), 3 deletions(-)
tools/testing/selftests/mm/write_to_hugetlbfs.c +5 -2
index 34c91f7e6128..ecb5f7619960 100644
@@ -68,7 +68,7 @@ int main(int argc, char **argv)
  	int key = 0;
  	int *ptr = NULL;
  	int c = 0;
-	int size = 0;
+	size_t size = 0;
  	char path[256] = "";
  	enum method method = MAX_METHOD;
  	int want_sleep = 0, private = 0;
@@ -86,7 +86,10 @@ int main(int argc, char **argv)
  	while ((c = getopt(argc, argv, "s:p:m:owlrn")) != -1) {
  		switch (c) {
  		case 's':
-			size = atoi(optarg);
+			if (sscanf(optarg, "%zu", &size) != 1) {
+				perror("Invalid -s.");
+				exit_usage();
+			}
  			break;
  		case 'p':
  			strncpy(path, optarg, sizeof(path) - 1);

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 140

Quoted 8 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +1 -1
@@ -131,7 +134,7 @@ int main(int argc, char **argv)
  	}
 
  	if (size != 0) {
-		printf("Writing this size: %d\n", size);
+		printf("Writing this size: %zu\n", size);
  	} else {
  		errno = EINVAL;
  		perror("size not found");

LGTM

#3 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

In reply to Li Wang
Quoted 3 lines · On Sun, 21 Dec 2025 20:26:37 +0800 Li Wang <[email protected]> wrote:

write_to_hugetlbfs currently parses the -s size argument with atoi() into an int. This silently accepts malformed input, cannot report overflow, and can truncate large sizes.

And sscanf() will just ignore invalid trailing characters. Probably much the same as atoi() apart from a leading '-'.

Maybe you could use "%zu%c" and check the count is 1 - but I bet some static checker won't like that.

Using strtoul() and checking the terminating character is 'reasonable', but won't detect overflow.

David

Quoted 68 lines

--- Error log ---

 # uname -r
 6.12.0-xxx.el10.aarch64+64k
 # ls /sys/kernel/mm/hugepages/hugepages-*
 hugepages-16777216kB/  hugepages-2048kB/  hugepages-524288kB/

#./charge_reserved_hugetlb.sh -cgroup-v2
# -----------------------------------------
...

 # nr hugepages = 10
 # writing cgroup limit: 5368709120
 # writing reseravation limit: 5368709120
 ...
 # Writing to this path: /mnt/huge/test
 # Writing this size: -1610612736        <--------

Switch the size variable to size_t and parse -s with sscanf("%zu", ...). Also print the size using %zu.

This avoids incorrect behavior with large -s values and makes the utility more robust.

---
 tools/testing/selftests/mm/write_to_hugetlbfs.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)
tools/testing/selftests/mm/write_to_hugetlbfs.c +6 -3
index 34c91f7e6128..ecb5f7619960 100644
@@ -68,7 +68,7 @@ int main(int argc, char **argv)
 	int key = 0;
 	int *ptr = NULL;
 	int c = 0;
-	int size = 0;
+	size_t size = 0;
 	char path[256] = "";
 	enum method method = MAX_METHOD;
 	int want_sleep = 0, private = 0;
@@ -86,7 +86,10 @@ int main(int argc, char **argv)
 	while ((c = getopt(argc, argv, "s:p:m:owlrn")) != -1) {
 		switch (c) {
 		case 's':
-			size = atoi(optarg);
+			if (sscanf(optarg, "%zu", &size) != 1) {
+				perror("Invalid -s.");
+				exit_usage();
+			}
 			break;
 		case 'p':
 			strncpy(path, optarg, sizeof(path) - 1);
@@ -131,7 +134,7 @@ int main(int argc, char **argv)
 	}
 
 	if (size != 0) {
-		printf("Writing this size: %d\n", size);
+		printf("Writing this size: %zu\n", size);
 	} else {
 		errno = EINVAL;
 		perror("size not found");
author
#4 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

Quoted 5 lines · David Laight
Quoted 2 lines · On Sun, 21 Dec 2025 20:26:37 +0800 Li Wang <[email protected]> wrote:

write_to_hugetlbfs currently parses the -s size argument with atoi() into an int. This silently accepts malformed input, cannot report

Quoted 9 lines

overflow,

Quoted 1 line

and can truncate large sizes.

And sscanf() will just ignore invalid trailing characters. Probably much the same as atoi() apart from a leading '-'.

Maybe you could use "%zu%c" and check the count is 1 - but I bet some static checker won't like that.

Yes, that would be stronger, since it would reject trailing garbage. But for a selftest this is probably sufficient: switching to size_t and parsing with "%zu" already avoids the int truncation issue.

@Andrew Morton <[email protected]>,

Hi Andrew, I noticed you have addedthe patches to your mm-new branch, Let me know if you prefer the "%zu%c" enhancement in a new version.

Signature · 2 lines
Regards,
Li Wang
#5 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

Quoted 14 lines · On Mon, 22 Dec 2025 09:45:41 +0800 Li Wang <[email protected]> wrote:
Quoted 11 lines · David Laight
Quoted 2 lines · On Sun, 21 Dec 2025 20:26:37 +0800 Li Wang <[email protected]> wrote:

write_to_hugetlbfs currently parses the -s size argument with atoi() into an int. This silently accepts malformed input, cannot report

overflow,

Quoted 1 line

and can truncate large sizes.

And sscanf() will just ignore invalid trailing characters. Probably much the same as atoi() apart from a leading '-'.

Quoted 7 lines
Quoted 3 lines

Maybe you could use "%zu%c" and check the count is 1 - but I bet some static checker won't like that.

Yes, that would be stronger, since it would reject trailing garbage. But for a selftest this is probably sufficient: switching to size_t and parsing with "%zu" already avoids the int truncation issue.

Have you checked at what does sscanf() does with an overlong digit string? I'd guess that it just processes all the digits and then masks the result to fix (like the kernel one does).

It reality scanf() is 'not the function you are lookign for'.

IIRC the 'SUS' (used to) say that this was absolutely fine for command line parsing for 'standard utilities'.

It is best to use strtoul() and check the 'end' character is '\0'.

David

Quoted 7 lines

@Andrew Morton <[email protected]>,

Hi Andrew, I noticed you have addedthe patches to your mm-new branch, Let me know if you prefer the "%zu%c" enhancement in a new version.

author
#6 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

Quoted 11 lines · David Laight
Quoted 7 lines
Quoted 3 lines

Maybe you could use "%zu%c" and check the count is 1 - but I bet some static checker won't like that.

Yes, that would be stronger, since it would reject trailing garbage. But for a selftest this is probably sufficient: switching to size_t and parsing with "%zu" already avoids the int truncation issue.

Have you checked at what does sscanf() does with an overlong digit string? I'd guess that it just processes all the digits and then masks the result to fix (like the kernel one does).

It will truncate the number to the size SIZE_MAX.

From my test:

# ./write_to_hugetlbfs -m 0 -s 99999999999999999999999999 -p /mnt/huge/test -o
Writing to this path: /mnt/huge/test
Writing this size: 18446744073709551615    <---------- SIZE_MAX
Populating.
Not writing to memory.
Using method=0
Shared mapping.
RESERVE mapping.
Allocating using HUGETLBFS.
write_to_hugetlbfs: Error mapping the file: Invalid argument
Quoted 6 lines

It reality scanf() is 'not the function you are lookign for'.

IIRC the 'SUS' (used to) say that this was absolutely fine for command line parsing for 'standard utilities'.

It is best to use strtoul() and check the 'end' character is '\0'.

Hmm, that sounds like we need to go back to the patch V1 [1] method. But I am not sure, @Andrew Morton, do you think so?

tools/testing/selftests/mm/write_to_hugetlbfs.c +9 -2
@@ -86,10 +86,17 @@ int main(int argc, char **argv)
        while ((c = getopt(argc, argv, "s:p:m:owlrn")) != -1) {
                switch (c) {
                case 's':
-                       if (sscanf(optarg, "%zu", &size) != 1) {
-                               perror("Invalid -s.");
+                       char *end = NULL;
+                       unsigned long tmp = strtoul(optarg, &end, 10);
+                       if (errno || end == optarg || *end != '\0') {
+                               perror("Invalid -s size");
                                exit_usage();
                        }
+                       if (tmp == 0) {
+                               perror("size not found");
+                               exit_usage();
+                       }
+                       size = (size_t)tmp;
                        break;
                case 'p':
 

[1] https://lore.kernel.org/linux-kselftest/[email protected]/T/#m5a5765349dedfda1ed66c54b8cab7af184bff371

--
Regards,
Li Wang

maintainer
#7 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

Quoted 21 lines · On Mon, 22 Dec 2025 18:56:49 +0800 Li Wang <[email protected]> wrote:
Quoted 6 lines

It reality scanf() is 'not the function you are lookign for'.

IIRC the 'SUS' (used to) say that this was absolutely fine for command line parsing for 'standard utilities'.

It is best to use strtoul() and check the 'end' character is '\0'.

Hmm, that sounds like we need to go back to the patch V1 [1] method. But I am not sure, @Andrew Morton, do you think so?

tools/testing/selftests/mm/write_to_hugetlbfs.c +3 -2
@@ -86,10 +86,17 @@ int main(int argc, char **argv)
        while ((c = getopt(argc, argv, "s:p:m:owlrn")) != -1) {
                switch (c) {
                case 's':
-                       if (sscanf(optarg, "%zu", &size) != 1) {
-                               perror("Invalid -s.");
+                       char *end = NULL;
+                       unsigned long tmp = strtoul(optarg, &end, 10);
+                       if (errno || end == optarg || *end != '\0') {

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 101

Quoted 10 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +6 -0
+                               perror("Invalid -s size");
                                exit_usage();
                        }
+                       if (tmp == 0) {
+                               perror("size not found");
+                               exit_usage();
+                       }
+                       size = (size_t)tmp;
                        break;
                case 'p':

Geeze guys, it's just a selftest.

hp2:/usr/src/linux-6.19-rc1> grep -r scanf tools/testing/selftests | wc -l 177

if your command line breaks the selftest, fix your command line?

author
#8 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

Quoted 29 lines · Andrew Morton
Quoted 16 lines
Quoted 1 line

It is best to use strtoul() and check the 'end' character is '\0'.

Hmm, that sounds like we need to go back to the patch V1 [1] method. But I am not sure, @Andrew Morton, do you think so?

tools/testing/selftests/mm/write_to_hugetlbfs.c +3 -2
@@ -86,10 +86,17 @@ int main(int argc, char **argv)
        while ((c = getopt(argc, argv, "s:p:m:owlrn")) != -1) {
                switch (c) {
                case 's':
-                       if (sscanf(optarg, "%zu", &size) != 1) {
-                               perror("Invalid -s.");
+                       char *end = NULL;
+                       unsigned long tmp = strtoul(optarg, &end, 10);
+                       if (errno || end == optarg || *end != '\0') {

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 101

Quoted 10 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +6 -0
+                               perror("Invalid -s size");
                                exit_usage();
                        }
+                       if (tmp == 0) {
+                               perror("size not found");
+                               exit_usage();
+                       }
+                       size = (size_t)tmp;
                        break;
                case 'p':

Geeze guys, it's just a selftest.

Quoted 4 lines

hp2:/usr/src/linux-6.19-rc1> grep -r scanf tools/testing/selftests | wc -l 177

if your command line breaks the selftest, fix your command line?

Yes, I am ok with sscanf() :-).

In fact, write_to hugetlbfs currently only accepts arguments from charge_reserved_hugetlb.sh, and the way the '-s' is used is not very diverse.

--
Regards,
Li Wang

#9 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

Quoted 7 lines · On Tue, 23 Dec 2025 10:41:22 +0800 Li Wang <[email protected]> wrote:
Quoted 5 lines · Andrew Morton
Quoted 5 lines
Quoted 1 line

It is best to use strtoul() and check the 'end' character is '\0'.

Hmm, that sounds like we need to go back to the patch V1 [1] method. But I am not sure, @Andrew Morton, do you think so?

Quoted 9 lines
Quoted 9 lines

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 89

Quoted 9 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +1 -2
@@ -86,10 +86,17 @@ int main(int argc, char **argv)
        while ((c = getopt(argc, argv, "s:p:m:owlrn")) != -1) {
                switch (c) {
                case 's':
-                       if (sscanf(optarg, "%zu", &size) != 1) {
-                               perror("Invalid -s.");
+                       char *end = NULL;

Initialiser not needed.

Quoted 2 lines
Quoted 2 lines

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 91

Quoted 2 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +2 -0
+                       unsigned long tmp = strtoul(optarg, &end, 10);
+                       if (errno || end == optarg || *end != '\0') {

I doubt that use of errno is correct.
Library functions that set errno on error don't set it to zero. The only test needed there is *end != '\'.
(end == optarg will be picked up by size == 0 later - if that is actually needed to stop things breaking.)

Quoted 4 lines
Quoted 4 lines

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 95

Quoted 4 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +2 -0
+                               perror("Invalid -s size");
                                exit_usage();
                        }
+                       if (tmp == 0) {

No point checking for zero before the assigning the 'unsigned long' to 'size_t'. So the result of strtoul() can just be just assigned to 'size'. (Ignoring the fact that size_t will be unsigned long.)

Quoted 7 lines
Quoted 7 lines
Quoted 6 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +4 -0
+                               perror("size not found");
+                               exit_usage();
+                       }
+                       size = (size_t)tmp;
                        break;
                case 'p':  
Quoted 8 lines
Quoted 6 lines

Geeze guys, it's just a selftest.

hp2:/usr/src/linux-6.19-rc1> grep -r scanf tools/testing/selftests | wc -l 177

if your command line breaks the selftest, fix your command line?

Yes, I am ok with sscanf() :-).

What was wrong with atoi() ?
Or, at most, strtoul() with a check that *end == 0.

David

Quoted 9 lines

In fact, write_to hugetlbfs currently only accepts arguments from charge_reserved_hugetlb.sh, and the way the '-s' is used is not very diverse.

--
Regards,
Li Wang

author
#10 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

Quoted 12 lines · David Laight
Quoted 9 lines
Quoted 9 lines

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 89

Quoted 9 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +1 -2
@@ -86,10 +86,17 @@ int main(int argc, char **argv)
        while ((c = getopt(argc, argv, "s:p:m:owlrn")) != -1) {
                switch (c) {
                case 's':
-                       if (sscanf(optarg, "%zu", &size) != 1) {
-                               perror("Invalid -s.");
+                       char *end = NULL;

Initialiser not needed.

Quoted 8 lines
Quoted 2 lines
Quoted 2 lines

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 91

Quoted 2 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +2 -0
+                       unsigned long tmp = strtoul(optarg, &end, 10);
+                       if (errno || end == optarg || *end != '\0') {

I doubt that use of errno is correct.
Library functions that set errno on error don't set it to zero. The only test needed there is *end != '\'.
(end == optarg will be picked up by size == 0 later - if that is actually needed to stop things breaking.)

Good point!

Quoted 19 lines
Quoted 5 lines
Quoted 5 lines

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 95

Quoted 5 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +2 -0
+                               perror("Invalid -s size");
                                exit_usage();
                        }
+                       if (tmp == 0) {

No point checking for zero before the assigning the 'unsigned long' to 'size_t'. So the result of strtoul() can just be just assigned to 'size'. (Ignoring the fact that size_t will be unsigned long.)

Quoted 9 lines
Quoted 9 lines

tools/testing/selftests/mm/write_to_hugetlbfs.c int main(int argc, char **argv) · line 101

Quoted 6 lines
tools/testing/selftests/mm/write_to_hugetlbfs.c +4 -0
+                               perror("size not found");
+                               exit_usage();
+                       }
+                       size = (size_t)tmp;
                        break;
                case 'p':

Geeze guys, it's just a selftest.

Quoted 8 lines
Quoted 6 lines
Quoted 4 lines

hp2:/usr/src/linux-6.19-rc1> grep -r scanf tools/testing/selftests | wc -l 177

if your command line breaks the selftest, fix your command line?

Yes, I am ok with sscanf() :-).

What was wrong with atoi() ?

As the patch summary described, write_to_hugetlbfs previously parsed -s via atoi() into an int, which can overflow and print negative sizes. This problem was
found on our kernel-64k platform and

#./charge_reserved_hugetlb.sh -cgroup-v2
# -----------------------------------------
...

 # nr hugepages = 10
 # writing cgroup limit: 5368709120
 # writing reseravation limit: 5368709120
 ...
 # Writing to this path: /mnt/huge/test
 # Writing this size: -1610612736        <--------
Quoted 1 line

Or, at most, strtoul() with a check that *end == 0.

True, this will work as well, but as Andrew pointed, it is a tiny test issue and also resolved by sscanf() so let's just go with it.
(He has added patchset to the mm-new branch and queued it for linux-next)

If the issue remains controversial, you could send a separate patch later. Anyway, thank you for the review comments.

Signature · 2 lines
Regards,
Li Wang
#11 lore raw

Re: [PATCH v3 1/3] selftests/mm/write_to_hugetlbfs: parse -s as size_t

Quoted 13 lines · On Tue, 23 Dec 2025 17:29:38 +0800 Li Wang <[email protected]> wrote:
Quoted 1 line · David Laight

What was wrong with atoi() ?

As the patch summary described, write_to_hugetlbfs previously parsed -s via atoi() into an int, which can overflow and print negative sizes. This problem was
found on our kernel-64k platform and

#./charge_reserved_hugetlb.sh -cgroup-v2
# -----------------------------------------
...

Quoted 6 lines
 # nr hugepages = 10
 # writing cgroup limit: 5368709120
 # writing reseravation limit: 5368709120
 ...
 # Writing to this path: /mnt/huge/test
 # Writing this size: -1610612736        <--------

So the problem was that atoi() doesn't let you specify valid values over 2GB.
That isn't how I read the patch summary.
It read as though you were worried about detecting invalid input.

David

author
#12 lore raw

PATCH v3 2/3 selftests/mm/charge_reserved_hugetlb: drop mount size for hugetlbfs

In reply to Li Wang

charge_reserved_hugetlb.sh mounts a hugetlbfs instance at /mnt/huge with a fixed size of 256M. On systems with large base hugepages (e.g. 512MB), this is smaller than a single hugepage, so the hugetlbfs mount ends up with zero capacity (often visible as size=0 in mount output).

As a result, write_to_hugetlbfs fails with ENOMEM and the test can hang waiting for progress.

--- Error log ---

  # uname -r
  6.12.0-xxx.el10.aarch64+64k

#./charge_reserved_hugetlb.sh -cgroup-v2
# -----------------------------------------
...

  # nr hugepages = 10
  # writing cgroup limit: 5368709120
  # writing reseravation limit: 5368709120
  ...
  # write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
  # Waiting for hugetlb memory reservation to reach size 2684354560.
  # 0
  # Waiting for hugetlb memory reservation to reach size 2684354560.
  # 0
  ...
  # mount |grep /mnt/huge
  none on /mnt/huge type hugetlbfs (rw,relatime,seclabel,pagesize=512M,size=0)
  # grep -i huge /proc/meminfo
  ...
  HugePages_Total:      10
  HugePages_Free:       10
  HugePages_Rsvd:        0
  HugePages_Surp:        0
  Hugepagesize:     524288 kB
  Hugetlb:         5242880 kB

Drop the mount args with 'size=256M', so the filesystem capacity is sufficient regardless of HugeTLB page size.

Fixes 29750f71a9 ("hugetlb_cgroup: add hugetlb_cgroup reservation tests")
Cc David Hildenbrand <[email protected]>
Cc Mark Brown <[email protected]>
Cc Shuah Khan <[email protected]>
Cc Waiman Long <[email protected]>
---
 tools/testing/selftests/mm/charge_reserved_hugetlb.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +2 -2
index e1fe16bcbbe8..fa6713892d82 100755
@@ -290,7 +290,7 @@ function run_test() {
   setup_cgroup "hugetlb_cgroup_test" "$cgroup_limit" "$reservation_limit"
 
   mkdir -p /mnt/huge
-  mount -t hugetlbfs -o pagesize=${MB}M,size=256M none /mnt/huge
+  mount -t hugetlbfs -o pagesize=${MB}M none /mnt/huge
 
   write_hugetlbfs_and_get_usage "hugetlb_cgroup_test" "$size" "$populate" \
     "$write" "/mnt/huge/test" "$method" "$private" "$expect_failure" \
@@ -344,7 +344,7 @@ function run_multiple_cgroup_test() {
   setup_cgroup "hugetlb_cgroup_test2" "$cgroup_limit2" "$reservation_limit2"
 
   mkdir -p /mnt/huge
-  mount -t hugetlbfs -o pagesize=${MB}M,size=256M none /mnt/huge
+  mount -t hugetlbfs -o pagesize=${MB}M none /mnt/huge
 
   write_hugetlbfs_and_get_usage "hugetlb_cgroup_test1" "$size1" \
     "$populate1" "$write1" "/mnt/huge/test1" "$method" "$private" \
Signature · 1 line
2.49.0
Acked-by on v3 2/3
#13 lore raw

Re: [PATCH v3 2/3] selftests/mm/charge_reserved_hugetlb: drop mount size for hugetlbfs

Quoted 65 lines · Li Wang

charge_reserved_hugetlb.sh mounts a hugetlbfs instance at /mnt/huge with a fixed size of 256M. On systems with large base hugepages (e.g. 512MB), this is smaller than a single hugepage, so the hugetlbfs mount ends up with zero capacity (often visible as size=0 in mount output).

As a result, write_to_hugetlbfs fails with ENOMEM and the test can hang waiting for progress.

--- Error log ---

   # uname -r
   6.12.0-xxx.el10.aarch64+64k
   #./charge_reserved_hugetlb.sh -cgroup-v2
   # -----------------------------------------
   ...
   # nr hugepages = 10
   # writing cgroup limit: 5368709120
   # writing reseravation limit: 5368709120
   ...
   # write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   ...

   # mount |grep /mnt/huge
   none on /mnt/huge type hugetlbfs (rw,relatime,seclabel,pagesize=512M,size=0)

   # grep -i huge /proc/meminfo
   ...
   HugePages_Total:      10
   HugePages_Free:       10
   HugePages_Rsvd:        0
   HugePages_Surp:        0
   Hugepagesize:     524288 kB
   Hugetlb:         5242880 kB

Drop the mount args with 'size=256M', so the filesystem capacity is sufficient regardless of HugeTLB page size.

Fixes 29750f71a9 ("hugetlb_cgroup: add hugetlb_cgroup reservation tests")
Cc David Hildenbrand <[email protected]>
Cc Mark Brown <[email protected]>
Cc Shuah Khan <[email protected]>
Cc Waiman Long <[email protected]>
---
  tools/testing/selftests/mm/charge_reserved_hugetlb.sh | 4 ++--
  1 file changed, 2 insertions(+), 2 deletions(-)
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +1 -1
index e1fe16bcbbe8..fa6713892d82 100755
@@ -290,7 +290,7 @@ function run_test() {
    setup_cgroup "hugetlb_cgroup_test" "$cgroup_limit" "$reservation_limit"
 
    mkdir -p /mnt/huge
-  mount -t hugetlbfs -o pagesize=${MB}M,size=256M none /mnt/huge
+  mount -t hugetlbfs -o pagesize=${MB}M none /mnt/huge
 
    write_hugetlbfs_and_get_usage "hugetlb_cgroup_test" "$size" "$populate" \
      "$write" "/mnt/huge/test" "$method" "$private" "$expect_failure" \

tools/testing/selftests/mm/charge_reserved_hugetlb.sh function run_multiple_cgroup_test() { · line 350

Quoted 8 lines
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +1 -1
@@ -344,7 +344,7 @@ function run_multiple_cgroup_test() {
    setup_cgroup "hugetlb_cgroup_test2" "$cgroup_limit2" "$reservation_limit2"
 
    mkdir -p /mnt/huge
-  mount -t hugetlbfs -o pagesize=${MB}M,size=256M none /mnt/huge
+  mount -t hugetlbfs -o pagesize=${MB}M none /mnt/huge
 
    write_hugetlbfs_and_get_usage "hugetlb_cgroup_test1" "$size1" \
      "$populate1" "$write1" "/mnt/huge/test1" "$method" "$private" \
maintainer Acked-by on v3 2/3
#14 lore raw

Re: [PATCH v3 2/3] selftests/mm/charge_reserved_hugetlb: drop mount size for hugetlbfs

In reply to Li Wang
Quoted 38 lines · Li Wang

charge_reserved_hugetlb.sh mounts a hugetlbfs instance at /mnt/huge with a fixed size of 256M. On systems with large base hugepages (e.g. 512MB), this is smaller than a single hugepage, so the hugetlbfs mount ends up with zero capacity (often visible as size=0 in mount output).

As a result, write_to_hugetlbfs fails with ENOMEM and the test can hang waiting for progress.

--- Error log ---

   # uname -r
   6.12.0-xxx.el10.aarch64+64k
   #./charge_reserved_hugetlb.sh -cgroup-v2
   # -----------------------------------------
   ...
   # nr hugepages = 10
   # writing cgroup limit: 5368709120
   # writing reseravation limit: 5368709120
   ...
   # write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   ...

   # mount |grep /mnt/huge
   none on /mnt/huge type hugetlbfs (rw,relatime,seclabel,pagesize=512M,size=0)

   # grep -i huge /proc/meminfo
   ...
   HugePages_Total:      10
   HugePages_Free:       10
   HugePages_Rsvd:        0
   HugePages_Surp:        0
   Hugepagesize:     524288 kB
   Hugetlb:         5242880 kB
Quoted 4 lines

Drop the mount args with 'size=256M', so the filesystem capacity is sufficient regardless of HugeTLB page size.

Fixes 29750f71a9 ("hugetlb_cgroup: add hugetlb_cgroup reservation tests")

Likely Andrew should add a CC of stable

Signature · 3 lines
Cheers

David
maintainer
#15 lore raw

Re: [PATCH v3 2/3] selftests/mm/charge_reserved_hugetlb: drop mount size for hugetlbfs

Quoted 4 lines · On Mon, 22 Dec 2025 11:01:17 +0100 "David Hildenbrand (Red Hat)"…
Quoted 1 line
Fixes 29750f71a9 ("hugetlb_cgroup: add hugetlb_cgroup reservation tests")

Likely Andrew should add a CC of stable

yep, thanks.

author
#16 lore raw

PATCH v3 3/3 selftests/mm/charge_reserved_hugetlb.sh: add waits with timeout helper

In reply to Li Wang

The hugetlb cgroup usage wait loops in charge_reserved_hugetlb.sh were unbounded and could hang forever if the expected cgroup file value never appears (e.g. due to write_to_hugetlbfs in Error mapping).

--- Error log ---

  # uname -r
  6.12.0-xxx.el10.aarch64+64k
  # ls /sys/kernel/mm/hugepages/hugepages-*
  hugepages-16777216kB/  hugepages-2048kB/  hugepages-524288kB/

#./charge_reserved_hugetlb.sh -cgroup-v2
# -----------------------------------------
...

  # nr hugepages = 10
  # writing cgroup limit: 5368709120
  # writing reseravation limit: 5368709120
  ...
  # write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
  # Waiting for hugetlb memory reservation to reach size 2684354560.
  # 0
  # Waiting for hugetlb memory reservation to reach size 2684354560.
  # 0
  # Waiting for hugetlb memory reservation to reach size 2684354560.
  # 0
  # Waiting for hugetlb memory reservation to reach size 2684354560.
  # 0
  # Waiting for hugetlb memory reservation to reach size 2684354560.
  # 0
  # Waiting for hugetlb memory reservation to reach size 2684354560.
  # 0
  ...

Introduce a small helper, wait_for_file_value(), and use it for:
- waiting for reservation usage to drop to 0,
- waiting for reservation usage to reach a given size,
- waiting for fault usage to reach a given size.

This makes the waits consistent and adds a hard timeout (60 tries with 1s sleep) so the test fails instead of stalling indefinitely.

Cc David Hildenbrand <[email protected]>
Cc Mark Brown <[email protected]>
Cc Shuah Khan <[email protected]>
Cc Waiman Long <[email protected]>
---
 .../selftests/mm/charge_reserved_hugetlb.sh   | 51 +++++++++++--------
 1 file changed, 30 insertions(+), 21 deletions(-)
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +30 -21
index fa6713892d82..447769657634 100755
@@ -100,7 +100,7 @@ function setup_cgroup() {
   echo writing cgroup limit: "$cgroup_limit"
   echo "$cgroup_limit" >$cgroup_path/$name/hugetlb.${MB}MB.$fault_limit_file
 
-  echo writing reseravation limit: "$reservation_limit"
+  echo writing reservation limit: "$reservation_limit"
   echo "$reservation_limit" > \
     $cgroup_path/$name/hugetlb.${MB}MB.$reservation_limit_file
 
@@ -112,41 +112,50 @@ function setup_cgroup() {
   fi
 }
 
+function wait_for_file_value() {
+  local path="$1"
+  local expect="$2"
+  local max_tries=60
+
+  if [[ ! -r "$path" ]]; then
+    echo "ERROR: cannot read '$path', missing or permission denied"
+    return 1
+  fi
+
+  for ((i=1; i<=max_tries; i++)); do
+    local cur="$(cat "$path")"
+    if [[ "$cur" == "$expect" ]]; then
+      return 0
+    fi
+    echo "Waiting for $path to become '$expect' (current: '$cur') (try $i/$max_tries)"
+    sleep 1
+  done
+
+  echo "ERROR: timeout waiting for $path to become '$expect'"
+  return 1
+}
+
 function wait_for_hugetlb_memory_to_get_depleted() {
   local cgroup="$1"
   local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get depleted.
-  while [ $(cat $path) != 0 ]; do
-    echo Waiting for hugetlb memory to get depleted.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "0"
 }
 
 function wait_for_hugetlb_memory_to_get_reserved() {
   local cgroup="$1"
   local size="$2"
-
   local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get written.
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory reservation to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
 }
 
 function wait_for_hugetlb_memory_to_get_written() {
   local cgroup="$1"
   local size="$2"
-
   local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$fault_usage_file"
-  # Wait for hugetlbfs memory to get written.
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
 }
 
 function write_hugetlbfs_and_get_usage() {
Signature · 1 line
2.49.0
#17 lore raw

Re: [PATCH v3 3/3] selftests/mm/charge_reserved_hugetlb.sh: add waits with timeout helper

Quoted 124 lines · Li Wang

The hugetlb cgroup usage wait loops in charge_reserved_hugetlb.sh were unbounded and could hang forever if the expected cgroup file value never appears (e.g. due to write_to_hugetlbfs in Error mapping).

--- Error log ---

   # uname -r
   6.12.0-xxx.el10.aarch64+64k
   # ls /sys/kernel/mm/hugepages/hugepages-*
   hugepages-16777216kB/  hugepages-2048kB/  hugepages-524288kB/
   #./charge_reserved_hugetlb.sh -cgroup-v2
   # -----------------------------------------
   ...
   # nr hugepages = 10
   # writing cgroup limit: 5368709120
   # writing reseravation limit: 5368709120
   ...
   # write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   ...

Introduce a small helper, wait_for_file_value(), and use it for:
- waiting for reservation usage to drop to 0,
- waiting for reservation usage to reach a given size,
- waiting for fault usage to reach a given size.

This makes the waits consistent and adds a hard timeout (60 tries with 1s sleep) so the test fails instead of stalling indefinitely.

Cc David Hildenbrand <[email protected]>
Cc Mark Brown <[email protected]>
Cc Shuah Khan <[email protected]>
Cc Waiman Long <[email protected]>
---
  .../selftests/mm/charge_reserved_hugetlb.sh   | 51 +++++++++++--------
  1 file changed, 30 insertions(+), 21 deletions(-)
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +28 -16
index fa6713892d82..447769657634 100755
@@ -100,7 +100,7 @@ function setup_cgroup() {
    echo writing cgroup limit: "$cgroup_limit"
    echo "$cgroup_limit" >$cgroup_path/$name/hugetlb.${MB}MB.$fault_limit_file
 
-  echo writing reseravation limit: "$reservation_limit"
+  echo writing reservation limit: "$reservation_limit"
    echo "$reservation_limit" > \
      $cgroup_path/$name/hugetlb.${MB}MB.$reservation_limit_file
 
@@ -112,41 +112,50 @@ function setup_cgroup() {
    fi
  }
 
+function wait_for_file_value() {
+  local path="$1"
+  local expect="$2"
+  local max_tries=60
+
+  if [[ ! -r "$path" ]]; then
+    echo "ERROR: cannot read '$path', missing or permission denied"
+    return 1
+  fi
+
+  for ((i=1; i<=max_tries; i++)); do
+    local cur="$(cat "$path")"
+    if [[ "$cur" == "$expect" ]]; then
+      return 0
+    fi
+    echo "Waiting for $path to become '$expect' (current: '$cur') (try $i/$max_tries)"
+    sleep 1
+  done
+
+  echo "ERROR: timeout waiting for $path to become '$expect'"
+  return 1
+}
+
  function wait_for_hugetlb_memory_to_get_depleted() {
    local cgroup="$1"
    local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get depleted.
-  while [ $(cat $path) != 0 ]; do
-    echo Waiting for hugetlb memory to get depleted.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "0"
  }
 
  function wait_for_hugetlb_memory_to_get_reserved() {
    local cgroup="$1"
    local size="$2"
-
    local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get written.
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory reservation to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
  }
 
  function wait_for_hugetlb_memory_to_get_written() {
    local cgroup="$1"
    local size="$2"
-
    local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$fault_usage_file"
-  # Wait for hugetlbfs memory to get written.

tools/testing/selftests/mm/charge_reserved_hugetlb.sh function setup_cgroup() { · line 161

Quoted 10 lines
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +2 -5
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
  }
 
  function write_hugetlbfs_and_get_usage() {

wait_for_file_value() now return 0 onr success and 1 on timeout. However, none of the callers of the wait_for_hugetlb_memory* are checking their return values and acting accordingly. Are we expecting that the test will show failure because the waiting isn't completed or should we explicitly exit with ksft_fail (1) value?

Cheers,
Longman

author
#18 lore raw

Re: [PATCH v3 3/3] selftests/mm/charge_reserved_hugetlb.sh: add waits with timeout helper

Quoted 136 lines · Waiman Long
Quoted 133 lines · Li Wang

The hugetlb cgroup usage wait loops in charge_reserved_hugetlb.sh were unbounded and could hang forever if the expected cgroup file value never appears (e.g. due to write_to_hugetlbfs in Error mapping).

--- Error log ---

   # uname -r
   6.12.0-xxx.el10.aarch64+64k
   # ls /sys/kernel/mm/hugepages/hugepages-*
   hugepages-16777216kB/  hugepages-2048kB/  hugepages-524288kB/
   #./charge_reserved_hugetlb.sh -cgroup-v2
   # -----------------------------------------
   ...
   # nr hugepages = 10
   # writing cgroup limit: 5368709120
   # writing reseravation limit: 5368709120
   ...
   # write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   ...

Introduce a small helper, wait_for_file_value(), and use it for:
- waiting for reservation usage to drop to 0,
- waiting for reservation usage to reach a given size,
- waiting for fault usage to reach a given size.

This makes the waits consistent and adds a hard timeout (60 tries with 1s sleep) so the test fails instead of stalling indefinitely.

Cc David Hildenbrand <[email protected]>
Cc Mark Brown <[email protected]>
Cc Shuah Khan <[email protected]>
Cc Waiman Long <[email protected]>
---
  .../selftests/mm/charge_reserved_hugetlb.sh   | 51 +++++++++++--------
  1 file changed, 30 insertions(+), 21 deletions(-)
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +30 -21
index fa6713892d82..447769657634 100755
@@ -100,7 +100,7 @@ function setup_cgroup() {
    echo writing cgroup limit: "$cgroup_limit"
    echo "$cgroup_limit" >$cgroup_path/$name/hugetlb.${MB}MB.$fault_limit_file
 
-  echo writing reseravation limit: "$reservation_limit"
+  echo writing reservation limit: "$reservation_limit"
    echo "$reservation_limit" > \
      $cgroup_path/$name/hugetlb.${MB}MB.$reservation_limit_file
 
@@ -112,41 +112,50 @@ function setup_cgroup() {
    fi
  }
 
+function wait_for_file_value() {
+  local path="$1"
+  local expect="$2"
+  local max_tries=60
+
+  if [[ ! -r "$path" ]]; then
+    echo "ERROR: cannot read '$path', missing or permission denied"
+    return 1
+  fi
+
+  for ((i=1; i<=max_tries; i++)); do
+    local cur="$(cat "$path")"
+    if [[ "$cur" == "$expect" ]]; then
+      return 0
+    fi
+    echo "Waiting for $path to become '$expect' (current: '$cur') (try $i/$max_tries)"
+    sleep 1
+  done
+
+  echo "ERROR: timeout waiting for $path to become '$expect'"
+  return 1
+}
+
  function wait_for_hugetlb_memory_to_get_depleted() {
    local cgroup="$1"
    local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get depleted.
-  while [ $(cat $path) != 0 ]; do
-    echo Waiting for hugetlb memory to get depleted.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "0"
  }
 
  function wait_for_hugetlb_memory_to_get_reserved() {
    local cgroup="$1"
    local size="$2"
-
    local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get written.
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory reservation to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
  }
 
  function wait_for_hugetlb_memory_to_get_written() {
    local cgroup="$1"
    local size="$2"
-
    local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$fault_usage_file"
-  # Wait for hugetlbfs memory to get written.
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
  }
 
Quoted 7 lines

tools/testing/selftests/mm/charge_reserved_hugetlb.sh function setup_cgroup() { · line 161

Quoted 1 line
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +0 -0
  function write_hugetlbfs_and_get_usage() {

wait_for_file_value() now return 0 onr success and 1 on timeout. However, none of the callers of the wait_for_hugetlb_memory* are checking their return values and acting accordingly. Are we expecting that the test will show failure because the waiting isn't completed or should we explicitly exit with ksft_fail (1) value?

Hmm, it seems the test shouldn't exit too early.

As the wait_for_hugetlb_memory* is only trying 60s to examine the file value, if timeouted, we still need to keep going because the test requires CLEANUP work and exit/report from there.

The key point of each subtest is to save the '$write_result' value and examine it
which controls the whole test to exit.

e.g.

This is an intentional error test:

# ./charge_reserved_hugetlb.sh -cgroup-v2
CLEANUP DONE
...
Writing to this path: /mnt/huge/test
Writing this size: 2684354560
Not populating.
Not writing to memory.
Using method=0
Shared mapping.
RESERVE mapping.
Allocating using HUGETLBFS.
write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 1/60)
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 2/60)
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 3/60)
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 4/60)
...
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 60/60)
ERROR: timeout waiting for
/sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current to
become '2684354560'
After write:
hugetlb_usage=0
reserved_usage=0
0
0
Memory charged to hugtlb=0
Memory charged to reservation=0
expected (2684354560) != actual (0): Reserved memory not charged to
reservation usage.
CLEANUP DONE
Signature · 2 lines
Regards,
Li Wang
#19 lore raw

Re: [PATCH v3 3/3] selftests/mm/charge_reserved_hugetlb.sh: add waits with timeout helper

Quoted 184 lines · Li Wang
Quoted 135 lines · Waiman Long
Quoted 133 lines · Li Wang

The hugetlb cgroup usage wait loops in charge_reserved_hugetlb.sh were unbounded and could hang forever if the expected cgroup file value never appears (e.g. due to write_to_hugetlbfs in Error mapping).

--- Error log ---

    # uname -r
    6.12.0-xxx.el10.aarch64+64k
    # ls /sys/kernel/mm/hugepages/hugepages-*
    hugepages-16777216kB/  hugepages-2048kB/  hugepages-524288kB/
    #./charge_reserved_hugetlb.sh -cgroup-v2
    # -----------------------------------------
    ...
    # nr hugepages = 10
    # writing cgroup limit: 5368709120
    # writing reseravation limit: 5368709120
    ...
    # write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
    # Waiting for hugetlb memory reservation to reach size 2684354560.
    # 0
    # Waiting for hugetlb memory reservation to reach size 2684354560.
    # 0
    # Waiting for hugetlb memory reservation to reach size 2684354560.
    # 0
    # Waiting for hugetlb memory reservation to reach size 2684354560.
    # 0
    # Waiting for hugetlb memory reservation to reach size 2684354560.
    # 0
    # Waiting for hugetlb memory reservation to reach size 2684354560.
    # 0
    ...

Introduce a small helper, wait_for_file_value(), and use it for:
- waiting for reservation usage to drop to 0,
- waiting for reservation usage to reach a given size,
- waiting for fault usage to reach a given size.

This makes the waits consistent and adds a hard timeout (60 tries with 1s sleep) so the test fails instead of stalling indefinitely.

Cc David Hildenbrand<[email protected]>
Cc Mark Brown<[email protected]>
Cc Shuah Khan<[email protected]>
Cc Waiman Long<[email protected]>
---
   .../selftests/mm/charge_reserved_hugetlb.sh   | 51 +++++++++++--------
   1 file changed, 30 insertions(+), 21 deletions(-)
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +30 -21
index fa6713892d82..447769657634 100755
@@ -100,7 +100,7 @@ function setup_cgroup() {
     echo writing cgroup limit: "$cgroup_limit"
     echo "$cgroup_limit" >$cgroup_path/$name/hugetlb.${MB}MB.$fault_limit_file
 
-  echo writing reseravation limit: "$reservation_limit"
+  echo writing reservation limit: "$reservation_limit"
     echo "$reservation_limit" > \
       $cgroup_path/$name/hugetlb.${MB}MB.$reservation_limit_file
 
@@ -112,41 +112,50 @@ function setup_cgroup() {
     fi
   }
 
+function wait_for_file_value() {
+  local path="$1"
+  local expect="$2"
+  local max_tries=60
+
+  if [[ ! -r "$path" ]]; then
+    echo "ERROR: cannot read '$path', missing or permission denied"
+    return 1
+  fi
+
+  for ((i=1; i<=max_tries; i++)); do
+    local cur="$(cat "$path")"
+    if [[ "$cur" == "$expect" ]]; then
+      return 0
+    fi
+    echo "Waiting for $path to become '$expect' (current: '$cur') (try $i/$max_tries)"
+    sleep 1
+  done
+
+  echo "ERROR: timeout waiting for $path to become '$expect'"
+  return 1
+}
+
   function wait_for_hugetlb_memory_to_get_depleted() {
     local cgroup="$1"
     local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get depleted.
-  while [ $(cat $path) != 0 ]; do
-    echo Waiting for hugetlb memory to get depleted.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "0"
   }
 
   function wait_for_hugetlb_memory_to_get_reserved() {
     local cgroup="$1"
     local size="$2"
-
     local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get written.
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory reservation to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
   }
 
   function wait_for_hugetlb_memory_to_get_written() {
     local cgroup="$1"
     local size="$2"
-
     local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$fault_usage_file"
-  # Wait for hugetlbfs memory to get written.
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
   }
 
Quoted 6 lines

tools/testing/selftests/mm/charge_reserved_hugetlb.sh function setup_cgroup() { · line 161

Quoted 1 line
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +0 -0
   function write_hugetlbfs_and_get_usage() {

wait_for_file_value() now return 0 onr success and 1 on timeout. However, none of the callers of the wait_for_hugetlb_memory* are checking their return values and acting accordingly. Are we expecting that the test will show failure because the waiting isn't completed or should we explicitly exit with ksft_fail (1) value?

Hmm, it seems the test shouldn't exit too early.

As the wait_for_hugetlb_memory* is only trying 60s to examine the file value, if timeouted, we still need to keep going because the test requires CLEANUP work and exit/report from there.

The key point of each subtest is to save the '$write_result' value and examine it
which controls the whole test to exit.

e.g.

This is an intentional error test:

# ./charge_reserved_hugetlb.sh -cgroup-v2
CLEANUP DONE
...
Writing to this path: /mnt/huge/test
Writing this size: 2684354560
Not populating.
Not writing to memory.
Using method=0
Shared mapping.
RESERVE mapping.
Allocating using HUGETLBFS.
write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 1/60)
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 2/60)
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 3/60)
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 4/60)
...
Waiting for /sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current
to become '2684354560' (current: '0') (try 60/60)
ERROR: timeout waiting for
/sys/fs/cgroup/hugetlb_cgroup_test/hugetlb.512MB.rsvd.current to
become '2684354560'
After write:
hugetlb_usage=0
Quoted 8 lines
reserved_usage=0
0
0
Memory charged to hugtlb=0
Memory charged to reservation=0
expected (2684354560) != actual (0): Reserved memory not charged to
reservation usage.
CLEANUP DONE

Thank for running a test case. As long as the test will still report a failure, it will be fine with me. I just want to note that the return value value of wait_for_file_value() isn't currently used at all.

Cheers, Longman

maintainer Acked-by on v3 3/3
#20 lore raw

Re: [PATCH v3 3/3] selftests/mm/charge_reserved_hugetlb.sh: add waits with timeout helper

In reply to Li Wang
Quoted 124 lines · Li Wang

The hugetlb cgroup usage wait loops in charge_reserved_hugetlb.sh were unbounded and could hang forever if the expected cgroup file value never appears (e.g. due to write_to_hugetlbfs in Error mapping).

--- Error log ---

   # uname -r
   6.12.0-xxx.el10.aarch64+64k
   # ls /sys/kernel/mm/hugepages/hugepages-*
   hugepages-16777216kB/  hugepages-2048kB/  hugepages-524288kB/
   #./charge_reserved_hugetlb.sh -cgroup-v2
   # -----------------------------------------
   ...
   # nr hugepages = 10
   # writing cgroup limit: 5368709120
   # writing reseravation limit: 5368709120
   ...
   # write_to_hugetlbfs: Error mapping the file: Cannot allocate memory
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   # Waiting for hugetlb memory reservation to reach size 2684354560.
   # 0
   ...

Introduce a small helper, wait_for_file_value(), and use it for:
- waiting for reservation usage to drop to 0,
- waiting for reservation usage to reach a given size,
- waiting for fault usage to reach a given size.

This makes the waits consistent and adds a hard timeout (60 tries with 1s sleep) so the test fails instead of stalling indefinitely.

Cc David Hildenbrand <[email protected]>
Cc Mark Brown <[email protected]>
Cc Shuah Khan <[email protected]>
Cc Waiman Long <[email protected]>
---
  .../selftests/mm/charge_reserved_hugetlb.sh   | 51 +++++++++++--------
  1 file changed, 30 insertions(+), 21 deletions(-)
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +28 -16
index fa6713892d82..447769657634 100755
@@ -100,7 +100,7 @@ function setup_cgroup() {
    echo writing cgroup limit: "$cgroup_limit"
    echo "$cgroup_limit" >$cgroup_path/$name/hugetlb.${MB}MB.$fault_limit_file
 
-  echo writing reseravation limit: "$reservation_limit"
+  echo writing reservation limit: "$reservation_limit"
    echo "$reservation_limit" > \
      $cgroup_path/$name/hugetlb.${MB}MB.$reservation_limit_file
 
@@ -112,41 +112,50 @@ function setup_cgroup() {
    fi
  }
 
+function wait_for_file_value() {
+  local path="$1"
+  local expect="$2"
+  local max_tries=60
+
+  if [[ ! -r "$path" ]]; then
+    echo "ERROR: cannot read '$path', missing or permission denied"
+    return 1
+  fi
+
+  for ((i=1; i<=max_tries; i++)); do
+    local cur="$(cat "$path")"
+    if [[ "$cur" == "$expect" ]]; then
+      return 0
+    fi
+    echo "Waiting for $path to become '$expect' (current: '$cur') (try $i/$max_tries)"
+    sleep 1
+  done
+
+  echo "ERROR: timeout waiting for $path to become '$expect'"
+  return 1
+}
+
  function wait_for_hugetlb_memory_to_get_depleted() {
    local cgroup="$1"
    local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get depleted.
-  while [ $(cat $path) != 0 ]; do
-    echo Waiting for hugetlb memory to get depleted.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "0"
  }
 
  function wait_for_hugetlb_memory_to_get_reserved() {
    local cgroup="$1"
    local size="$2"
-
    local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$reservation_usage_file"
-  # Wait for hugetlbfs memory to get written.
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory reservation to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
  }
 
  function wait_for_hugetlb_memory_to_get_written() {
    local cgroup="$1"
    local size="$2"
-
    local path="$cgroup_path/$cgroup/hugetlb.${MB}MB.$fault_usage_file"
-  # Wait for hugetlbfs memory to get written.

tools/testing/selftests/mm/charge_reserved_hugetlb.sh function setup_cgroup() { · line 161

Quoted 10 lines
tools/testing/selftests/mm/charge_reserved_hugetlb.sh +2 -5
-  while [ $(cat $path) != $size ]; do
-    echo Waiting for hugetlb memory to reach size $size.
-    cat $path
-    sleep 0.5
-  done
+
+  wait_for_file_value "$path" "$size"
  }
 
  function write_hugetlbfs_and_get_usage() {

It would indeed be cleaner to propagate the error and make it clearer how we then cleanly abort the test.

But if it keeps working for the time beiing, fine with me

Signature · 3 lines
Cheers

David