[RFC] mm: Add KUNIT test for ptval_bytes_to_hex_str()
From: Anshuman Khandual
Date: Tue Sep 29 2026 - 08:07:08 EST
Add KUnit tests for ptval_bytes_to_hex_str() to verify conversion of 32-bit
64-bit, and 128-bit (when supported) page table entry values into printable
hexadecimal strings.
Add a new PTVAL_HEX_STR_KUNIT_TEST option to enable the tests.
Cc: Andrew Morton <akpm@xxxxxxxxxxxxxxxxxxxx>
Cc: David Hildenbrand <david@xxxxxxxxxx>
Cc: Lorenzo Stoakes <ljs@xxxxxxxxxx>
Cc: linux-kernel@xxxxxxxxxxxxxxx
Cc: linux-mm@xxxxxxxxx
Signed-off-by: Anshuman Khandual <anshuman.khandual@xxxxxxx>
---
This patch applies on v7.3-rc5 after the following series
https://lore.kernel.org/linux-mm/20260831054331.625505-1-anshuman.khandual@xxxxxxx/
mm/Kconfig | 11 +++
mm/Makefile | 1 +
mm/tests/ptval_hex_string_kunit.c | 111 ++++++++++++++++++++++++++++++
3 files changed, 123 insertions(+)
create mode 100644 mm/tests/ptval_hex_string_kunit.c
diff --git a/mm/Kconfig b/mm/Kconfig
index 604c58199acbf..f68bf26b98c83 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -1511,6 +1511,17 @@ config LAZY_MMU_MODE_KUNIT_TEST
If unsure, say N.
+config PTVAL_HEX_STR_KUNIT_TEST
+ bool "KUnit tests for pgtable entry string conversion" if !KUNIT_ALL_TESTS
+ depends on KUNIT
+ default KUNIT_ALL_TESTS
+ help
+ Enable this option to check that ptval_bytes_to_hex_str() is able
+ convert given pgtable entry value in bytes into hex strings which
+ could be printed.
+
+ If unsure, say N.
+
source "mm/damon/Kconfig"
endmenu
diff --git a/mm/Makefile b/mm/Makefile
index e7245cb88c665..d08b8bd01917b 100644
--- a/mm/Makefile
+++ b/mm/Makefile
@@ -147,4 +147,5 @@ obj-$(CONFIG_SHRINKER_DEBUG) += shrinker_debug.o
obj-$(CONFIG_EXECMEM) += execmem.o
obj-$(CONFIG_TMPFS_QUOTA) += shmem_quota.o
obj-$(CONFIG_LAZY_MMU_MODE_KUNIT_TEST) += tests/lazy_mmu_mode_kunit.o
+obj-$(CONFIG_PTVAL_HEX_STR_KUNIT_TEST) += tests/ptval_hex_string_kunit.o
obj-$(CONFIG_MEM_ALLOC_PROFILING) += alloc_tag.o
diff --git a/mm/tests/ptval_hex_string_kunit.c b/mm/tests/ptval_hex_string_kunit.c
new file mode 100644
index 0000000000000..45c203cfb49ae
--- /dev/null
+++ b/mm/tests/ptval_hex_string_kunit.c
@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <kunit/test.h>
+#include <linux/pgtable.h>
+
+struct ptval_str {
+ u64 val;
+ const char *str;
+};
+
+static struct ptval_str ptval_u32_tests[] = {
+ { .val = 0x1234abcd, .str = "1234abcd"},
+ { .val = 0x4455aabb, .str = "4455aabb"},
+ { .val = 0xccddeeff, .str = "ccddeeff"},
+ { .val = 0x12345678, .str = "12345678"},
+ { .val = 0x87654321, .str = "87654321"},
+ { .val = 0xaabbccdd, .str = "aabbccdd"},
+ { .val = 0xaa44cc66, .str = "aa44cc66"},
+ { .val = 0x11442266, .str = "11442266"},
+};
+
+static struct ptval_str ptval_u64_tests[] = {
+ { .val = 0x123456789abcdef0ULL, .str = "123456789abcdef0"},
+ { .val = 0x113355779abcdef0ULL, .str = "113355779abcdef0"},
+ { .val = 0xaabbccddeeffaabbULL, .str = "aabbccddeeffaabb"},
+ { .val = 0x1234567812345678ULL, .str = "1234567812345678"},
+ { .val = 0x0000000000000000ULL, .str = "0000000000000000"},
+ { .val = 0xffffffffffffffffULL, .str = "ffffffffffffffff"},
+ { .val = 0xaa00cc00ee00aa00ULL, .str = "aa00cc00ee00aa00"},
+ { .val = 0xc0ffeec0ffeedeadULL, .str = "c0ffeec0ffeedead"},
+};
+
+static void ptval_hex_str_u32(struct kunit *test)
+{
+ char buf[PTVAL_STR_MAX];
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(ptval_u32_tests); i++) {
+ u32 val = ptval_u32_tests[i].val;
+
+ ptval_bytes_to_hex_str(buf, sizeof(buf), &val, sizeof(val));
+ KUNIT_EXPECT_STREQ(test, buf, ptval_u32_tests[i].str);
+ }
+}
+
+static void ptval_hex_str_u64(struct kunit *test)
+{
+ char buf[PTVAL_STR_MAX];
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(ptval_u64_tests); i++) {
+ u64 val = ptval_u64_tests[i].val;
+
+ ptval_bytes_to_hex_str(buf, sizeof(buf), &val, sizeof(val));
+ KUNIT_EXPECT_STREQ(test, buf, ptval_u64_tests[i].str);
+ }
+}
+
+#ifdef __SIZEOF_INT128__
+struct ptval_128_str {
+ u128 val;
+ const char *str;
+};
+
+static struct ptval_128_str ptval_u128_tests[] = {
+ { .val = (u128)0x1122334455667788 << 64 |
+ (u128)0x123456789abcdef0, .str = "1122334455667788123456789abcdef0"},
+ { .val = (u128)0xaabbccddeeffaabb << 64 |
+ (u128)0xaabbccddeeffaabb, .str = "aabbccddeeffaabbaabbccddeeffaabb"},
+ { .val = (u128)0x0000000000000000 << 64 |
+ (u128)0x0000000000000000, .str = "00000000000000000000000000000000"},
+ { .val = (u128)0xffffffffffffffff << 64 |
+ (u128)0xffffffffffffffff, .str = "ffffffffffffffffffffffffffffffff"},
+ { .val = (u128)0x1234123412341234 << 64 |
+ (u128)0xabcdabcdabcdabcd, .str = "1234123412341234abcdabcdabcdabcd"},
+ { .val = (u128)0xc0ffeec0ffeedead << 64 |
+ (u128)0xc0ffeec0ffeedead, .str = "c0ffeec0ffeedeadc0ffeec0ffeedead"},
+ { .val = (u128)0xa5a5a5a5a55a5a5a << 64 |
+ (u128)0xa5a5a5a55a5a5a5a, .str = "a5a5a5a5a55a5a5aa5a5a5a5a55a5a5a"},
+ { .val = (u128)0x4455445544554455 << 64 |
+ (u128)0x2233223322332233, .str = "44554455445544552233223322332233"},
+};
+
+static void ptval_hex_str_u128(struct kunit *test)
+{
+ char buf[PTVAL_STR_MAX];
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(ptval_u128_tests); i++) {
+ u128 val = ptval_u128_tests[i].val;
+
+ ptval_bytes_to_hex_str(buf, sizeof(buf), &val, sizeof(val));
+ KUNIT_EXPECT_STREQ(test, buf, ptval_u128_tests[i].str);
+ }
+}
+#endif
+
+static struct kunit_case ptval_hex_str_tests[] = {
+ KUNIT_CASE(ptval_hex_str_u32),
+ KUNIT_CASE(ptval_hex_str_u64),
+#ifdef __SIZEOF_INT128__
+ KUNIT_CASE(ptval_hex_str_u128),
+#endif
+ {}
+};
+
+static struct kunit_suite ptval_hex_str_test_suite = {
+ .name = "ptval-hex-str",
+ .test_cases = ptval_hex_str_tests,
+};
+kunit_test_suite(ptval_hex_str_test_suite);
--
2.43.0