# Re: \[PATCH 8/8\] kprobes: Add KUnit test cases for kprobes regressions

- From: sashiko-bot@kernel.org
- Date: 2026-11-04 00:25:14 
- List: linux-trace-kernel
- Page: https://ratatoskr.run/linux-trace-kernel/2026/11/17857121
- Thread: https://ratatoskr.run/linux-trace-kernel/2026/11/17857037/t.md

```text
Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [Medium] kprobes: test_optprobe_rearm_unoptimizing() probes ftrace entry
- [Medium] kprobes: stack UAF if KUNIT_ASSERT_EQ() aborts with registered kprobe
- [Low] kprobes: unexported wait_for_kprobe_optimizer() breaks module build
--

commit 879cc55db87246da67610c427cb32cb35c372768
Author: Masami Hiramatsu (Google) [ref]

kprobes: Add KUnit test cases for kprobes regressions

This commit adds four KUnit test cases to lib/tests/test_kprobes.c to
verify fixes for regressions in kretprobe unregistration, kretprobe
re-registration, ftrace ops switching, and optprobe re-arming.

> diff --git a/lib/tests/test_kprobes.c b/lib/tests/test_kprobes.c
> index 06e729e4de051..c20f70cc63d73 100644
> --- a/lib/tests/test_kprobes.c
> +++ b/lib/tests/test_kprobes.c
[ ... ]
> +#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));

[Severity: Medium]
In test_kprobe_ftrace_post_handler_switch(), kp_entry is allocated on the
test kthread stack. If the second register_kprobe(&kp_post) call fails (for
example, if alloc_aggr_kprobe() or ftrace ops switching fails), the assertion
macro aborts the test immediately via:

  __kunit_abort()
    -> kunit_try_catch_throw()
      -> kthread_exit(0)

Would this exit the kthread and free its stack while kp_entry is still
registered in kprobe_table, leaving a dangling stack pointer that causes a
stack use-after-free?

The same question applies to test_optprobe_rearm_unoptimizing() below, where
opt_kp is on the stack and registered before the assertions on
disable_kprobe(&opt_kp) and enable_kprobe(&opt_kp).

> +
> +	/* 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));

[Severity: Medium]
Does test_optprobe_rearm_unoptimizing() actually exercise jump optimization
when ftrace-based kprobes are enabled?

Because opt_kp is registered at kprobe_target with offset 0, on kernels with
ftrace-based kprobes enabled, register_kprobe() marks the probe as an ftrace
kprobe:

  register_kprobe()
    -> check_kprobe_address_safe()
      -> check_ftrace_location()
         if (ftrace_location(addr) == addr)
             p->flags |= KPROBE_FLAG_FTRACE;

Then __register_kprobe() calls try_to_optimize_kprobe(), which bails out
immediately:

  try_to_optimize_kprobe()
    if (kprobe_ftrace(p))
        return;

As a result, disable_kprobe() and enable_kprobe() take the ftrace disarm/arm
paths instead of queuing opt_kp on unoptimizing_list and re-arming an
optimized probe. Should opt_kp be placed at a non-zero instruction offset
within kprobe_target, or target a notrace function, so that jump optimization
is actually used?

> +
> +	/* Allow background optimizer thread to jump-optimize the probe */
> +	wait_for_kprobe_optimizer();

[Severity: Low]
Can this break the build when the test is compiled as a loadable module?

In lib/Kconfig.debug, this test suite is tristate:

  config KPROBES_SANITY_TEST
  	tristate "Kprobes sanity tests" if !KUNIT_ALL_TESTS

However, wait_for_kprobe_optimizer() in kernel/kprobes.c is not exported to
modules, causing modpost to fail with an undefined symbol when the test is
built as a module with optprobes enabled. Should wait_for_kprobe_optimizer()
be exported, or should this test be guarded like the stack_trace_save_regs()
callers earlier in lib/tests/test_kprobes.c?

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/179375029807.247640.13024754173032838618.stgit@devnote2?part=8
```
