From: Masami Hiramatsu (Google) <[email protected]>

Add KUnit test cases to lib/tests/test_kprobes.c to verify that the
recent regressions in kprobes registration, ftrace ops switching, and
optimization state transitions are resolved:

1. test_kretprobe_unregistered_cleanup:
   Verifies that unregistering an uninitialized or already-unregistered
   kretprobe does not cause a NULL pointer dereference or double free.

2. test_kretprobe_rereg_by_symbol:
   Verifies that attempting to re-register an active kretprobe by symbol
   name fails with -EINVAL and does not destroy the active probe's
   underlying rethook state.

3. test_kprobe_ftrace_post_handler_switch:
   Verifies that adding a second kprobe with a post_handler to a probe
   point armed with kprobe_ftrace_ops correctly switches to
   kprobe_ipmodify_ops and both probes cleanly unregister without
   disarming errors (-ENOENT).

4. test_optprobe_rearm_unoptimizing:
   Verifies that disabling an optimized kprobe and immediately
   re-enabling it before the optimizer thread runs does not overwrite the
   jump instruction opcode or crash on execution.

Signed-off-by: Masami Hiramatsu (Google) <[email protected]>
---
 lib/tests/test_kprobes.c |  123 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 123 insertions(+)

diff --git a/lib/tests/test_kprobes.c b/lib/tests/test_kprobes.c
index 06e729e4de05..c20f70cc63d7 100644
--- a/lib/tests/test_kprobes.c
+++ b/lib/tests/test_kprobes.c
@@ -358,8 +358,123 @@ static void test_stacktrace_on_nested_kretprobe(struct 
kunit *test)
 }
 #endif /* CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE */
 
+/* Test for: kprobes: Fix double free and NULL deref in 
unregister_kretprobes() */
+static void test_kretprobe_unregistered_cleanup(struct kunit *test)
+{
+       struct kretprobe unreg_rp = {
+               .kp.symbol_name = "kprobe_target",
+       };
+
+       current_test = test;
+
+       /* Unregistering a probe that was never registered must return cleanly 
*/
+       unregister_kretprobe(&unreg_rp);
+
+       /* Double unregister of a valid registered probe */
+       KUNIT_ASSERT_EQ(test, 0, register_kretprobe(&unreg_rp));
+       unregister_kretprobe(&unreg_rp);
+       /* Second unregister must not cause double-free or NULL pointer 
dereference */
+       unregister_kretprobe(&unreg_rp);
+}
+
+/* Test for: kprobes: Validate re-registration earlier in register_kretprobe() 
*/
+static void test_kretprobe_rereg_by_symbol(struct kunit *test)
+{
+       struct kretprobe test_rp = {
+               .kp.symbol_name = "kprobe_target",
+               .handler = return_handler,
+               .entry_handler = entry_handler,
+       };
+
+       current_test = test;
+       KUNIT_ASSERT_EQ(test, 0, register_kretprobe(&test_rp));
+
+       /* Verify the probe is live and functional */
+       krph_val = 0;
+       target(rand1);
+       KUNIT_EXPECT_EQ(test, krph_val, rand1);
+
+       /*
+        * Attempt re-registration with symbol_name (with kp.addr cleared).
+        * Must fail with -EINVAL and NOT destroy the live probe's rethook.
+        */
+       test_rp.kp.addr = NULL;
+       KUNIT_EXPECT_EQ(test, -EINVAL, register_kretprobe(&test_rp));
+
+       /* The original kretprobe must still be functional */
+       krph_val = 0;
+       target(rand1);
+       KUNIT_EXPECT_EQ(test, krph_val, rand1);
+
+       unregister_kretprobe(&test_rp);
+}
+
 #endif /* CONFIG_KRETPROBES */
 
+#if defined(CONFIG_KPROBES_ON_FTRACE)
+/* Test for: kprobes: Switch ftrace ops when adding probe with post_handler */
+static void test_kprobe_ftrace_post_handler_switch(struct kunit *test)
+{
+       struct kprobe kp_entry = {
+               .symbol_name = "kprobe_target",
+               .pre_handler = kp_pre_handler,
+       };
+       struct kprobe kp_post = {
+               .symbol_name = "kprobe_target",
+               .post_handler = kp_post_handler,
+       };
+
+       current_test = test;
+
+       /* 1. Register first probe without post_handler (armed with 
kprobe_ftrace_ops) */
+       KUNIT_ASSERT_EQ(test, 0, register_kprobe(&kp_entry));
+
+       /* 2. Register second probe with post_handler at same IP (must switch 
ops) */
+       KUNIT_ASSERT_EQ(test, 0, register_kprobe(&kp_post));
+
+       /* 3. Execute target function to trigger both */
+       preh_val = 0;
+       posth_val = 0;
+       target(rand1);
+       KUNIT_EXPECT_NE(test, 0, preh_val);
+       KUNIT_EXPECT_NE(test, 0, posth_val);
+
+       /* 4. Unregistering must successfully disarm without -ENOENT */
+       unregister_kprobe(&kp_post);
+       unregister_kprobe(&kp_entry);
+}
+#endif
+
+#if defined(CONFIG_OPTPROBES)
+/* Test for: kprobes: Do not overwrite jump instruction when re-arming 
unoptimizing probe */
+static void test_optprobe_rearm_unoptimizing(struct kunit *test)
+{
+       struct kprobe opt_kp = {
+               .symbol_name = "kprobe_target",
+               .pre_handler = kp_pre_handler,
+       };
+
+       current_test = test;
+       KUNIT_ASSERT_EQ(test, 0, register_kprobe(&opt_kp));
+
+       /* Allow background optimizer thread to jump-optimize the probe */
+       wait_for_kprobe_optimizer();
+
+       /* Temporarily disable probe (queues on unoptimizing_list, leaves jump) 
*/
+       KUNIT_ASSERT_EQ(test, 0, disable_kprobe(&opt_kp));
+
+       /* Immediately re-enable (re-arm) before optimizer thread unoptimizes */
+       KUNIT_ASSERT_EQ(test, 0, enable_kprobe(&opt_kp));
+
+       /* Verify jump opcode was not corrupted by an unaligned INT3 overwrite 
*/
+       preh_val = 0;
+       target(rand1);
+       KUNIT_EXPECT_NE(test, 0, preh_val);
+
+       unregister_kprobe(&opt_kp);
+}
+#endif
+
 static int kprobes_test_init(struct kunit *test)
 {
        KP_CLEAR(kp);
@@ -391,10 +506,18 @@ static struct kunit_case kprobes_testcases[] = {
 #ifdef CONFIG_KRETPROBES
        KUNIT_CASE(test_kretprobe),
        KUNIT_CASE(test_kretprobes),
+       KUNIT_CASE(test_kretprobe_unregistered_cleanup),
+       KUNIT_CASE(test_kretprobe_rereg_by_symbol),
 #ifdef CONFIG_ARCH_CORRECT_STACKTRACE_ON_KRETPROBE
        KUNIT_CASE(test_stacktrace_on_kretprobe),
        KUNIT_CASE(test_stacktrace_on_nested_kretprobe),
 #endif
+#endif
+#if defined(CONFIG_KPROBES_ON_FTRACE)
+       KUNIT_CASE(test_kprobe_ftrace_post_handler_switch),
+#endif
+#if defined(CONFIG_OPTPROBES)
+       KUNIT_CASE(test_optprobe_rearm_unoptimizing),
 #endif
        {}
 };


Reply via email to