Add support for suppressing warning backtraces
Subsystems (18)
v3 cover Add support for suppressing warning backtraces
Some unit tests intentionally trigger warning backtraces by passing bad parameters to kernel API functions. Such unit tests typically check the return value from such calls, not the existence of the warning backtrace.
Such intentionally generated warning backtraces are neither desirable nor useful for a number of reasons.
- They can result in overlooked real problems.
- A warning that suddenly starts to show up in unit tests needs to be investigated and has to be marked to be ignored, for example by adjusting filter scripts. Such filters are ad-hoc because there is no real standard format for warnings. On top of that, such filter scripts would require constant maintenance.
One option to address problem would be to add messages such as "expected warning backtraces start / end here" to the kernel log. However, that would again require filter scripts, it might result in missing real problematic warning backtraces triggered while the test is running, and the irrelevant backtrace(s) would still clog the kernel log.
Solve the problem by providing a means to identify and suppress specific warning backtraces while executing test code. Support suppressing multiple backtraces while at the same time limiting changes to generic code to the absolute minimum. Architecture specific changes are kept at minimum by retaining function names only if both CONFIG_DEBUG_BUGVERBOSE and CONFIG_KUNIT are enabled.
The first patch of the series introduces the necessary infrastructure. The second patch introduces support for counting suppressed backtraces. This capability is used in patch three to implement unit tests. Patch four documents the new API.
The next two patches add support for suppressing backtraces in drm_rect and dev_addr_lists unit tests. These patches are intended to serve as examples for the use of the functionality introduced with this series. The remaining patches implement the necessary changes for all architectures with GENERIC_BUG support.
With CONFIG_KUNIT enabled, image size increase with this series applied is approximately 1%. The image size increase (and with it the functionality introduced by this series) can be avoided by disabling CONFIG_KUNIT_SUPPRESS_BACKTRACE.
This series is based on the RFC patch and subsequent discussion at
https://patchwork.kernel.org/project/linux-kselftest/patch/[email protected]/
and offers a more comprehensive solution of the problem discussed there.
Design note:
Function pointers are only added to the __bug_table section if both CONFIG_KUNIT_SUPPRESS_BACKTRACE and CONFIG_DEBUG_BUGVERBOSE are enabled to avoid image size increases if CONFIG_KUNIT is disabled. There would be some benefits to adding those pointers all the time (reduced complexity, ability to display function names in BUG/WARNING messages). That change, if desired, can be made later.
Checkpatch note:
Remaining checkpatch errors and warnings were deliberately ignored. Some are triggered by matching coding style or by comments interpreted as code, others by assembler macros which are disliked by checkpatch. Suggestions for improvements are welcome.
Changes since RFC:
- Introduced CONFIG_KUNIT_SUPPRESS_BACKTRACE
- Minor cleanups and bug fixes
- Added support for all affected architectures
- Added support for counting suppressed warnings
- Added unit tests using those counters
- Added patch to suppress warning backtraces in dev_addr_lists tests
Changes since v1:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
[I retained those tags since there have been no functional changes]
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option, enabled by default.
Changes since v2:
- Rebased to v6.9-rc2
- Added comments to drm warning suppression explaining why it is needed.
- Added patch to move conditional code in arch/sh/include/asm/bug.h to avoid kerneldoc warning
- Added architecture maintainers to Cc: for architecture specific patches
- No functional changes
----------------------------------------------------------------
Guenter Roeck (15):
bug/kunit: Core support for suppressing warning backtraces
kunit: bug: Count suppressed warning backtraces
kunit: Add test cases for backtrace warning suppression
kunit: Add documentation for warning backtrace suppression API
drm: Suppress intentional warning backtraces in scaling unit tests
net: kunit: Suppress lock warning noise at end of dev_addr_lists tests
x86: Add support for suppressing warning backtraces
arm64: Add support for suppressing warning backtraces
loongarch: Add support for suppressing warning backtraces
parisc: Add support for suppressing warning backtraces
s390: Add support for suppressing warning backtraces
sh: Add support for suppressing warning backtraces
sh: Move defines needed for suppressing warning backtraces
riscv: Add support for suppressing warning backtraces
powerpc: Add support for suppressing warning backtraces
Documentation/dev-tools/kunit/usage.rst | 30 ++++++++- arch/arm64/include/asm/asm-bug.h | 29 ++++++--- arch/arm64/include/asm/bug.h | 8 ++- arch/loongarch/include/asm/bug.h | 38 ++++++++---- arch/parisc/include/asm/bug.h | 29 ++++++--- arch/powerpc/include/asm/bug.h | 37 +++++++++--- arch/riscv/include/asm/bug.h | 38 ++++++++---- arch/s390/include/asm/bug.h | 17 +++++- arch/sh/include/asm/bug.h | 28 +++++++-- arch/x86/include/asm/bug.h | 21 +++++-- drivers/gpu/drm/tests/drm_rect_test.c | 16 +++++ include/asm-generic/bug.h | 16 ++++- include/kunit/bug.h | 56 +++++++++++++++++ include/kunit/test.h | 1 + include/linux/bug.h | 13 ++++ lib/bug.c | 51 ++++++++++++++-- lib/kunit/Kconfig | 9 +++ lib/kunit/Makefile | 7 ++- lib/kunit/backtrace-suppression-test.c | 104 ++++++++++++++++++++++++++++++++ lib/kunit/bug.c | 42 +++++++++++++ net/core/dev_addr_lists_test.c | 6 ++ 21 files changed, 524 insertions(+), 72 deletions(-) create mode 100644 include/kunit/bug.h create mode 100644 lib/kunit/backtrace-suppression-test.c create mode 100644 lib/kunit/bug.c
PATCH v3 1/15 bug/kunit: Core support for suppressing warning backtraces
Some unit tests intentionally trigger warning backtraces by passing bad parameters to API functions. Such unit tests typically check the return value from those calls, not the existence of the warning backtrace.
Such intentionally generated warning backtraces are neither desirable nor useful for a number of reasons.
- They can result in overlooked real problems.
- A warning that suddenly starts to show up in unit tests needs to be investigated and has to be marked to be ignored, for example by adjusting filter scripts. Such filters are ad-hoc because there is no real standard format for warnings. On top of that, such filter scripts would require constant maintenance.
One option to address problem would be to add messages such as "expected warning backtraces start / end here" to the kernel log. However, that would again require filter scripts, it might result in missing real problematic warning backtraces triggered while the test is running, and the irrelevant backtrace(s) would still clog the kernel log.
Solve the problem by providing a means to identify and suppress specific warning backtraces while executing test code. Since the new functionality results in an image size increase of about 1% if CONFIG_KUNIT is enabled, provide configuration option KUNIT_SUPPRESS_BACKTRACE to be able to disable the new functionality. This option is by default enabled since almost all systems with CONFIG_KUNIT enabled will want to benefit from it.
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Added CONFIG_KUNIT_SUPPRESS_BACKTRACE configuration option, enabled by default
v3:
- Rebased to v6.9-rc2
include/asm-generic/bug.h | 16 +++++++++--- include/kunit/bug.h | 51 +++++++++++++++++++++++++++++++++++++++ include/kunit/test.h | 1 + include/linux/bug.h | 13 ++++++++++ lib/bug.c | 51 ++++++++++++++++++++++++++++++++++++--- lib/kunit/Kconfig | 9 +++++++ lib/kunit/Makefile | 6 +++-- lib/kunit/bug.c | 40 ++++++++++++++++++++++++++++++ 8 files changed, 178 insertions(+), 9 deletions(-) create mode 100644 include/kunit/bug.h create mode 100644 lib/kunit/bug.c
include/asm-generic/bug.h +13 -3
@@ -18,6 +18,7 @@#endif #ifndef __ASSEMBLY__ +#include <kunit/bug.h> #include <linux/panic.h> #include <linux/printk.h>
@@ -39,8 +40,14 @@ struct bug_entry {#ifdef CONFIG_DEBUG_BUGVERBOSE #ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS const char *file; +#ifdef HAVE_BUG_FUNCTION +const char *function; +#endif #else signed int file_disp; +#ifdef HAVE_BUG_FUNCTION +signed int function_disp; +#endif #endif unsigned short line;#endif
@@ -96,15 +103,18 @@ extern __printf(1, 2) void __warn_printk(const char *fmt, ...);#define __WARN () __WARN_printf(TAINT_WARN, NULL) #define __WARN_printf(taint, arg...) do { \ instrumentation_begin(); \ - warn_slowpath_fmt(__FILE__, __LINE__, taint, arg); \ + if (!IS_SUPPRESSED_WARNING(__func__)) \ + warn_slowpath_fmt(__FILE__, __LINE__, taint, arg);\ instrumentation_end(); \ } while (0)#else #define __WARN () __WARN_FLAGS(BUGFLAG_TAINT(TAINT_WARN)) #define __WARN_printf(taint, arg...) do { \ instrumentation_begin(); \ - __warn_printk(arg); \ - __WARN_FLAGS(BUGFLAG_NO_CUT_HERE | BUGFLAG_TAINT(taint));\ + if (!IS_SUPPRESSED_WARNING(__func__)) { \ + __warn_printk(arg); \ + __WARN_FLAGS(BUGFLAG_NO_CUT_HERE | BUGFLAG_TAINT(taint));\ + } \ instrumentation_end(); \ } while (0)#define WARN_ON_ONCE (condition) ({ \
include/kunit/bug.h new file +51 -0
51 lines not on this page · raw message
include/kunit/test.h +1 -0
@@ -10,6 +10,7 @@#define _KUNIT_TEST_H#include <kunit/assert.h> +#include <kunit/bug.h> #include <kunit/try-catch.h> #include <linux/args.h>
include/linux/bug.h +13 -0
@@ -36,6 +36,9 @@ static inline int is_warning_bug(const struct bug_entry *bug)return bug->flags &BUGFLAG_WARNING ; } +void bug_get_file_function_line (struct bug_entry *bug,const char **file, +const char **function,unsigned int *line); +void bug_get_file_line (struct bug_entry *bug,const char **file,unsigned int *line);
@@ -62,6 +65,16 @@ static inline enum bug_trap_type report_bug(unsigned long bug_addr, }struct bug_entry ; +static inline void bug_get_file_function_line (struct bug_entry *bug, +const char **file, +const char **function, +unsigned int *line) +{ + *file =NULL ; + *function =NULL ; + *line =0 ; +} +static inline void bug_get_file_line (struct bug_entry *bug,const char **file,unsigned int *line) {
lib/bug.c +47 -4
93 lines not on this page · raw message
lib/kunit/Kconfig +9 -0
@@ -15,6 +15,15 @@ menuconfig KUNIT if KUNIT +config KUNIT_SUPPRESS_BACKTRACE + bool "KUnit - Enable backtrace suppression" + default y + help + Enable backtrace suppression for KUnit. If enabled, backtraces + generated intentionally by KUnit tests are suppressed. Disable + to reduce kernel image size if image size is more important than + suppression of backtraces generated by KUnit tests. + config KUNIT_DEBUGFS bool "KUnit - Enable /sys/kernel/debug/kunit debugfs representation" if !KUNIT_ALL_TESTS default KUNIT_ALL_TESTS
lib/kunit/Makefile +4 -2
@@ -14,8 +14,10 @@ ifeq ($(CONFIG_KUNIT_DEBUGFS),y) kunit-objs += debugfs.o endif -# KUnit 'hooks' are built-in even when KUnit is built as a module. -obj-y += hooks.o +# KUnit 'hooks' and bug handling are built-in even when KUnit is built +# as a module. +obj-y += hooks.o \ + bug.o obj-$(CONFIG_KUNIT_TEST) += kunit-test.o
lib/kunit/bug.c new file +40 -0
@@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* KUnit helpers for backtrace suppression +* +* Copyright (c) 2024 Guenter Roeck <[email protected]> +*/ + +#include <kunit/bug.h> +#include <linux/export.h> +#include <linux/list.h> +#include <linux/string.h> + +static LIST_HEAD (suppressed_warnings); + +void __start_suppress_warning (struct __suppressed_warning *warning) +{ +list_add (&warning->node, &suppressed_warnings); +} +EXPORT_SYMBOL_GPL (__start_suppress_warning); + +void __end_suppress_warning (struct __suppressed_warning *warning) +{ +list_del (&warning->node); +} +EXPORT_SYMBOL_GPL (__end_suppress_warning); + +bool __is_suppressed_warning (const char *function) +{ +struct __suppressed_warning *warning; + +if (!function) +return false; + +list_for_each_entry (warning, &suppressed_warnings, node) { +if (!strcmp (function, warning->function)) +return true; + } +return false; +} +EXPORT_SYMBOL_GPL (__is_suppressed_warning);
Signature · 1 line
2.39.2
PATCH v3 2/15 kunit: bug: Count suppressed warning backtraces
In reply to Guenter RoeckCount suppressed warning backtraces to enable code which suppresses warning backtraces to check if the expected backtrace(s) have been observed.
Using atomics for the backtrace count resulted in build errors on some architectures due to include file recursion, so use a plain integer for now.
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2
include/kunit/bug.h | 7 ++++++- lib/kunit/bug.c | 4 +++- 2 files changed, 9 insertions(+), 2 deletions(-)
include/kunit/bug.h +6 -1
@@ -20,6 +20,7 @@struct __suppressed_warning {struct list_head node;const char *function; +int counter; };void __start_suppress_warning (struct __suppressed_warning *warning);
@@ -28,7 +29,7 @@ bool __is_suppressed_warning(const char *function);#define DEFINE_SUPPRESSED_WARNING (func) \ struct __suppressed_warning __kunit_suppress_##func = \ - { .function = __stringify(func) } + { .function = __stringify(func), .counter = 0 }#define START_SUPPRESSED_WARNING (func) \ __start_suppress_warning(&__kunit_suppress_##func)
@@ -39,12 +40,16 @@ bool __is_suppressed_warning(const char *function);#define IS_SUPPRESSED_WARNING (func) \ __is_suppressed_warning(func) +#define SUPPRESSED_WARNING_COUNT (func) \ + (__kunit_suppress_##func.counter) +#else /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ #define DEFINE_SUPPRESSED_WARNING (func)#define START_SUPPRESSED_WARNING (func)#define END_SUPPRESSED_WARNING (func)#define IS_SUPPRESSED_WARNING (func) (false) +#define SUPPRESSED_WARNING_COUNT (func) (0)#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ #endif /* __ASSEMBLY__ */
lib/kunit/bug.c +3 -1
@@ -32,8 +32,10 @@ bool __is_suppressed_warning(const char *function)return false;list_for_each_entry (warning, &suppressed_warnings, node) { -if (!strcmp (function, warning->function)) +if (!strcmp (function, warning->function)) { + warning->counter++;return true; + } }return false; }
Signature · 1 line
2.39.2
PATCH v3 3/15 kunit: Add test cases for backtrace warning suppression
In reply to Guenter RoeckAdd unit tests to verify that warning backtrace suppression works.
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.
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2
lib/kunit/Makefile | 7 +- lib/kunit/backtrace-suppression-test.c | 104 +++++++++++++++++++++++++ 2 files changed, 109 insertions(+), 2 deletions(-) create mode 100644 lib/kunit/backtrace-suppression-test.c
lib/kunit/Makefile +5 -2
@@ -16,10 +16,13 @@ endif # KUnit 'hooks' and bug handling are built-in even when KUnit is built # as a module. -obj-y += hooks.o \ - bug.o +obj-y += hooks.o +obj-$(CONFIG_KUNIT_SUPPRESS_BACKTRACE) += bug.o obj-$(CONFIG_KUNIT_TEST) += kunit-test.o +ifeq ($(CCONFIG_KUNIT_SUPPRESS_BACKTRACE),y) +obj-$(CONFIG_KUNIT_TEST) += backtrace-suppression-test.o +endif # string-stream-test compiles built-in only. ifeq ($(CONFIG_KUNIT_TEST),y)
lib/kunit/backtrace-suppression-test.c new file +104 -0
104 lines not on this page · raw message
Signature · 1 line
2.39.2
PATCH v3 4/15 kunit: Add documentation for warning backtrace suppression API
In reply to Guenter RoeckDocument API functions for suppressing warning backtraces.
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags v3:
- Rebased to v6.9-rc2
Documentation/dev-tools/kunit/usage.rst | 30 ++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-)
Documentation/dev-tools/kunit/usage.rst +29 -1
@@ -157,6 +157,34 @@ Alternatively, one can take full control over the error message by using if (some_setup_function()) KUNIT_FAIL(test, "Failed to setup thing for testing"); +Suppressing warning backtraces +------------------------------ + +Some unit tests trigger warning backtraces either intentionally or as side +effect. Such backtraces are normally undesirable since they distract from +the actual test and may result in the impression that there is a problem. + +Such backtraces can be suppressed. To suppress a backtrace in some_function(), +use the following code. + +.. code-block:: c + + static void some_test(struct kunit *test) + { + DEFINE_SUPPRESSED_WARNING(some_function); + + START_SUPPRESSED_WARNING(some_function); + trigger_backtrace(); + END_SUPPRESSED_WARNING(some_function); + } + +SUPPRESSED_WARNING_COUNT() returns the number of suppressed backtraces. If the +suppressed backtrace was triggered on purpose, this can be used to check if +the backtrace was actually triggered. + +.. code-block:: c + + KUNIT_EXPECT_EQ(test, SUPPRESSED_WARNING_COUNT(some_function), 1); Test Suites ~~~~~~~~~~~
@@ -857,4 +885,4 @@ For example: dev_managed_string = devm_kstrdup(fake_device, "Hello, World!"); // Everything is cleaned up automatically when the test ends. - } + }
Signature · 1 line
2.39.2
PATCH v3 5/15 drm: Suppress intentional warning backtraces in scaling unit tests
In reply to Guenter RoeckThe drm_test_rect_calc_hscale and drm_test_rect_calc_vscale unit tests intentionally trigger warning backtraces by providing bad parameters to the tested functions. What is tested is the return value, not the existence of a warning backtrace. Suppress the backtraces to avoid clogging the kernel log and distraction from real problems.
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags v3:
- Rebased to v6.9-rc2
drivers/gpu/drm/tests/drm_rect_test.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
drivers/gpu/drm/tests/drm_rect_test.c +16 -0
@@ -406,22 +406,38 @@ KUNIT_ARRAY_PARAM(drm_rect_scale, drm_rect_scale_cases, drm_rect_scale_case_descstatic void drm_test_rect_calc_hscale (struct kunit *test) { +DEFINE_SUPPRESSED_WARNING (drm_calc_scale);const struct drm_rect_scale_case *params = test->param_value;int scaling_factor; +/* +* drm_rect_calc_hscale() generates a warning backtrace whenever bad +* parameters are passed to it. This affects all unit tests with an +* error code in expected_scaling_factor. +*/ +START_SUPPRESSED_WARNING (drm_calc_scale); scaling_factor =drm_rect_calc_hscale (¶ms->src, ¶ms->dst, params->min_range, params->max_range); +END_SUPPRESSED_WARNING (drm_calc_scale);KUNIT_EXPECT_EQ (test, scaling_factor, params->expected_scaling_factor); }static void drm_test_rect_calc_vscale (struct kunit *test) { +DEFINE_SUPPRESSED_WARNING (drm_calc_scale);const struct drm_rect_scale_case *params = test->param_value;int scaling_factor; +/* +* drm_rect_calc_vscale() generates a warning backtrace whenever bad +* parameters are passed to it. This affects all unit tests with an +* error code in expected_scaling_factor. +*/ +START_SUPPRESSED_WARNING (drm_calc_scale); scaling_factor =drm_rect_calc_vscale (¶ms->src, ¶ms->dst, params->min_range, params->max_range); +END_SUPPRESSED_WARNING (drm_calc_scale);KUNIT_EXPECT_EQ (test, scaling_factor, params->expected_scaling_factor); }
Signature · 1 line
2.39.2
PATCH v3 6/15 net: kunit: Suppress lock warning noise at end of dev_addr_lists tests
In reply to Guenter Roeckdev_addr_lists_test generates lock warning noise at the end of tests if lock debugging is enabled. There are two sets of warnings.
WARNING: CPU: 0 PID: 689 at kernel/locking/mutex.c:923 __mutex_unlock_slowpath.constprop.0+0x13c/0x368
DEBUG_LOCKS_WARN_ON(__owner_task(owner) != __get_current())
WARNING: kunit_try_catch/1336 still has locks held!
KUnit test cleanup is not guaranteed to run in the same thread as the test itself. For this test, this means that rtnl_lock() and rtnl_unlock() may be called from different threads. This triggers the warnings. Suppress the warnings because they are irrelevant for the test and just confusing and distracting.
The first warning can be suppressed by using START_SUPPRESSED_WARNING() and END_SUPPRESSED_WARNING() around the call to rtnl_unlock(). To suppress the second warning, it is necessary to set debug_locks_silent while the rtnl lock is held.
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags v3:
- Rebased to v6.9-rc2
net/core/dev_addr_lists_test.c | 6 ++++++ 1 file changed, 6 insertions(+)
net/core/dev_addr_lists_test.c +6 -0
@@ -1,6 +1,7 @@// SPDX-License-Identifier: GPL-2.0-or-later #include <kunit/test.h> +#include <linux/debug_locks.h> #include <linux/etherdevice.h> #include <linux/netdevice.h> #include <linux/rtnetlink.h>
@@ -49,6 +50,7 @@ static int dev_addr_test_init(struct kunit *test)KUNIT_FAIL (test,"Can't register netdev %d" , err); } + debug_locks_silent =1 ;rtnl_lock ();return 0 ; }
@@ -56,8 +58,12 @@ static int dev_addr_test_init(struct kunit *test)static void dev_addr_test_exit (struct kunit *test) {struct net_device *netdev = test->priv; +DEFINE_SUPPRESSED_WARNING (__mutex_unlock_slowpath); +START_SUPPRESSED_WARNING (__mutex_unlock_slowpath);rtnl_unlock (); +END_SUPPRESSED_WARNING (__mutex_unlock_slowpath); + debug_locks_silent =0 ;unregister_netdev (netdev);free_netdev (netdev); }
Signature · 1 line
2.39.2
PATCH v3 7/15 x86: Add support for suppressing warning backtraces
In reply to Guenter RoeckAdd name of functions triggering warning backtraces to the __bug_table object section to enable support for suppressing WARNING backtraces.
To limit image size impact, the pointer to the function name is only added to the __bug_table section if both CONFIG_KUNIT_SUPPRESS_BACKTRACE and CONFIG_DEBUG_BUGVERBOSE are enabled. Otherwise, the __func__ assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused __func__ entries (this is necessary because __func__ is not a define but a virtual variable).
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2
arch/x86/include/asm/bug.h | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-)
arch/x86/include/asm/bug.h +16 -5
@@ -23,18 +23,28 @@#ifdef CONFIG_DEBUG_BUGVERBOSE +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR __BUG_REL(%c1) +# define __BUG_FUNC __func__ +#else +# define __BUG_FUNC_PTR +# define __BUG_FUNC NULL +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#define _BUG_FLAGS (ins, flags, extra) \ do { \ asm_inline volatile("1:\t" ins "\n" \ ".pushsection __bug_table,\"aw\"\n" \ "2:\t" __BUG_REL(1b) "\t# bug_entry::bug_addr\n" \ "\t" __BUG_REL(%c0) "\t# bug_entry::file\n" \ - "\t.word %c1" "\t# bug_entry::line\n" \ - "\t.word %c2" "\t# bug_entry::flags\n" \ - "\t.org 2b+%c3\n" \ + "\t" __BUG_FUNC_PTR "\t# bug_entry::function\n" \ + "\t.word %c2" "\t# bug_entry::line\n" \ + "\t.word %c3" "\t# bug_entry::flags\n" \ + "\t.org 2b+%c4\n" \ ".popsection\n" \ extra \ - : : "i" (__FILE__), "i" (__LINE__), \ + : : "i" (__FILE__), "i" (__BUG_FUNC), "i" (__LINE__),\ "i" (flags), \ "i" (sizeof(struct bug_entry))); \ } while (0)
@@ -80,7 +90,8 @@ do { \do { \__auto_type __flags =BUGFLAG_WARNING |(flags); \instrumentation_begin (); \ -_BUG_FLAGS (ASM_UD2 , __flags,ASM_REACHABLE ); \ +if (!IS_SUPPRESSED_WARNING (__func__)) \ +_BUG_FLAGS (ASM_UD2 , __flags,ASM_REACHABLE ); \instrumentation_end (); \ }while (0 )
Signature · 1 line
2.39.2
PATCH v3 8/15 arm64: Add support for suppressing warning backtraces
In reply to Guenter RoeckAdd name of functions triggering warning backtraces to the __bug_table object section to enable support for suppressing WARNING backtraces.
To limit image size impact, the pointer to the function name is only added to the __bug_table section if both CONFIG_KUNIT_SUPPRESS_BACKTRACE and CONFIG_DEBUG_BUGVERBOSE are enabled. Otherwise, the __func__ assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused __func__ entries (this is necessary because __func__ is not a define but a virtual variable).
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2
arch/arm64/include/asm/asm-bug.h | 29 +++++++++++++++++++---------- arch/arm64/include/asm/bug.h | 8 +++++++- 2 files changed, 26 insertions(+), 11 deletions(-)
arch/arm64/include/asm/asm-bug.h +19 -10
@@ -8,36 +8,45 @@#include <asm/brk-imm.h> #ifdef CONFIG_DEBUG_BUGVERBOSE -#define _BUGVERBOSE_LOCATION (file, line) __BUGVERBOSE_LOCATION(file, line) -#define __BUGVERBOSE_LOCATION (file, line) \ + +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR (func) .long func - .; +#else +# define __BUG_FUNC_PTR (func) +#endif + +#define _BUGVERBOSE_LOCATION (file, func, line) __BUGVERBOSE_LOCATION(file, func, line) +#define __BUGVERBOSE_LOCATION (file, func, line) \ .pushsection .rodata.str,"aMS",@progbits,1; \ 14472: .string file; \ .popsection; \ \ .long 14472b - .; \ + __BUG_FUNC_PTR(func) \ .short line;#else -#define _BUGVERBOSE_LOCATION (file, line) +#define _BUGVERBOSE_LOCATION (file, func, line)#endif #ifdef CONFIG_GENERIC_BUG -#define __BUG_ENTRY (flags) \ +#define __BUG_ENTRY (flags, func) \ .pushsection __bug_table,"aw"; \ .align 2; \ 14470: .long 14471f - .; \ -_BUGVERBOSE_LOCATION(__FILE__, __LINE__) \ - .short flags; \ +_BUGVERBOSE_LOCATION(__FILE__, func, __LINE__) \ + .short flags; \ .popsection; \ 14471:#else -#define __BUG_ENTRY (flags) +#define __BUG_ENTRY (flags, func)#endif -#define ASM_BUG_FLAGS (flags) \ - __BUG_ENTRY(flags) \ +#define ASM_BUG_FLAGS (flags, func) \ + __BUG_ENTRY(flags, func) \ brk BUG_BRK_IMM -#define ASM_BUG () ASM_BUG_FLAGS(0) +#define ASM_BUG () ASM_BUG_FLAGS(0, .)#endif /* __ASM_ASM_BUG_H */
arch/arm64/include/asm/bug.h +7 -1
@@ -11,8 +11,14 @@#include <asm/asm-bug.h> +#ifdef HAVE_BUG_FUNCTION +# define __BUG_FUNC __func__ +#else +# define __BUG_FUNC NULL +#endif +#define __BUG_FLAGS (flags) \ - asm volatile (__stringify(ASM_BUG_FLAGS(flags))); + asm volatile (__stringify(ASM_BUG_FLAGS(flags, %c0)) : : "i" (__BUG_FUNC));#define BUG () do { \ __BUG_FLAGS(0); \
Signature · 1 line
2.39.2
PATCH v3 9/15 loongarch: Add support for suppressing warning backtraces
In reply to Guenter RoeckAdd name of functions triggering warning backtraces to the __bug_table object section to enable support for suppressing WARNING backtraces.
To limit image size impact, the pointer to the function name is only added to the __bug_table section if both CONFIG_KUNIT_SUPPRESS_BACKTRACE and CONFIG_DEBUG_BUGVERBOSE are enabled. Otherwise, the __func__ assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused __func__ entries (this is necessary because __func__ is not a define but a virtual variable).
---
v2:
- Rebased to v6.9-rc1; resolved context conflict
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2; resolved context conflict
arch/loongarch/include/asm/bug.h | 38 +++++++++++++++++++++++--------- 1 file changed, 27 insertions(+), 11 deletions(-)
arch/loongarch/include/asm/bug.h +27 -11
@@ -3,47 +3,63 @@#define __ASM_BUG_H#include <asm/break.h> +#include <kunit/bug.h> #include <linux/stringify.h> #ifndef CONFIG_DEBUG_BUGVERBOSE -#define _BUGVERBOSE_LOCATION (file, line) +#define _BUGVERBOSE_LOCATION (file, func, line)#else -#define __BUGVERBOSE_LOCATION (file, line) \ +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR (func) .long func - .; +#else +# define __BUG_FUNC_PTR (func) +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ + +#define __BUGVERBOSE_LOCATION (file, func, line) \ .pushsection .rodata.str, "aMS", @progbits, 1; \ 10002: .string file; \ .popsection; \ \ .long 10002b - .; \ + __BUG_FUNC_PTR(func) \ .short line; -#define _BUGVERBOSE_LOCATION (file, line) __BUGVERBOSE_LOCATION(file, line) +#define _BUGVERBOSE_LOCATION (file, func, line) __BUGVERBOSE_LOCATION(file, func, line)#endif #ifndef CONFIG_GENERIC_BUG -#define __BUG_ENTRY (flags) +#define __BUG_ENTRY (flags, func)#else -#define __BUG_ENTRY (flags) \ +#define __BUG_ENTRY (flags, func) \ .pushsection __bug_table, "aw"; \ .align 2; \ 10000: .long 10001f - .; \ - _BUGVERBOSE_LOCATION(__FILE__, __LINE__) \ + _BUGVERBOSE_LOCATION(__FILE__, func, __LINE__) \ .short flags; \ .popsection; \ 10001:#endif -#define ASM_BUG_FLAGS (flags) \ - __BUG_ENTRY(flags) \ +#define ASM_BUG_FLAGS (flags, func) \ + __BUG_ENTRY(flags, func) \ break BRK_BUG -#define ASM_BUG () ASM_BUG_FLAGS(0) +#define ASM_BUG () ASM_BUG_FLAGS(0, .) + +#ifdef HAVE_BUG_FUNCTION +# define __BUG_FUNC __func__ +#else +# define __BUG_FUNC NULL +#endif #define __BUG_FLAGS (flags) \ - asm_inline volatile (__stringify(ASM_BUG_FLAGS(flags))); + asm_inline volatile (__stringify(ASM_BUG_FLAGS(flags, %0)) : : "i" (__BUG_FUNC));#define __WARN_FLAGS (flags) \ do { \ instrumentation_begin(); \ - __BUG_FLAGS(BUGFLAG_WARNING|(flags)); \ + if (!IS_SUPPRESSED_WARNING(__func__)) \ + __BUG_FLAGS(BUGFLAG_WARNING|(flags)); \ annotate_reachable(); \ instrumentation_end(); \ } while (0)
Signature · 1 line
2.39.2
PATCH v3 10/15 parisc: Add support for suppressing warning backtraces
In reply to Guenter RoeckAdd name of functions triggering warning backtraces to the __bug_table object section to enable support for suppressing WARNING backtraces.
To limit image size impact, the pointer to the function name is only added to the __bug_table section if both CONFIG_KUNIT_SUPPRESS_BACKTRACE and CONFIG_DEBUG_BUGVERBOSE are enabled. Otherwise, the __func__ assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused __func__ entries (this is necessary because __func__ is not a define but a virtual variable).
While at it, declare assembler parameters as constants where possible. Refine .blockz instructions to calculate the necessary padding instead of using fixed values.
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2
arch/parisc/include/asm/bug.h | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-)
arch/parisc/include/asm/bug.h +21 -8
@@ -23,8 +23,17 @@# define __BUG_REL (val) ".word " __stringify(val)#endif -#ifdef CONFIG_DEBUG_BUGVERBOSE + +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR __BUG_REL(%c1) +# define __BUG_FUNC __func__ +#else +# define __BUG_FUNC_PTR +# define __BUG_FUNC NULL +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#define BUG () \ do { \ asm volatile("\n" \
@@ -33,10 +42,12 @@"\t.align 4\n" \ "2:\t" __BUG_REL(1b) "\n" \ "\t" __BUG_REL(%c0) "\n" \ -"\t.short %1, %2\n" \ -"\t.blockz %3-2*4-2*2\n" \ +"\t" __BUG_FUNC_PTR"\n" \ +"\t.short %c2, %c3\n" \ +"\t.blockz %c4-(.-2b)\n" \"\t.popsection" \ - : : "i" (__FILE__), "i" (__LINE__), \ + : : "i" (__FILE__), "i" (__BUG_FUNC), \ +"i" (__LINE__), \ "i" (0), "i" (sizeof(struct bug_entry)) ); \unreachable (); \ }while (0 )
@@ -58,10 +69,12 @@"\t.align 4\n" \ "2:\t" __BUG_REL(1b) "\n" \ "\t" __BUG_REL(%c0) "\n" \ -"\t.short %1, %2\n" \ -"\t.blockz %3-2*4-2*2\n" \ +"\t" __BUG_FUNC_PTR"\n" \ +"\t.short %c2, %3\n" \ +"\t.blockz %c4-(.-2b)\n" \"\t.popsection" \ - : : "i" (__FILE__), "i" (__LINE__), \ + : : "i" (__FILE__), "i" (__BUG_FUNC), \ +"i" (__LINE__), \"i" (BUGFLAG_WARNING |(flags)), \ "i" (sizeof(struct bug_entry)) ); \ }while (0 )
@@ -74,7 +87,7 @@"\t.align 4\n" \ "2:\t" __BUG_REL(1b) "\n" \"\t.short %0\n" \ -"\t.blockz %1-4-2\n" \ +"\t.blockz %c1-(.-2b)\n" \"\t.popsection" \ : : "i" (BUGFLAG_WARNING|(flags)), \ "i" (sizeof(struct bug_entry)) ); \
Signature · 1 line
2.39.2
PATCH v3 11/15 s390: Add support for suppressing warning backtraces
In reply to Guenter RoeckAdd name of functions triggering warning backtraces to the __bug_table object section to enable support for suppressing WARNING backtraces.
To limit image size impact, the pointer to the function name is only added to the __bug_table section if both CONFIG_KUNIT_SUPPRESS_BACKTRACE and CONFIG_DEBUG_BUGVERBOSE are enabled. Otherwise, the __func__ assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused __func__ entries (this is necessary because __func__ is not a define but a virtual variable).
---
v2:
- Rebased to v6.9-rc1 (simplified assembler changes after upstream commit 3938490e78f4 ("s390/bug: remove entry size from __bug_table section")
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2
arch/s390/include/asm/bug.h | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-)
arch/s390/include/asm/bug.h +14 -3
@@ -8,6 +8,15 @@#ifdef CONFIG_DEBUG_BUGVERBOSE +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR " .long %0-.\n" +# define __BUG_FUNC __func__ +#else +# define __BUG_FUNC_PTR +# define __BUG_FUNC NULL +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#define __EMIT_BUG (x) do { \ asm_inline volatile( \ "0: mc 0,0\n" \
@@ -17,10 +26,12 @@".section __bug_table,\"aw\"\n" \"2: .long 0b-.\n" \" .long 1b-.\n" \ -" .short %0,%1\n" \ -" .org 2b+%2\n" \ + __BUG_FUNC_PTR \ +" .short %1,%2\n" \ +" .org 2b+%3\n" \".previous\n" \ - : : "i" (__LINE__), \ + : : "i" (__BUG_FUNC), \ +"i" (__LINE__), \"i" (x), \ "i" (sizeof(struct bug_entry))); \ }while (0 )
Signature · 1 line
2.39.2
PATCH v3 12/15 sh: Add support for suppressing warning backtraces
In reply to Guenter RoeckAdd name of functions triggering warning backtraces to the __bug_table object section to enable support for suppressing WARNING backtraces.
To limit image size impact, the pointer to the function name is only added to the __bug_table section if both CONFIG_KUNIT_SUPPRESS_BACKTRACE and CONFIG_DEBUG_BUGVERBOSE are enabled. Otherwise, the __func__ assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused __func__ entries (this is necessary because __func__ is not a define but a virtual variable).
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2
arch/sh/include/asm/bug.h | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-)
arch/sh/include/asm/bug.h +22 -4
@@ -24,21 +24,36 @@* The offending file and line are encoded in the __bug_table section. */ #ifdef CONFIG_DEBUG_BUGVERBOSE + +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR "\t.long %O2\n" +#else +# define __BUG_FUNC_PTR +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#define _EMIT_BUG_ENTRY \ "\t.pushsection __bug_table,\"aw\"\n" \ "2:\t.long 1b, %O1\n" \ - "\t.short %O2, %O3\n" \ - "\t.org 2b+%O4\n" \ + __BUG_FUNC_PTR \ + "\t.short %O3, %O4\n" \ + "\t.org 2b+%O5\n" \ "\t.popsection\n"#else #define _EMIT_BUG_ENTRY \ "\t.pushsection __bug_table,\"aw\"\n" \ "2:\t.long 1b\n" \ - "\t.short %O3\n" \ - "\t.org 2b+%O4\n" \ + "\t.short %O4\n" \ + "\t.org 2b+%O5\n" \ "\t.popsection\n"#endif +#ifdef HAVE_BUG_FUNCTION +# define __BUG_FUNC __func__ +#else +# define __BUG_FUNC NULL +#endif +#define BUG () \ do { \ __asm__ __volatile__ ( \
@@ -47,6 +62,7 @@ do { \ : \ : "n" (TRAPA_BUG_OPCODE), \"i" (__FILE__), \ +"i" (__BUG_FUNC), \"i" (__LINE__),"i" (0 ), \ "i" (sizeof(struct bug_entry))); \unreachable (); \
@@ -60,6 +76,7 @@ do { \ : \ : "n" (TRAPA_BUG_OPCODE), \"i" (__FILE__), \ +"i" (__BUG_FUNC), \"i" (__LINE__), \"i" (BUGFLAG_WARNING |(flags)), \ "i" (sizeof(struct bug_entry))); \
@@ -85,6 +102,7 @@ do { \ : \ : "n" (TRAPA_BUG_OPCODE), \"i" (__FILE__), \ +"i" (__BUG_FUNC), \"i" (__LINE__), \"i" (BUGFLAG_UNWINDER ), \ "i" (sizeof(struct bug_entry))); \
Signature · 1 line
2.39.2
PATCH v3 13/15 sh: Move defines needed for suppressing warning backtraces
In reply to Guenter RoeckDeclaring the defines needed for suppressing warning inside '#ifdef CONFIG_DEBUG_BUGVERBOSE' results in a kerneldoc warning.
.../bug.h:29: warning: expecting prototype for _EMIT_BUG_ENTRY().
Prototype was for HAVE_BUG_FUNCTION() instead
Move the defines above the kerneldoc entry for _EMIT_BUG_ENTRY to make kerneldoc happy.
---
v3: Added patch. Possibly squash into previous patch.
arch/sh/include/asm/bug.h | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)
arch/sh/include/asm/bug.h +9 -7
@@ -11,6 +11,15 @@#define HAVE_ARCH_BUG #define HAVE_ARCH_WARN_ON +#ifdef CONFIG_DEBUG_BUGVERBOSE +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR "\t.long %O2\n" +#else +# define __BUG_FUNC_PTR +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#endif /* CONFIG_DEBUG_BUGVERBOSE */ +/** * _EMIT_BUG_ENTRY * %1 - __FILE__
@@ -25,13 +34,6 @@*/ #ifdef CONFIG_DEBUG_BUGVERBOSE -#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE -# define HAVE_BUG_FUNCTION -# define __BUG_FUNC_PTR "\t.long %O2\n" -#else -# define __BUG_FUNC_PTR -#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ -#define _EMIT_BUG_ENTRY \ "\t.pushsection __bug_table,\"aw\"\n" \ "2:\t.long 1b, %O1\n" \
Signature · 1 line
2.39.2
PATCH v3 14/15 riscv: Add support for suppressing warning backtraces
In reply to Guenter RoeckAdd name of functions triggering warning backtraces to the __bug_table object section to enable support for suppressing WARNING backtraces.
To limit image size impact, the pointer to the function name is only added to the __bug_table section if both CONFIG_KUNIT_SUPPRESS_BACKTRACE and CONFIG_DEBUG_BUGVERBOSE are enabled. Otherwise, the __func__ assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused __func__ entries (this is necessary because __func__ is not a define but a virtual variable).
To simplify the implementation, unify the __BUG_ENTRY_ADDR and __BUG_ENTRY_FILE macros into a single macro named __BUG_REL() which takes the address, file, or function reference as parameter.
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2
arch/riscv/include/asm/bug.h | 38 ++++++++++++++++++++++++------------ 1 file changed, 26 insertions(+), 12 deletions(-)
arch/riscv/include/asm/bug.h +26 -12
@@ -30,26 +30,39 @@typedef u32 bug_insn_t ;#ifdef CONFIG_GENERIC_BUG_RELATIVE_POINTERS -#define __BUG_ENTRY_ADDR RISCV_INT " 1b - ." -#define __BUG_ENTRY_FILE RISCV_INT " %0 - ." +#define __BUG_REL (val) RISCV_INT " " __stringify(val) " - ."#else -#define __BUG_ENTRY_ADDR RISCV_PTR " 1b" -#define __BUG_ENTRY_FILE RISCV_PTR " %0" +#define __BUG_REL (val) RISCV_PTR " " __stringify(val)#endif #ifdef CONFIG_DEBUG_BUGVERBOSE + +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR __BUG_REL(%1) +#else +# define __BUG_FUNC_PTR +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#define __BUG_ENTRY \ - __BUG_ENTRY_ADDR "\n\t" \ - __BUG_ENTRY_FILE "\n\t" \ - RISCV_SHORT " %1\n\t" \ - RISCV_SHORT " %2" + __BUG_REL(1b) "\n\t" \ + __BUG_REL(%0) "\n\t" \ + __BUG_FUNC_PTR "\n\t" \ + RISCV_SHORT " %2\n\t" \ + RISCV_SHORT " %3"#else #define __BUG_ENTRY \ - __BUG_ENTRY_ADDR "\n\t" \ - RISCV_SHORT " %2" + __BUG_REL(1b) "\n\t" \ + RISCV_SHORT " %3"#endif #ifdef CONFIG_GENERIC_BUG +#ifdef HAVE_BUG_FUNCTION +# define __BUG_FUNC __func__ +#else +# define __BUG_FUNC NULL +#endif +#define __BUG_FLAGS (flags) \ do { \ __asm__ __volatile__ ( \
@@ -58,10 +71,11 @@ do { \".pushsection __bug_table,\"aw\"\n\t" \"2:\n\t" \ __BUG_ENTRY"\n\t" \ -".org 2b + %3\n\t" \ +".org 2b + %4\n\t" \".popsection" \ : \ - : "i" (__FILE__), "i" (__LINE__), \ + : "i" (__FILE__), "i" (__BUG_FUNC), \ +"i" (__LINE__), \"i" (flags), \ "i" (sizeof(struct bug_entry))); \ }while (0 )
Signature · 1 line
2.39.2
PATCH v3 15/15 powerpc: Add support for suppressing warning backtraces
In reply to Guenter RoeckAdd name of functions triggering warning backtraces to the __bug_table object section to enable support for suppressing WARNING backtraces.
To limit image size impact, the pointer to the function name is only added to the __bug_table section if both CONFIG_KUNIT_SUPPRESS_BACKTRACE and CONFIG_DEBUG_BUGVERBOSE are enabled. Otherwise, the __func__ assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused __func__ entries (this is necessary because __func__ is not a define but a virtual variable).
---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- Introduced KUNIT_SUPPRESS_BACKTRACE configuration option v3:
- Rebased to v6.9-rc2
arch/powerpc/include/asm/bug.h | 37 +++++++++++++++++++++++++--------- 1 file changed, 28 insertions(+), 9 deletions(-)
arch/powerpc/include/asm/bug.h +28 -9
@@ -14,6 +14,9 @@ .section __bug_table,"aw" 5001: .4byte \addr - . .4byte 5002f - . +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE + .4byte 0 +#endif .short \line, \flags .org 5001b+BUG_ENTRY_SIZE .previous
@@ -32,30 +35,46 @@#endif /* verbose */ #else /* !__ASSEMBLY__ */ -/* _EMIT_BUG_ENTRY expects args %0,%1,%2,%3 to be FILE, LINE, flags and -sizeof(struct bug_entry), respectively */ +/* _EMIT_BUG_ENTRY expects args %0,%1,%2,%3,%4 to be FILE, __func__, LINE, flags +and sizeof(struct bug_entry), respectively */ #ifdef CONFIG_DEBUG_BUGVERBOSE + +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR " .4byte %1 - .\n" +#else +# define __BUG_FUNC_PTR +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#define _EMIT_BUG_ENTRY \ ".section __bug_table,\"aw\"\n" \ "2: .4byte 1b - .\n" \ " .4byte %0 - .\n" \ - " .short %1, %2\n" \ - ".org 2b+%3\n" \ + __BUG_FUNC_PTR \ + " .short %2, %3\n" \ + ".org 2b+%4\n" \ ".previous\n"#else #define _EMIT_BUG_ENTRY \ ".section __bug_table,\"aw\"\n" \ "2: .4byte 1b - .\n" \ - " .short %2\n" \ - ".org 2b+%3\n" \ + " .short %3\n" \ + ".org 2b+%4\n" \ ".previous\n"#endif +#ifdef HAVE_BUG_FUNCTION +# define __BUG_FUNC __func__ +#else +# define __BUG_FUNC NULL +#endif +#define BUG_ENTRY (insn, flags, ...) \ __asm__ __volatile__( \ "1: " insn "\n" \ _EMIT_BUG_ENTRY \ - : : "i" (__FILE__), "i" (__LINE__), \ + : : "i" (__FILE__), "i" (__BUG_FUNC), \ + "i" (__LINE__), \ "i" (flags), \ "i" (sizeof(struct bug_entry)), \ ##__VA_ARGS__)
@@ -80,7 +99,7 @@if (x) \BUG (); \ }else { \ -BUG_ENTRY (PPC_TLNEI " %4, 0" ,0 ,"r" ((__force long )(x))); \ +BUG_ENTRY (PPC_TLNEI " %5, 0" ,0 ,"r" ((__force long )(x))); \ } \ }while (0 )
@@ -90,7 +109,7 @@if (__ret_warn_on) \__WARN (); \ }else { \ -BUG_ENTRY (PPC_TLNEI " %4, 0" , \ +BUG_ENTRY (PPC_TLNEI " %5, 0" , \BUGFLAG_WARNING |BUGFLAG_TAINT (TAINT_WARN ), \"r" (__ret_warn_on)); \ } \
Signature · 1 line
2.39.2
Quoted 91 lines · Guenter Roeck
Some unit tests intentionally trigger warning backtraces by passing bad parameters to kernel API functions. Such unit tests typically check the return value from such calls, not the existence of the warning backtrace.
Such intentionally generated warning backtraces are neither desirable nor useful for a number of reasons.
- They can result in overlooked real problems.
- A warning that suddenly starts to show up in unit tests needs to be investigated and has to be marked to be ignored, for example by adjusting filter scripts. Such filters are ad-hoc because there is no real standard format for warnings. On top of that, such filter scripts would require constant maintenance.One option to address problem would be to add messages such as "expected warning backtraces start / end here" to the kernel log. However, that would again require filter scripts, it might result in missing real problematic warning backtraces triggered while the test is running, and the irrelevant backtrace(s) would still clog the kernel log.
Solve the problem by providing a means to identify and suppress specific warning backtraces while executing test code. Support suppressing multiple backtraces while at the same time limiting changes to generic code to the absolute minimum. Architecture specific changes are kept at minimum by retaining function names only if both
CONFIG_DEBUG_BUGVERBOSEandCONFIG_KUNITare enabled.The first patch of the series introduces the necessary infrastructure. The second patch introduces support for counting suppressed backtraces. This capability is used in patch three to implement unit tests. Patch four documents the new API.
The next two patches add support for suppressing backtraces indrm_rectanddev_addr_listsunit tests. These patches are intended to serve as examples for the use of the functionality introduced with this series. The remaining patches implement the necessary changes for all architectures withGENERIC_BUGsupport.With
CONFIG_KUNITenabled, image size increase with this series applied is approximately 1%. The image size increase (and with it the functionality introduced by this series) can be avoided by disablingCONFIG_KUNIT_SUPPRESS_BACKTRACE.This series is based on the RFC patch and subsequent discussion at
https://patchwork.kernel.org/project/linux-kselftest/patch/[email protected]/
and offers a more comprehensive solution of the problem discussed there.Design note:
Function pointers are only added to the__bug_tablesection if bothCONFIG_KUNIT_SUPPRESS_BACKTRACEandCONFIG_DEBUG_BUGVERBOSEare enabled to avoid image size increases ifCONFIG_KUNITis disabled. There would be some benefits to adding those pointers all the time (reduced complexity, ability to display function names in BUG/WARNING messages). That change, if desired, can be made later.Checkpatch note:
Remaining checkpatch errors and warnings were deliberately ignored. Some are triggered by matching coding style or by comments interpreted as code, others by assembler macros which are disliked by checkpatch. Suggestions for improvements are welcome.Changes since RFC:
- IntroducedCONFIG_KUNIT_SUPPRESS_BACKTRACE
- Minor cleanups and bug fixes
- Added support for all affected architectures
- Added support for counting suppressed warnings
- Added unit tests using those counters
- Added patch to suppress warning backtraces indev_addr_liststestsChanges since v1:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
[I retained those tags since there have been no functional changes]
- IntroducedKUNIT_SUPPRESS_BACKTRACEconfiguration option, enabled by default.Changes since v2:
- Rebased to v6.9-rc2
- Added comments to drm warning suppression explaining why it is needed.
- Added patch to move conditional code inarch/sh/include/asm/bug.hto avoid kerneldoc warning
- Added architecture maintainers to Cc: for architecture specific patches
- No functional changes----------------------------------------------------------------
Guenter Roeck (15):
bug/kunit: Core support for suppressing warning backtraces
kunit: bug: Count suppressed warning backtraces
kunit: Add test cases for backtrace warning suppression
kunit: Add documentation for warning backtrace suppression API
drm: Suppress intentional warning backtraces in scaling unit tests
net: kunit: Suppress lock warning noise at end ofdev_addr_liststests
x86: Add support for suppressing warning backtraces
Quoted 8 lines
arm64: Add support for suppressing warning backtraces
loongarch: Add support for suppressing warning backtraces
parisc: Add support for suppressing warning backtraces
s390: Add support for suppressing warning backtraces
sh: Add support for suppressing warning backtraces
sh: Move defines needed for suppressing warning backtraces
riscv: Add support for suppressing warning backtraces
powerpc: Add support for suppressing warning backtraces
(for x86 and um)
I was planning to add warning suppression for the "overflow" KUnit tests, but it seems the vmalloc routines aren't calling warn_alloc() any more for impossible sizes. So, I think, no patches needed for lib/overflow_kunit.c, but at the end of the day, I've tested this series is working for me. :P
Signature · 1 line
Kees Cook
Jakub Kicinski
maintainerRe: [PATCH v3 06/15] net: kunit: Suppress lock warning noise at end of dev_addr_lists tests
In reply to Guenter RoeckQuoted 14 lines · On Wed, 3 Apr 2024 06:19:27 -0700 Guenter Roeck wrote:
dev_addr_lists_testgenerates lock warning noise at the end of tests if lock debugging is enabled. There are two sets of warnings.WARNING: CPU: 0 PID: 689 at kernel/locking/mutex.c:923 __mutex_unlock_slowpath.constprop.0+0x13c/0x368
DEBUG_LOCKS_WARN_ON(__owner_task(owner) != __get_current())WARNING: kunit_try_catch/1336 still has locks held!
KUnit test cleanup is not guaranteed to run in the same thread as the test itself. For this test, this means that
rtnl_lock()andrtnl_unlock()may be called from different threads. This triggers the warnings. Suppress the warnings because they are irrelevant for the test and just confusing and distracting.
Quoted 4 lines
The first warning can be suppressed by using
START_SUPPRESSED_WARNING()andEND_SUPPRESSED_WARNING()around the call tortnl_unlock(). To suppress the second warning, it is necessary to setdebug_locks_silentwhile the rtnl lock is held.
Is it okay if I move the locking into the tests, instead? It's only 4 lines more and no magic required, seems to work fine.
Re: [PATCH v3 15/15] powerpc: Add support for suppressing warning backtraces
In reply to Guenter RoeckQuoted 22 lines · Guenter Roeck
Add name of functions triggering warning backtraces to the
__bug_tableobject section to enable support for suppressing WARNING backtraces.To limit image size impact, the pointer to the function name is only added to the
__bug_tablesection if bothCONFIG_KUNIT_SUPPRESS_BACKTRACEandCONFIG_DEBUG_BUGVERBOSEare enabled. Otherwise, the__func__assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused__func__entries (this is necessary because__func__is not a define but a virtual variable).Acked-by Dan Carpenter <[email protected]>Cc Michael Ellerman <[email protected]>Signed-off-by Guenter Roeck <[email protected]>---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- IntroducedKUNIT_SUPPRESS_BACKTRACEconfiguration option v3:
- Rebased to v6.9-rc2
Quoted 2 lines
arch/powerpc/include/asm/bug.h | 37 +++++++++++++++++++++++++--------- 1 file changed, 28 insertions(+), 9 deletions(-)
I ran it through some build and boot tests, LGTM.
cheers
Simon Horman
reviewerRe: [PATCH v3 13/15] sh: Move defines needed for suppressing warning backtraces
In reply to Guenter RoeckQuoted 9 lines · Guenter Roeck
Declaring the defines needed for suppressing warning inside '#ifdef
CONFIG_DEBUG_BUGVERBOSE' results in a kerneldoc warning.
.../bug.h:29: warning: expecting prototype for_EMIT_BUG_ENTRY().
Prototype was forHAVE_BUG_FUNCTION()insteadMove the defines above the kerneldoc entry for
_EMIT_BUG_ENTRYto make kerneldoc happy.
Quoted 8 lines
Reported-by Simon Horman <[email protected]>Cc Simon Horman <[email protected]>Cc Yoshinori Sato <[email protected]>Cc Rich Felker <[email protected]>Cc John Paul Adrian Glaubitz <[email protected]>Signed-off-by Guenter Roeck <[email protected]>---
v3: Added patch. Possibly squash into previous patch.
FWIIW, this looks good to me.
Quoted 40 lines
arch/sh/include/asm/bug.h | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)arch/sh/include/asm/bug.h +9
-7@@ -11,6 +11,15 @@#define HAVE_ARCH_BUG #define HAVE_ARCH_WARN_ON +#ifdef CONFIG_DEBUG_BUGVERBOSE +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR "\t.long %O2\n" +#else +# define __BUG_FUNC_PTR +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#endif /* CONFIG_DEBUG_BUGVERBOSE */ +/** * _EMIT_BUG_ENTRY * %1 - __FILE__ @@ -25,13 +34,6 @@*/ #ifdef CONFIG_DEBUG_BUGVERBOSE -#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE -# define HAVE_BUG_FUNCTION -# define __BUG_FUNC_PTR "\t.long %O2\n" -#else -# define __BUG_FUNC_PTR -#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ -#define _EMIT_BUG_ENTRY \ "\t.pushsection __bug_table,\"aw\"\n" \ "2:\t.long 1b, %O1\n" \Signature · 1 line
2.39.2
Re: [PATCH v3 06/15] net: kunit: Suppress lock warning noise at end of dev_addr_lists tests
In reply to Jakub KicinskiQuoted 15 lines · Jakub Kicinski
Quoted 14 lines · On Wed, 3 Apr 2024 06:19:27 -0700 Guenter Roeck wrote:
dev_addr_lists_testgenerates lock warning noise at the end of tests if lock debugging is enabled. There are two sets of warnings.WARNING: CPU: 0 PID: 689 at kernel/locking/mutex.c:923 __mutex_unlock_slowpath.constprop.0+0x13c/0x368
DEBUG_LOCKS_WARN_ON(__owner_task(owner) != __get_current())WARNING: kunit_try_catch/1336 still has locks held!
KUnit test cleanup is not guaranteed to run in the same thread as the test itself. For this test, this means that
rtnl_lock()andrtnl_unlock()may be called from different threads. This triggers the warnings. Suppress the warnings because they are irrelevant for the test and just confusing and distracting.
Quoted 7 lines
Quoted 4 lines
The first warning can be suppressed by using
START_SUPPRESSED_WARNING()andEND_SUPPRESSED_WARNING()around the call tortnl_unlock(). To suppress the second warning, it is necessary to setdebug_locks_silentwhile the rtnl lock is held.Is it okay if I move the locking into the tests, instead? It's only 4 lines more and no magic required, seems to work fine.
I don't think it is that simple. Unit tests run in a kernel thread and exit immediately if a test fails. While the unit test code _looks_ sequential, that isn't really the case. Every instance of KUNIT_ASSERT_x or KUNIT_FAIL() results in immediate kernel thread termination. If that happens, any rtnl_unlock() in the failed function would not be executed. I am not aware of an equivalent of atexit() for kernel threads which would fix the problem. My understanding is that the kunit system doesn't support an equivalent either, but at least sometimes executes the exit function in a different thread context.
Guenter
Re: [PATCH v3 01/15] bug/kunit: Core support for suppressing warning backtraces
In reply to Guenter RoeckQuoted 35 lines · Guenter Roeck
Some unit tests intentionally trigger warning backtraces by passing bad parameters to API functions. Such unit tests typically check the return value from those calls, not the existence of the warning backtrace.
Such intentionally generated warning backtraces are neither desirable nor useful for a number of reasons.
- They can result in overlooked real problems.
- A warning that suddenly starts to show up in unit tests needs to be investigated and has to be marked to be ignored, for example by adjusting filter scripts. Such filters are ad-hoc because there is no real standard format for warnings. On top of that, such filter scripts would require constant maintenance.One option to address problem would be to add messages such as "expected warning backtraces start / end here" to the kernel log. However, that would again require filter scripts, it might result in missing real problematic warning backtraces triggered while the test is running, and the irrelevant backtrace(s) would still clog the kernel log.
Solve the problem by providing a means to identify and suppress specific warning backtraces while executing test code. Since the new functionality results in an image size increase of about 1% if
CONFIG_KUNITis enabled, provide configuration optionKUNIT_SUPPRESS_BACKTRACEto be able to disable the new functionality. This option is by default enabled since almost all systems withCONFIG_KUNITenabled will want to benefit from it.Cc Dan Carpenter <[email protected]>Cc Daniel Diaz <[email protected]>Cc Naresh Kamboju <[email protected]>Cc Kees Cook <[email protected]>Acked-by Dan Carpenter <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by Guenter Roeck <[email protected]>
Quoted 1 line
---
Sorry it took so long to get to this.
I love the idea, we've needed this for a while.
There are some downsides to this being entirely based on the name of the function which contains WARN(). Partly because there could be several WARN()s within a function, and there'd be overlap, and partly because the function name is never actually printed during a warning (it may come from the stack trace, but that can be misleading with inlined functions). I don't think either of these are showstoppers, though, but it'd be nice to extend this in the future with (a) other ways of identifying warnings, such as the format string, and (b) print the function name in the report, if it's present. The function name is probably a good middle ground, complexity-wise, though, so I'm happy to have it thus far.
I also think we're missing some opportunities to integrate this
better with existing KUnit infrastructure, like the action/resource/cleanup system. In particular, it'd be nice to have a way of ensuring that suppressions won't get leaked if the test aborts between START_SUPPRESSED_WARNING() and END_SUPPRESSED_WARNING(). It's not difficult to use this as-is, but it'd be nice to have some helpers, rather than having to, for instance:KUNIT_DEFINE_ACTION_WRAPPER(kunit_stop_suppressing_warning, __end_suppress_warning, struct __suppressed_warning *); DEFINE_SUPPRESSED_WARNING(vfree); START_SUPPRESSED_WARNING(vfree);kunit_add_action(test, kunit_stop_suppressing_warning, (void *)&__kunit_suppress_vfree);
(With the note that the DEFINE_SUPPRESSED_WARNING() will have to be global, or put on the heap, lest it become a dangling pointer by the time the suppression has stopped.)
Equally, do we want to make the __{start,end,is}_suppress[ed]_warning() functions KUnit 'hooks'? This would allow them to be used in modules which don't depend directly on KUnit. I suspect it's not important in this case: but worth keeping in mind in case we find a situation where we'd need to suppress a warning elsewhere.
These are all things which could be added/changed in follow-up patches, though, so I don't think they're blockers. Otherwise, this looks good: perhaps the naming could be a bit more consistent with other KUnit things, but that depends on how much we want this to be 'a part of KUnit' versus an independent bit of functionality.
Quoted 92 lines
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- AddedCONFIG_KUNIT_SUPPRESS_BACKTRACEconfiguration option, enabled by default
v3:
- Rebased to v6.9-rc2include/asm-generic/bug.h | 16 +++++++++--- include/kunit/bug.h | 51 +++++++++++++++++++++++++++++++++++++++ include/kunit/test.h | 1 + include/linux/bug.h | 13 ++++++++++ lib/bug.c | 51 ++++++++++++++++++++++++++++++++++++--- lib/kunit/Kconfig | 9 +++++++ lib/kunit/Makefile | 6 +++-- lib/kunit/bug.c | 40 ++++++++++++++++++++++++++++++ 8 files changed, 178 insertions(+), 9 deletions(-) create mode 100644 include/kunit/bug.h create mode 100644 lib/kunit/bug.cinclude/asm-generic/bug.h +13
-3@@ -18,6 +18,7 @@#endif #ifndef __ASSEMBLY__ +#include <kunit/bug.h> #include <linux/panic.h> #include <linux/printk.h> @@ -39,8 +40,14 @@ struct bug_entry {#ifdef CONFIG_DEBUG_BUGVERBOSE #ifndef CONFIG_GENERIC_BUG_RELATIVE_POINTERS const char *file; +#ifdef HAVE_BUG_FUNCTION +const char *function; +#endif #else signed int file_disp; +#ifdef HAVE_BUG_FUNCTION +signed int function_disp; +#endif #endif unsigned short line;#endif @@ -96,15 +103,18 @@ extern __printf(1, 2) void __warn_printk(const char *fmt, ...);#define __WARN () __WARN_printf(TAINT_WARN, NULL) #define __WARN_printf(taint, arg...) do { \ instrumentation_begin(); \ - warn_slowpath_fmt(__FILE__, __LINE__, taint, arg); \ + if (!IS_SUPPRESSED_WARNING(__func__)) \ + warn_slowpath_fmt(__FILE__, __LINE__, taint, arg);\ instrumentation_end(); \ } while (0)#else #define __WARN () __WARN_FLAGS(BUGFLAG_TAINT(TAINT_WARN)) #define __WARN_printf(taint, arg...) do { \ instrumentation_begin(); \ - __warn_printk(arg); \ - __WARN_FLAGS(BUGFLAG_NO_CUT_HERE | BUGFLAG_TAINT(taint));\ + if (!IS_SUPPRESSED_WARNING(__func__)) { \ + __warn_printk(arg); \ + __WARN_FLAGS(BUGFLAG_NO_CUT_HERE | BUGFLAG_TAINT(taint));\ + } \ instrumentation_end(); \ } while (0)#define WARN_ON_ONCE (condition) ({ \include/kunit/bug.h new file +17
-0@@ -0,0 +1,51 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* KUnit helpers for backtrace suppression +* +* Copyright (c) 2024 Guenter Roeck <[email protected]> +*/ + +#ifndef _KUNIT_BUG_H +#define _KUNIT_BUG_H + +#ifndef __ASSEMBLY__ + +#include <linux/kconfig.h> + +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE + +#include <linux/stringify.h>
include/kunit/bug.h line 27
Quoted 10 lines
include/kunit/bug.h new file +10
-0+#include <linux/types.h> + +struct __suppressed_warning { +struct list_head node; +const char *function; +}; + +void __start_suppress_warning (struct __suppressed_warning *warning); +void __end_suppress_warning (struct __suppressed_warning *warning); +bool __is_suppressed_warning (const char *function);
Do we want to call these '__kunit_start_suppress_warning', etc., to match other similar functions exported by KUnit to be used in macros, et al.
include/kunit/bug.h line 30
Quoted 3 lines
include/kunit/bug.h new file +3
-0+ +#define DEFINE_SUPPRESSED_WARNING (func) \ + struct __suppressed_warning __kunit_suppress_##func = \
We use the __kunit_ prefix here...
include/kunit/bug.h line 41
Quoted 11 lines
include/kunit/bug.h new file +11
-0+ { .function = __stringify(func) } + +#define START_SUPPRESSED_WARNING (func) \ + __start_suppress_warning(&__kunit_suppress_##func) + +#define END_SUPPRESSED_WARNING (func) \ + __end_suppress_warning(&__kunit_suppress_##func) + +#define IS_SUPPRESSED_WARNING (func) \ + __is_suppressed_warning(func) +
Similarly, do we want to give these KUNIT_ prefixes to match other KUnit macros.
One possibility would be to have both KUNIT_- and non-KUNIT_- variants, the latter of which accepts a struct kunit*, and registers the suppression with the test for automated cleanup.
Quoted 111 lines
include/kunit/bug.h new file +10
-0+#else /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ + +#define DEFINE_SUPPRESSED_WARNING (func) +#define START_SUPPRESSED_WARNING (func) +#define END_SUPPRESSED_WARNING (func) +#define IS_SUPPRESSED_WARNING (func) (false) + +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#endif /* __ASSEMBLY__ */ +#endif /* _KUNIT_BUG_H */ include/kunit/test.h +1
-0@@ -10,6 +10,7 @@#define _KUNIT_TEST_H#include <kunit/assert.h> +#include <kunit/bug.h> #include <kunit/try-catch.h> #include <linux/args.h> include/linux/bug.h +13
-0@@ -36,6 +36,9 @@ static inline int is_warning_bug(const struct bug_entry *bug)return bug->flags &BUGFLAG_WARNING ; } +void bug_get_file_function_line (struct bug_entry *bug,const char **file, +const char **function,unsigned int *line); +void bug_get_file_line (struct bug_entry *bug,const char **file,unsigned int *line);@@ -62,6 +65,16 @@ static inline enum bug_trap_type report_bug(unsigned long bug_addr, }struct bug_entry ; +static inline void bug_get_file_function_line (struct bug_entry *bug, +const char **file, +const char **function, +unsigned int *line) +{ + *file =NULL ; + *function =NULL ; + *line =0 ; +} +static inline void bug_get_file_line (struct bug_entry *bug,const char **file,unsigned int *line) {lib/bug.c +24
-2@@ -26,6 +26,14 @@ when CONFIG_DEBUG_BUGVERBOSE is not enabled, so you must generate the values accordingly. + 2a.Optionally implement support for the "function" entry in struct + bug_entry. This entry must point to the name of the function triggering + the warning or bug trap (normally __func__). This is only needed if + both CONFIG_DEBUG_BUGVERBOSE and CONFIG_KUNIT_SUPPRESS_BACKTRACE are + enabled and if the architecture wants to implement support for suppressing + warning backtraces. The architecture must define HAVE_BUG_FUNCTION if it + adds pointers to function names to struct bug_entry. + 3. Implement the trap - In the illegal instruction trap handler (typically), verify that the fault was in kernel mode, and call report_bug()@@ -127,14 +135,21 @@ static inline struct bug_entry *module_find_bug(unsigned long bugaddr) }#endif -void bug_get_file_line (struct bug_entry *bug,const char **file, -unsigned int *line) +void bug_get_file_function_line (struct bug_entry *bug,const char **file, +const char **function,unsigned int *line) { + *function =NULL ;#ifdef CONFIG_DEBUG_BUGVERBOSE #ifdef CONFIG_GENERIC_BUG_RELATIVE_POINTERS *file = (const char *)&bug->file_disp + bug->file_disp; +#ifdef HAVE_BUG_FUNCTION + *function = (const char *)&bug->function_disp + bug->function_disp; +#endif #else *file = bug->file; +#ifdef HAVE_BUG_FUNCTION + *function = bug->function; +#endif #endif *line = bug->line;#else @@ -143,6 +158,13 @@ void bug_get_file_line(struct bug_entry *bug, const char **file,#endif } +void bug_get_file_line (struct bug_entry *bug,const char **file,unsigned int *line) +{ +const char *function; + +bug_get_file_function_line (bug, file, &function, line); +} +struct bug_entry *find_bug (unsigned long bugaddr) {struct bug_entry *bug;
lib/bug.c struct bug_entry *find_bug(unsigned long bugaddr) · line 182
Quoted 5 lines
lib/bug.c +1
-1@@ -157,8 +179,9 @@ struct bug_entry *find_bug(unsigned long bugaddr)static enum bug_trap_type __report_bug (unsigned long bugaddr,struct pt_regs *regs) {struct bug_entry *bug; -const char *file; +const char *file, *function;
As mentioned, I'd love to see the function plumbed through and reported some day, both to make it easier to know what to suppress, and also because it's possibly more reliable even outside the suppression use-case. Could be a follow-up patch later, though.
Quoted 123 lines
lib/bug.c +22
-1unsigned line, warning, once, done; +char __maybe_unused sym[KSYM_SYMBOL_LEN ];if (!is_valid_bugaddr (bugaddr))return BUG_TRAP_TYPE_NONE ;@@ -169,12 +192,32 @@ static enum bug_trap_type __report_bug(unsigned long bugaddr, struct pt_regs *redisable_trace_on_warning (); -bug_get_file_line (bug, &file, &line); +bug_get_file_function_line (bug, &file, &function, &line); +#if defined(CONFIG_KUNIT_SUPPRESS_BACKTRACE ) && defined(CONFIG_KALLSYMS ) +if (!function) { +/* +* This will be seen if report_bug is called on an architecture +* with no architecture-specific support for suppressing warning +* backtraces, if CONFIG_DEBUG_BUGVERBOSE is not enabled, or if +* the calling code is from assembler which does not record a +* function name. Extracting the function name from the bug +* address is less than perfect since compiler optimization may +* result in 'bugaddr' pointing to a function which does not +* actually trigger the warning, but it is better than no +* suppression at all. +*/ +sprint_symbol_no_offset (sym, bugaddr); + function = sym; + } +#endif /* defined(CONFIG_KUNIT_SUPPRESS_BACKTRACE) && defined(CONFIG_KALLSYMS) */ warning = (bug->flags &BUGFLAG_WARNING ) !=0 ; once = (bug->flags &BUGFLAG_ONCE ) !=0 ; done = (bug->flags &BUGFLAG_DONE ) !=0 ; +if (warning &&IS_SUPPRESSED_WARNING (function)) +return BUG_TRAP_TYPE_WARN ; +if (warning && once) {if (done)return BUG_TRAP_TYPE_WARN ;lib/kunit/Kconfig +9
-0@@ -15,6 +15,15 @@ menuconfig KUNIT if KUNIT +config KUNIT_SUPPRESS_BACKTRACE + bool "KUnit - Enable backtrace suppression" + default y + help + Enable backtrace suppression for KUnit. If enabled, backtraces + generated intentionally by KUnit tests are suppressed. Disable + to reduce kernel image size if image size is more important than + suppression of backtraces generated by KUnit tests. + config KUNIT_DEBUGFS bool "KUnit - Enable /sys/kernel/debug/kunit debugfs representation" if !KUNIT_ALL_TESTS default KUNIT_ALL_TESTSlib/kunit/Makefile +4
-2@@ -14,8 +14,10 @@ ifeq ($(CONFIG_KUNIT_DEBUGFS),y) kunit-objs += debugfs.o endif -# KUnit 'hooks' are built-in even when KUnit is built as a module. -obj-y += hooks.o +# KUnit 'hooks' and bug handling are built-in even when KUnit is built +# as a module. +obj-y += hooks.o \ + bug.o obj-$(CONFIG_KUNIT_TEST) += kunit-test.olib/kunit/bug.c new file +40
-1@@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* KUnit helpers for backtrace suppression +* +* Copyright (c) 2024 Guenter Roeck <[email protected]> +*/ + +#include <kunit/bug.h> +#include <linux/export.h> +#include <linux/list.h> +#include <linux/string.h> + +static LIST_HEAD (suppressed_warnings); + +void __start_suppress_warning (struct __suppressed_warning *warning) +{ +list_add (&warning->node, &suppressed_warnings); +} +EXPORT_SYMBOL_GPL (__start_suppress_warning); + +void __end_suppress_warning (struct __suppressed_warning *warning) +{ +list_del (&warning->node); +} +EXPORT_SYMBOL_GPL (__end_suppress_warning); + +bool __is_suppressed_warning (const char *function) +{ +struct __suppressed_warning *warning; + +if (!function) +return false; + +list_for_each_entry (warning, &suppressed_warnings, node) { +if (!strcmp (function, warning->function)) +return true; + } +return false; +} +EXPORT_SYMBOL_GPL (__is_suppressed_warning); --
Quoted 2 lines
2.39.2
Thanks,
-- David
Re: [PATCH v3 02/15] kunit: bug: Count suppressed warning backtraces
In reply to Guenter RoeckQuoted 9 lines · Guenter Roeck
Count suppressed warning backtraces to enable code which suppresses warning backtraces to check if the expected backtrace(s) have been observed.
Using atomics for the backtrace count resulted in build errors on some architectures due to include file recursion, so use a plain integer for now.
Quoted 5 lines
Acked-by Dan Carpenter <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by Guenter Roeck <[email protected]>---
Looks good to me, thanks.
Cheers,
-- David
Quoted 72 lines
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- IntroducedKUNIT_SUPPRESS_BACKTRACEconfiguration option v3:
- Rebased to v6.9-rc2include/kunit/bug.h | 7 ++++++- lib/kunit/bug.c | 4 +++- 2 files changed, 9 insertions(+), 2 deletions(-)include/kunit/bug.h +6
-1@@ -20,6 +20,7 @@struct __suppressed_warning {struct list_head node;const char *function; +int counter; };void __start_suppress_warning (struct __suppressed_warning *warning);@@ -28,7 +29,7 @@ bool __is_suppressed_warning(const char *function);#define DEFINE_SUPPRESSED_WARNING (func) \ struct __suppressed_warning __kunit_suppress_##func = \ - { .function = __stringify(func) } + { .function = __stringify(func), .counter = 0 }#define START_SUPPRESSED_WARNING (func) \ __start_suppress_warning(&__kunit_suppress_##func)@@ -39,12 +40,16 @@ bool __is_suppressed_warning(const char *function);#define IS_SUPPRESSED_WARNING (func) \ __is_suppressed_warning(func) +#define SUPPRESSED_WARNING_COUNT (func) \ + (__kunit_suppress_##func.counter) +#else /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ #define DEFINE_SUPPRESSED_WARNING (func)#define START_SUPPRESSED_WARNING (func)#define END_SUPPRESSED_WARNING (func)#define IS_SUPPRESSED_WARNING (func) (false) +#define SUPPRESSED_WARNING_COUNT (func) (0)#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ #endif /* __ASSEMBLY__ */ lib/kunit/bug.c +3
-2@@ -32,8 +32,10 @@ bool __is_suppressed_warning(const char *function)return false;list_for_each_entry (warning, &suppressed_warnings, node) { -if (!strcmp (function, warning->function)) +if (!strcmp (function, warning->function)) { + warning->counter++;return true; + } }return false; } --2.39.2
--
You received this message because you are subscribed to the Google Groups "KUnit Development" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [email protected]. To view this discussion on the web visit https://groups.google.com/d/msgid/kunit-dev/20240403131936.787234-3-linux%40roeck-us.net.
Re: [PATCH v3 03/15] kunit: Add test cases for backtrace warning suppression
In reply to Guenter RoeckQuoted 7 lines · Guenter Roeck
Add unit tests to verify that warning backtrace suppression works.
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.
Quoted 5 lines
Acked-by Dan Carpenter <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by Guenter Roeck <[email protected]>---
There's a typo in the Makefile, which stops this from being built at all. Otherwise, it seems good to me.
-- David
Quoted 17 lines
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- IntroducedKUNIT_SUPPRESS_BACKTRACEconfiguration option v3:
- Rebased to v6.9-rc2lib/kunit/Makefile | 7 +- lib/kunit/backtrace-suppression-test.c | 104 +++++++++++++++++++++++++ 2 files changed, 109 insertions(+), 2 deletions(-) create mode 100644 lib/kunit/backtrace-suppression-test.clib/kunit/Makefile +0
-0
lib/kunit/Makefile endif · line 23
Quoted 10 lines
lib/kunit/Makefile +3
-2@@ -16,10 +16,13 @@ endif # KUnit 'hooks' and bug handling are built-in even when KUnit is built # as a module. -obj-y += hooks.o \ - bug.o +obj-y += hooks.o +obj-$(CONFIG_KUNIT_SUPPRESS_BACKTRACE) += bug.o obj-$(CONFIG_KUNIT_TEST) += kunit-test.o +ifeq ($(CCONFIG_KUNIT_SUPPRESS_BACKTRACE),y)
s/CCONFIG_/CONFIG_/ ?
Quoted 118 lines
lib/kunit/Makefile +2
-0+obj-$(CONFIG_KUNIT_TEST) += backtrace-suppression-test.o +endif # string-stream-test compiles built-in only. ifeq ($(CONFIG_KUNIT_TEST),y)lib/kunit/backtrace-suppression-test.c new file +104
-1@@ -0,0 +1,104 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* KUnit test for suppressing warning tracebacks +* +* Copyright (C) 2024, Guenter Roeck +* Author: Guenter Roeck <[email protected]> +*/ + +#include <kunit/test.h> +#include <linux/bug.h> + +static void backtrace_suppression_test_warn_direct (struct kunit *test) +{ +DEFINE_SUPPRESSED_WARNING (backtrace_suppression_test_warn_direct); + +START_SUPPRESSED_WARNING (backtrace_suppression_test_warn_direct); +WARN (1 ,"This backtrace should be suppressed" ); +END_SUPPRESSED_WARNING (backtrace_suppression_test_warn_direct); + +KUNIT_EXPECT_EQ (test,SUPPRESSED_WARNING_COUNT (backtrace_suppression_test_warn_direct),1 ); +} + +static void trigger_backtrace_warn (void ) +{ +WARN (1 ,"This backtrace should be suppressed" ); +} + +static void backtrace_suppression_test_warn_indirect (struct kunit *test) +{ +DEFINE_SUPPRESSED_WARNING (trigger_backtrace_warn); + +START_SUPPRESSED_WARNING (trigger_backtrace_warn); +trigger_backtrace_warn (); +END_SUPPRESSED_WARNING (trigger_backtrace_warn); + +KUNIT_EXPECT_EQ (test,SUPPRESSED_WARNING_COUNT (trigger_backtrace_warn),1 ); +} + +static void backtrace_suppression_test_warn_multi (struct kunit *test) +{ +DEFINE_SUPPRESSED_WARNING (trigger_backtrace_warn); +DEFINE_SUPPRESSED_WARNING (backtrace_suppression_test_warn_multi); + +START_SUPPRESSED_WARNING (backtrace_suppression_test_warn_multi); +START_SUPPRESSED_WARNING (trigger_backtrace_warn); +WARN (1 ,"This backtrace should be suppressed" ); +trigger_backtrace_warn (); +END_SUPPRESSED_WARNING (trigger_backtrace_warn); +END_SUPPRESSED_WARNING (backtrace_suppression_test_warn_multi); + +KUNIT_EXPECT_EQ (test,SUPPRESSED_WARNING_COUNT (backtrace_suppression_test_warn_multi),1 ); +KUNIT_EXPECT_EQ (test,SUPPRESSED_WARNING_COUNT (trigger_backtrace_warn),1 ); +} + +static void backtrace_suppression_test_warn_on_direct (struct kunit *test) +{ +DEFINE_SUPPRESSED_WARNING (backtrace_suppression_test_warn_on_direct); + +if (!IS_ENABLED (CONFIG_DEBUG_BUGVERBOSE ) && !IS_ENABLED (CONFIG_KALLSYMS )) +kunit_skip (test,"requires CONFIG_DEBUG_BUGVERBOSE or CONFIG_KALLSYMS" ); + +START_SUPPRESSED_WARNING (backtrace_suppression_test_warn_on_direct); +WARN_ON (1 ); +END_SUPPRESSED_WARNING (backtrace_suppression_test_warn_on_direct); + +KUNIT_EXPECT_EQ (test, +SUPPRESSED_WARNING_COUNT (backtrace_suppression_test_warn_on_direct),1 ); +} + +static void trigger_backtrace_warn_on (void ) +{ +WARN_ON (1 ); +} + +static void backtrace_suppression_test_warn_on_indirect (struct kunit *test) +{ +DEFINE_SUPPRESSED_WARNING (trigger_backtrace_warn_on); + +if (!IS_ENABLED (CONFIG_DEBUG_BUGVERBOSE )) +kunit_skip (test,"requires CONFIG_DEBUG_BUGVERBOSE" ); + +START_SUPPRESSED_WARNING (trigger_backtrace_warn_on); +trigger_backtrace_warn_on (); +END_SUPPRESSED_WARNING (trigger_backtrace_warn_on); + +KUNIT_EXPECT_EQ (test,SUPPRESSED_WARNING_COUNT (trigger_backtrace_warn_on),1 ); +} + +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), + {} +}; + +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" ); --2.39.2
Re: [PATCH v3 04/15] kunit: Add documentation for warning backtrace suppression API
In reply to Guenter RoeckQuoted 8 lines · Guenter Roeck
Document API functions for suppressing warning backtraces.
Acked-by Dan Carpenter <[email protected]>Reviewed-by Kees Cook <[email protected]>Signed-off-by Guenter Roeck <[email protected]>---
This looks good to me: thanks for adding the documentation!
If we add integration between this and the KUnit resource system, we'll need to add that to this documentation.
I wonder if it would make sense to have an example where the DEFINE_SUPPRESSED_WARNING() is global, e.g., in the test init/exit functions. That might overcomplicate it a bit.
It also might be nice to document the individual macros with kerneldoc comments. (Though, that could equally fit in patch #1).
Still, this is the most important bit, so I'm happy to have it as-is.
Cheers,
-- David
Quoted 58 lines
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags v3:
- Rebased to v6.9-rc2Documentation/dev-tools/kunit/usage.rst | 30 ++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-)Documentation/dev-tools/kunit/usage.rst +29
-2@@ -157,6 +157,34 @@ Alternatively, one can take full control over the error message by using if (some_setup_function()) KUNIT_FAIL(test, "Failed to setup thing for testing"); +Suppressing warning backtraces +------------------------------ + +Some unit tests trigger warning backtraces either intentionally or as side +effect. Such backtraces are normally undesirable since they distract from +the actual test and may result in the impression that there is a problem. + +Such backtraces can be suppressed. To suppress a backtrace in some_function(), +use the following code. + +.. code-block:: c + + static void some_test(struct kunit *test) + { + DEFINE_SUPPRESSED_WARNING(some_function); + + START_SUPPRESSED_WARNING(some_function); + trigger_backtrace(); + END_SUPPRESSED_WARNING(some_function); + } + +SUPPRESSED_WARNING_COUNT() returns the number of suppressed backtraces. If the +suppressed backtrace was triggered on purpose, this can be used to check if +the backtrace was actually triggered. + +.. code-block:: c + + KUNIT_EXPECT_EQ(test, SUPPRESSED_WARNING_COUNT(some_function), 1); Test Suites ~~~~~~~~~~~@@ -857,4 +885,4 @@ For example: dev_managed_string = devm_kstrdup(fake_device, "Hello, World!"); // Everything is cleaned up automatically when the test ends. - } + } --2.39.2
Re: [PATCH v3 03/15] kunit: Add test cases for backtrace warning suppression
In reply to David GowQuoted 5 lines · David Gow
Quoted 1 line
+ifeq ($(CCONFIG_KUNIT_SUPPRESS_BACKTRACE),y)
s/CCONFIG_/CONFIG_/ ?
Odd, I know I tested this (and it still works ;-). The additional "C" must have slipped in at some point. Thanks for noticing!
Guenter
Re: [PATCH v3 14/15] riscv: Add support for suppressing warning backtraces
In reply to Guenter RoeckQuoted 107 lines · Guenter Roeck
Add name of functions triggering warning backtraces to the
__bug_tableobject section to enable support for suppressing WARNING backtraces.To limit image size impact, the pointer to the function name is only added to the
__bug_tablesection if bothCONFIG_KUNIT_SUPPRESS_BACKTRACEandCONFIG_DEBUG_BUGVERBOSEare enabled. Otherwise, the__func__assembly parameter is replaced with a (dummy) NULL parameter to avoid an image size increase due to unused__func__entries (this is necessary because__func__is not a define but a virtual variable).To simplify the implementation, unify the
__BUG_ENTRY_ADDRand__BUG_ENTRY_FILEmacros into a single macro named__BUG_REL()which takes the address, file, or function reference as parameter.Acked-by Dan Carpenter <[email protected]>Cc Paul Walmsley <[email protected]>Cc Palmer Dabbelt <[email protected]>Cc Albert Ou <[email protected]>Signed-off-by Guenter Roeck <[email protected]>---
v2:
- Rebased to v6.9-rc1
- Added Tested-by:, Acked-by:, and Reviewed-by: tags
- IntroducedKUNIT_SUPPRESS_BACKTRACEconfiguration option v3:
- Rebased to v6.9-rc2arch/riscv/include/asm/bug.h | 38 ++++++++++++++++++++++++------------ 1 file changed, 26 insertions(+), 12 deletions(-)arch/riscv/include/asm/bug.h +26
-12@@ -30,26 +30,39 @@typedef u32 bug_insn_t ;#ifdef CONFIG_GENERIC_BUG_RELATIVE_POINTERS -#define __BUG_ENTRY_ADDR RISCV_INT " 1b - ." -#define __BUG_ENTRY_FILE RISCV_INT " %0 - ." +#define __BUG_REL (val) RISCV_INT " " __stringify(val) " - ."#else -#define __BUG_ENTRY_ADDR RISCV_PTR " 1b" -#define __BUG_ENTRY_FILE RISCV_PTR " %0" +#define __BUG_REL (val) RISCV_PTR " " __stringify(val)#endif #ifdef CONFIG_DEBUG_BUGVERBOSE + +#ifdef CONFIG_KUNIT_SUPPRESS_BACKTRACE +# define HAVE_BUG_FUNCTION +# define __BUG_FUNC_PTR __BUG_REL(%1) +#else +# define __BUG_FUNC_PTR +#endif /* CONFIG_KUNIT_SUPPRESS_BACKTRACE */ +#define __BUG_ENTRY \ - __BUG_ENTRY_ADDR "\n\t" \ - __BUG_ENTRY_FILE "\n\t" \ - RISCV_SHORT " %1\n\t" \ - RISCV_SHORT " %2" + __BUG_REL(1b) "\n\t" \ + __BUG_REL(%0) "\n\t" \ + __BUG_FUNC_PTR "\n\t" \ + RISCV_SHORT " %2\n\t" \ + RISCV_SHORT " %3"#else #define __BUG_ENTRY \ - __BUG_ENTRY_ADDR "\n\t" \ - RISCV_SHORT " %2" + __BUG_REL(1b) "\n\t" \ + RISCV_SHORT " %3"#endif #ifdef CONFIG_GENERIC_BUG +#ifdef HAVE_BUG_FUNCTION +# define __BUG_FUNC __func__ +#else +# define __BUG_FUNC NULL +#endif +#define __BUG_FLAGS (flags) \ do { \ __asm__ __volatile__ ( \@@ -58,10 +71,11 @@ do { \".pushsection __bug_table,\"aw\"\n\t" \"2:\n\t" \ __BUG_ENTRY"\n\t" \ -".org 2b + %3\n\t" \ +".org 2b + %4\n\t" \".popsection" \ : \ - : "i" (__FILE__), "i" (__LINE__), \ + : "i" (__FILE__), "i" (__BUG_FUNC), \ +"i" (__LINE__), \"i" (flags), \ "i" (sizeof(struct bug_entry))); \ }while (0 )Signature · 7 lines
2.39.2 _______________________________________________ linux-riscv mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-riscv
- Charlie