tracing: Some fixes for 5.5
Subsystems (2)
Steven Rostedt
maintainercover tracing: Some fixes for 5.5
Keita Suzuki (1):
tracing: Avoid memory leak in process_system_preds()
Prateek Sood (1):
tracing: Fix lock inversion in trace_event_enable_tgid_record()
Steven Rostedt (VMware) (1):
tracing: Have the histogram compare functions convert to u64 first
Sven Schnelle (2):
samples/trace_printk: Wait for IRQ work to finish
tracing: Fix endianness bug in histogram trigger
----
kernel/trace/trace.c | 8 ++++++++ kernel/trace/trace_events.c | 8 ++++---- kernel/trace/trace_events_filter.c | 2 +- kernel/trace/trace_events_hist.c | 21 ++++++++++++++++++++- kernel/trace/tracing_map.c | 4 ++-- samples/trace_printk/trace-printk.c | 1 + 6 files changed, 36 insertions(+), 8 deletions(-)
Steven Rostedt
maintainerPATCH 1/5 tracing: Avoid memory leak in process_system_preds()
From: Keita Suzuki <[email protected]>
When failing in the allocation of filter_item, process_system_preds() goes to fail_mem, where the allocated filter is freed.
However, this leads to memory leak of filter->filter_string and filter->prog, which is allocated before and in process_preds(). This bug has been detected by kmemleak as well.
Fix this by changing kfree to __free_fiter.
unreferenced object 0xffff8880658007c0 (size 32):
comm "bash", pid 579, jiffies 4295096372 (age 17.752s) hex dump (first 32 bytes):
63 6f 6d 6d 6f 6e 5f 70 69 64 20 20 3e 20 31 30 common_pid > 10
00 00 00 00 00 00 00 00 65 73 00 00 00 00 00 00 ........es......
backtrace:
[<0000000067441602>] kstrdup+0x2d/0x60
[<00000000141cf7b7>] apply_subsystem_event_filter+0x378/0x932
[<000000009ca32334>] subsystem_filter_write+0x5a/0x90
[<0000000072da2bee>] vfs_write+0xe1/0x240
[<000000004f14f473>] ksys_write+0xb4/0x150
[<00000000a968b4a0>] do_syscall_64+0x6d/0x1e0
[<000000001a189f40>] entry_SYSCALL_64_after_hwframe+0x44/0xa9
unreferenced object 0xffff888060c22d00 (size 64):
comm "bash", pid 579, jiffies 4295096372 (age 17.752s)
hex dump (first 32 bytes):
01 00 00 00 00 00 00 00 00 e8 d7 41 80 88 ff ff ...........A....
01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
backtrace:
[<00000000b8c1b109>] process_preds+0x243/0x1820
[<000000003972c7f0>] apply_subsystem_event_filter+0x3be/0x932
[<000000009ca32334>] subsystem_filter_write+0x5a/0x90
[<0000000072da2bee>] vfs_write+0xe1/0x240
[<000000004f14f473>] ksys_write+0xb4/0x150
[<00000000a968b4a0>] do_syscall_64+0x6d/0x1e0
[<000000001a189f40>] entry_SYSCALL_64_after_hwframe+0x44/0xa9
unreferenced object 0xffff888041d7e800 (size 512):
comm "bash", pid 579, jiffies 4295096372 (age 17.752s)
hex dump (first 32 bytes):
70 bc 85 97 ff ff ff ff 0a 00 00 00 00 00 00 00 p...............
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
backtrace:
[<000000001e04af34>] process_preds+0x71a/0x1820
[<000000003972c7f0>] apply_subsystem_event_filter+0x3be/0x932
[<000000009ca32334>] subsystem_filter_write+0x5a/0x90
[<0000000072da2bee>] vfs_write+0xe1/0x240
[<000000004f14f473>] ksys_write+0xb4/0x150
[<00000000a968b4a0>] do_syscall_64+0x6d/0x1e0
[<000000001a189f40>] entry_SYSCALL_64_after_hwframe+0x44/0xa9--- kernel/trace/trace_events_filter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/trace_events_filter.c +1 -1
@@ -1662,7 +1662,7 @@ static int process_system_preds(struct trace_subsystem_dir *dir,parse_error (pe,FILT_ERR_BAD_SUBSYS_FILTER ,0 );return -EINVAL ; fail_mem: -kfree (filter); +__free_filter (filter);/* If any call succeeded, we still need to sync */ if (!fail)tracepoint_synchronize_unregister ();
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 2/5 tracing: Have the histogram compare functions convert to u64 first
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
The compare functions of the histogram code would be specific for the size of the value being compared (byte, short, int, long long). It would reference the value from the array via the type of the compare, but the value was stored in a 64 bit number. This is fine for little endian machines, but for big endian machines, it would end up comparing zeros or all ones (depending on the sign) for anything but 64 bit numbers.
To fix this, first derference the value as a u64 then convert it to the type being compared.
--- kernel/trace/tracing_map.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/trace/tracing_map.c +2 -2
@@ -148,8 +148,8 @@ static int tracing_map_cmp_atomic64(void *val_a, void *val_b)#define DEFINE_TRACING_MAP_CMP_FN (type) \ static int tracing_map_cmp_##type(void *val_a, void *val_b) \ { \ - type a = *(type *)val_a; \ - type b = *(type *)val_b; \ + type a = (type)(*(u64 *)val_a); \ + type b = (type)(*(u64 *)val_b); \ \ return (a > b) ? 1 : ((a < b) ? -1 : 0); \ }
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 3/5 tracing: Fix lock inversion in trace_event_enable_tgid_record()
In reply to Steven RostedtFrom: Prateek Sood <[email protected]>
Task T2 Task T3trace_options_core_write() subsystem_open()
mutex_lock(trace_types_lock) mutex_lock(event_mutex)
set_tracer_flag()
trace_event_enable_tgid_record() mutex_lock(trace_types_lock)
mutex_lock(event_mutex)
This gives a circular dependency deadlock between trace_types_lock and event_mutex. To fix this invert the usage of trace_types_lock and event_mutex in trace_options_core_write(). This keeps the sequence of lock usage consistent.
--- kernel/trace/trace.c | 8 ++++++++ kernel/trace/trace_events.c | 8 ++++---- 2 files changed, 12 insertions(+), 4 deletions(-)
kernel/trace/trace.c +8 -0
@@ -4685,6 +4685,10 @@ int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set)int set_tracer_flag (struct trace_array *tr,unsigned int mask,int enabled) { +if ((mask ==TRACE_ITER_RECORD_TGID ) || + (mask ==TRACE_ITER_RECORD_CMD )) +lockdep_assert_held (&event_mutex); +/* do nothing if flag is already set */ if (!!(tr->trace_flags & mask) == !!enabled)return 0 ;
@@ -4752,6 +4756,7 @@ static int trace_set_options(struct trace_array *tr, char *option) cmp += len; +mutex_lock (&event_mutex);mutex_lock (&trace_types_lock); ret =match_string (trace_options,-1 , cmp);
@@ -4762,6 +4767,7 @@ static int trace_set_options(struct trace_array *tr, char *option) ret =set_tracer_flag (tr,1 << ret, !neg);mutex_unlock (&trace_types_lock); +mutex_unlock (&event_mutex);/* * If the first trailing whitespace is replaced with '\0' by strstrip,
@@ -8076,9 +8082,11 @@ trace_options_core_write(struct file *filp, const char __user *ubuf, size_t cnt,if (val !=0 && val !=1 )return -EINVAL ; +mutex_lock (&event_mutex);mutex_lock (&trace_types_lock); ret =set_tracer_flag (tr,1 << index, val);mutex_unlock (&trace_types_lock); +mutex_unlock (&event_mutex);if (ret <0 )return ret;
kernel/trace/trace_events.c +4 -4
@@ -320,7 +320,8 @@ void trace_event_enable_cmd_record(bool enable)struct trace_event_file *file;struct trace_array *tr; -mutex_lock (&event_mutex); +lockdep_assert_held (&event_mutex); +do_for_each_event_file (tr, file) {if (!(file->flags &EVENT_FILE_FL_ENABLED ))
@@ -334,7 +335,6 @@ void trace_event_enable_cmd_record(bool enable)clear_bit (EVENT_FILE_FL_RECORDED_CMD_BIT , &file->flags); } }while_for_each_event_file (); -mutex_unlock (&event_mutex); }void trace_event_enable_tgid_record (bool enable)
@@ -342,7 +342,8 @@ void trace_event_enable_tgid_record(bool enable)struct trace_event_file *file;struct trace_array *tr; -mutex_lock (&event_mutex); +lockdep_assert_held (&event_mutex); +do_for_each_event_file (tr, file) {if (!(file->flags &EVENT_FILE_FL_ENABLED ))continue ;
@@ -356,7 +357,6 @@ void trace_event_enable_tgid_record(bool enable) &file->flags); } }while_for_each_event_file (); -mutex_unlock (&event_mutex); } static int __ftrace_event_enable_disable(struct trace_event_file *file,
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 4/5 samples/trace_printk: Wait for IRQ work to finish
In reply to Steven RostedtFrom: Sven Schnelle <[email protected]>
trace_printk schedules work via irq_work_queue(), but doesn't wait until it was processed. The kprobe_module.tc testcase does:
:;: "Load module again, which means the event1 should be recorded";:
modprobe trace-printk
grep "event1:" trace
so the grep which checks the trace file might run before the irq work was processed. Fix this by adding a irq_work_sync().
--- samples/trace_printk/trace-printk.c | 1 + 1 file changed, 1 insertion(+)
samples/trace_printk/trace-printk.c +1 -0
@@ -36,6 +36,7 @@ static int __init trace_printk_init(void)/* Kick off printing in irq context */ irq_work_queue (&irqwork); +irq_work_sync (&irqwork);trace_printk ("This is a %s that will use trace_bprintk()\n" ,"static string" );
Signature · 1 line
2.24.0
Steven Rostedt
maintainerPATCH 5/5 tracing: Fix endianness bug in histogram trigger
In reply to Steven RostedtFrom: Sven Schnelle <[email protected]>
At least on PA-RISC and s390 synthetic histogram triggers are failing selftests because trace_event_raw_event_synth() always writes a 64 bit values, but the reader expects a field->size sized value. On little endian machines this doesn't hurt, but on big endian this makes the reader always read zero values.
--- kernel/trace/trace_events_hist.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-)
kernel/trace/trace_events_hist.c +20 -1
@@ -911,7 +911,26 @@ static notrace void trace_event_raw_event_synth(void *__data,strscpy (str_field, str_val,STR_VAR_LEN_MAX ); n_u64 +=STR_VAR_LEN_MAX /sizeof (u64); }else { - entry->fields[n_u64] = var_ref_vals[var_ref_idx + i]; +struct synth_field *field = event->fields[i]; +u64 val = var_ref_vals[var_ref_idx + i]; + +switch (field->size) { +case 1 : + *(u8 *)&entry->fields[n_u64] = (u8 )val; +break ; + +case 2 : + *(u16 *)&entry->fields[n_u64] = (u16 )val; +break ; + +case 4 : + *(u32 *)&entry->fields[n_u64] = (u32 )val; +break ; + +default : + entry->fields[n_u64] = val; +break ; + } n_u64++; } }
Signature · 1 line
2.24.0