shmctl03: Fix 32-bit compat mode failure
v9 cover shmctl03: Fix 32-bit compat mode failure
v8->v9:
- use enum for type of tst_assert_flags
- update comments format
Wei Gao (2):
lib: Extend tst_assert_ulong() with enum flags
shmctl03: Fix 32-bit compat mode failure
include/tst_assert.h | 36 ++++++++++++++++++--- lib/tst_assert.c | 26 +++++++++++---- testcases/kernel/syscalls/shmctl/shmctl03.c | 13 ++++++-- 3 files changed, 61 insertions(+), 14 deletions(-)
Signature · 5 lines
2.55.0 -- Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v9 1/2 lib: Extend tst_assert_ulong() with enum flags
Introduce enum tst_assert_flags (including TST_ASSERT_NONE, 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.
--- include/tst_assert.h | 36 +++++++++++++++++++++++++++++++----- lib/tst_assert.c | 26 ++++++++++++++++++++------ 2 files changed, 51 insertions(+), 11 deletions(-)
include/tst_assert.h +31 -5
@@ -21,14 +21,40 @@ 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 - Flags for tst_assert_ulong(). +* +* @TST_ASSERT_NONE: No flags, default direct comparison. +* @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_NONE =0x00 , +TST_ASSERT_SATURATED_INT =0x01 , +TST_ASSERT_TRUNC_32BIT =0x02 , +}; + +/** +* 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__, TST_ASSERT_NONE))/* * Asserts that integer value stored in the prefix field of file pointed by path
lib/tst_assert.c +20 -6
@@ -23,18 +23,32 @@ void tst_assert_int(const char *file, const int lineno, const char *path, int vatst_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)
Signature · 5 lines
2.55.0 -- Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] lib: Extend tst_assert_ulong() with enum flags
Hi Wei,
Quoted 1 line · Wei Gao
lib: Extend
tst_assert_ulong()with enum flags
--- [PATCH 1/2] ---
Quoted 3 lines
#define TST_ASSERT_ULONG(path, val, ...) \ tst_assert_ulong(__FILE__, __LINE__, path, val, \ TST_2_(dummy, ##__VA_ARGS__, TST_ASSERT_NONE))
The modified public TST_ASSERT_ULONG() macro needs a kernel-doc comment documenting its optional flags argument.
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
Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
Re: [LTP] [PATCH v9 1/2] lib: Extend tst_assert_ulong() with enum flags
In reply to Wei Gao via ltpHi Wei,
Quoted 17 lines
Introduce enum
tst_assert_flags(includingTST_ASSERT_NONE,TST_ASSERT_SATURATED_INT, andTST_ASSERT_TRUNC_32BIT) totst_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.Signed-off-by Wei Gao <[email protected]>--- include/tst_assert.h | 36 +++++++++++++++++++++++++++++++----- lib/tst_assert.c | 26 ++++++++++++++++++++------ 2 files changed, 51 insertions(+), 11 deletions(-)include/tst_assert.h +0
-0
include/tst_assert.h void tst_assert_int(const char *file, const int lineno, · line 25
Quoted 7 lines
include/tst_assert.h +2
-2@@ -21,14 +21,40 @@ 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 - Flags for tst_assert_ulong().
nit: I'd use "Bitwise flags" as you write below.
include/tst_assert.h void tst_assert_int(const char *file, const int lineno, · line 33
Quoted 8 lines
include/tst_assert.h +8
-0+* +* @TST_ASSERT_NONE: No flags, default direct comparison. +* @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_NONE =0x00 ,
IMHO TST_ASSERT_NONE is overkill, I'd just use 0. But others might have a different opinion.
include/tst_assert.h void tst_assert_int(const char *file, const int lineno, · line 35
Quoted 2 lines
include/tst_assert.h +2
-0+TST_ASSERT_SATURATED_INT =0x01 , + TST_ASSERT_TRUNC_32BIT = 0x02,
Also, I'd use decimal numbers instead of hexadecimal when we have just 3 values (specially 0x00 looks really strange).
The rest LGTM.
Kind regards,
Petr
Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
PATCH v9 2/2 shmctl03: Fix 32-bit compat mode failure
In reply to Wei Gao via ltpOn 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.
--- testcases/kernel/syscalls/shmctl/shmctl03.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
testcases/kernel/syscalls/shmctl/shmctl03.c +10 -3
@@ -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 :TST_ASSERT_NONE ); +TST_ASSERT_ULONG (PATH_KERN_SHMMNI , info.shmmni, c ?TST_ASSERT_TRUNC_32BIT :TST_ASSERT_NONE ); +TST_ASSERT_ULONG (PATH_KERN_SHMALL , info.shmall, c ?TST_ASSERT_TRUNC_32BIT :TST_ASSERT_NONE ); }static struct tst_test test = {
Signature · 5 lines
2.55.0 -- Mailing list info: https://lists.linux.it/listinfo/ltp
Hi Wei,
Quoted 6 lines
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.
...
testcases/kernel/syscalls/shmctl/shmctl03.c static void verify_ipcinfo(void) · line 42
Quoted 13 lines
testcases/kernel/syscalls/shmctl/shmctl03.c +10
-3-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 :TST_ASSERT_NONE ); +TST_ASSERT_ULONG (PATH_KERN_SHMMNI , info.shmmni, c ?TST_ASSERT_TRUNC_32BIT :TST_ASSERT_NONE ); +TST_ASSERT_ULONG (PATH_KERN_SHMALL , info.shmall, c ?TST_ASSERT_TRUNC_32BIT :TST_ASSERT_NONE );
Obviously correct (with the fact I already noted, that I'd use 0 instead adding TST_ASSERT_NONE into enum).
Kind regards,
Petr
Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp
Hi all,
[ Cc Dan's actual address, Linaro one no longer works ]
Quoted 11 lines
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.Suggested-by Cyril Hrubis <[email protected]>Reviewed-by Andrea Cervesato <[email protected]>Reported-by Dan Carpenter <[email protected]>
Quoted 29 lines
Signed-off-by Wei Gao <[email protected]>--- testcases/kernel/syscalls/shmctl/shmctl03.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)testcases/kernel/syscalls/shmctl/shmctl03.c +10
-3@@ -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 :TST_ASSERT_NONE ); +TST_ASSERT_ULONG (PATH_KERN_SHMMNI , info.shmmni, c ?TST_ASSERT_TRUNC_32BIT :TST_ASSERT_NONE ); +TST_ASSERT_ULONG (PATH_KERN_SHMALL , info.shmall, c ?TST_ASSERT_TRUNC_32BIT :TST_ASSERT_NONE ); }static struct tst_test test = {
Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp