tracing: Memleak fix and sparse warning fix ups
Subsystems (2)
Steven Rostedt
maintainercover tracing: Memleak fix and sparse warning fix ups
Linus,
This includes a fix to a memory leak when adding filters to traces.
Also, Masami Hiramatsu fixed up some minor bugs that were discovered by sparse.
Please pull the latest trace-fixes-v3.10-rc1 tree, which can be found at:
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
trace-fixes-v3.10-rc1
Head SHA1: b62fdd97fcae17e483b005bafd13fadbd9840672 Tag SHA1: 6edfe0df5694052bc42faabe98bfe031eab3a41f
Masami Hiramatsu (3):
tracing/kprobes: Use rcu_dereference_raw for tp->files tracing/kprobes: Fix a sparse warning for incorrect type in assignment tracing/kprobes: Make print_*probe_event static
Steven Rostedt (Red Hat) (1):
tracing: Fix leaks of filter preds
----
kernel/trace/trace_events_filter.c | 4 +++ kernel/trace/trace_kprobe.c | 53 +++++++++++++++++++++++++++--------- 2 files changed, 44 insertions(+), 13 deletions(-)
Steven Rostedt
maintainerPATCH 1/4 tracing: Fix leaks of filter preds
From: "Steven Rostedt (Red Hat)" <[email protected]>
Special preds are created when folding a series of preds that can be done in serial. These are allocated in an ops field of the pred structure. But they were never freed, causing memory leaks.
This was discovered using the kmemleak checker:
unreferenced object 0xffff8800797fd5e0 (size 32):
comm "swapper/0", pid 1, jiffies 4294690605 (age 104.608s) hex dump (first 32 bytes):
00 00 01 00 03 00 05 00 07 00 09 00 0b 00 0d 00 ................
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................
backtrace:
[<ffffffff814b52af>] kmemleak_alloc+0x73/0x98
[<ffffffff8111ff84>] kmemleak_alloc_recursive.constprop.42+0x16/0x18
[<ffffffff81120e68>] __kmalloc+0xd7/0x125
[<ffffffff810d47eb>] kcalloc.constprop.24+0x2d/0x2f
[<ffffffff810d4896>] fold_pred_tree_cb+0xa9/0xf4
[<ffffffff810d3781>] walk_pred_tree+0x47/0xcc
[<ffffffff810d5030>] replace_preds.isra.20+0x6f8/0x72f
[<ffffffff810d50b5>] create_filter+0x4e/0x8b
[<ffffffff81b1c30d>] ftrace_test_event_filter+0x5a/0x155
[<ffffffff8100028d>] do_one_initcall+0xa0/0x137
[<ffffffff81afbedf>] kernel_init_freeable+0x14d/0x1dc
[<ffffffff814b24b7>] kernel_init+0xe/0xdb
[<ffffffff814d539c>] ret_from_fork+0x7c/0xb0
[<ffffffffffffffff>] 0xffffffffffffffff--- kernel/trace/trace_events_filter.c | 4 ++++ 1 file changed, 4 insertions(+)
kernel/trace/trace_events_filter.c +4 -0
@@ -750,7 +750,11 @@ static int filter_set_pred(struct event_filter *filter,static void __free_preds (struct event_filter *filter) { +int i; +if (filter->preds) { +for (i =0 ; i < filter->n_preds; i++) +kfree (filter->preds[i].ops);kfree (filter->preds); filter->preds =NULL ; }
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 2/4 tracing/kprobes: Use rcu_dereference_raw for tp->files
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Use rcu_dereference_raw() for accessing tp->files. Because the write-side uses rcu_assign_pointer() for memory barrier, the read-side also has to use rcu_dereference_raw() with read memory barrier.
--- kernel/trace/trace_kprobe.c | 47 ++++++++++++++++++++++++++++++++++--------- 1 file changed, 37 insertions(+), 10 deletions(-)
kernel/trace/trace_kprobe.c +37 -10
@@ -185,9 +185,14 @@ static struct trace_probe *find_trace_probe(const char *event,static int trace_probe_nr_files (struct trace_probe *tp) { -struct ftrace_event_file **file = tp->files; +struct ftrace_event_file **file;int ret =0 ; +/* +* Since all tp->files updater is protected by probe_enable_lock, +* we don't need to lock an rcu_read_lock. +*/ + file =rcu_dereference_raw (tp->files);if (file)while (*(file++)) ret++;
@@ -209,9 +214,10 @@ enable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)mutex_lock (&probe_enable_lock);if (file) { -struct ftrace_event_file **new, **old = tp->files; +struct ftrace_event_file **new, **old;int n =trace_probe_nr_files (tp); + old =rcu_dereference_raw (tp->files);/* 1 is for new one and 1 is for stopper */ new =kzalloc ((n +2 ) *sizeof (struct ftrace_event_file *),GFP_KERNEL );
@@ -251,11 +257,17 @@ enable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)static int trace_probe_file_index (struct trace_probe *tp,struct ftrace_event_file *file) { +struct ftrace_event_file **files;int i; -if (tp->files) { -for (i =0 ; tp->files[i]; i++) -if (tp->files[i] == file) +/* +* Since all tp->files updater is protected by probe_enable_lock, +* we don't need to lock an rcu_read_lock. +*/ + files =rcu_dereference_raw (tp->files); +if (files) { +for (i =0 ; files[i]; i++) +if (files[i] == file)return i; }
@@ -274,10 +286,11 @@ disable_trace_probe(struct trace_probe *tp, struct ftrace_event_file *file)mutex_lock (&probe_enable_lock);if (file) { -struct ftrace_event_file **new, **old = tp->files; +struct ftrace_event_file **new, **old;int n =trace_probe_nr_files (tp);int i, j; + old =rcu_dereference_raw (tp->files);if (n ==0 ||trace_probe_file_index (tp, file) <0 ) { ret = -EINVAL ; goto out_unlock;
@@ -872,9 +885,16 @@ __kprobe_trace_func(struct trace_probe *tp, struct pt_regs *regs,static __kprobes void kprobe_trace_func (struct trace_probe *tp,struct pt_regs *regs) { -struct ftrace_event_file **file = tp->files; +/* +* Note: preempt is already disabled around the kprobe handler. +* However, we still need an smp_read_barrier_depends() corresponding +* to smp_wmb() in rcu_assign_pointer() to access the pointer. +*/ +struct ftrace_event_file **file =rcu_dereference_raw (tp->files); + +if (unlikely (!file)) +return ; -/* Note: preempt is already disabled around the kprobe handler */ while (*file) {__kprobe_trace_func (tp, regs, *file); file++;
@@ -925,9 +945,16 @@ static __kprobes void kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri, struct pt_regs *regs) { - struct ftrace_event_file **file = tp->files; +/* +* Note: preempt is already disabled around the kprobe handler. +* However, we still need an smp_read_barrier_depends() corresponding +* to smp_wmb() in rcu_assign_pointer() to access the pointer. +*/ +struct ftrace_event_file **file =rcu_dereference_raw (tp->files); + +if (unlikely (!file)) +return ; -/* Note: preempt is already disabled around the kprobe handler */ while (*file) {__kretprobe_trace_func (tp, ri, regs, *file); file++;
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 3/4 tracing/kprobes: Fix a sparse warning for incorrect type in assignment
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Fix a sparse warning about the rcu operated pointer is defined without __rcu address space.
--- kernel/trace/trace_kprobe.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/trace_kprobe.c +1 -1
@@ -35,7 +35,7 @@ struct trace_probe {const char *symbol;/* symbol name */ struct ftrace_event_class class;struct ftrace_event_call call; -struct ftrace_event_file **files; +struct ftrace_event_file *__rcu *files;ssize_t size;/* trace entry size */ unsigned int nr_args;struct probe_arg args[];
Signature · 1 line
1.7.10.4
Steven Rostedt
maintainerPATCH 4/4 tracing/kprobes: Make print_*probe_event static
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
According to sparse warning, print_*probe_event static because those functions are not directly called from outside.
--- kernel/trace/trace_kprobe.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/trace/trace_kprobe.c +2 -2
@@ -962,7 +962,7 @@ kretprobe_trace_func(struct trace_probe *tp, struct kretprobe_instance *ri, }/* Event entry printers */ -enum print_line_t +static enum print_line_t print_kprobe_event (struct trace_iterator *iter,int flags,struct trace_event *event) {
@@ -998,7 +998,7 @@ partial:return TRACE_TYPE_PARTIAL_LINE ; } -enum print_line_t +static enum print_line_t print_kretprobe_event (struct trace_iterator *iter,int flags,struct trace_event *event) {
Signature · 1 line
1.7.10.4