Add sysfs interface to collect reports from debugging tools
Subsystems (5)
Alexander Potapenko
maintainercover Add sysfs interface to collect reports from debugging tools
This patchset adds a library that captures error reports from debugging tools like KASAN or KFENCE and exposes those reports to userspace via sysfs. Report capturing is controlled by two new types of tracepoints:error_report_start and error_report_end, that must be added to the tools that want to use this new feature.
Alexander Potapenko (4):
tracing: add error_report trace points
lib: add error_report_notify to collect debugging tools' reports
kfence: use error_report_start and error_report_end tracepoints
kasan: use error_report_start and error_report_end tracepoints
include/trace/events/error_report.h | 51 +++++ kernel/trace/Makefile | 1 + kernel/trace/error_report-traces.c | 11 ++ lib/Kconfig.debug | 14 ++ lib/Makefile | 2 + lib/error_report_notify.c | 278 ++++++++++++++++++++++++++++ mm/kasan/report.c | 15 +- mm/kfence/report.c | 3 + 8 files changed, 369 insertions(+), 6 deletions(-) create mode 100644 include/trace/events/error_report.h create mode 100644 kernel/trace/error_report-traces.c create mode 100644 lib/error_report_notify.c
Signature · 1 line
2.30.0.284.gd98b1dd5eaa7-goog
Alexander Potapenko
maintainerPATCH 1/4 tracing: add error_report trace points
Introduce error_report_start and error_report_end tracepoints. Those can be used in debugging tools like KASAN, KFENCE, etc. to provide extensions to the error reporting mechanisms (e.g. allow tests hook into error reporting, ease error report collection from production kernels).
Another benefit would be making use of ftrace for debugging or benchmarking the tools themselves.
--- include/trace/events/error_report.h | 51 +++++++++++++++++++++++++++++ kernel/trace/Makefile | 1 + kernel/trace/error_report-traces.c | 11 +++++++ 3 files changed, 63 insertions(+) create mode 100644 include/trace/events/error_report.h create mode 100644 kernel/trace/error_report-traces.c
include/trace/events/error_report.h new file +51 -0
@@ -0,0 +1,51 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#undef TRACE_SYSTEM +#define TRACE_SYSTEM error_report + +#if !defined(_TRACE_ERROR_REPORT_H) || defined(TRACE_HEADER_MULTI_READ ) +#define _TRACE_ERROR_REPORT_H + +#include <linux/tracepoint.h> + +DECLARE_EVENT_CLASS (error_report_template, + TP_PROTO(const char *error_detector, unsigned long id), +TP_ARGS (error_detector, id), + TP_STRUCT__entry(__field(const char *, error_detector) + __field(unsigned long, id)), + TP_fast_assign(__entry->error_detector = error_detector; + __entry->id = id;), +TP_printk ("[%s] %lx" , __entry->error_detector, + __entry->id)); + +/** +* error_report_start - called before printing the error report +* @error_detector: short string describing the error detection tool +* @id: pseudo-unique descriptor that can help distinguish reports +* from one another. Depending on the tool, good examples +* could be: memory access address, call site, allocation +* site, etc. +* +* This event occurs right before a debugging tool starts printing the error +* report. +*/ +DEFINE_EVENT (error_report_template, error_report_start, + TP_PROTO(const char *error_detector, unsigned long id), +TP_ARGS (error_detector, id)); + +/** +* error_report_end - called after printing the error report +* @error_detector: short string describing the error detection tool +* @id: pseudo-unique descriptor, matches that passed to +* error_report_start +* +* This event occurs right after a debugging tool finishes printing the error +* report. +*/ +DEFINE_EVENT (error_report_template, error_report_end, + TP_PROTO(const char *error_detector, unsigned long id), +TP_ARGS (error_detector, id)); + +#endif /* _TRACE_ERROR_REPORT_H */ + +/* This part must be outside protection */ +#include <trace/define_trace.h>
kernel/trace/Makefile +1 -0
@@ -81,6 +81,7 @@ obj-$(CONFIG_SYNTH_EVENTS) += trace_events_synth.o obj-$(CONFIG_HIST_TRIGGERS) += trace_events_hist.o obj-$(CONFIG_BPF_EVENTS) += bpf_trace.o obj-$(CONFIG_KPROBE_EVENTS) += trace_kprobe.o +obj-$(CONFIG_TRACEPOINTS) += error_report-traces.o obj-$(CONFIG_TRACEPOINTS) += power-traces.o ifeq ($(CONFIG_PM),y) obj-$(CONFIG_TRACEPOINTS) += rpm-traces.o
kernel/trace/error_report-traces.c new file +11 -0
@@ -0,0 +1,11 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Error reporting trace points +*/ + +#define CREATE_TRACE_POINTS +#include <trace/events/error_report.h> + +EXPORT_TRACEPOINT_SYMBOL_GPL (error_report_start); +EXPORT_TRACEPOINT_SYMBOL_GPL (error_report_end); +
Signature · 1 line
2.30.0.284.gd98b1dd5eaa7-goog
Steven Rostedt
maintainerRe: [PATCH 1/4] tracing: add error_report trace points
Review
Quoted 2 lines · On Wed, 13 Jan 2021 10:16:54 +0100 Alexander Potapenko <[email protected]>…
(quoted diff) +2
-0+DECLARE_EVENT_CLASS(error_report_template, + TP_PROTO(const char *error_detector, unsigned long id),
Instead of having a random string, as this should be used by a small finite set of subsystems, why not make the above into an enum?
include/trace/events/error_report.h line 17
Quoted 6 lines
include/trace/events/error_report.h new file +6
-0+TP_ARGS (error_detector, id), + TP_STRUCT__entry(__field(const char *, error_detector) + __field(unsigned long, id)), + TP_fast_assign(__entry->error_detector = error_detector; + __entry->id = id;), + TP_printk("[%s] %lx", __entry->error_detector,
Then the [%s] portion of this could also be just a __print_symbolic().
-- Steve
Quoted 3 lines
include/trace/events/error_report.h new file +3
-0+ __entry->id)); + +/**
Alexander Potapenko
maintainerRe: [PATCH 1/4] tracing: add error_report trace points
Quoted 9 lines · Steven Rostedt
Review
Quoted 2 lines · On Wed, 13 Jan 2021 10:16:54 +0100 Alexander Potapenko <[email protected]>…
(quoted diff) +2
-0+DECLARE_EVENT_CLASS(error_report_template, + TP_PROTO(const char *error_detector, unsigned long id),Instead of having a random string, as this should be used by a small finite set of subsystems, why not make the above into an enum?
You're probably right.
I just thought it might be a good idea to minimize the effort needed from tools' authors to add these tracepoints to the tools (see the following two patches), and leave room for some extensibility (e.g. passing bug type together with the tool name etc.)
Quoted 8 lines
include/trace/events/error_report.h line 17
Quoted 6 lines
include/trace/events/error_report.h new file +6
-0+TP_ARGS (error_detector, id), + TP_STRUCT__entry(__field(const char *, error_detector) + __field(unsigned long, id)), + TP_fast_assign(__entry->error_detector = error_detector; + __entry->id = id;), + TP_printk("[%s] %lx", __entry->error_detector,Then the [%s] portion of this could also be just a
__print_symbolic().
We'll need to explicitly list the enum values once again in __print_symbolic(), right? E.g.:
enum debugging_tool {
TOOL_KFENCE,
TOOL_KASAN,
...
}TP_printk(__print_symbolic(__entry->error_detector, TOOL_KFENCE, TOOL_KASAN, ...),
Marco Elver
maintainerRe: [PATCH 1/4] tracing: add error_report trace points
Quoted 25 lines · Alexander Potapenko
Quoted 9 lines · Steven Rostedt
Review
Quoted 2 lines · On Wed, 13 Jan 2021 10:16:54 +0100 Alexander Potapenko <[email protected]>…
(quoted diff) +2
-0+DECLARE_EVENT_CLASS(error_report_template, + TP_PROTO(const char *error_detector, unsigned long id),Instead of having a random string, as this should be used by a small finite set of subsystems, why not make the above into an enum?
You're probably right.
I just thought it might be a good idea to minimize the effort needed from tools' authors to add these tracepoints to the tools (see the following two patches), and leave room for some extensibility (e.g. passing bug type together with the tool name etc.)Quoted 7 lines
Quoted 6 lines
include/trace/events/error_report.h new file +6
-0+TP_ARGS (error_detector, id), + TP_STRUCT__entry(__field(const char *, error_detector) + __field(unsigned long, id)), + TP_fast_assign(__entry->error_detector = error_detector; + __entry->id = id;), + TP_printk("[%s] %lx", __entry->error_detector,
Quoted 6 lines
Quoted 1 line
Then the [%s] portion of this could also be just a
__print_symbolic().We'll need to explicitly list the enum values once again in
__print_symbolic(), right? E.g.:enum
debugging_tool{
We need to use TRACE_DEFINE_ENUM().
Quoted 1 line
TOOL_KFENCE,
For consistency I would call the enum simply "ERROR_DETECTOR" as well. (Hypothetically, there could also be an "error detector" that is not a "debugging tool".)
Quoted 6 lines
TOOL_KASAN, ... }TP_printk(__print_symbolic(__entry->error_detector,
TOOL_KFENCE,TOOL_KASAN, ...),
It takes a list of val -> str. E.g. __print_symbolic(__entry->error_detector, { TOOL_KFENCE, "KFENCE" }, { TOOL_KASAN, "KASAN" }).
Looking around the kernel, sometimes this is simplified with macros, but not sure if it's worth it. Typing the same thing 3 times is fine, given this list won't grow really fast.
Thanks,
-- Marco
Steven Rostedt
maintainerRe: [PATCH 1/4] tracing: add error_report trace points
In reply to Alexander PotapenkoQuoted 11 lines · On Thu, 14 Jan 2021 08:49:57 +0100 Alexander Potapenko <[email protected]>…
We'll need to explicitly list the enum values once again in
__print_symbolic(), right? E.g.:enum debugging_tool { TOOL_KFENCE, TOOL_KASAN, ... }TP_printk(__print_symbolic(__entry->error_detector,
TOOL_KFENCE,TOOL_KASAN, ...),
Usually what is done is to make this into a macro:
#define REPORT_TOOL_LIST \
EM(KFENCE, kfence) \
EMe(KASAN, kasan)
#undef EM
#undef EMe
#define EM(a,b) TRACE_DEFINE_ENUM(a)
#define EMe(a,b) TRACE_DEFINE_ENUM(a)
REPORT_TOOL_LIST
#undef EM
#undef EMe
#define EM(a, b) { a, b },
#define EMe(a, b) { a, b }
#define show_report_tool_list(val) \
__print_symbolic(val, REPORT_TOOL_LIST)
[..]
TP_printk("[%s] %lx", show_report_tool_list(__entry->error_detector),
__entry->id)
This is done in several other trace event files. For example, see
include/trace/events/sock.h
-- Steve
Alexander Potapenko
maintainerRe: [PATCH 1/4] tracing: add error_report trace points
Quoted 13 lines · Steven Rostedt
Quoted 9 lines · On Thu, 14 Jan 2021 08:49:57 +0100 Alexander Potapenko <[email protected]>…
We'll need to explicitly list the enum values once again in
__print_symbolic(), right? E.g.:enum debugging_tool { TOOL_KFENCE, TOOL_KASAN, ... }
Quoted 8 lines
Quoted 2 lines
TP_printk(__print_symbolic(__entry->error_detector,
TOOL_KFENCE,TOOL_KASAN, ...),Usually what is done is to make this into a macro:
#define
REPORT_TOOL_LIST\
EM(KFENCE, kfence)\
EMe(KASAN, kasan)
Thanks, will be done in v2!
Note that checkpatch doesn't really like this declaration style, claiming that "Macros with complex values should be enclosed in parentheses".
(although it is consistent with what's done in other trace event headers)
Quoted 3 lines
#define
EM(a,b)TRACE_DEFINE_ENUM(a)
#defineEMe(a,b)TRACE_DEFINE_ENUM(a)
These lines must end with a semicolon, according to other headers (and that becomes yet another thing that checkpatch barks at).
Steven Rostedt
maintainerRe: [PATCH 1/4] tracing: add error_report trace points
Quoted 9 lines · On Fri, 15 Jan 2021 13:53:19 +0100 Alexander Potapenko <[email protected]>…
Quoted 3 lines
#define
REPORT_TOOL_LIST\
EM(KFENCE, kfence)\
EMe(KASAN, kasan)Thanks, will be done in v2!
Note that checkpatch doesn't really like this declaration style, claiming that "Macros with complex values should be enclosed in parentheses".
(although it is consistent with what's done in other trace event headers)
checkpatch.pl hates most of the tracing macro code ;-)
It's the one place that you can mostly ignore checkpatch reports.
-- Steve
Alexander Potapenko
maintainerPATCH 2/4 lib: add error_report_notify to collect debugging tools' reports
In reply to Alexander PotapenkoWith the introduction of various production error-detection tools, such as MTE-based KASAN and KFENCE, the need arises to efficiently notify the userspace OS components about kernel errors. Currently, no facility exists to notify userspace about a kernel error from such bug-detection tools. The problem is obviously not restricted to the above bug detection tools, and applies to any error reporting mechanism that does not panic the kernel; this series, however, will only add support for KASAN and KFENCE reporting.
All such error reports appear in the kernel log. But, when such errors occur, userspace would normally need to read the entire kernel log and parse the relevant errors. This is error prone and inefficient, as userspace needs to continuously monitor the kernel log for error messages. On certain devices, this is unfortunately not acceptable. Therefore, we need to revisit how reports are propagated to userspace.
The library added, error_report_notify (CONFIG_ERROR_REPORT_NOTIFY), solves the above by using the error_report_start/error_report_end tracing events and exposing the last report and the total report count to the userspace via /sys/kernel/error_report/last_report and /sys/kernel/error_report/report_count.
Userspace apps can call poll(POLLPRI) on those files to get notified about the new reports without having to watch dmesg in a loop.
--- lib/Kconfig.debug | 14 ++ lib/Makefile | 2 + lib/error_report_notify.c | 278 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 294 insertions(+) create mode 100644 lib/error_report_notify.c
lib/Kconfig.debug +14 -0
@@ -209,6 +209,20 @@ config DEBUG_BUGVERBOSE of the BUG call as well as the EIP and oops trace. This aids debugging but costs about 70-100K of memory. +config ERROR_REPORT_NOTIFY + bool "Expose memory error reports to the userspace" + depends on TRACING + help + When enabled, captures error reports from debugging tools (such as + KFENCE or KASAN) using console tracing, and exposes reports in + /sys/kernel/error_report/: the file last_report contains the last + report (with maximum report length of PAGE_SIZE), and report_count, + the total report count. + + Userspace programs can call poll(POLLPRI) on those files to get + notified about the new reports without having to watch dmesg in a + loop. + endmenu # "printk and dmesg options" menu "Compile-time checks and compiler options"
lib/Makefile +2 -0
@@ -240,6 +240,8 @@ obj-$(CONFIG_CPU_RMAP) += cpu_rmap.o obj-$(CONFIG_DQL) += dynamic_queue_limits.o +obj-$(CONFIG_ERROR_REPORT_NOTIFY) += error_report_notify.o + obj-$(CONFIG_GLOB) += glob.o obj-$(CONFIG_GLOB_SELFTEST) += globtest.o
lib/error_report_notify.c new file +278 -0
278 lines not on this page · raw message
Signature · 1 line
2.30.0.284.gd98b1dd5eaa7-goog
Andrew Morton
maintainerRe: [PATCH 2/4] lib: add error_report_notify to collect debugging tools' reports
Quoted 16 lines · On Wed, 13 Jan 2021 10:16:55 +0100 Alexander Potapenko <[email protected]>…
With the introduction of various production error-detection tools, such as MTE-based KASAN and KFENCE, the need arises to efficiently notify the userspace OS components about kernel errors. Currently, no facility exists to notify userspace about a kernel error from such bug-detection tools. The problem is obviously not restricted to the above bug detection tools, and applies to any error reporting mechanism that does not panic the kernel; this series, however, will only add support for KASAN and KFENCE reporting.
All such error reports appear in the kernel log. But, when such errors occur, userspace would normally need to read the entire kernel log and parse the relevant errors. This is error prone and inefficient, as userspace needs to continuously monitor the kernel log for error messages. On certain devices, this is unfortunately not acceptable. Therefore, we need to revisit how reports are propagated to userspace.
Quoted 8 lines
The library added,
error_report_notify(CONFIG_ERROR_REPORT_NOTIFY), solves the above by using the error_report_start/error_report_end tracing events and exposing the last report and the total report count to the userspace via/sys/kernel/error_report/last_reportand/sys/kernel/error_report/report_count.Userspace apps can call poll(POLLPRI) on those files to get notified about the new reports without having to watch dmesg in a loop.
It would be nice to see some user-facing documentation for this, under Documentation/. How to use it, what the shortcomings are, etc.
For instance... what happens when userspace is slow reading /sys/kernel/error_report/last_report? Does that file buffer multiple reports? Does the previous one get overwritten? etc. Words on how this obvious issue is handled...
lib/Kconfig.debug config DEBUG_BUGVERBOSE · line 213
Quoted 8 lines
lib/Kconfig.debug +2
-0@@ -209,6 +209,20 @@ config DEBUG_BUGVERBOSE of the BUG call as well as the EIP and oops trace. This aids debugging but costs about 70-100K of memory. +config ERROR_REPORT_NOTIFY + bool "Expose memory error reports to the userspace"
There's really nothing "memory" specific about this? Any kernel subsystem could use it?
lib/Kconfig.debug config DEBUG_BUGVERBOSE · line 224
Quoted 11 lines
lib/Kconfig.debug +11
-0+ depends on TRACING + help + When enabled, captures error reports from debugging tools (such as + KFENCE or KASAN) using console tracing, and exposes reports in + /sys/kernel/error_report/: the file last_report contains the last + report (with maximum report length of PAGE_SIZE), and report_count, + the total report count. + + Userspace programs can call poll(POLLPRI) on those files to get + notified about the new reports without having to watch dmesg in a + loop.
So we have a whole new way of getting debug info out of the kernel. I fear this will become a monster. And anticipating that, we should make darn sure that the interface is right, and is extensible.
Alexander Potapenko
maintainerRe: [PATCH 2/4] lib: add error_report_notify to collect debugging tools' reports
Quoted 25 lines · Andrew Morton
Quoted 22 lines · On Wed, 13 Jan 2021 10:16:55 +0100 Alexander Potapenko <[email protected]>…
With the introduction of various production error-detection tools, such as MTE-based KASAN and KFENCE, the need arises to efficiently notify the userspace OS components about kernel errors. Currently, no facility exists to notify userspace about a kernel error from such bug-detection tools. The problem is obviously not restricted to the above bug detection tools, and applies to any error reporting mechanism that does not panic the kernel; this series, however, will only add support for KASAN and KFENCE reporting.
All such error reports appear in the kernel log. But, when such errors occur, userspace would normally need to read the entire kernel log and parse the relevant errors. This is error prone and inefficient, as userspace needs to continuously monitor the kernel log for error messages. On certain devices, this is unfortunately not acceptable. Therefore, we need to revisit how reports are propagated to userspace.
The library added,
error_report_notify(CONFIG_ERROR_REPORT_NOTIFY), solves the above by using the error_report_start/error_report_end tracing events and exposing the last report and the total report count to the userspace via/sys/kernel/error_report/last_reportand/sys/kernel/error_report/report_count.
Quoted 5 lines
Quoted 2 lines
Userspace apps can call poll(POLLPRI) on those files to get notified about the new reports without having to watch dmesg in a loop.
It would be nice to see some user-facing documentation for this, under
Documentation/. How to use it, what the shortcomings are, etc.
Good point, will do.
Quoted 4 lines
For instance... what happens when userspace is slow reading
/sys/kernel/error_report/last_report? Does that file buffer multiple reports? Does the previous one get overwritten? etc. Words on how this obvious issue is handled...
Yes, there can be issues with overwriting, and the recommended way to handle them would be to check the value in /sys/kernel/error_report/report_count before and after reading the report.
Quoted 11 lines
lib/Kconfig.debug config DEBUG_BUGVERBOSE · line 213
Quoted 8 lines
lib/Kconfig.debug +2
-0@@ -209,6 +209,20 @@ config DEBUG_BUGVERBOSE of the BUG call as well as the EIP and oops trace. This aids debugging but costs about 70-100K of memory. +config ERROR_REPORT_NOTIFY + bool "Expose memory error reports to the userspace"There's really nothing "memory" specific about this? Any kernel subsystem could use it?
Indeed. Perhaps it's better to emphasize "production" here, because users of debugging tools are more or less happy with dmesg output.
Quoted 13 lines
lib/Kconfig.debug config DEBUG_BUGVERBOSE · line 224
Quoted 12 lines
lib/Kconfig.debug +11
-0+ depends on TRACING + help + When enabled, captures error reports from debugging tools (such as + KFENCE or KASAN) using console tracing, and exposes reports in + /sys/kernel/error_report/: the file last_report contains the last + report (with maximum report length of PAGE_SIZE), and report_count, + the total report count. + + Userspace programs can call poll(POLLPRI) on those files to get + notified about the new reports without having to watch dmesg in a + loop.
Quoted 3 lines
So we have a whole new way of getting debug info out of the kernel. I fear this will become a monster. And anticipating that, we should make darn sure that the interface is right, and is extensible.
Let me elaborate a bit on the problem we are trying to solve here. It is specific to Android, but other Linux-based systems may require something similar.
There's a userspace daemon that collects kernel/userspace crashes from the device if its owner has opted into that, and we want that daemon to also collect non-fatal error reports.
There are several issues with that:
- there is currently no way to synchronously notify the userspace
about an error, and without that the daemon will have to actively monitor the kernel log (or some other file, e.g. /proc/kernel/tainted for certain strings;
- once we figure out there is an error report available, the daemon will have to find its beginning and end, and also filter out the lines that do not belong to that report;
- this all requires letting that daemon see the whole dmesg output,
which may contain sensitive data accidentally printed by the kernel.
So, first of all, our solution had to provide some poll()-based interface to avoid reading files in a loop, and that interface should trigger every time an error report is printed.
Adding ftrace tracepoints to every tool at the points where reports start/end is perhaps least invasive, and also allows multiple subscribers (plus free tracing!).
Then, since the notification library was already in the business of trace probes, we thought it makes sense to capture the whole report, assuming that every dmesg line from the same task/cpu between the report probes belongs to the report.
That drastically reduces the amount of data the userspace daemon has access to (only the report instead of the whole dmesg), and removes the need of active polling.
A potential pinch-point is the report size, which cannot exceed 4K if we want it to live in sysfs.
It turned out certain reports didn't fit under that limit when taken as-is, but stripping away the timestamps and task IDs printed by CONFIG_PRINTK_CALLER saved us 1.5-2K in those cases.
Given that the information we expose is a subset of what dmesg provides, I wouldn't call it a "whole new way" though. Existing users will probably still stick to dmesg unless they want to be notified of errors.
Alexander Potapenko
maintainerRe: [PATCH 2/4] lib: add error_report_notify to collect debugging tools' reports
Quoted 27 lines · Alexander Potapenko
Quoted 25 lines · Andrew Morton
Quoted 22 lines · On Wed, 13 Jan 2021 10:16:55 +0100 Alexander Potapenko <[email protected]>…
With the introduction of various production error-detection tools, such as MTE-based KASAN and KFENCE, the need arises to efficiently notify the userspace OS components about kernel errors. Currently, no facility exists to notify userspace about a kernel error from such bug-detection tools. The problem is obviously not restricted to the above bug detection tools, and applies to any error reporting mechanism that does not panic the kernel; this series, however, will only add support for KASAN and KFENCE reporting.
All such error reports appear in the kernel log. But, when such errors occur, userspace would normally need to read the entire kernel log and parse the relevant errors. This is error prone and inefficient, as userspace needs to continuously monitor the kernel log for error messages. On certain devices, this is unfortunately not acceptable. Therefore, we need to revisit how reports are propagated to userspace.
The library added,
error_report_notify(CONFIG_ERROR_REPORT_NOTIFY), solves the above by using the error_report_start/error_report_end tracing events and exposing the last report and the total report count to the userspace via/sys/kernel/error_report/last_reportand/sys/kernel/error_report/report_count.
Quoted 7 lines
Quoted 5 lines
Quoted 2 lines
Userspace apps can call poll(POLLPRI) on those files to get notified about the new reports without having to watch dmesg in a loop.
It would be nice to see some user-facing documentation for this, under
Documentation/. How to use it, what the shortcomings are, etc.Good point, will do.
Added in v2.
Quoted 9 lines
Quoted 4 lines
For instance... what happens when userspace is slow reading
/sys/kernel/error_report/last_report? Does that file buffer multiple reports? Does the previous one get overwritten? etc. Words on how this obvious issue is handled...Yes, there can be issues with overwriting, and the recommended way to handle them would be to check the value in
/sys/kernel/error_report/report_countbefore and after reading the report.
After looking closer it occurs to me that sysfs retains the buffer returned by the attribute's show() method, so that one can read the whole report up to the end even if the file contents change.
Quoted 5 lines
Quoted 2 lines
There's really nothing "memory" specific about this? Any kernel subsystem could use it?
Indeed. Perhaps it's better to emphasize "production" here, because users of debugging tools are more or less happy with dmesg output.
Changed to "error reports from debugging tools".
Alexander Potapenko
maintainerPATCH 3/4 kfence: use error_report_start and error_report_end tracepoints
In reply to Alexander PotapenkoMake it possible to trace KFENCE error reporting (in particular, for compatibility with CONFIG_ERROR_REPORT_NOTIFY).
--- mm/kfence/report.c | 3 +++ 1 file changed, 3 insertions(+)
mm/kfence/report.c +3 -0
@@ -9,6 +9,7 @@#include <linux/seq_file.h> #include <linux/stacktrace.h> #include <linux/string.h> +#include <trace/events/error_report.h> #include <asm/kfence.h>
@@ -184,6 +185,7 @@ void kfence_report_error(unsigned long address, struct pt_regs *regs,lockdep_off ();pr_err ("==================================================================\n" ); +trace_error_report_start ("kfence" , address);/* Print report header. */ switch (type) {case KFENCE_ERROR_OOB : {
@@ -232,6 +234,7 @@ void kfence_report_error(unsigned long address, struct pt_regs *regs,show_regs (regs); elsedump_stack_print_info (KERN_ERR ); +trace_error_report_end ("kfence" , address);pr_err ("==================================================================\n" );lockdep_on ();
Signature · 1 line
2.30.0.284.gd98b1dd5eaa7-goog
Alexander Potapenko
maintainerPATCH 4/4 kasan: use error_report_start and error_report_end tracepoints
In reply to Alexander PotapenkoMake it possible to trace KASAN error reporting (in particular, for compatibility with CONFIG_ERROR_REPORT_NOTIFY).
--- mm/kasan/report.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-)
mm/kasan/report.c +9 -6
@@ -25,6 +25,7 @@#include <linux/module.h> #include <linux/sched/task_stack.h> #include <linux/uaccess.h> +#include <trace/events/error_report.h> #include <asm/sections.h>
@@ -74,7 +75,7 @@ static void print_error_description(struct kasan_access_info *info)static DEFINE_SPINLOCK (report_lock); -static void start_report (unsigned long *flags) +static void start_report (unsigned long *flags,unsigned long addr) {/* * Make sure we don't end up in loop.
@@ -82,10 +83,12 @@ static void start_report(unsigned long *flags)kasan_disable_current ();spin_lock_irqsave (&report_lock, *flags);pr_err ("==================================================================\n" ); +trace_error_report_start ("kasan" , addr); } -static void end_report (unsigned long *flags) +static void end_report (unsigned long *flags,unsigned long addr) { +trace_error_report_end ("kasan" , addr);pr_err ("==================================================================\n" );add_taint (TAINT_BAD_PAGE ,LOCKDEP_NOW_UNRELIABLE );spin_unlock_irqrestore (&report_lock, *flags);
@@ -348,14 +351,14 @@ void kasan_report_invalid_free(void *object, unsigned long ip)kasan_update_kunit_status (current->kunit_test);#endif /* IS_ENABLED(CONFIG_KUNIT) */ -start_report (&flags); +start_report (&flags, (unsigned long )object);pr_err ("BUG: KASAN: double-free or invalid-free in %pS\n" , (void *)ip);print_tags (tag, object);pr_err ("\n" );print_address_description (object, tag);pr_err ("\n" );print_memory_metadata (object); -end_report (&flags); +end_report (&flags, (unsigned long )object); } static void __kasan_report(unsigned long addr, size_t size, bool is_write,
@@ -385,7 +388,7 @@ static void __kasan_report(unsigned long addr, size_t size, bool is_write, info.is_write = is_write; info.ip = ip; -start_report (&flags); +start_report (&flags, addr);print_error_description (&info);if (addr_has_metadata (untagged_addr))
@@ -400,7 +403,7 @@ static void __kasan_report(unsigned long addr, size_t size, bool is_write,dump_stack (); } -end_report (&flags); +end_report (&flags, addr); } bool kasan_report(unsigned long addr, size_t size, bool is_write,
Signature · 1 line
2.30.0.284.gd98b1dd5eaa7-goog