[PATCH v8 2/4] kunit: Add backtrace suppression self-tests

[David Gow]

Le 04/05/2026 à 3:41 PM, Albert Esteve a écrit :
> From: Guenter Roeck <linux at roeck-us.net>
> 
> Add unit tests to verify that warning backtrace suppression works.
> 
> Tests cover all three API forms:
> - Scoped: kunit_warning_suppress() with in-block count verification
>    and post-block inactivity check.
> - Manual macros: KUNIT_START/END_SUPPRESSED_WARNING() with WARN()
>    and WARN_ON(), both direct and through helper functions, as well
>    as multiple warnings in a single block.
> - Direct functions: kunit_start/end_suppress_warning() with
>    sequential independent suppression blocks and per-block counts.
> 
> Furthermore, tests verify incremental warning counting, that
> kunit_has_active_suppress_warning() transitions correctly around
> suppression boundaries, and that suppression active in the test
> kthread does not leak to a separate kthread.
> 
> If backtrace suppression does _not_ work, the unit tests will likely
> trigger unsuppressed backtraces, which should actually help to get
> the affected architectures / platforms fixed.
> 
> Tested-by: Linux Kernel Functional Testing <lkft at linaro.org>
> Acked-by: Dan Carpenter <dan.carpenter at linaro.org>
> Reviewed-by: Kees Cook <keescook at chromium.org>
> Signed-off-by: Guenter Roeck <linux at roeck-us.net>
> Signed-off-by: Alessandro Carminati <acarmina at redhat.com>
> Reviewed-by: David Gow <david at davidgow.net>
> Signed-off-by: Albert Esteve <aesteve at redhat.com>
> ---

Looks good to me, thanks!

This is still:

Reviewed-by: David Gow <david at davidgow.net>

Cheers,
-- David

>   lib/kunit/Makefile                     |   1 +
>   lib/kunit/backtrace-suppression-test.c | 184 +++++++++++++++++++++++++++++++++
>   2 files changed, 185 insertions(+)
> 
> diff --git a/lib/kunit/Makefile b/lib/kunit/Makefile
> index 4592f9d0aa8dd..2e8a6b71a2ab0 100644
> --- a/lib/kunit/Makefile
> +++ b/lib/kunit/Makefile
> @@ -22,6 +22,7 @@ obj-$(if $(CONFIG_KUNIT),y) +=		hooks.o
>   
>   obj-$(CONFIG_KUNIT_TEST) +=		kunit-test.o
>   obj-$(CONFIG_KUNIT_TEST) +=		platform-test.o
> +obj-$(CONFIG_KUNIT_TEST) +=		backtrace-suppression-test.o
>   
>   # string-stream-test compiles built-in only.
>   ifeq ($(CONFIG_KUNIT_TEST),y)
> diff --git a/lib/kunit/backtrace-suppression-test.c b/lib/kunit/backtrace-suppression-test.c
> new file mode 100644
> index 0000000000000..0e6fb685d2cbb
> --- /dev/null
> +++ b/lib/kunit/backtrace-suppression-test.c
> @@ -0,0 +1,184 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * KUnit test for suppressing warning tracebacks.
> + *
> + * Copyright (C) 2024, Guenter Roeck
> + * Author: Guenter Roeck <linux at roeck-us.net>
> + */
> +
> +#include <kunit/test.h>
> +#include <linux/bug.h>
> +#include <linux/completion.h>
> +#include <linux/kthread.h>
> +
> +static void backtrace_suppression_test_warn_direct(struct kunit *test)
> +{
> +	kunit_warning_suppress(test) {
> +		WARN(1, "This backtrace should be suppressed");
> +		/*
> +		 * Count must be checked inside the scope; the handle
> +		 * is not accessible after the block exits.
> +		 */
> +		KUNIT_EXPECT_SUPPRESSED_WARNING_COUNT(test, 1);
> +	}
> +	KUNIT_EXPECT_FALSE(test, kunit_has_active_suppress_warning());
> +}
> +
> +static void trigger_backtrace_warn(void)
> +{
> +	WARN(1, "This backtrace should be suppressed");
> +}
> +
> +static void backtrace_suppression_test_warn_indirect(struct kunit *test)
> +{
> +	KUNIT_START_SUPPRESSED_WARNING(test);
> +	trigger_backtrace_warn();
> +	KUNIT_END_SUPPRESSED_WARNING(test);
> +
> +	KUNIT_EXPECT_SUPPRESSED_WARNING_COUNT(test, 1);
> +}
> +
> +static void backtrace_suppression_test_warn_multi(struct kunit *test)
> +{
> +	KUNIT_START_SUPPRESSED_WARNING(test);
> +	WARN(1, "This backtrace should be suppressed");
> +	trigger_backtrace_warn();
> +	KUNIT_END_SUPPRESSED_WARNING(test);
> +
> +	KUNIT_EXPECT_SUPPRESSED_WARNING_COUNT(test, 2);
> +}
> +
> +static void backtrace_suppression_test_warn_on_direct(struct kunit *test)
> +{
> +	if (!IS_ENABLED(CONFIG_DEBUG_BUGVERBOSE) && !IS_ENABLED(CONFIG_KALLSYMS))
> +		kunit_skip(test, "requires CONFIG_DEBUG_BUGVERBOSE or CONFIG_KALLSYMS");
> +
> +	KUNIT_START_SUPPRESSED_WARNING(test);
> +	WARN_ON(1);
> +	KUNIT_END_SUPPRESSED_WARNING(test);
> +
> +	KUNIT_EXPECT_SUPPRESSED_WARNING_COUNT(test, 1);
> +}
> +
> +static void trigger_backtrace_warn_on(void)
> +{
> +	WARN_ON(1);
> +}
> +
> +static void backtrace_suppression_test_warn_on_indirect(struct kunit *test)
> +{
> +	if (!IS_ENABLED(CONFIG_DEBUG_BUGVERBOSE))
> +		kunit_skip(test, "requires CONFIG_DEBUG_BUGVERBOSE");
> +
> +	KUNIT_START_SUPPRESSED_WARNING(test);
> +	trigger_backtrace_warn_on();
> +	KUNIT_END_SUPPRESSED_WARNING(test);
> +
> +	KUNIT_EXPECT_SUPPRESSED_WARNING_COUNT(test, 1);
> +}
> +
> +static void backtrace_suppression_test_count(struct kunit *test)
> +{
> +	KUNIT_START_SUPPRESSED_WARNING(test);
> +
> +	KUNIT_EXPECT_SUPPRESSED_WARNING_COUNT(test, 0);
> +
> +	WARN(1, "suppressed");
> +	KUNIT_EXPECT_SUPPRESSED_WARNING_COUNT(test, 1);
> +
> +	WARN(1, "suppressed again");
> +	KUNIT_EXPECT_SUPPRESSED_WARNING_COUNT(test, 2);
> +
> +	KUNIT_END_SUPPRESSED_WARNING(test);
> +}
> +
> +static void backtrace_suppression_test_active_state(struct kunit *test)
> +{
> +	KUNIT_EXPECT_FALSE(test, kunit_has_active_suppress_warning());
> +
> +	KUNIT_START_SUPPRESSED_WARNING(test);
> +	KUNIT_EXPECT_TRUE(test, kunit_has_active_suppress_warning());
> +	KUNIT_END_SUPPRESSED_WARNING(test);
> +
> +	KUNIT_EXPECT_FALSE(test, kunit_has_active_suppress_warning());
> +
> +	kunit_warning_suppress(test) {
> +		KUNIT_EXPECT_TRUE(test, kunit_has_active_suppress_warning());
> +	}
> +
> +	KUNIT_EXPECT_FALSE(test, kunit_has_active_suppress_warning());
> +}
> +
> +static void backtrace_suppression_test_multi_scope(struct kunit *test)
> +{
> +	struct kunit_suppressed_warning *sw1, *sw2;
> +
> +	if (!IS_ENABLED(CONFIG_DEBUG_BUGVERBOSE))
> +		kunit_skip(test, "requires CONFIG_DEBUG_BUGVERBOSE");
> +
> +	sw1 = kunit_start_suppress_warning(test);
> +	trigger_backtrace_warn_on();
> +	WARN(1, "suppressed by sw1");
> +	kunit_end_suppress_warning(test, sw1);
> +
> +	sw2 = kunit_start_suppress_warning(test);
> +	WARN(1, "suppressed by sw2");
> +	kunit_end_suppress_warning(test, sw2);
> +
> +	KUNIT_EXPECT_EQ(test, kunit_suppressed_warning_count(sw1), 2);
> +	KUNIT_EXPECT_EQ(test, kunit_suppressed_warning_count(sw2), 1);
> +}
> +
> +struct cross_kthread_data {
> +	bool was_active;
> +	struct completion done;
> +};
> +
> +static int cross_kthread_fn(void *data)
> +{
> +	struct cross_kthread_data *d = data;
> +
> +	d->was_active = kunit_has_active_suppress_warning();
> +	complete(&d->done);
> +	return 0;
> +}
> +
> +static void backtrace_suppression_test_cross_kthread(struct kunit *test)
> +{
> +	struct cross_kthread_data data;
> +	struct task_struct *task;
> +
> +	init_completion(&data.done);
> +
> +	KUNIT_START_SUPPRESSED_WARNING(test);
> +
> +	task = kthread_run(cross_kthread_fn, &data, "kunit-cross-test");
> +	KUNIT_ASSERT_FALSE(test, IS_ERR(task));
> +	wait_for_completion(&data.done);
> +
> +	KUNIT_END_SUPPRESSED_WARNING(test);
> +
> +	KUNIT_EXPECT_FALSE(test, data.was_active);
> +}
> +
> +static struct kunit_case backtrace_suppression_test_cases[] = {
> +	KUNIT_CASE(backtrace_suppression_test_warn_direct),
> +	KUNIT_CASE(backtrace_suppression_test_warn_indirect),
> +	KUNIT_CASE(backtrace_suppression_test_warn_multi),
> +	KUNIT_CASE(backtrace_suppression_test_warn_on_direct),
> +	KUNIT_CASE(backtrace_suppression_test_warn_on_indirect),
> +	KUNIT_CASE(backtrace_suppression_test_count),
> +	KUNIT_CASE(backtrace_suppression_test_active_state),
> +	KUNIT_CASE(backtrace_suppression_test_multi_scope),
> +	KUNIT_CASE(backtrace_suppression_test_cross_kthread),
> +	{}
> +};
> +
> +static struct kunit_suite backtrace_suppression_test_suite = {
> +	.name = "backtrace-suppression-test",
> +	.test_cases = backtrace_suppression_test_cases,
> +};
> +kunit_test_suites(&backtrace_suppression_test_suite);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_DESCRIPTION("KUnit test to verify warning backtrace suppression");
>