tracing: Fixes for 5.11-rc5
Subsystems (5)
Steven Rostedt
maintainercover tracing: Fixes for 5.11-rc5
Tracing fixes:
- Initialize tracing-graph-pause at task creation, not start of function tracing. Causes the pause counter to be corrupted.
- Set "pause-on-trace" for latency tracers as that option breaks their output (regression).
- Fix the wrong error return for setting kretprobes on future modules (before they are loaded).
- Fix re-registering the same kretprobe.
- Add missing value check for added RCU variable reload.
Alexey Kardashevskiy (1):
tracepoint: Fix race between tracing and removing tracepoint
Masami Hiramatsu (1):
tracing/kprobe: Fix to support kretprobe events on unloaded modules
Steven Rostedt (VMware) (1):
fgraph: Initialize tracing_graph_pause at task creation
Viktor Rosendahl (1):
tracing: Use pause-on-trace with the latency tracers
Wang ShaoBo (1):
kretprobe: Avoid re-registration of the same kretprobe earlier
----
include/linux/kprobes.h | 2 +- include/linux/tracepoint.h | 12 +++++++----- init/init_task.c | 3 ++- kernel/kprobes.c | 36 ++++++++++++++++++++++++++++-------- kernel/trace/fgraph.c | 2 -- kernel/trace/trace_irqsoff.c | 4 ++++ kernel/trace/trace_kprobe.c | 10 ++++++---- 7 files changed, 48 insertions(+), 21 deletions(-)
Steven Rostedt
maintainerPATCH 1/5 fgraph: Initialize tracing_graph_pause at task creation
From: "Steven Rostedt (VMware)" <[email protected]>
On some archs, the idle task can call into cpu_suspend(). The cpu_suspend() will disable or pause function graph tracing, as there's some paths in bringing down the CPU that can have issues with its return address being modified. The task_struct structure has a "tracing_graph_pause" atomic counter, that when set to something other than zero, the function graph tracer will not modify the return address.
The problem is that the tracing_graph_pause counter is initialized when the function graph tracer is enabled. This can corrupt the counter for the idle task if it is suspended in these architectures.
CPU 1 CPU 2
----- -----
do_idle()
cpu_suspend()
pause_graph_tracing()
task_struct->tracing_graph_pause++ (0 -> 1)
start_graph_tracing()
for_each_online_cpu(cpu) {
ftrace_graph_init_idle_task(cpu)
task-struct->tracing_graph_pause = 0 (1 -> 0)
unpause_graph_tracing()
task_struct->tracing_graph_pause-- (0 -> -1)The above should have gone from 1 to zero, and enabled function graph tracing again. But instead, it is set to -1, which keeps it disabled.
There's no reason that the field tracing_graph_pause on the task_struct can not be initialized at boot up.
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=211339
--- init/init_task.c | 3 ++- kernel/trace/fgraph.c | 2 -- 2 files changed, 2 insertions(+), 3 deletions(-)
init/init_task.c +2 -1
@@ -198,7 +198,8 @@ struct task_struct init_task .lockdep_recursion = 0,#endif #ifdef CONFIG_FUNCTION_GRAPH_TRACER - .ret_stack = NULL, + .ret_stack = NULL, + .tracing_graph_pause = ATOMIC_INIT(0),#endif #if defined(CONFIG_TRACING ) && defined(CONFIG_PREEMPTION ) .trace_recursion = 0,
kernel/trace/fgraph.c +0 -2
@@ -394,7 +394,6 @@ static int alloc_retstack_tasklist(struct ftrace_ret_stack **ret_stack_list) }if (t->ret_stack ==NULL ) { -atomic_set (&t->tracing_graph_pause,0 );atomic_set (&t->trace_overrun,0 ); t->curr_ret_stack =-1 ; t->curr_ret_depth =-1 ;
@@ -489,7 +488,6 @@ static DEFINE_PER_CPU(struct ftrace_ret_stack *, idle_ret_stack);static void graph_init_task (struct task_struct *t,struct ftrace_ret_stack *ret_stack) { -atomic_set (&t->tracing_graph_pause,0 );atomic_set (&t->trace_overrun,0 ); t->ftrace_timestamp =0 ;/* make curr_ret_stack visible before we add the ret_stack */
Signature · 1 line
2.29.2
Steven Rostedt
maintainerPATCH 2/5 tracing: Use pause-on-trace with the latency tracers
In reply to Steven RostedtFrom: Viktor Rosendahl <[email protected]>
Eaerlier, tracing was disabled when reading the trace file. This behavior was changed with:
commit 06e0a548bad0 ("tracing: Do not disable tracing when reading the trace file").
This doesn't seem to work with the latency tracers.
The above mentioned commit dit not only change the behavior but also added an option to emulate the old behavior. The idea with this patch is to enable this pause-on-trace option when the latency tracers are used.
--- kernel/trace/trace_irqsoff.c | 4 ++++ 1 file changed, 4 insertions(+)
kernel/trace/trace_irqsoff.c +4 -0
@@ -562,6 +562,8 @@ static int __irqsoff_tracer_init(struct trace_array *tr)/* non overwrite screws up the latency tracers */ set_tracer_flag (tr,TRACE_ITER_OVERWRITE ,1 );set_tracer_flag (tr,TRACE_ITER_LATENCY_FMT ,1 ); +/* without pause, we will produce garbage if another latency occurs */ +set_tracer_flag (tr,TRACE_ITER_PAUSE_ON_TRACE ,1 ); tr->max_latency =0 ; irqsoff_trace = tr;
@@ -583,11 +585,13 @@ static void __irqsoff_tracer_reset(struct trace_array *tr) {int lat_flag = save_flags &TRACE_ITER_LATENCY_FMT ;int overwrite_flag = save_flags &TRACE_ITER_OVERWRITE ; +int pause_flag = save_flags &TRACE_ITER_PAUSE_ON_TRACE ;stop_irqsoff_tracer (tr,is_graph (tr));set_tracer_flag (tr,TRACE_ITER_LATENCY_FMT , lat_flag);set_tracer_flag (tr,TRACE_ITER_OVERWRITE , overwrite_flag); +set_tracer_flag (tr,TRACE_ITER_PAUSE_ON_TRACE , pause_flag);ftrace_reset_array_ops (tr); irqsoff_busy = false;
Signature · 1 line
2.29.2
Steven Rostedt
maintainerPATCH 3/5 tracing/kprobe: Fix to support kretprobe events on unloaded modules
In reply to Steven RostedtFrom: Masami Hiramatsu <[email protected]>
Fix kprobe_on_func_entry() returns error code instead of false so that register_kretprobe() can return an appropriate error code.
append_trace_kprobe() expects the kprobe registration returns -ENOENT when the target symbol is not found, and it checks whether the target module is unloaded or not. If the target module doesn't exist, it defers to probe the target symbol until the module is loaded.
However, since register_kretprobe() returns -EINVAL instead of -ENOENT in that case, it always fail on putting the kretprobe event on unloaded modules. e.g.
Kprobe event:/sys/kernel/debug/tracing # echo p xfs:xfs_end_io >> kprobe_events
[ 16.515574] trace_kprobe: This probe might be able to register after target module is loaded. Continue.
Kretprobe event: (p -> r)/sys/kernel/debug/tracing # echo r xfs:xfs_end_io >> kprobe_events
sh: write error: Invalid argument /sys/kernel/debug/tracing # cat error_log
[ 41.122514] trace_kprobe: error: Failed to register probe event
Command: r xfs:xfs_end_io
^To fix this bug, change kprobe_on_func_entry() to detect symbol lookup failure and return -ENOENT in that case. Otherwise it returns -EINVAL or 0 (succeeded, given address is on the entry).
--- include/linux/kprobes.h | 2 +- kernel/kprobes.c | 34 +++++++++++++++++++++++++--------- kernel/trace/trace_kprobe.c | 10 ++++++---- 3 files changed, 32 insertions(+), 14 deletions(-)
include/linux/kprobes.h +1 -1
@@ -266,7 +266,7 @@ extern void kprobes_inc_nmissed_count(struct kprobe *p);extern bool arch_within_kprobe_blacklist (unsigned long addr);extern int arch_populate_kprobe_blacklist (void );extern bool arch_kprobe_on_func_entry (unsigned long offset); -extern bool kprobe_on_func_entry (kprobe_opcode_t *addr,const char *sym,unsigned long offset); +extern int kprobe_on_func_entry (kprobe_opcode_t *addr,const char *sym,unsigned long offset);extern bool within_kprobe_blacklist (unsigned long addr);extern int kprobe_add_ksym_blacklist (unsigned long entry);
kernel/kprobes.c +25 -9
@@ -1954,29 +1954,45 @@ bool __weak arch_kprobe_on_func_entry(unsigned long offset)return !offset; } -bool kprobe_on_func_entry (kprobe_opcode_t *addr,const char *sym,unsigned long offset) +/** +* kprobe_on_func_entry() -- check whether given address is function entry +* @addr: Target address +* @sym: Target symbol name +* @offset: The offset from the symbol or the address +* +* This checks whether the given @addr+@offset or @sym+@offset is on the +* function entry address or not. +* This returns 0 if it is the function entry, or -EINVAL if it is not. +* And also it returns -ENOENT if it fails the symbol or address lookup. +* Caller must pass @addr or @sym (either one must be NULL), or this +* returns -EINVAL. +*/ +int kprobe_on_func_entry (kprobe_opcode_t *addr,const char *sym,unsigned long offset) {kprobe_opcode_t *kp_addr =_kprobe_addr (addr, sym, offset);if (IS_ERR (kp_addr)) -return false; +return PTR_ERR (kp_addr); -if (!kallsyms_lookup_size_offset ((unsigned long )kp_addr,NULL , &offset) || - !arch_kprobe_on_func_entry (offset)) -return false; +if (!kallsyms_lookup_size_offset ((unsigned long )kp_addr,NULL , &offset)) +return -ENOENT ; -return true; +if (!arch_kprobe_on_func_entry (offset)) +return -EINVAL ; + +return 0 ; }int register_kretprobe (struct kretprobe *rp) { -int ret =0 ; +int ret;struct kretprobe_instance *inst;int i;void *addr; -if (!kprobe_on_func_entry (rp->kp.addr, rp->kp.symbol_name, rp->kp.offset)) -return -EINVAL ; + ret =kprobe_on_func_entry (rp->kp.addr, rp->kp.symbol_name, rp->kp.offset); +if (ret) +return ret;if (kretprobe_blacklist_size) { addr =kprobe_addr (&rp->kp);
kernel/trace/trace_kprobe.c +6 -4
@@ -221,9 +221,9 @@ bool trace_kprobe_on_func_entry(struct trace_event_call *call) {struct trace_kprobe *tk =trace_kprobe_primary_from_call (call); -return tk ?kprobe_on_func_entry (tk->rp.kp.addr, +return tk ? (kprobe_on_func_entry (tk->rp.kp.addr, tk->rp.kp.addr ?NULL : tk->rp.kp.symbol_name, - tk->rp.kp.addr ?0 : tk->rp.kp.offset) : false; + tk->rp.kp.addr ?0 : tk->rp.kp.offset) ==0 ) : false; }bool trace_kprobe_error_injectable (struct trace_event_call *call)
@@ -828,9 +828,11 @@ static int trace_kprobe_create(int argc, const char *argv[]) }if (is_return) flags |=TPARG_FL_RETURN ; -if (kprobe_on_func_entry (NULL , symbol, offset)) + ret =kprobe_on_func_entry (NULL , symbol, offset); +if (ret ==0 ) flags |=TPARG_FL_FENTRY ; -if (offset && is_return && !(flags &TPARG_FL_FENTRY )) { +/* Defer the ENOENT case until register kprobe */ +if (ret == -EINVAL && is_return) {trace_probe_log_err (0 ,BAD_RETPROBE ); goto parse_error; }
Signature · 1 line
2.29.2
Steven Rostedt
maintainerPATCH 4/5 kretprobe: Avoid re-registration of the same kretprobe earlier
In reply to Steven RostedtFrom: Wang ShaoBo <[email protected]>
Our system encountered a re-init error when re-registering same kretprobe, where the kretprobe_instance in rp->free_instances is illegally accessed after re-init.
Implementation to avoid re-registration has been introduced for kprobe before, but lags for register_kretprobe(). We must check if kprobe has been re-registered before re-initializing kretprobe, otherwise it will destroy the data struct of kretprobe registered, which can lead to memory leak, system crash, also some unexpected behaviors.
We use check_kprobe_rereg() to check if kprobe has been re-registered before running register_kretprobe()'s body, for giving a warning message and terminate registration process.
--- kernel/kprobes.c | 4 ++++ 1 file changed, 4 insertions(+)
kernel/kprobes.c +4 -0
@@ -1994,6 +1994,10 @@ int register_kretprobe(struct kretprobe *rp)if (ret)return ret; +/* If only rp->kp.addr is specified, check reregistering kprobes */ +if (rp->kp.addr &&check_kprobe_rereg (&rp->kp)) +return -EINVAL ; +if (kretprobe_blacklist_size) { addr =kprobe_addr (&rp->kp);if (IS_ERR (addr))
Signature · 1 line
2.29.2
Steven Rostedt
maintainerPATCH 5/5 tracepoint: Fix race between tracing and removing tracepoint
In reply to Steven RostedtFrom: Alexey Kardashevskiy <[email protected]>
When executing a tracepoint, the tracepoint's func is dereferenced twice - in __DO_TRACE() (where the returned pointer is checked) and later on in __traceiter_##_name where the returned pointer is dereferenced without checking which leads to races against tracepoint_removal_sync() and crashes.
This adds a check before referencing the pointer in tracepoint_ptr_deref.
--- include/linux/tracepoint.h | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-)
include/linux/tracepoint.h +7 -5
@@ -307,11 +307,13 @@ static inline struct tracepoint *tracepoint_ptr_deref(tracepoint_ptr_t *p) \ it_func_ptr = \ rcu_dereference_raw((&__tracepoint_##_name)->funcs); \ -do { \ - it_func = (it_func_ptr)->func; \ - __data = (it_func_ptr)->data; \ - ((void (*)(void *,proto ))(it_func))(__data, args); \ - }while ((++it_func_ptr)->func); \ +if (it_func_ptr) { \ +do { \ + it_func = (it_func_ptr)->func; \ + __data = (it_func_ptr)->data; \ + ((void (*)(void *,proto ))(it_func))(__data, args); \ + }while ((++it_func_ptr)->func); \ + } \return 0 ; \ } \ DEFINE_STATIC_CALL(tp_func_##_name, __traceiter_##_name);
Signature · 1 line
2.29.2