[RFC PATCH v2 12/13] mm/kwatch: add KUnit tests for the watch expression parser
From: Jinchao Wang <hidden>
Date: 2026-07-17 13:07:20
Also in:
linux-doc, linux-perf-users, lkml
Subsystem:
memory management, the rest · Maintainers:
Andrew Morton, Linus Torvalds
Cover base anchors (stack, argN, absolute address), positive and negative offsets, dereference chains, and rejection of malformed expressions (missing offsets, bad argument index, junk offsets). Signed-off-by: Jinchao Wang <redacted> --- mm/kwatch/.kunitconfig | 9 +++ mm/kwatch/Kconfig | 12 ++++ mm/kwatch/Makefile | 1 + mm/kwatch/deref_test.c | 146 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 168 insertions(+) create mode 100644 mm/kwatch/.kunitconfig create mode 100644 mm/kwatch/deref_test.c
diff --git a/mm/kwatch/.kunitconfig b/mm/kwatch/.kunitconfig
new file mode 100644
index 000000000000..7e977ddf0da1
--- /dev/null
+++ b/mm/kwatch/.kunitconfig@@ -0,0 +1,9 @@ +CONFIG_KUNIT=y +CONFIG_KWATCH=y +CONFIG_KWATCH_KUNIT_TEST=y +CONFIG_PERF_EVENTS=y +CONFIG_HAVE_HW_BREAKPOINT=y +CONFIG_HAVE_REINSTALL_HW_BREAKPOINT=y +CONFIG_KPROBES=y +CONFIG_KRETPROBES=y +CONFIG_PRINTK=y
diff --git a/mm/kwatch/Kconfig b/mm/kwatch/Kconfig
index 9daf6d4463ef..6ec9aa448ece 100644
--- a/mm/kwatch/Kconfig
+++ b/mm/kwatch/Kconfig@@ -14,3 +14,15 @@ config KWATCH exact instruction causing the illegal access. If unsure, say N. + +config KWATCH_KUNIT_TEST + bool "KUnit tests for KWatch" if !KUNIT_ALL_TESTS + # Built into the kwatch module, so it must be y; a bool cannot be + # enabled when KWATCH is a module (KWATCH=m would force it off). + depends on KWATCH=y && KUNIT + default KUNIT_ALL_TESTS + help + Enable KUnit tests for the KWatch kernel module. + This suite tests the core parsing logic, the pointer-chasing + finite state machine, and edge cases involving complex watchpoint + expressions. If unsure, say N.
diff --git a/mm/kwatch/Makefile b/mm/kwatch/Makefile
index 02d7917602f1..1d223d73b461 100644
--- a/mm/kwatch/Makefile
+++ b/mm/kwatch/Makefile@@ -1,3 +1,4 @@ obj-$(CONFIG_KWATCH) += kwatch.o kwatch-y := core.o deref.o task_ctx.o hwbp.o probe.o anchor.o +kwatch-$(CONFIG_KWATCH_KUNIT_TEST) += deref_test.o
diff --git a/mm/kwatch/deref_test.c b/mm/kwatch/deref_test.c
new file mode 100644
index 000000000000..35919dd24d92
--- /dev/null
+++ b/mm/kwatch/deref_test.c@@ -0,0 +1,146 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <kunit/test.h> +#include "kwatch.h" +#include <linux/string.h> + +static void kwatch_test_parse_deref_chain(struct kunit *test) +{ + struct kwatch_config cfg; + int ret; + + // Test 1: stack + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "stack"); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_STACK); + KUNIT_EXPECT_EQ(test, cfg.offset_count, 1); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], 0); + + // Test 2: arg1 + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg1"); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_ARG1); + KUNIT_EXPECT_EQ(test, cfg.offset_count, 1); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], 0); + + // Test 3: arg6+8 + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg6+8"); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_ARG6); + KUNIT_EXPECT_EQ(test, cfg.offset_count, 1); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], 8); + + // Test 4: arg2-16 + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg2-16"); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_ARG2); + KUNIT_EXPECT_EQ(test, cfg.offset_count, 1); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], -16); + + // Test 5: arg3->8 + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg3->8"); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_ARG3); + KUNIT_EXPECT_EQ(test, cfg.offset_count, 2); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], 0); + KUNIT_EXPECT_EQ(test, cfg.offsets[1], 8); + + // Test 6: arg4+8->16 + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg4+8->16"); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_ARG4); + KUNIT_EXPECT_EQ(test, cfg.offset_count, 2); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], 8); + KUNIT_EXPECT_EQ(test, cfg.offsets[1], 16); + + // Test 7: arg5-8->-16 + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg5-8->-16"); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_ARG5); + KUNIT_EXPECT_EQ(test, cfg.offset_count, 2); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], -8); + KUNIT_EXPECT_EQ(test, cfg.offsets[1], -16); + + // Test 8: stack->0->8 + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "stack->0->8"); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_STACK); + KUNIT_EXPECT_EQ(test, cfg.offset_count, 3); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], 0); + KUNIT_EXPECT_EQ(test, cfg.offsets[1], 0); + KUNIT_EXPECT_EQ(test, cfg.offsets[2], 8); + + // Test 9: arg1->+8 + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg1->+8"); + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_ARG1); + KUNIT_EXPECT_EQ(test, cfg.offset_count, 2); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], 0); + KUNIT_EXPECT_EQ(test, cfg.offsets[1], 8); + + // Test 9.1: arg1-> (implicit 0 should fail) + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg1->"); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + // Test 9.2: stack->->8 (implicit 0 should fail) + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "stack->->8"); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + // Test 10: Invalid base + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "invalid_base"); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + // Test 11: Invalid offset + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg1+abc"); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + // Test 12: Invalid arg + memset(&cfg, 0, sizeof(cfg)); + ret = kwatch_deref_parse(&cfg, "arg7"); + KUNIT_EXPECT_EQ(test, ret, -EINVAL); + + // Test 13: Absolute address. Use a width-appropriate literal: a 64-bit + // address would overflow unsigned long and fail kstrtoul() on 32-bit. + memset(&cfg, 0, sizeof(cfg)); +#if BITS_PER_LONG == 64 + ret = kwatch_deref_parse(&cfg, "0xffffffff81000000+8"); +#else + ret = kwatch_deref_parse(&cfg, "0xc1000000+8"); +#endif + KUNIT_EXPECT_EQ(test, ret, 0); + KUNIT_EXPECT_EQ(test, cfg.base, KWATCH_BASE_ABS_ADDR); +#if BITS_PER_LONG == 64 + KUNIT_EXPECT_EQ(test, cfg.sym_addr, 0xffffffff81000000UL); +#else + KUNIT_EXPECT_EQ(test, cfg.sym_addr, 0xc1000000UL); +#endif + KUNIT_EXPECT_EQ(test, cfg.offset_count, 1); + KUNIT_EXPECT_EQ(test, cfg.offsets[0], 8); +} + +static struct kunit_case kwatch_deref_test_cases[] = { + KUNIT_CASE(kwatch_test_parse_deref_chain), + {} +}; + +static struct kunit_suite kwatch_deref_test_suite = { + .name = "kwatch_deref", + .test_cases = kwatch_deref_test_cases, +}; + +kunit_test_suite(kwatch_deref_test_suite); + +MODULE_DESCRIPTION("KUnit tests for the KWatch watch expression parser"); +MODULE_LICENSE("GPL");
--
2.53.0