[LTP] [PATCH v11 0/2] shmctl03: Fix 32-bit compat mode failure

[LTP] [PATCH v11 0/2] shmctl03: Fix 32-bit compat mode failure

[Wei Gao via ltp]

v10-v11:
- Fix make check format issue

Wei Gao (2):
  lib: Extend tst_assert_ulong() with enum flags
  shmctl03: Fix 32-bit compat mode failure

 include/tst_assert.h                        | 34 ++++++++++++++++++---
 lib/tst_assert.c                            | 26 ++++++++++++----
 testcases/kernel/syscalls/shmctl/shmctl03.c | 13 ++++++--
 3 files changed, 59 insertions(+), 14 deletions(-)

-- 
2.55.0


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

[LTP] [PATCH v11 1/2] lib: Extend tst_assert_ulong() with enum flags

[Wei Gao via ltp]

Introduce enum tst_assert_flags (including TST_ASSERT_SATURATED_INT and
TST_ASSERT_TRUNC_32BIT) to tst_assert_ulong(). This enables type-safe
handling of 32-bit compat-mode truncation and clamping behaviors on
64-bit kernels when verifying sysfs/procfs limits.

Reviewed-by: Petr Vorel <pvorel@suse.cz>
Signed-off-by: Wei Gao <wegao@suse.com>
---
 include/tst_assert.h | 34 +++++++++++++++++++++++++++++-----
 lib/tst_assert.c     | 26 ++++++++++++++++++++------
 2 files changed, 49 insertions(+), 11 deletions(-)

diff --git a/include/tst_assert.h b/include/tst_assert.h
index dcb62dfea..ee4f735e4 100644
--- a/include/tst_assert.h
+++ b/include/tst_assert.h
@@ -21,14 +21,38 @@ void tst_assert_int(const char *file, const int lineno,
 #define TST_ASSERT_FILE_INT(path, prefix, val) \
 	tst_assert_file_int(__FILE__, __LINE__, path, prefix, val)
 
-/*
- * Same as tst_assert_int() but for unsigned long.
+/**
+ * enum tst_assert_flags - Bitwise flags for tst_assert_ulong().
+ *
+ * @TST_ASSERT_SATURATED_INT: Clamps the value at %INT_MAX if it exceeds it.
+ * @TST_ASSERT_TRUNC_32BIT: Keeps only the low 32 bits of the read value,
+ *                          truncating any higher bits.
+ */
+enum tst_assert_flags {
+	TST_ASSERT_SATURATED_INT = 1,
+	TST_ASSERT_TRUNC_32BIT   = 2,
+};
+
+/**
+ * tst_assert_ulong() - Assert that an unsigned long value in a file matches.
+ * @file: The source file of the assertion (usually __FILE__).
+ * @lineno: The source line number of the assertion (usually __LINE__).
+ * @path: Path to the sysfs or procfs file to read from.
+ * @val: The expected unsigned long value to compare against.
+ * @flags: Bitwise flags controlling how the read value is processed.
+ *         See &enum tst_assert_flags.
+ *
+ * This function reads an integer value from the file specified by @path
+ * and compares it with @val. It allows handling of 32-bit compat mode
+ * truncation/clamping on 64-bit systems via @flags.
  */
 void tst_assert_ulong(const char *file, const int lineno,
-                      const char *path, unsigned long val);
+		      const char *path, unsigned long val,
+		      enum tst_assert_flags flags);
 
-#define TST_ASSERT_ULONG(path, val) \
-	tst_assert_ulong(__FILE__, __LINE__, path, val)
+#define TST_ASSERT_ULONG(path, val, ...) \
+	tst_assert_ulong(__FILE__, __LINE__, path, val, \
+		TST_2_(dummy, ##__VA_ARGS__, 0))
 
 /*
  * Asserts that integer value stored in the prefix field of file pointed by path
diff --git a/lib/tst_assert.c b/lib/tst_assert.c
index b68bd5d39..04241d31b 100644
--- a/lib/tst_assert.c
+++ b/lib/tst_assert.c
@@ -23,18 +23,32 @@ void tst_assert_int(const char *file, const int lineno, const char *path, int va
 	tst_res_(file, lineno, TFAIL, "%s != %d got %d", path, val, sys_val);
 }
 
-void tst_assert_ulong(const char *file, const int lineno, const char *path, unsigned long val)
+void tst_assert_ulong(const char *file, const int lineno, const char *path,
+		      unsigned long val, enum tst_assert_flags flags)
 {
-	unsigned long sys_val;
-
-	safe_file_scanf(file, lineno, NULL, path, "%lu", &sys_val);
+	unsigned long long sys_val_64;
+	unsigned long expected_val;
+
+	safe_file_scanf(file, lineno, NULL, path, "%llu", &sys_val_64);
+
+	if (flags & TST_ASSERT_SATURATED_INT) {
+		if (sys_val_64 > (unsigned long long)INT_MAX)
+			expected_val = (unsigned long)INT_MAX;
+		else
+			expected_val = (unsigned long)sys_val_64;
+	} else if (flags & TST_ASSERT_TRUNC_32BIT) {
+		expected_val = (unsigned long)(sys_val_64 & 0xFFFFFFFFULL);
+	} else {
+		expected_val = (unsigned long)sys_val_64;
+	}
 
-	if (val == sys_val) {
+	if (val == expected_val) {
 		tst_res_(file, lineno, TPASS, "%s = %lu", path, val);
 		return;
 	}
 
-	tst_res_(file, lineno, TFAIL, "%s != %lu got %lu", path, val, sys_val);
+	tst_res_(file, lineno, TFAIL, "%s != %lu got %lu (raw: %llu)",
+		path, val, expected_val, sys_val_64);
 }
 
 void tst_assert_file_int(const char *file, const int lineno, const char *path, const char *prefix, int val)
-- 
2.55.0


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

[LTP] [PATCH v11 2/2] shmctl03: Fix 32-bit compat mode failure

[Wei Gao via ltp]

On 64-bit kernels, the default shmmax and shmall values often exceed
the range of a 32-bit unsigned long or are clipped differently by
the kernel's compat syscall layer than they appear in /proc.

Fix this by utilizing the new TST_ASSERT_ULONG() flags to properly
clamp and truncate the expected values under compat mode.

Link: https://lore.kernel.org/ltp/aJm5SBOaRoe1e0PB@yuki.lan/
Suggested-by: Cyril Hrubis <chrubis@suse.cz>
Reviewed-by: Andrea Cervesato <andrea.cervesato@suse.com>
Reviewed-by: Petr Vorel <pvorel@suse.cz>
Reported-by: Dan Carpenter <error27@gmail.com>
Signed-off-by: Wei Gao <wegao@suse.com>
---
 testcases/kernel/syscalls/shmctl/shmctl03.c | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/testcases/kernel/syscalls/shmctl/shmctl03.c b/testcases/kernel/syscalls/shmctl/shmctl03.c
index 9e1c2f099..cf021be4c 100644
--- a/testcases/kernel/syscalls/shmctl/shmctl03.c
+++ b/testcases/kernel/syscalls/shmctl/shmctl03.c
@@ -30,9 +30,16 @@ static void verify_ipcinfo(void)
 	else
 		tst_res(TPASS, "shmmin = 1");
 
-	TST_ASSERT_ULONG(PATH_KERN_SHMMAX, info.shmmax);
-	TST_ASSERT_ULONG(PATH_KERN_SHMMNI, info.shmmni);
-	TST_ASSERT_ULONG(PATH_KERN_SHMALL, info.shmall);
+	int c = tst_is_compat_mode();
+
+	/*
+	 * On 64-bit kernel, shmmax is clamped to INT_MAX for 32-bit
+	 * compat syscall, while shmmni and shmall are truncated
+	 * to 32-bit.
+	 */
+	TST_ASSERT_ULONG(PATH_KERN_SHMMAX, info.shmmax, c ? TST_ASSERT_SATURATED_INT : 0);
+	TST_ASSERT_ULONG(PATH_KERN_SHMMNI, info.shmmni, c ? TST_ASSERT_TRUNC_32BIT : 0);
+	TST_ASSERT_ULONG(PATH_KERN_SHMALL, info.shmall, c ? TST_ASSERT_TRUNC_32BIT : 0);
 }
 
 static struct tst_test test = {
-- 
2.55.0


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

Re: [LTP] lib: Extend tst_assert_ulong() with enum flags

[linuxtestproject.agent]

Hi Wei,

On Sep 3, 2026, Wei Gao wrote:
> lib: Extend tst_assert_ulong() with enum flags

--- [PATCH 1/2] ---

> +#define TST_ASSERT_ULONG(path, val, ...) \
> +	tst_assert_ulong(__FILE__, __LINE__, path, val, \
> +		TST_2_(dummy, ##__VA_ARGS__, 0))

TST_ASSERT_ULONG is a modified public macro but lacks the required
kernel-doc comment. Please document its optional flags argument and the
zero-flags default at the macro itself.

Verdict - Needs revision

---
Note:

The agent can sometimes produce false positives although often its
findings are genuine. If you find issues with the review, please
comment this email or ignore the suggestions.

Regards,
LTP AI Reviewer

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

Re: [LTP] [PATCH v11 1/2] lib: Extend tst_assert_ulong() with enum flags

[Andrea Cervesato via ltp]

H Wei,

I was re-checking the whole patch-set and it looks a bit overengineered
from my point of view. A few points below.

> +enum tst_assert_flags {
> +	TST_ASSERT_SATURATED_INT = 1,
> +	TST_ASSERT_TRUNC_32BIT   = 2,
> +};

Adding new flags for the whole LTP core library trying to fix a single
test is not a good idea in general. Also, TST_ASSERT_TRUNC_32BIT is
probably not needed.

> +	safe_file_scanf(file, lineno, NULL, path, "%llu", &sys_val_64);

This is the real fix. Read below.

> +
> +	if (flags & TST_ASSERT_SATURATED_INT) {
> +		if (sys_val_64 > (unsigned long long)INT_MAX)
> +			expected_val = (unsigned long)INT_MAX;
> +		else
> +			expected_val = (unsigned long)sys_val_64;
> +	} else if (flags & TST_ASSERT_TRUNC_32BIT) {

In 32bit compat mode `unsigned long` becomes 32bit, so we can simply do:

void tst_assert_ulong(const char *file, const int lineno, const char *path, unsigned long val)
{
	unsigned long long sys_val;

	safe_file_scanf(file, lineno, NULL, path, "%llu", &sys_val);

	if (val == (unsigned long)sys_val) {
		tst_res_(file, lineno, TPASS, "%s = %lu", path, val);
		return;
	}

	tst_res_(file, lineno, TFAIL, "%s != %lu got %lu",
		path, val, (unsigned long)sys_val);
}

And then, inside the test:

	if (tst_is_compat_mode() && info.shmmax == INT_MAX)
		tst_res(TPASS, "shmmax clamped to INT_MAX in compat mode");
	else
		TST_ASSERT_ULONG(PATH_KERN_SHMMAX, info.shmmax);

	TST_ASSERT_ULONG(PATH_KERN_SHMMNI, info.shmmni);
	TST_ASSERT_ULONG(PATH_KERN_SHMALL, info.shmall);


Please verify if this is working anyway. We can probably fix the
whole patch-set with a couple of lines instead of defining
redundant flags and specific code for a single test.

Regards,
--
Andrea Cervesato
SUSE QE Automation Engineer Linux
andrea.cervesato@suse.com

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

Re: [LTP] [PATCH v11 1/2] lib: Extend tst_assert_ulong() with enum flags

[Wei Gao via ltp]

On Fri, Sep 04, 2026 at 08:51:06AM +0000, Andrea Cervesato wrote:
> H Wei,
> 
> I was re-checking the whole patch-set and it looks a bit overengineered
> from my point of view. A few points below.
> 
> > +enum tst_assert_flags {
> > +	TST_ASSERT_SATURATED_INT = 1,
> > +	TST_ASSERT_TRUNC_32BIT   = 2,
> > +};
> 
> Adding new flags for the whole LTP core library trying to fix a single
> test is not a good idea in general. Also, TST_ASSERT_TRUNC_32BIT is
> probably not needed.

But this is follow Cyril's suggestion:
https://lore.kernel.org/ltp/aJm5SBOaRoe1e0PB@yuki.lan/

> 
> > +	safe_file_scanf(file, lineno, NULL, path, "%llu", &sys_val_64);
> 
> This is the real fix. Read below.
> 
> > +
> > +	if (flags & TST_ASSERT_SATURATED_INT) {
> > +		if (sys_val_64 > (unsigned long long)INT_MAX)
> > +			expected_val = (unsigned long)INT_MAX;
> > +		else
> > +			expected_val = (unsigned long)sys_val_64;
> > +	} else if (flags & TST_ASSERT_TRUNC_32BIT) {
> 
> In 32bit compat mode `unsigned long` becomes 32bit, so we can simply do:
> 
> void tst_assert_ulong(const char *file, const int lineno, const char *path, unsigned long val)
> {
> 	unsigned long long sys_val;
> 
> 	safe_file_scanf(file, lineno, NULL, path, "%llu", &sys_val);
> 
> 	if (val == (unsigned long)sys_val) {
> 		tst_res_(file, lineno, TPASS, "%s = %lu", path, val);
> 		return;
> 	}
> 
> 	tst_res_(file, lineno, TFAIL, "%s != %lu got %lu",
> 		path, val, (unsigned long)sys_val);
> }
> 
> And then, inside the test:
> 
> 	if (tst_is_compat_mode() && info.shmmax == INT_MAX)
> 		tst_res(TPASS, "shmmax clamped to INT_MAX in compat mode");
> 	else
> 		TST_ASSERT_ULONG(PATH_KERN_SHMMAX, info.shmmax);
> 
> 	TST_ASSERT_ULONG(PATH_KERN_SHMMNI, info.shmmni);
> 	TST_ASSERT_ULONG(PATH_KERN_SHMALL, info.shmall);
> 
> 
> Please verify if this is working anyway. We can probably fix the
> whole patch-set with a couple of lines instead of defining
> redundant flags and specific code for a single test.
> 
> Regards,
> --
> Andrea Cervesato
> SUSE QE Automation Engineer Linux
> andrea.cervesato@suse.com

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