tracing: Fixes for 6.1
Subsystems (4)
Steven Rostedt
maintainercover tracing: Fixes for 6.1
git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace.git
trace/urgent
Head SHA1: 94eedf3dded5fb472ce97bfaf3ac1c6c29c35d26
Aashish Sharma (1):
tracing: Fix warning on variable 'struct trace_array'
Daniil Tatianin (1):
ring_buffer: Do not deactivate non-existant pages
Qiujun Huang (1):
tracing: Remove unused __bad_type_size() method
Shang XiaoJing (2):
tracing: Fix memory leak in test_gen_synth_cmd() and test_empty_synth_event()
tracing: Fix wild-memory-access in register_synth_event()
Steven Rostedt (Google) (3):
tracing/ring-buffer: Have polling block on watermark
ring-buffer: Include dropped pages in counting dirty patches
tracing: Fix race where eprobes can be called before the event
Wang Wensheng (2):
ftrace: Fix the possible incorrect kernel message
ftrace: Optimize the allocation for mcount entries
Wang Yufen (1):
tracing: Fix memory leak in tracing_read_pipe()
Xiu Jianfeng (1):
ftrace: Fix null pointer dereference in ftrace_add_mod()
Zheng Yejian (1):
tracing: Fix potential null-pointer-access of entry in list 'tr->err_log'
----
include/linux/ring_buffer.h | 2 +- include/linux/trace.h | 4 +-- kernel/trace/ftrace.c | 5 +-- kernel/trace/ring_buffer.c | 71 ++++++++++++++++++++++++++----------- kernel/trace/synth_event_gen_test.c | 16 ++++----- kernel/trace/trace.c | 12 ++++--- kernel/trace/trace_eprobe.c | 3 ++ kernel/trace/trace_events_synth.c | 5 ++- kernel/trace/trace_syscalls.c | 2 -- 9 files changed, 74 insertions(+), 46 deletions(-)
Steven Rostedt
maintainerPATCH 1/13 tracing/ring-buffer: Have polling block on watermark
From: "Steven Rostedt (Google)" <[email protected]>
Currently the way polling works on the ring buffer is broken. It will return immediately if there's any data in the ring buffer whereas a read will block until the watermark (defined by the tracefs buffer_percent file) is hit.
That is, a select() or poll() will return as if there's data available, but then the following read will block. This is broken for the way select()s and poll()s are supposed to work.
Have the polling on the ring buffer also block the same way reads and splice does on the ring buffer.
--- include/linux/ring_buffer.h | 2 +- kernel/trace/ring_buffer.c | 55 ++++++++++++++++++++++++------------- kernel/trace/trace.c | 2 +- 3 files changed, 38 insertions(+), 21 deletions(-)
include/linux/ring_buffer.h +1 -1
@@ -100,7 +100,7 @@ __ring_buffer_alloc(unsigned long size, unsigned flags, struct lock_class_key *kint ring_buffer_wait (struct trace_buffer *buffer,int cpu,int full);__poll_t ring_buffer_poll_wait (struct trace_buffer *buffer,int cpu, -struct file *filp,poll_table *poll_table); +struct file *filp,poll_table *poll_table,int full);void ring_buffer_wake_waiters (struct trace_buffer *buffer,int cpu);#define RING_BUFFER_ALL_CPUS -1
kernel/trace/ring_buffer.c +36 -19
118 lines not on this page · raw message
kernel/trace/trace.c +1 -1
@@ -6681,7 +6681,7 @@ trace_poll(struct trace_iterator *iter, struct file *filp, poll_table *poll_tablreturn EPOLLIN |EPOLLRDNORM ; else return ring_buffer_poll_wait(iter->array_buffer->buffer, iter->cpu_file, - filp, poll_table); + filp, poll_table, iter->tr->buffer_percent); } static __poll_t
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 2/13 ring-buffer: Include dropped pages in counting dirty patches
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
The function ring_buffer_nr_dirty_pages() was created to find out how many pages are filled in the ring buffer. There's two running counters. One is incremented whenever a new page is touched (pages_touched) and the other is whenever a page is read (pages_read). The dirty count is the number touched minus the number read. This is used to determine if a blocked task should be woken up if the percentage of the ring buffer it is waiting for is hit.
The problem is that it does not take into account dropped pages (when the new writes overwrite pages that were not read). And then the dirty pages will always be greater than the percentage.
This makes the "buffer_percent" file inaccurate, as the number of dirty pages end up always being larger than the percentage, event when it's not and this causes user space to be woken up more than it wants to be.
Add a new counter to keep track of lost pages, and include that in the accounting of dirty pages so that it is actually accurate.
--- kernel/trace/ring_buffer.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
kernel/trace/ring_buffer.c +12 -0
@@ -519,6 +519,7 @@ struct ring_buffer_per_cpu {local_t committing;local_t commits;local_t pages_touched; +local_t pages_lost;local_t pages_read;long last_pages_touch;size_t shortest_full;
@@ -894,10 +895,18 @@ size_t ring_buffer_nr_pages(struct trace_buffer *buffer, int cpu)size_t ring_buffer_nr_dirty_pages (struct trace_buffer *buffer,int cpu) {size_t read; +size_t lost;size_t cnt; read =local_read (&buffer->buffers[cpu]->pages_read); + lost =local_read (&buffer->buffers[cpu]->pages_lost); cnt =local_read (&buffer->buffers[cpu]->pages_touched); + +if (WARN_ON_ONCE (cnt < lost)) +return 0 ; + + cnt -= lost; +/* The reader can read an empty page, but not more than that */ if (cnt < read) {WARN_ON_ONCE (read > cnt +1 );
@@ -2031,6 +2040,7 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned long nr_pages)*/ local_add (page_entries, &cpu_buffer->overrun);local_sub (BUF_PAGE_SIZE , &cpu_buffer->entries_bytes); +local_inc (&cpu_buffer->pages_lost); }/*
@@ -2515,6 +2525,7 @@ rb_handle_head_page(struct ring_buffer_per_cpu *cpu_buffer,*/ local_add (entries, &cpu_buffer->overrun);local_sub (BUF_PAGE_SIZE , &cpu_buffer->entries_bytes); +local_inc (&cpu_buffer->pages_lost);/* * The entries will be zeroed out when we move the
@@ -5265,6 +5276,7 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)local_set (&cpu_buffer->committing,0 );local_set (&cpu_buffer->commits,0 );local_set (&cpu_buffer->pages_touched,0 ); +local_set (&cpu_buffer->pages_lost,0 );local_set (&cpu_buffer->pages_read,0 ); cpu_buffer->last_pages_touch =0 ; cpu_buffer->shortest_full =0 ;
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 3/13 tracing: Fix memory leak in tracing_read_pipe()
In reply to Steven RostedtFrom: Wang Yufen <[email protected]>
kmemleak reports this issue:
unreferenced object 0xffff888105a18900 (size 128):
comm "test_progs", pid 18933, jiffies 4336275356 (age 22801.766s) hex dump (first 32 bytes):
25 73 00 90 81 88 ff ff 26 05 00 00 42 01 58 04 %s......&...B.X.
03 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00 ................
backtrace:
[<00000000560143a1>] __kmalloc_node_track_caller+0x4a/0x140
[<000000006af00822>] krealloc+0x8d/0xf0
[<00000000c309be6a>] trace_iter_expand_format+0x99/0x150
[<000000005a53bdb6>] trace_check_vprintf+0x1e0/0x11d0
[<0000000065629d9d>] trace_event_printf+0xb6/0xf0
[<000000009a690dc7>] trace_raw_output_bpf_trace_printk+0x89/0xc0
[<00000000d22db172>] print_trace_line+0x73c/0x1480
[<00000000cdba76ba>] tracing_read_pipe+0x45c/0x9f0
[<0000000015b58459>] vfs_read+0x17b/0x7c0
[<000000004aeee8ed>] ksys_read+0xed/0x1c0
[<0000000063d3d898>] do_syscall_64+0x3b/0x90
[<00000000a06dda7f>] entry_SYSCALL_64_after_hwframe+0x63/0xcditer->fmt alloced in
tracing_read_pipe() -> .. ->trace_iter_expand_format(), but not
freed, to fix, add free in tracing_release_pipe()
--- kernel/trace/trace.c | 1 + 1 file changed, 1 insertion(+)
kernel/trace/trace.c +1 -0
@@ -6657,6 +6657,7 @@ static int tracing_release_pipe(struct inode *inode, struct file *file)mutex_unlock (&trace_types_lock);free_cpumask_var (iter->started); +kfree (iter->fmt);mutex_destroy (&iter->mutex);kfree (iter);
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 4/13 tracing: Fix warning on variable struct trace_array
In reply to Steven RostedtFrom: Aashish Sharma <[email protected]>
Move the declaration of 'struct trace_array' out of #ifdef CONFIG_TRACING block, to fix the following warning when CONFIG_TRACING is not set:
Quoted 1 line
Quoted 1 line
include/linux/trace.h:63:45: warning: 'structtrace_array' declared
inside parameter list will not be visible outside of this definition or declaration
--- include/linux/trace.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
include/linux/trace.h +2 -2
@@ -26,13 +26,13 @@ struct trace_export {int flags; }; +struct trace_array ; +#ifdef CONFIG_TRACING int register_ftrace_export (struct trace_export *export);int unregister_ftrace_export (struct trace_export *export); -struct trace_array ; -void trace_printk_init_buffers (void ); __printf(3, 4) int trace_array_printk(struct trace_array *tr, unsigned long ip,
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 5/13 ftrace: Fix the possible incorrect kernel message
In reply to Steven RostedtFrom: Wang Wensheng <[email protected]>
If the number of mcount entries is an integer multiple of ENTRIES_PER_PAGE, the page count showing on the console would be wrong.
--- kernel/trace/ftrace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/ftrace.c +1 -1
@@ -7391,7 +7391,7 @@ void __init ftrace_init(void) }pr_info ("ftrace: allocating %ld entries in %ld pages\n" , - count, count /ENTRIES_PER_PAGE +1 ); + count,DIV_ROUND_UP (count,ENTRIES_PER_PAGE )); ret = ftrace_process_locs(NULL, __start_mcount_loc,
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 6/13 ftrace: Optimize the allocation for mcount entries
In reply to Steven RostedtFrom: Wang Wensheng <[email protected]>
If we can't allocate this size, try something smaller with half of the size. Its order should be decreased by one instead of divided by two.
--- kernel/trace/ftrace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/ftrace.c +1 -1
@@ -3190,7 +3190,7 @@ static int ftrace_allocate_records(struct ftrace_page *pg, int count)/* if we can't allocate this size, try something smaller */ if (!order)return -ENOMEM ; - order >>=1 ; + order--; goto again; }
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 7/13 ring_buffer: Do not deactivate non-existant pages
In reply to Steven RostedtFrom: Daniil Tatianin <[email protected]>
rb_head_page_deactivate() expects cpu_buffer to contain a valid list of ->pages, so verify that the list is actually present before calling it.
Found by Linux Verification Center (linuxtesting.org) with the SVACE static analysis tool.
--- kernel/trace/ring_buffer.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/trace/ring_buffer.c +2 -2
@@ -1802,9 +1802,9 @@ static void rb_free_cpu_buffer(struct ring_buffer_per_cpu *cpu_buffer)free_buffer_page (cpu_buffer->reader_page); -rb_head_page_deactivate (cpu_buffer); -if (head) { +rb_head_page_deactivate (cpu_buffer); +list_for_each_entry_safe (bpage, tmp, head, list) {list_del_init (&bpage->list);free_buffer_page (bpage);
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 8/13 ftrace: Fix null pointer dereference in ftrace_add_mod()
In reply to Steven RostedtFrom: Xiu Jianfeng <[email protected]>
The @ftrace_mod is allocated by kzalloc(), so both the members {prev,next} of @ftrace_mode->list are NULL, it's not a valid state to call list_del(). If kstrdup() for @ftrace_mod->{func|module} fails, it goes to @out_free tag and calls free_ftrace_mod() to destroy @ftrace_mod, then list_del() will write prev->next and next->prev, where null pointer dereference happens.
BUG: kernel NULL pointer dereference, address: 0000000000000008 Oops: 0002 [#1] PREEMPT SMP NOPTI Call Trace: <TASK> ftrace_mod_callback+0x20d/0x220 ? do_filp_open+0xd9/0x140 ftrace_process_regex.isra.51+0xbf/0x130 ftrace_regex_write.isra.52.part.53+0x6e/0x90 vfs_write+0xee/0x3a0 ? __audit_filter_op+0xb1/0x100 ? auditd_test_task+0x38/0x50 ksys_write+0xa5/0xe0 do_syscall_64+0x3a/0x90 entry_SYSCALL_64_after_hwframe+0x63/0xcd Kernel panic - not syncing: Fatal exception
So call INIT_LIST_HEAD() to initialize the list member to fix this issue.
--- kernel/trace/ftrace.c | 1 + 1 file changed, 1 insertion(+)
kernel/trace/ftrace.c +1 -0
@@ -1289,6 +1289,7 @@ static int ftrace_add_mod(struct trace_array *tr,if (!ftrace_mod)return -ENOMEM ; +INIT_LIST_HEAD (&ftrace_mod->list); ftrace_mod->func =kstrdup (func,GFP_KERNEL ); ftrace_mod->module =kstrdup (module,GFP_KERNEL ); ftrace_mod->enable = enable;
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 9/13 tracing: Fix memory leak in test_gen_synth_cmd() and test_empty_synth_event()
In reply to Steven RostedtFrom: Shang XiaoJing <[email protected]>
test_gen_synth_cmd() only free buf in fail path, hence buf will leak when there is no failure. Add kfree(buf) to prevent the memleak. The same reason and solution in test_empty_synth_event().
unreferenced object 0xffff8881127de000 (size 2048):
comm "modprobe", pid 247, jiffies 4294972316 (age 78.756s) hex dump (first 32 bytes):
20 67 65 6e 5f 73 79 6e 74 68 5f 74 65 73 74 20 gen_synth_test
20 70 69 64 5f 74 20 6e 65 78 74 5f 70 69 64 5f pid_t next_pid_
backtrace:
[<000000004254801a>] kmalloc_trace+0x26/0x100
[<0000000039eb1cf5>] 0xffffffffa00083cd
[<000000000e8c3bc8>] 0xffffffffa00086ba
[<00000000c293d1ea>] do_one_initcall+0xdb/0x480
[<00000000aa189e6d>] do_init_module+0x1cf/0x680
[<00000000d513222b>] load_module+0x6a50/0x70a0
[<000000001fd4d529>] __do_sys_finit_module+0x12f/0x1c0
[<00000000b36c4c0f>] do_syscall_64+0x3f/0x90
[<00000000bbf20cf3>] entry_SYSCALL_64_after_hwframe+0x63/0xcd
unreferenced object 0xffff8881127df000 (size 2048):
comm "modprobe", pid 247, jiffies 4294972324 (age 78.728s)
hex dump (first 32 bytes):
20 65 6d 70 74 79 5f 73 79 6e 74 68 5f 74 65 73 empty_synth_tes
74 20 20 70 69 64 5f 74 20 6e 65 78 74 5f 70 69 t pid_t next_pi
backtrace:
[<000000004254801a>] kmalloc_trace+0x26/0x100
[<00000000d4db9a3d>] 0xffffffffa0008071
[<00000000c31354a5>] 0xffffffffa00086ce
[<00000000c293d1ea>] do_one_initcall+0xdb/0x480
[<00000000aa189e6d>] do_init_module+0x1cf/0x680
[<00000000d513222b>] load_module+0x6a50/0x70a0
[<000000001fd4d529>] __do_sys_finit_module+0x12f/0x1c0
[<00000000b36c4c0f>] do_syscall_64+0x3f/0x90
[<00000000bbf20cf3>] entry_SYSCALL_64_after_hwframe+0x63/0xcd--- kernel/trace/synth_event_gen_test.c | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-)
kernel/trace/synth_event_gen_test.c +6 -10
@@ -120,15 +120,13 @@ static int __init test_gen_synth_cmd(void)/* Now generate a gen_synth_test event */ ret =synth_event_trace_array (gen_synth_test, vals,ARRAY_SIZE (vals)); - out: + free: +kfree (buf);return ret; delete:/* We got an error after creating the event, delete it */ synth_event_delete ("gen_synth_test" ); - free: -kfree (buf); - - goto out; + goto free; }/*
@@ -227,15 +225,13 @@ static int __init test_empty_synth_event(void)/* Now trace an empty_synth_test event */ ret =synth_event_trace_array (empty_synth_test, vals,ARRAY_SIZE (vals)); - out: + free: +kfree (buf);return ret; delete:/* We got an error after creating the event, delete it */ synth_event_delete ("empty_synth_test" ); - free: -kfree (buf); - - goto out; + goto free; }static struct synth_field_desc create_synth_test_fields[] = {
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 10/13 tracing: Fix wild-memory-access in register_synth_event()
In reply to Steven RostedtFrom: Shang XiaoJing <[email protected]>
In register_synth_event(), if set_synth_event_print_fmt() failed, then both trace_remove_event_call() and unregister_trace_event() will be called, which means the trace_event_call will call __unregister_trace_event() twice. As the result, the second unregister will causes the wild-memory-access.
register_synth_event
set_synth_event_print_fmt failed
trace_remove_event_call
event_remove
if call->event.funcs then
__unregister_trace_event (first call)
unregister_trace_event
__unregister_trace_event (second call)
Fix the bug by avoiding to call the second __unregister_trace_event() by checking if the first one is called.
general protection fault, probably for non-canonical address 0xfbd59c0000000024: 0000 [#1] SMP KASAN PTI KASAN: maybe wild-memory-access in range [0xdead000000000120-0xdead000000000127] CPU: 0 PID: 3807 Comm: modprobe Not tainted 6.1.0-rc1-00186-g76f33a7eedb4 #299 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.15.0-0-g2dd4b9b3f840-prebuilt.qemu.org 04/01/2014 RIP: 0010:unregister_trace_event+0x6e/0x280 Code: 00 fc ff df 4c 89 ea 48 c1 ea 03 80 3c 02 00 0f 85 0e 02 00 00 48 b8 00 00 00 00 00 fc ff df 4c 8b 63 08 4c 89 e2 48 c1 ea 03 <80> 3c 02 00 0f 85 e2 01 00 00 49 89 2c 24 48 85 ed 74 28 e8 7a 9b RSP: 0018:ffff88810413f370 EFLAGS: 00010a06 RAX: dffffc0000000000 RBX: ffff888105d050b0 RCX: 0000000000000000 RDX: 1bd5a00000000024 RSI: ffff888119e276e0 RDI: ffffffff835a8b20 RBP: dead000000000100 R08: 0000000000000000 R09: fffffbfff0913481 R10: ffffffff8489a407 R11: fffffbfff0913480 R12: dead000000000122 R13: ffff888105d050b8 R14: 0000000000000000 R15: ffff888105d05028 FS: 00007f7823e8d540(0000) GS:ffff888119e00000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00007f7823e7ebec CR3: 000000010a058002 CR4: 0000000000330ef0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 Call Trace: <TASK> __create_synth_event+0x1e37/0x1eb0 create_or_delete_synth_event+0x110/0x250 synth_event_run_command+0x2f/0x110 test_gen_synth_cmd+0x170/0x2eb [synth_event_gen_test] synth_event_gen_test_init+0x76/0x9bc [synth_event_gen_test] do_one_initcall+0xdb/0x480 do_init_module+0x1cf/0x680 load_module+0x6a50/0x70a0 __do_sys_finit_module+0x12f/0x1c0 do_syscall_64+0x3f/0x90 entry_SYSCALL_64_after_hwframe+0x63/0xcd
--- kernel/trace/trace_events_synth.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
kernel/trace/trace_events_synth.c +2 -3
@@ -828,10 +828,9 @@ static int register_synth_event(struct synth_event *event) } ret =set_synth_event_print_fmt (call); -if (ret <0 ) { +/* unregister_trace_event() will be called inside */ +if (ret <0 )trace_remove_event_call (call); - goto err; - } out:return ret; err:
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 11/13 tracing: Remove unused __bad_type_size() method
In reply to Steven RostedtFrom: Qiujun Huang <[email protected]>
__bad_type_size() is unused after
commit 04ae87a52074("ftrace: Rework event_create_dir()"). So, remove it.
--- kernel/trace/trace_syscalls.c | 2 -- 1 file changed, 2 deletions(-)
kernel/trace/trace_syscalls.c +0 -2
@@ -201,8 +201,6 @@ print_syscall_exit(struct trace_iterator *iter, int flags,return trace_handle_return (s); } -extern char *__bad_type_size (void ); -#define SYSCALL_FIELD (_type, _name) { \ .type = #_type, .name = #_name, \ .size = sizeof(_type), .align = __alignof__(_type), \
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 12/13 tracing: Fix potential null-pointer-access of entry in list tr->err_log
In reply to Steven RostedtFrom: Zheng Yejian <[email protected]>
Entries in list 'tr->err_log' will be reused after entry number exceed TRACING_LOG_ERRS_MAX.
The cmd string of the to be reused entry will be freed first then allocated a new one. If the allocation failed, then the entry will still be in list 'tr->err_log' but its 'cmd' field is set to be NULL, later access of 'cmd' is risky.
Currently above problem can cause the loss of 'cmd' information of first entry in 'tr->err_log'. When execute cat /sys/kernel/tracing/error_log, reproduce logs like:
[ 37.495100] trace_kprobe: error: Maxactive is not for kprobe(null) ^
[ 38.412517] trace_kprobe: error: Maxactive is not for kprobe
Command: p4:myprobe2 do_sys_openat2
^--- kernel/trace/trace.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
kernel/trace/trace.c +5 -4
@@ -7803,6 +7803,7 @@ static struct tracing_log_err *get_tracing_log_err(struct trace_array *tr, int len) {struct tracing_log_err *err; +char *cmd;if (tr->n_err_log_entries <TRACING_LOG_ERRS_MAX ) { err =alloc_tracing_log_err (len);
@@ -7811,12 +7812,12 @@ static struct tracing_log_err *get_tracing_log_err(struct trace_array *tr,return err; } - + cmd =kzalloc (len,GFP_KERNEL ); +if (!cmd) +return ERR_PTR (-ENOMEM ); err = list_first_entry(&tr->err_log, struct tracing_log_err, list);kfree (err->cmd); - err->cmd =kzalloc (len,GFP_KERNEL ); -if (!err->cmd) -return ERR_PTR (-ENOMEM ); + err->cmd = cmd;list_del (&err->list);return err;
Signature · 1 line
2.35.1
Steven Rostedt
maintainerPATCH 13/13 tracing: Fix race where eprobes can be called before the event
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
The flag that tells the event to call its triggers after reading the event is set for eprobes after the eprobe is enabled. This leads to a race where the eprobe may be triggered at the beginning of the event where the record information is NULL. The eprobe then dereferences the NULL record causing a NULL kernel pointer bug.
Test for a NULL record to keep this from happening.
--- kernel/trace/trace_eprobe.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/trace/trace_eprobe.c +3 -0
@@ -563,6 +563,9 @@ static void eprobe_trigger_func(struct event_trigger_data *data, {struct eprobe_data *edata = data->private_data; +if (unlikely (!rec)) +return ; +__eprobe_trace_func (edata, rec); }
Signature · 1 line
2.35.1