* [PATCH 1/3] rv/reactors: fix lockdep "Invalid wait context" in rv_react()
2026-06-15 16:44 [PATCH 0/3] rv/reactors: fix lockdep warning and add KUnit tests wen.yang
@ 2026-06-15 16:44 ` wen.yang
2026-06-15 16:44 ` [PATCH 2/3] rv/reactors: add KUnit tests for reactor_printk wen.yang
2026-06-15 16:44 ` [PATCH 3/3] rv/reactors: add KUnit tests for reactor_panic wen.yang
2 siblings, 0 replies; 4+ messages in thread
From: wen.yang @ 2026-06-15 16:44 UTC (permalink / raw)
To: Gabriele Monaco
Cc: Nam Cao, linux-trace-kernel, linux-kernel, Wen Yang,
Thomas Weißschuh
From: Wen Yang <wen.yang@linux.dev>
The DEFINE_WAIT_OVERRIDE_MAP() macro creates a lockdep map with
wait_type_inner = LD_WAIT_CONFIG, which inherits the outer context's
wait type. When rv_react() is called from a LD_WAIT_FREE context
(e.g., a KUnit test with busy-wait), and the reactor callback triggers
a timer interrupt during the busy-loop, the interrupt exit path attempts
to schedule (preempt_schedule_irq -> __schedule -> rq->__lock), which is
LD_WAIT_SPIN. Lockdep then reports:
[ BUG: Invalid wait context ]
context-{5:5}
1 lock held by kunit_try_catch/209:
#0: rv_react_map-wait-type-override at rv_react+0x9d/0xf0
The wait_type_override map allowed the outer LD_WAIT_FREE to propagate
inward, but scheduling from an interrupt is LD_WAIT_SPIN, violating the
constraint.
Fix by explicitly setting wait_type_inner = LD_WAIT_SPIN, which is the
tightest constraint rv_react() callbacks must satisfy: they may not
sleep (LD_WAIT_SLEEP) or use mutexes, but can use spinlocks and be
interrupted. This matches the documented LD_WAIT_FREE constraint.
Fixes: 69d8895cb9a9 ("rv: Add explicit lockdep context for reactors")
Signed-off-by: Wen Yang <wen.yang@linux.dev>
Cc: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
kernel/trace/rv/rv_reactors.c | 8 +++++++-
1 file changed, 7 insertions(+), 1 deletion(-)
diff --git a/kernel/trace/rv/rv_reactors.c b/kernel/trace/rv/rv_reactors.c
index 460af07f7aba..423f843bbd68 100644
--- a/kernel/trace/rv/rv_reactors.c
+++ b/kernel/trace/rv/rv_reactors.c
@@ -465,7 +465,13 @@ int init_rv_reactors(struct dentry *root_dir)
void rv_react(struct rv_monitor *monitor, const char *msg, ...)
{
- static DEFINE_WAIT_OVERRIDE_MAP(rv_react_map, LD_WAIT_FREE);
+#ifdef CONFIG_LOCKDEP
+ static struct lockdep_map rv_react_map = {
+ .name = "rv_react",
+ .wait_type_outer = LD_WAIT_FREE,
+ .wait_type_inner = LD_WAIT_SPIN,
+ };
+#endif
va_list args;
if (!rv_reacting_on() || !monitor->react)
--
2.25.1
^ permalink raw reply related [flat|nested] 4+ messages in thread* [PATCH 2/3] rv/reactors: add KUnit tests for reactor_printk
2026-06-15 16:44 [PATCH 0/3] rv/reactors: fix lockdep warning and add KUnit tests wen.yang
2026-06-15 16:44 ` [PATCH 1/3] rv/reactors: fix lockdep "Invalid wait context" in rv_react() wen.yang
@ 2026-06-15 16:44 ` wen.yang
2026-06-15 16:44 ` [PATCH 3/3] rv/reactors: add KUnit tests for reactor_panic wen.yang
2 siblings, 0 replies; 4+ messages in thread
From: wen.yang @ 2026-06-15 16:44 UTC (permalink / raw)
To: Gabriele Monaco; +Cc: Nam Cao, linux-trace-kernel, linux-kernel, Wen Yang
From: Wen Yang <wen.yang@linux.dev>
Add KUnit tests for the printk reactor covering:
- Reactor registration and unregistration lifecycle
- React callback invocation via rv_react()
- Double registration rejection
- Multiple register/unregister cycles
The mock callback calls vprintk_deferred() — the same path as the real
reactor — then busy-waits to simulate I/O back-pressure, exercising the
LD_WAIT_FREE constraint of rv_react() under load.
Signed-off-by: Wen Yang <wen.yang@linux.dev>
---
kernel/trace/rv/Kconfig | 10 ++
kernel/trace/rv/Makefile | 1 +
kernel/trace/rv/reactor_printk_kunit.c | 123 +++++++++++++++++++++++++
3 files changed, 134 insertions(+)
create mode 100644 kernel/trace/rv/reactor_printk_kunit.c
diff --git a/kernel/trace/rv/Kconfig b/kernel/trace/rv/Kconfig
index 3884b14df375..ff47895c897f 100644
--- a/kernel/trace/rv/Kconfig
+++ b/kernel/trace/rv/Kconfig
@@ -104,6 +104,16 @@ config RV_REACT_PRINTK
Enables the printk reactor. The printk reactor emits a printk()
message if an exception is found.
+config RV_REACT_PRINTK_KUNIT
+ bool "KUnit tests for reactor_printk" if !KUNIT_ALL_TESTS
+ depends on RV_REACT_PRINTK && KUNIT
+ default KUNIT_ALL_TESTS
+ help
+ This builds KUnit tests for the printk reactor. These are only
+ for development and testing, not for regular kernel use cases.
+
+ If unsure, say N.
+
config RV_REACT_PANIC
bool "Panic reactor"
depends on RV_REACTORS
diff --git a/kernel/trace/rv/Makefile b/kernel/trace/rv/Makefile
index 94498da35b37..ef0a2dcb927c 100644
--- a/kernel/trace/rv/Makefile
+++ b/kernel/trace/rv/Makefile
@@ -23,4 +23,5 @@ obj-$(CONFIG_RV_MON_NOMISS) += monitors/nomiss/nomiss.o
# Add new monitors here
obj-$(CONFIG_RV_REACTORS) += rv_reactors.o
obj-$(CONFIG_RV_REACT_PRINTK) += reactor_printk.o
+obj-$(CONFIG_RV_REACT_PRINTK_KUNIT) += reactor_printk_kunit.o
obj-$(CONFIG_RV_REACT_PANIC) += reactor_panic.o
diff --git a/kernel/trace/rv/reactor_printk_kunit.c b/kernel/trace/rv/reactor_printk_kunit.c
new file mode 100644
index 000000000000..933aa5602226
--- /dev/null
+++ b/kernel/trace/rv/reactor_printk_kunit.c
@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit tests for reactor_printk
+ *
+ */
+
+#include <kunit/test.h>
+#include <linux/rv.h>
+#include <linux/printk.h>
+#include <linux/sched/clock.h>
+#include <linux/processor.h>
+
+/*
+ * Simulated execution time for mock_printk_react (sched_clock units,
+ * nanoseconds). Models the time a real printk reactor callback may consume
+ * under I/O pressure, exercising the LD_WAIT_FREE constraint of rv_react().
+ */
+#define MOCK_REACT_DURATION_NS 5000000ULL
+
+/*
+ * Mock react callback mirroring rv_printk_reaction().
+ *
+ * Calls vprintk_deferred() — the same path as the real reactor — then holds
+ * the CPU for MOCK_REACT_DURATION_NS via a sched_clock() timed busy-loop,
+ * simulating a callback that is slow due to I/O back-pressure.
+ * sched_clock() is notrace and lock-free; no sleep or lock acquisition is
+ * performed, satisfying the LD_WAIT_FREE constraint of rv_react().
+ */
+__printf(1, 0) static void mock_printk_react(const char *msg, va_list args)
+{
+ u64 start = sched_clock();
+
+ vprintk_deferred(msg, args);
+
+ while (sched_clock() - start < MOCK_REACT_DURATION_NS)
+ cpu_relax();
+}
+
+static struct rv_reactor mock_printk_reactor = {
+ .name = "test_printk",
+ .description = "test printk reactor",
+ .react = mock_printk_react,
+};
+
+/* Test 1: register and unregister reactor */
+static void test_printk_register_unregister(struct kunit *test)
+{
+ int ret;
+
+ ret = rv_register_reactor(&mock_printk_reactor);
+ KUNIT_EXPECT_EQ(test, ret, 0);
+ KUNIT_EXPECT_STREQ(test, mock_printk_reactor.name, "test_printk");
+
+ rv_unregister_reactor(&mock_printk_reactor);
+}
+
+/* Test 2: react callback is invoked via rv_react() */
+static void test_printk_react_called(struct kunit *test)
+{
+ struct rv_reactor reactor = {
+ .name = "printk_cb_test",
+ .react = mock_printk_react,
+ };
+ struct rv_monitor monitor = {
+ .name = "test_monitor",
+ .reactor = &reactor,
+ .react = mock_printk_react,
+ };
+
+ rv_react(&monitor, "printk violation message");
+}
+
+/* Test 3: double registration should fail */
+static void test_printk_double_register(struct kunit *test)
+{
+ int ret;
+
+ ret = rv_register_reactor(&mock_printk_reactor);
+ KUNIT_ASSERT_EQ(test, ret, 0);
+
+ ret = rv_register_reactor(&mock_printk_reactor);
+ KUNIT_EXPECT_NE(test, ret, 0);
+
+ rv_unregister_reactor(&mock_printk_reactor);
+}
+
+/* Test 4: register/unregister cycle */
+static void test_printk_register_cycle(struct kunit *test)
+{
+ int ret, i;
+
+ for (i = 0; i < 5; i++) {
+ ret = rv_register_reactor(&mock_printk_reactor);
+ KUNIT_EXPECT_EQ(test, ret, 0);
+
+ rv_unregister_reactor(&mock_printk_reactor);
+ }
+}
+
+/* Test 5: react callback is not NULL (printk reactors must provide react) */
+static void test_printk_react_not_null(struct kunit *test)
+{
+ KUNIT_EXPECT_NOT_NULL(test, mock_printk_reactor.react);
+}
+
+static struct kunit_case reactor_printk_kunit_cases[] = {
+ KUNIT_CASE(test_printk_register_unregister),
+ KUNIT_CASE(test_printk_react_called),
+ KUNIT_CASE(test_printk_double_register),
+ KUNIT_CASE(test_printk_register_cycle),
+ KUNIT_CASE(test_printk_react_not_null),
+ {}
+};
+
+static struct kunit_suite reactor_printk_kunit_suite = {
+ .name = "rv_reactor_printk",
+ .test_cases = reactor_printk_kunit_cases,
+};
+
+kunit_test_suite(reactor_printk_kunit_suite);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("KUnit tests for reactor_printk");
--
2.25.1
^ permalink raw reply related [flat|nested] 4+ messages in thread* [PATCH 3/3] rv/reactors: add KUnit tests for reactor_panic
2026-06-15 16:44 [PATCH 0/3] rv/reactors: fix lockdep warning and add KUnit tests wen.yang
2026-06-15 16:44 ` [PATCH 1/3] rv/reactors: fix lockdep "Invalid wait context" in rv_react() wen.yang
2026-06-15 16:44 ` [PATCH 2/3] rv/reactors: add KUnit tests for reactor_printk wen.yang
@ 2026-06-15 16:44 ` wen.yang
2 siblings, 0 replies; 4+ messages in thread
From: wen.yang @ 2026-06-15 16:44 UTC (permalink / raw)
To: Gabriele Monaco; +Cc: Nam Cao, linux-trace-kernel, linux-kernel, Wen Yang
From: Wen Yang <wen.yang@linux.dev>
Add KUnit tests for the panic reactor covering:
- Reactor registration and unregistration lifecycle
- Panic notifier chain reachability
The real rv_panic_reaction() calls vpanic(), which is __noreturn and
halts the system. KUnit cannot test across that boundary. Instead, the
test drives atomic_notifier_call_chain(&panic_notifier_list, ...) directly
with a high-priority mock notifier that returns NOTIFY_STOP, verifying
that the panic notification propagates without triggering real handlers
(kdump, watchdog, reboot).
The mock notifier busy-waits to simulate real handler execution time
(e.g., crash_save_vmcoreinfo, emergency_restart preamble) under the
panic context constraints.
Signed-off-by: Wen Yang <wen.yang@linux.dev>
---
kernel/trace/rv/Kconfig | 10 +++
kernel/trace/rv/Makefile | 1 +
kernel/trace/rv/reactor_panic_kunit.c | 106 ++++++++++++++++++++++++++
3 files changed, 117 insertions(+)
create mode 100644 kernel/trace/rv/reactor_panic_kunit.c
diff --git a/kernel/trace/rv/Kconfig b/kernel/trace/rv/Kconfig
index ff47895c897f..6c6c43c5f86c 100644
--- a/kernel/trace/rv/Kconfig
+++ b/kernel/trace/rv/Kconfig
@@ -121,3 +121,13 @@ config RV_REACT_PANIC
help
Enables the panic reactor. The panic reactor emits a printk()
message if an exception is found and panic()s the system.
+
+config RV_REACT_PANIC_KUNIT
+ bool "KUnit tests for reactor_panic" if !KUNIT_ALL_TESTS
+ depends on RV_REACT_PANIC && KUNIT
+ default KUNIT_ALL_TESTS
+ help
+ This builds KUnit tests for the panic reactor. These are only
+ for development and testing, not for regular kernel use cases.
+
+ If unsure, say N.
diff --git a/kernel/trace/rv/Makefile b/kernel/trace/rv/Makefile
index ef0a2dcb927c..2ebfe5e5068c 100644
--- a/kernel/trace/rv/Makefile
+++ b/kernel/trace/rv/Makefile
@@ -25,3 +25,4 @@ obj-$(CONFIG_RV_REACTORS) += rv_reactors.o
obj-$(CONFIG_RV_REACT_PRINTK) += reactor_printk.o
obj-$(CONFIG_RV_REACT_PRINTK_KUNIT) += reactor_printk_kunit.o
obj-$(CONFIG_RV_REACT_PANIC) += reactor_panic.o
+obj-$(CONFIG_RV_REACT_PANIC_KUNIT) += reactor_panic_kunit.o
diff --git a/kernel/trace/rv/reactor_panic_kunit.c b/kernel/trace/rv/reactor_panic_kunit.c
new file mode 100644
index 000000000000..f9a09ae7aaad
--- /dev/null
+++ b/kernel/trace/rv/reactor_panic_kunit.c
@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit tests for reactor_panic
+ *
+ */
+
+#include <kunit/test.h>
+#include <linux/rv.h>
+#include <linux/panic_notifier.h>
+#include <linux/notifier.h>
+#include <linux/limits.h>
+#include <linux/sched/clock.h>
+#include <linux/processor.h>
+
+/* Simulated execution time for mock panic notifier (nanoseconds). */
+#define RV_PANIC_NOTIFIER_EXEC_NS 2000000ULL
+
+/* Test state */
+static struct {
+ bool notifier_called;
+} panic_test_state;
+
+/*
+ * Mock panic notifier callback.
+ *
+ * Runs at INT_MAX priority and returns NOTIFY_STOP to prevent real panic
+ * handlers (kdump, watchdog) from executing during the test. Busy-waits
+ * RV_PANIC_NOTIFIER_EXEC_NS to simulate a real handler's execution time.
+ */
+static int mock_panic_notifier_fn(struct notifier_block *nb,
+ unsigned long action, void *data)
+{
+ char *msg = data;
+ u64 start = sched_clock();
+
+ panic_test_state.notifier_called = true;
+ pr_emerg("KUnit: reactor_panic test intercepted panic notifier: %s\n",
+ msg ? msg : "(no message)");
+
+ while (sched_clock() - start < RV_PANIC_NOTIFIER_EXEC_NS)
+ cpu_relax();
+
+ return NOTIFY_STOP;
+}
+
+static struct notifier_block mock_panic_nb = {
+ .notifier_call = mock_panic_notifier_fn,
+ .priority = INT_MAX,
+};
+
+static struct rv_reactor mock_panic_reactor = {
+ .name = "test_panic",
+ .description = "test panic reactor",
+};
+
+static int reactor_panic_kunit_init(struct kunit *test)
+{
+ panic_test_state.notifier_called = false;
+ return 0;
+}
+
+/* Test 1: register and unregister reactor */
+static void test_panic_register_unregister(struct kunit *test)
+{
+ int ret;
+
+ ret = rv_register_reactor(&mock_panic_reactor);
+ KUNIT_EXPECT_EQ(test, ret, 0);
+ KUNIT_EXPECT_STREQ(test, mock_panic_reactor.name, "test_panic");
+
+ rv_unregister_reactor(&mock_panic_reactor);
+}
+
+/*
+ * Test 2: panic notifier chain is reachable.
+ *
+ * vpanic() calls atomic_notifier_call_chain(&panic_notifier_list, ...).
+ * Drive the chain directly to verify panic notifiers receive the notification —
+ * the observable side-effect of reactor_panic without halting the system.
+ */
+static void test_panic_notifier_called(struct kunit *test)
+{
+ atomic_notifier_chain_register(&panic_notifier_list, &mock_panic_nb);
+ atomic_notifier_call_chain(&panic_notifier_list, 0,
+ "panic violation message");
+ atomic_notifier_chain_unregister(&panic_notifier_list, &mock_panic_nb);
+
+ KUNIT_EXPECT_TRUE(test, panic_test_state.notifier_called);
+}
+
+static struct kunit_case reactor_panic_kunit_cases[] = {
+ KUNIT_CASE(test_panic_register_unregister),
+ KUNIT_CASE(test_panic_notifier_called),
+ {}
+};
+
+static struct kunit_suite reactor_panic_kunit_suite = {
+ .name = "rv_reactor_panic",
+ .init = reactor_panic_kunit_init,
+ .test_cases = reactor_panic_kunit_cases,
+};
+
+kunit_test_suite(reactor_panic_kunit_suite);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("KUnit tests for reactor_panic");
--
2.25.1
^ permalink raw reply related [flat|nested] 4+ messages in thread