tracing: Updates for 5.11
Subsystems (16)
Steven Rostedt
maintainercover tracing: Updates for 5.11
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
for-next
Head SHA1: 58954b3be8b7a8a0ebf1ced6fbbab808e8ccc4b6
Alex Shi (1):
ftrace: Remove unused varible 'ret'
Lukas Bulwahn (1):
MAINTAINERS: assign ./fs/tracefs to TRACING
Qiujun Huang (1):
tracing: Fix some typos in comments
Steven Rostedt (VMware) (14):
ftrace: Move the recursion testing into global headers
ftrace: Add ftrace_test_recursion_trylock() helper function
ftrace: Optimize testing what context current is in pstore/ftrace: Add recursion protection to the ftrace callback kprobes/ftrace: Add recursion protection to the ftrace callback livepatch/ftrace: Add recursion protection to the ftrace callback
livepatch: Trigger WARNING if livepatch function fails due to recursion perf/ftrace: Add recursion protection to the ftrace callback perf/ftrace: Check for rcu_is_watching() in callback function
ftrace: Reverse what the RECURSION flag means in the ftrace_ops
ftrace: Add recording of functions that caused recursion
fgraph: Make overruns 4 bytes in graph stack structure
ftrace: Clean up the recursion code a bit
ring-buffer: Add recording of ring buffer recursion into recursed_functions
----
Documentation/trace/ftrace-uses.rst | 84 ++++++++---- MAINTAINERS | 1 + arch/csky/kernel/probes/ftrace.c | 12 +- arch/parisc/kernel/ftrace.c | 16 ++- arch/powerpc/kernel/kprobes-ftrace.c | 11 +- arch/s390/kernel/ftrace.c | 16 ++- arch/x86/kernel/kprobes/ftrace.c | 12 +- fs/pstore/ftrace.c | 6 + include/linux/ftrace.h | 17 +-- include/linux/trace_recursion.h | 232 +++++++++++++++++++++++++++++++++ kernel/livepatch/patch.c | 5 + kernel/trace/Kconfig | 39 ++++++ kernel/trace/Makefile | 1 + kernel/trace/blktrace.c | 4 +- kernel/trace/bpf_trace.c | 2 +- kernel/trace/fgraph.c | 3 +- kernel/trace/ftrace.c | 30 ++--- kernel/trace/ring_buffer.c | 12 +- kernel/trace/trace.c | 2 +- kernel/trace/trace.h | 177 ------------------------- kernel/trace/trace_benchmark.c | 6 +- kernel/trace/trace_dynevent.c | 2 +- kernel/trace/trace_dynevent.h | 6 +- kernel/trace/trace_entries.h | 6 +- kernel/trace/trace_event_perf.c | 13 +- kernel/trace/trace_events.c | 5 +- kernel/trace/trace_events_filter.c | 2 +- kernel/trace/trace_events_hist.c | 2 +- kernel/trace/trace_events_synth.c | 4 +- kernel/trace/trace_export.c | 2 +- kernel/trace/trace_functions.c | 14 +- kernel/trace/trace_functions_graph.c | 2 +- kernel/trace/trace_hwlat.c | 4 +- kernel/trace/trace_output.c | 6 +- kernel/trace/trace_output.h | 1 + kernel/trace/trace_recursion_record.c | 236 ++++++++++++++++++++++++++++++++++ kernel/trace/trace_selftest.c | 7 +- kernel/trace/trace_stack.c | 1 - kernel/trace/tracing_map.c | 6 +- kernel/trace/tracing_map.h | 2 +- 40 files changed, 723 insertions(+), 286 deletions(-) create mode 100644 include/linux/trace_recursion.h create mode 100644 kernel/trace/trace_recursion_record.c
Steven Rostedt
maintainerPATCH 1/17 ftrace: Move the recursion testing into global headers
From: "Steven Rostedt (VMware)" <[email protected]>
Currently, if a callback is registered to a ftrace function and its ftrace_ops does not have the RECURSION flag set, it is encapsulated in a helper function that does the recursion for it.
Really, all the callbacks should have their own recursion protection for performance reasons. But they should not all implement their own. Move the recursion helpers to global headers, so that all callbacks can use them.
--- include/linux/ftrace.h | 1 + include/linux/trace_recursion.h | 187 ++++++++++++++++++++++++++++++++ kernel/trace/trace.h | 177 ------------------------------ 3 files changed, 188 insertions(+), 177 deletions(-) create mode 100644 include/linux/trace_recursion.h
include/linux/ftrace.h +1 -0
@@ -7,6 +7,7 @@#ifndef _LINUX_FTRACE_H#define _LINUX_FTRACE_H +#include <linux/trace_recursion.h> #include <linux/trace_clock.h> #include <linux/kallsyms.h> #include <linux/linkage.h>
include/linux/trace_recursion.h new file +187 -0
187 lines not on this page · raw message
kernel/trace/trace.h +0 -177
183 lines not on this page · raw message
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 2/17 ftrace: Add ftrace_test_recursion_trylock() helper function
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
To make it easier for ftrace callbacks to have recursion protection, provide a ftrace_test_recursion_trylock() and ftrace_test_recursion_unlock() helper that tests for recursion.
--- include/linux/trace_recursion.h | 25 +++++++++++++++++++++++++ kernel/trace/trace_functions.c | 12 +++++------- 2 files changed, 30 insertions(+), 7 deletions(-)
include/linux/trace_recursion.h +25 -0
@@ -183,5 +183,30 @@ static __always_inline void trace_clear_recursion(int bit) current->trace_recursion = val; } +/** +* ftrace_test_recursion_trylock - tests for recursion in same context +* +* Use this for ftrace callbacks. This will detect if the function +* tracing recursed in the same context (normal vs interrupt), +* +* Returns: -1 if a recursion happened. +* >= 0 if no recursion +*/ +static __always_inline int ftrace_test_recursion_trylock(void) +{ +return trace_test_and_set_recursion (TRACE_FTRACE_START ,TRACE_FTRACE_MAX ); +} + +/** +* ftrace_test_recursion_unlock - called when function callback is complete +* @bit: The return of a successful ftrace_test_recursion_trylock() +* +* This is used at the end of a ftrace callback. +*/ +static __always_inline void ftrace_test_recursion_unlock(int bit) +{ +trace_clear_recursion (bit); +} +#endif /* CONFIG_TRACING */ #endif /* _LINUX_TRACE_RECURSION_H */
kernel/trace/trace_functions.c +5 -7
@@ -141,22 +141,20 @@ function_trace_call(unsigned long ip, unsigned long parent_ip,if (unlikely (!tr->function_enabled))return ; + bit =ftrace_test_recursion_trylock (); +if (bit <0 ) +return ; + pc =preempt_count ();preempt_disable_notrace (); - bit =trace_test_and_set_recursion (TRACE_FTRACE_START ,TRACE_FTRACE_MAX ); -if (bit <0 ) - goto out; - cpu =smp_processor_id (); data =per_cpu_ptr (tr->array_buffer.data, cpu);if (!atomic_read (&data->disabled)) {local_save_flags (flags);trace_function (tr, ip, parent_ip, flags, pc); } -trace_clear_recursion (bit); - - out: +ftrace_test_recursion_unlock (bit);preempt_enable_notrace (); }
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 3/17 ftrace: Optimize testing what context current is in
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
The preempt_count() is not a simple location in memory, it could be part of per_cpu code or more. Each access to preempt_count(), or one of its accessor functions (like in_interrupt()) takes several cycles. By reading preempt_count() once, and then doing tests to find the context against the value return is slightly faster than using in_nmi() and in_interrupt().
--- include/linux/trace_recursion.h | 33 ++++++++++++++++++++------------- 1 file changed, 20 insertions(+), 13 deletions(-)
include/linux/trace_recursion.h +20 -13
@@ -117,22 +117,29 @@ enum {#define TRACE_CONTEXT_MASK TRACE_LIST_MAX +/* +* Used for setting context +* NMI = 0 +* IRQ = 1 +* SOFTIRQ = 2 +* NORMAL = 3 +*/ +enum { +TRACE_CTX_NMI , +TRACE_CTX_IRQ , +TRACE_CTX_SOFTIRQ , +TRACE_CTX_NORMAL , +}; + static __always_inline int trace_get_context_bit(void) { -int bit; - -if (in_interrupt ()) { -if (in_nmi ()) - bit =0 ; - -else if (in_irq ()) - bit =1 ; -else - bit =2 ; - }else - bit =3 ; +unsigned long pc =preempt_count (); -return bit; +if (!(pc & (NMI_MASK |HARDIRQ_MASK |SOFTIRQ_OFFSET ))) +return TRACE_CTX_NORMAL ; +else +return pc &NMI_MASK ?TRACE_CTX_NMI : + pc &HARDIRQ_MASK ?TRACE_CTX_IRQ :TRACE_CTX_SOFTIRQ ; } static __always_inline int trace_test_and_set_recursion(int start, int max)
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 4/17 pstore/ftrace: Add recursion protection to the ftrace callback
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.
The default for ftrace_ops is going to change. It will expect that handlers provide their own recursion protection, unless its ftrace_ops states otherwise.
--- fs/pstore/ftrace.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/pstore/ftrace.c +6 -0
@@ -28,6 +28,7 @@ static void notrace pstore_ftrace_call(unsigned long ip,struct ftrace_ops *op, struct pt_regs *regs) { + int bit;unsigned long flags;struct pstore_ftrace_record rec = {}; struct pstore_record record = {
@@ -40,6 +41,10 @@ static void notrace pstore_ftrace_call(unsigned long ip,if (unlikely (oops_in_progress))return ; + bit =ftrace_test_recursion_trylock (); +if (bit <0 ) +return ; +local_irq_save (flags); rec.ip = ip;
@@ -49,6 +54,7 @@ static void notrace pstore_ftrace_call(unsigned long ip, psinfo->write (&record);local_irq_restore (flags); +ftrace_test_recursion_unlock (bit); }static struct ftrace_ops pstore_ftrace_ops__read_mostly = {
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 5/17 kprobes/ftrace: Add recursion protection to the ftrace callback
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.
The default for ftrace_ops is going to change. It will expect that handlers provide their own recursion protection, unless its ftrace_ops states otherwise.
--- arch/csky/kernel/probes/ftrace.c | 12 ++++++++++-- arch/parisc/kernel/ftrace.c | 16 +++++++++++++--- arch/powerpc/kernel/kprobes-ftrace.c | 11 ++++++++++- arch/s390/kernel/ftrace.c | 16 +++++++++++++--- arch/x86/kernel/kprobes/ftrace.c | 12 ++++++++++-- 5 files changed, 56 insertions(+), 11 deletions(-)
arch/csky/kernel/probes/ftrace.c +10 -2
@@ -13,16 +13,21 @@ int arch_check_ftrace_location(struct kprobe *p)void kprobe_ftrace_handler (unsigned long ip,unsigned long parent_ip,struct ftrace_ops *ops,struct pt_regs *regs) { +int bit;bool lr_saver = false;struct kprobe *p;struct kprobe_ctlblk *kcb; -/* Preempt is disabled by ftrace */ + bit =ftrace_test_recursion_trylock (); +if (bit <0 ) +return ; + +preempt_disable_notrace (); p =get_kprobe ((kprobe_opcode_t *)ip);if (!p) { p =get_kprobe ((kprobe_opcode_t *)(ip -MCOUNT_INSN_SIZE ));if (unlikely (!p) ||kprobe_disabled (p)) -return ; + goto out; lr_saver = true; }
@@ -56,6 +61,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,*/ __this_cpu_write (current_kprobe,NULL ); } +out: +preempt_enable_notrace (); +ftrace_test_recursion_unlock (bit); }NOKPROBE_SYMBOL (kprobe_ftrace_handler);
arch/parisc/kernel/ftrace.c +13 -3
@@ -207,14 +207,21 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *ops, struct pt_regs *regs) { struct kprobe_ctlblk *kcb; -struct kprobe *p =get_kprobe ((kprobe_opcode_t *)ip); +struct kprobe *p; +int bit; -if (unlikely (!p) ||kprobe_disabled (p)) + bit =ftrace_test_recursion_trylock (); +if (bit <0 )return ; +preempt_disable_notrace (); + p =get_kprobe ((kprobe_opcode_t *)ip); +if (unlikely (!p) ||kprobe_disabled (p)) + goto out; +if (kprobe_running ()) {kprobes_inc_nmissed_count (p); -return ; + goto out; }__this_cpu_write (current_kprobe, p);
@@ -235,6 +242,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, } }__this_cpu_write (current_kprobe,NULL ); +out: +preempt_enable_notrace (); +ftrace_test_recursion_unlock (bit); }NOKPROBE_SYMBOL (kprobe_ftrace_handler);
arch/powerpc/kernel/kprobes-ftrace.c +10 -1
@@ -18,10 +18,16 @@ void kprobe_ftrace_handler(unsigned long nip, unsigned long parent_nip, {struct kprobe *p;struct kprobe_ctlblk *kcb; +int bit; + bit =ftrace_test_recursion_trylock (); +if (bit <0 ) +return ; + +preempt_disable_notrace (); p =get_kprobe ((kprobe_opcode_t *)nip);if (unlikely (!p) ||kprobe_disabled (p)) -return ; + goto out; kcb =get_kprobe_ctlblk ();if (kprobe_running ()) {
@@ -52,6 +58,9 @@ void kprobe_ftrace_handler(unsigned long nip, unsigned long parent_nip,*/ __this_cpu_write (current_kprobe,NULL ); } +out: +preempt_enable_notrace (); +ftrace_test_recursion_unlock (bit); }NOKPROBE_SYMBOL (kprobe_ftrace_handler);
arch/s390/kernel/ftrace.c +13 -3
@@ -201,14 +201,21 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *ops, struct pt_regs *regs) { struct kprobe_ctlblk *kcb; -struct kprobe *p =get_kprobe ((kprobe_opcode_t *)ip); +struct kprobe *p; +int bit; -if (unlikely (!p) ||kprobe_disabled (p)) + bit =ftrace_test_recursion_trylock (); +if (bit <0 )return ; +preempt_disable_notrace (); + p =get_kprobe ((kprobe_opcode_t *)ip); +if (unlikely (!p) ||kprobe_disabled (p)) + goto out; +if (kprobe_running ()) {kprobes_inc_nmissed_count (p); -return ; + goto out; }__this_cpu_write (current_kprobe, p);
@@ -228,6 +235,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, } }__this_cpu_write (current_kprobe,NULL ); +out: +preempt_enable_notrace (); +ftrace_test_recursion_unlock (bit); }NOKPROBE_SYMBOL (kprobe_ftrace_handler);
arch/x86/kernel/kprobes/ftrace.c +10 -2
@@ -18,11 +18,16 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip, {struct kprobe *p;struct kprobe_ctlblk *kcb; +int bit; -/* Preempt is disabled by ftrace */ + bit =ftrace_test_recursion_trylock (); +if (bit <0 ) +return ; + +preempt_disable_notrace (); p =get_kprobe ((kprobe_opcode_t *)ip);if (unlikely (!p) ||kprobe_disabled (p)) -return ; + goto out; kcb =get_kprobe_ctlblk ();if (kprobe_running ()) {
@@ -52,6 +57,9 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,*/ __this_cpu_write (current_kprobe,NULL ); } +out: +preempt_enable_notrace (); +ftrace_test_recursion_unlock (bit); }NOKPROBE_SYMBOL (kprobe_ftrace_handler);
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 6/17 livepatch/ftrace: Add recursion protection to the ftrace callback
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.
The default for ftrace_ops is going to change. It will expect that handlers provide their own recursion protection, unless its ftrace_ops states otherwise.
--- kernel/livepatch/patch.c | 5 +++++ 1 file changed, 5 insertions(+)
kernel/livepatch/patch.c +5 -0
@@ -45,9 +45,13 @@ static void notrace klp_ftrace_handler(unsigned long ip,struct klp_ops *ops;struct klp_func *func;int patch_state; +int bit; ops = container_of(fops, struct klp_ops, fops); + bit =ftrace_test_recursion_trylock (); +if (bit <0 ) +return ;/* * A variant of synchronize_rcu() is used to allow patching functions * where RCU is not watching, see klp_synchronize_transition().
@@ -117,6 +121,7 @@ static void notrace klp_ftrace_handler(unsigned long ip, unlock:preempt_enable_notrace (); +ftrace_test_recursion_unlock (bit); }/*
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 7/17 livepatch: Trigger WARNING if livepatch function fails due to recursion
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
If for some reason a function is called that triggers the recursion detection of live patching, trigger a warning. By not executing the live patch code, it is possible that the old unpatched function will be called placing the system into an unknown state.
--- kernel/livepatch/patch.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/livepatch/patch.c +1 -1
@@ -50,7 +50,7 @@ static void notrace klp_ftrace_handler(unsigned long ip, ops = container_of(fops, struct klp_ops, fops); bit =ftrace_test_recursion_trylock (); -if (bit <0 ) +if (WARN_ON_ONCE (bit <0 ))return ;/* * A variant of synchronize_rcu() is used to allow patching functions
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 8/17 perf/ftrace: Add recursion protection to the ftrace callback
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
If a ftrace callback does not supply its own recursion protection and does not set the RECURSION_SAFE flag in its ftrace_ops, then ftrace will make a helper trampoline to do so before calling the callback instead of just calling the callback directly.
The default for ftrace_ops is going to change. It will expect that handlers provide their own recursion protection, unless its ftrace_ops states otherwise.
--- kernel/trace/trace_event_perf.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
kernel/trace/trace_event_perf.c +8 -1
@@ -439,10 +439,15 @@ perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,struct hlist_head head;struct pt_regs regs;int rctx; +int bit;if ((unsigned long )ops->private !=smp_processor_id ())return ; + bit =ftrace_test_recursion_trylock (); +if (bit <0 ) +return ; + event = container_of(ops, struct perf_event, ftrace_ops);/*
@@ -463,13 +468,15 @@ perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip, entry =perf_trace_buf_alloc (ENTRY_SIZE ,NULL , &rctx);if (!entry) -return ; + goto out; entry->ip = ip; entry->parent_ip = parent_ip;perf_trace_buf_submit (entry,ENTRY_SIZE , rctx,TRACE_FN ,1 , ®s, &head,NULL ); +out: +ftrace_test_recursion_unlock (bit);#undef ENTRY_SIZE }
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 9/17 perf/ftrace: Check for rcu_is_watching() in callback function
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
If a ftrace callback requires "rcu_is_watching", then it adds the FTRACE_OPS_FL_RCU flag and it will not be called if RCU is not "watching". But this means that it will use a trampoline when called, and this slows down the function tracing a tad. By checking rcu_is_watching() from within the callback, it no longer needs the RCU flag set in the ftrace_ops and it can be safely called directly.
--- kernel/trace/trace_event_perf.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
kernel/trace/trace_event_perf.c +3 -1
@@ -441,6 +441,9 @@ perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,int rctx;int bit; +if (!rcu_is_watching ()) +return ; +if ((unsigned long )ops->private !=smp_processor_id ())return ;
@@ -484,7 +487,6 @@ static int perf_ftrace_function_register(struct perf_event *event) {struct ftrace_ops *ops = &event->ftrace_ops; - ops->flags =FTRACE_OPS_FL_RCU ; ops->func = perf_ftrace_function_call; ops->private = (void *)(unsigned long )nr_cpu_ids;
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 10/17 ftrace: Reverse what the RECURSION flag means in the ftrace_ops
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
Now that all callbacks are recursion safe, reverse the meaning of the RECURSION flag and rename it from RECURSION_SAFE to simply RECURSION. Now only callbacks that request to have recursion protecting it will have the added trampoline to do so.
Also remove the outdated comment about "PER_CPU" when determining to use the ftrace_ops_assist_func.
--- Documentation/trace/ftrace-uses.rst | 82 +++++++++++++++++++++-------- include/linux/ftrace.h | 12 ++--- kernel/trace/fgraph.c | 3 +- kernel/trace/ftrace.c | 20 ++++--- kernel/trace/trace_events.c | 1 - kernel/trace/trace_functions.c | 2 +- kernel/trace/trace_selftest.c | 7 +-- kernel/trace/trace_stack.c | 1 - 8 files changed, 79 insertions(+), 49 deletions(-)
Documentation/trace/ftrace-uses.rst +60 -22
@@ -30,8 +30,8 @@ The ftrace context This requires extra care to what can be done inside a callback. A callback can be called outside the protective scope of RCU. -The ftrace infrastructure has some protections against recursions and RCU -but one must still be very careful how they use the callbacks. +There are helper functions to help against recursion, and making sure +RCU is watching. These are explained below. The ftrace_ops structure
@@ -108,6 +108,50 @@ The prototype of the callback function is as follows (as of v4.14): at the start of the function where ftrace was tracing. Otherwise it either contains garbage, or NULL. +Protect your callback +===================== + +As functions can be called from anywhere, and it is possible that a function +called by a callback may also be traced, and call that same callback, +recursion protection must be used. There are two helper functions that +can help in this regard. If you start your code with: + + int bit; + + bit = ftrace_test_recursion_trylock(); + if (bit < 0) + return; + +and end it with: + + ftrace_test_recursion_unlock(bit); + +The code in between will be safe to use, even if it ends up calling a +function that the callback is tracing. Note, on success, +ftrace_test_recursion_trylock() will disable preemption, and the +ftrace_test_recursion_unlock() will enable it again (if it was previously +enabled). + +Alternatively, if the FTRACE_OPS_FL_RECURSION flag is set on the ftrace_ops +(as explained below), then a helper trampoline will be used to test +for recursion for the callback and no recursion test needs to be done. +But this is at the expense of a slightly more overhead from an extra +function call. + +If your callback accesses any data or critical section that requires RCU +protection, it is best to make sure that RCU is "watching", otherwise +that data or critical section will not be protected as expected. In this +case add: + + if (!rcu_is_watching()) + return; + +Alternatively, if the FTRACE_OPS_FL_RCU flag is set on the ftrace_ops +(as explained below), then a helper trampoline will be used to test +for rcu_is_watching for the callback and no other test needs to be done. +But this is at the expense of a slightly more overhead from an extra +function call. + The ftrace FLAGS ================
@@ -128,26 +172,20 @@ FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED will not fail with this flag set. But the callback must check if regs is NULL or not to determine if the architecture supports it. -FTRACE_OPS_FL_RECURSION_SAFE - By default, a wrapper is added around the callback to - make sure that recursion of the function does not occur. That is, - if a function that is called as a result of the callback's execution - is also traced, ftrace will prevent the callback from being called - again. But this wrapper adds some overhead, and if the callback is - safe from recursion, it can set this flag to disable the ftrace - protection. - - Note, if this flag is set, and recursion does occur, it could cause - the system to crash, and possibly reboot via a triple fault. - - It is OK if another callback traces a function that is called by a - callback that is marked recursion safe. Recursion safe callbacks - must never trace any function that are called by the callback - itself or any nested functions that those functions call. - - If this flag is set, it is possible that the callback will also - be called with preemption enabled (when CONFIG_PREEMPTION is set), - but this is not guaranteed. +FTRACE_OPS_FL_RECURSION + By default, it is expected that the callback can handle recursion. + But if the callback is not that worried about overehead, then + setting this bit will add the recursion protection around the + callback by calling a helper function that will do the recursion + protection and only call the callback if it did not recurse. + + Note, if this flag is not set, and recursion does occur, it could + cause the system to crash, and possibly reboot via a triple fault. + + Not, if this flag is set, then the callback will always be called + with preemption disabled. If it is not set, then it is possible + (but not guaranteed) that the callback will be called in + preemptable context. FTRACE_OPS_FL_IPMODIFY Requires FTRACE_OPS_FL_SAVE_REGS set. If the callback is to "hijack"
include/linux/ftrace.h +6 -6
@@ -98,7 +98,7 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);/* * FTRACE_OPS_FL_* bits denote the state of ftrace_ops struct and are * set in the flags member. -* CONTROL, SAVE_REGS, SAVE_REGS_IF_SUPPORTED, RECURSION_SAFE, STUB and +* CONTROL, SAVE_REGS, SAVE_REGS_IF_SUPPORTED, RECURSION, STUB and * IPMODIFY are a kind of attribute flags which can be set only before * registering the ftrace_ops, and can not be modified while registered. * Changing those attribute flags after registering ftrace_ops will
@@ -121,10 +121,10 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);* passing regs to the handler. * Note, if this flag is set, the SAVE_REGS flag will automatically * get set upon registering the ftrace_ops, if the arch supports it. -* RECURSION_SAFE - The ftrace_ops can set this to tell the ftrace infrastructure -* that the call back has its own recursion protection. If it does -* not set this, then the ftrace infrastructure will add recursion -* protection for the caller. +* RECURSION - The ftrace_ops can set this to tell the ftrace infrastructure +* that the call back needs recursion protection. If it does +* not set this, then the ftrace infrastructure will assume +* that the callback can handle recursion on its own. * STUB - The ftrace_ops is just a place holder. * INITIALIZED - The ftrace_ops has already been initialized (first use time * register_ftrace_function() is called, it will initialized the ops)
@@ -156,7 +156,7 @@ enum {FTRACE_OPS_FL_DYNAMIC =BIT (1 ),FTRACE_OPS_FL_SAVE_REGS =BIT (2 ),FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED =BIT (3 ), -FTRACE_OPS_FL_RECURSION_SAFE =BIT (4 ), +FTRACE_OPS_FL_RECURSION =BIT (4 ),FTRACE_OPS_FL_STUB =BIT (5 ),FTRACE_OPS_FL_INITIALIZED =BIT (6 ), FTRACE_OPS_FL_DELETED = BIT(7),
kernel/trace/fgraph.c +1 -2
@@ -334,8 +334,7 @@ unsigned long ftrace_graph_ret_addr(struct task_struct *task, int *idx,static struct ftrace_ops graph_ops = { .func = ftrace_stub, - .flags =FTRACE_OPS_FL_RECURSION_SAFE | -FTRACE_OPS_FL_INITIALIZED | + .flags =FTRACE_OPS_FL_INITIALIZED |FTRACE_OPS_FL_PID |FTRACE_OPS_FL_STUB , #ifdef FTRACE_GRAPH_TRAMP_ADDR
kernel/trace/ftrace.c +9 -11
@@ -80,7 +80,7 @@ enum {struct ftrace_ops ftrace_list_end__read_mostly = { .func = ftrace_stub, - .flags =FTRACE_OPS_FL_RECURSION_SAFE |FTRACE_OPS_FL_STUB , + .flags =FTRACE_OPS_FL_STUB ,INIT_OPS_HASH (ftrace_list_end) };
@@ -866,7 +866,7 @@ static void unregister_ftrace_profiler(void)#else static struct ftrace_ops ftrace_profile_ops__read_mostly = { .func = function_profile_call, - .flags =FTRACE_OPS_FL_RECURSION_SAFE |FTRACE_OPS_FL_INITIALIZED , + .flags =FTRACE_OPS_FL_INITIALIZED ,INIT_OPS_HASH (ftrace_profile_ops) };
@@ -1040,8 +1040,7 @@ struct ftrace_ops global_ops = { .local_hash.notrace_hash = EMPTY_HASH, .local_hash.filter_hash = EMPTY_HASH,INIT_OPS_HASH (global_ops) - .flags =FTRACE_OPS_FL_RECURSION_SAFE | -FTRACE_OPS_FL_INITIALIZED | + .flags =FTRACE_OPS_FL_INITIALIZED | FTRACE_OPS_FL_PID, };
@@ -2382,7 +2381,7 @@ static void call_direct_funcs(unsigned long ip, unsigned long pip,struct ftrace_ops direct_ops = { .func = call_direct_funcs, - .flags =FTRACE_OPS_FL_IPMODIFY |FTRACE_OPS_FL_RECURSION_SAFE + .flags =FTRACE_OPS_FL_IPMODIFY |FTRACE_OPS_FL_DIRECT |FTRACE_OPS_FL_SAVE_REGS |FTRACE_OPS_FL_PERMANENT ,/*
@@ -6864,8 +6863,7 @@ void ftrace_init_trace_array(struct trace_array *tr)struct ftrace_ops global_ops = { .func = ftrace_stub, - .flags =FTRACE_OPS_FL_RECURSION_SAFE | -FTRACE_OPS_FL_INITIALIZED | + .flags =FTRACE_OPS_FL_INITIALIZED |FTRACE_OPS_FL_PID , };
@@ -7023,11 +7021,11 @@ NOKPROBE_SYMBOL(ftrace_ops_assist_func);ftrace_func_t ftrace_ops_get_func (struct ftrace_ops *ops) {/* -* If the function does not handle recursion, needs to be RCU safe, -* or does per cpu logic, then we need to call the assist handler. +* If the function does not handle recursion or needs to be RCU safe, +* then we need to call the assist handler. */ -if (!(ops->flags &FTRACE_OPS_FL_RECURSION_SAFE ) || - ops->flags &FTRACE_OPS_FL_RCU ) +if (ops->flags & (FTRACE_OPS_FL_RECURSION | +FTRACE_OPS_FL_RCU ))return ftrace_ops_assist_func;return ops->func;
kernel/trace/trace_events.c +0 -1
@@ -3712,7 +3712,6 @@ function_test_events_call(unsigned long ip, unsigned long parent_ip,static struct ftrace_ops trace_ops__initdata = { .func = function_test_events_call, - .flags =FTRACE_OPS_FL_RECURSION_SAFE , };static __init void event_trace_self_test_with_function (void )
kernel/trace/trace_functions.c +1 -1
@@ -48,7 +48,7 @@ int ftrace_allocate_ftrace_ops(struct trace_array *tr)/* Currently only the non stack version is supported */ ops->func = function_trace_call; - ops->flags =FTRACE_OPS_FL_RECURSION_SAFE |FTRACE_OPS_FL_PID ; + ops->flags =FTRACE_OPS_FL_PID ; tr->ops = ops; ops->private = tr;
kernel/trace/trace_selftest.c +2 -5
@@ -150,17 +150,14 @@ static void trace_selftest_test_dyn_func(unsigned long ip,static struct ftrace_ops test_probe1 = { .func = trace_selftest_test_probe1_func, - .flags =FTRACE_OPS_FL_RECURSION_SAFE , };static struct ftrace_ops test_probe2 = { .func = trace_selftest_test_probe2_func, - .flags =FTRACE_OPS_FL_RECURSION_SAFE , };static struct ftrace_ops test_probe3 = { .func = trace_selftest_test_probe3_func, - .flags =FTRACE_OPS_FL_RECURSION_SAFE , };static void print_counts (void )
@@ -448,11 +445,11 @@ static void trace_selftest_test_recursion_safe_func(unsigned long ip,static struct ftrace_ops test_rec_probe = { .func = trace_selftest_test_recursion_func, + .flags =FTRACE_OPS_FL_RECURSION , };static struct ftrace_ops test_recsafe_probe = { .func = trace_selftest_test_recursion_safe_func, - .flags =FTRACE_OPS_FL_RECURSION_SAFE , }; static int
@@ -561,7 +558,7 @@ static void trace_selftest_test_regs_func(unsigned long ip,static struct ftrace_ops test_regs_probe = { .func = trace_selftest_test_regs_func, - .flags =FTRACE_OPS_FL_RECURSION_SAFE |FTRACE_OPS_FL_SAVE_REGS , + .flags =FTRACE_OPS_FL_SAVE_REGS , }; static int
kernel/trace/trace_stack.c +0 -1
@@ -318,7 +318,6 @@ stack_trace_call(unsigned long ip, unsigned long parent_ip,static struct ftrace_ops trace_ops__read_mostly = { .func = stack_trace_call, - .flags =FTRACE_OPS_FL_RECURSION_SAFE , }; static ssize_t
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 11/17 ftrace: Add recording of functions that caused recursion
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
This adds CONFIG_FTRACE_RECORD_RECURSION that will record to a file "recursed_functions" all the functions that caused recursion while a callback to the function tracer was running.
--- Documentation/trace/ftrace-uses.rst | 6 +- arch/csky/kernel/probes/ftrace.c | 2 +- arch/parisc/kernel/ftrace.c | 2 +- arch/powerpc/kernel/kprobes-ftrace.c | 2 +- arch/s390/kernel/ftrace.c | 2 +- arch/x86/kernel/kprobes/ftrace.c | 2 +- fs/pstore/ftrace.c | 2 +- include/linux/trace_recursion.h | 29 +++- kernel/livepatch/patch.c | 2 +- kernel/trace/Kconfig | 25 +++ kernel/trace/Makefile | 1 + kernel/trace/ftrace.c | 4 +- kernel/trace/trace_event_perf.c | 2 +- kernel/trace/trace_functions.c | 2 +- kernel/trace/trace_output.c | 6 +- kernel/trace/trace_output.h | 1 + kernel/trace/trace_recursion_record.c | 236 ++++++++++++++++++++++++++ 17 files changed, 306 insertions(+), 20 deletions(-) create mode 100644 kernel/trace/trace_recursion_record.c
Documentation/trace/ftrace-uses.rst +4 -2
@@ -118,7 +118,7 @@ can help in this regard. If you start your code with: int bit; - bit = ftrace_test_recursion_trylock(); + bit = ftrace_test_recursion_trylock(ip, parent_ip); if (bit < 0) return;
@@ -130,7 +130,9 @@ The code in between will be safe to use, even if it ends up calling a function that the callback is tracing. Note, on success, ftrace_test_recursion_trylock() will disable preemption, and the ftrace_test_recursion_unlock() will enable it again (if it was previously -enabled). +enabled). The instruction pointer (ip) and its parent (parent_ip) is passed to +ftrace_test_recursion_trylock() to record where the recursion happened +(if CONFIG_FTRACE_RECORD_RECURSION is set). Alternatively, if the FTRACE_OPS_FL_RECURSION flag is set on the ftrace_ops (as explained below), then a helper trampoline will be used to test
arch/csky/kernel/probes/ftrace.c +1 -1
@@ -18,7 +18,7 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,struct kprobe *p;struct kprobe_ctlblk *kcb; - bit =ftrace_test_recursion_trylock (); + bit =ftrace_test_recursion_trylock (ip, parent_ip);if (bit <0 )return ;
arch/parisc/kernel/ftrace.c +1 -1
@@ -210,7 +210,7 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,struct kprobe *p;int bit; - bit =ftrace_test_recursion_trylock (); + bit =ftrace_test_recursion_trylock (ip, parent_ip);if (bit <0 )return ;
arch/powerpc/kernel/kprobes-ftrace.c +1 -1
@@ -20,7 +20,7 @@ void kprobe_ftrace_handler(unsigned long nip, unsigned long parent_nip,struct kprobe_ctlblk *kcb;int bit; - bit =ftrace_test_recursion_trylock (); + bit =ftrace_test_recursion_trylock (nip, parent_nip);if (bit <0 )return ;
arch/s390/kernel/ftrace.c +1 -1
@@ -204,7 +204,7 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,struct kprobe *p;int bit; - bit =ftrace_test_recursion_trylock (); + bit =ftrace_test_recursion_trylock (ip, parent_ip);if (bit <0 )return ;
arch/x86/kernel/kprobes/ftrace.c +1 -1
@@ -20,7 +20,7 @@ void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,struct kprobe_ctlblk *kcb;int bit; - bit =ftrace_test_recursion_trylock (); + bit =ftrace_test_recursion_trylock (ip, parent_ip);if (bit <0 )return ;
fs/pstore/ftrace.c +1 -1
@@ -41,7 +41,7 @@ static void notrace pstore_ftrace_call(unsigned long ip,if (unlikely (oops_in_progress))return ; - bit =ftrace_test_recursion_trylock (); + bit =ftrace_test_recursion_trylock (ip, parent_ip);if (bit <0 )return ;
include/linux/trace_recursion.h +25 -4
@@ -91,6 +91,9 @@ enum {* not be correct. Allow for a single recursion to cover this case. */ TRACE_TRANSITION_BIT , + +/* Used to prevent recursion recording from recursing. */ + TRACE_RECORD_RECURSION_BIT, };#define trace_recursion_set (bit) do { (current)->trace_recursion |= (1<<(bit)); } while (0)
@@ -142,7 +145,22 @@ static __always_inline int trace_get_context_bit(void) pc &HARDIRQ_MASK ?TRACE_CTX_IRQ :TRACE_CTX_SOFTIRQ ; } -static __always_inline int trace_test_and_set_recursion(int start, int max) +#ifdef CONFIG_FTRACE_RECORD_RECURSION +extern void ftrace_record_recursion (unsigned long ip,unsigned long parent_ip); +# define do_ftrace_record_recursion (ip, pip) \ + do { \ + if (!trace_recursion_test(TRACE_RECORD_RECURSION_BIT)) { \ + trace_recursion_set(TRACE_RECORD_RECURSION_BIT); \ + ftrace_record_recursion(ip, pip); \ + trace_recursion_clear(TRACE_RECORD_RECURSION_BIT); \ + } \ + } while (0) +#else +# define do_ftrace_record_recursion (ip, pip) do { } while (0) +#endif + +static __always_inline int trace_test_and_set_recursion(unsigned long ip, unsigned long pip, +int start,int max) {unsigned int val = current->trace_recursion;int bit;
@@ -158,8 +176,10 @@ static __always_inline int trace_test_and_set_recursion(int start, int max)* a switch between contexts. Allow for a single recursion. */ bit =TRACE_TRANSITION_BIT ; -if (trace_recursion_test (bit)) +if (trace_recursion_test (bit)) { +do_ftrace_record_recursion (ip, pip);return -1 ; + }trace_recursion_set (bit);barrier ();return bit +1 ;
@@ -199,9 +219,10 @@ static __always_inline void trace_clear_recursion(int bit)* Returns: -1 if a recursion happened. * >= 0 if no recursion */ -static __always_inline int ftrace_test_recursion_trylock(void) +static __always_inline int ftrace_test_recursion_trylock(unsigned long ip, +unsigned long parent_ip) { -return trace_test_and_set_recursion (TRACE_FTRACE_START ,TRACE_FTRACE_MAX ); +return trace_test_and_set_recursion (ip, parent_ip,TRACE_FTRACE_START ,TRACE_FTRACE_MAX ); }/**
kernel/livepatch/patch.c +1 -1
@@ -49,7 +49,7 @@ static void notrace klp_ftrace_handler(unsigned long ip, ops = container_of(fops, struct klp_ops, fops); - bit =ftrace_test_recursion_trylock (); + bit =ftrace_test_recursion_trylock (ip, parent_ip);if (WARN_ON_ONCE (bit <0 ))return ;/*
kernel/trace/Kconfig +25 -0
@@ -727,6 +727,31 @@ config TRACE_EVAL_MAP_FILE If unsure, say N. +config FTRACE_RECORD_RECURSION + bool "Record functions that recurse in function tracing" + depends on FUNCTION_TRACER + help + All callbacks that attach to the function tracing have some sort + of protection against recursion. Even though the protection exists, + it adds overhead. This option will create a file in the tracefs + file system called "recursed_functions" that will list the functions + that triggered a recursion. + + This will add more overhead to cases that have recursion. + + If unsure, say N + +config FTRACE_RECORD_RECURSION_SIZE + int "Max number of recursed functions to record" + default 128 + depends on FTRACE_RECORD_RECURSION + help + This defines the limit of number of functions that can be + listed in the "recursed_functions" file, that lists all + the functions that caused a recursion to happen. + This file can be reset, but the limit can not change in + size at runtime. + config GCOV_PROFILE_FTRACE bool "Enable GCOV profiling on ftrace subsystem" depends on GCOV_KERNEL
kernel/trace/Makefile +1 -0
@@ -92,6 +92,7 @@ obj-$(CONFIG_DYNAMIC_EVENTS) += trace_dynevent.o obj-$(CONFIG_PROBE_EVENTS) += trace_probe.o obj-$(CONFIG_UPROBE_EVENTS) += trace_uprobe.o obj-$(CONFIG_BOOTTIME_TRACING) += trace_boot.o +obj-$(CONFIG_FTRACE_RECORD_RECURSION) += trace_recursion_record.o obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o
kernel/trace/ftrace.c +2 -2
@@ -6918,7 +6918,7 @@ __ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,struct ftrace_ops *op;int bit; - bit =trace_test_and_set_recursion (TRACE_LIST_START ,TRACE_LIST_MAX ); + bit =trace_test_and_set_recursion (ip, parent_ip,TRACE_LIST_START ,TRACE_LIST_MAX );if (bit <0 )return ;
@@ -6993,7 +6993,7 @@ static void ftrace_ops_assist_func(unsigned long ip, unsigned long parent_ip, {int bit; - bit =trace_test_and_set_recursion (TRACE_LIST_START ,TRACE_LIST_MAX ); + bit =trace_test_and_set_recursion (ip, parent_ip,TRACE_LIST_START ,TRACE_LIST_MAX );if (bit <0 )return ;
kernel/trace/trace_event_perf.c +1 -1
@@ -447,7 +447,7 @@ perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,if ((unsigned long )ops->private !=smp_processor_id ())return ; - bit =ftrace_test_recursion_trylock (); + bit =ftrace_test_recursion_trylock (ip, parent_ip);if (bit <0 )return ;
kernel/trace/trace_functions.c +1 -1
@@ -141,7 +141,7 @@ function_trace_call(unsigned long ip, unsigned long parent_ip,if (unlikely (!tr->function_enabled))return ; - bit =ftrace_test_recursion_trylock (); + bit =ftrace_test_recursion_trylock (ip, parent_ip);if (bit <0 )return ;
kernel/trace/trace_output.c +3 -3
@@ -353,8 +353,8 @@ static inline const char *kretprobed(const char *name) }#endif /* CONFIG_KRETPROBES */ -static void -seq_print_sym (struct trace_seq *s,unsigned long address,bool offset) +void +trace_seq_print_sym (struct trace_seq *s,unsigned long address,bool offset) {#ifdef CONFIG_KALLSYMS char str[KSYM_SYMBOL_LEN ];
@@ -420,7 +420,7 @@ seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags) goto out; } -seq_print_sym (s, ip, sym_flags &TRACE_ITER_SYM_OFFSET ); +trace_seq_print_sym (s, ip, sym_flags &TRACE_ITER_SYM_OFFSET );if (sym_flags &TRACE_ITER_SYM_ADDR )trace_seq_printf (s," <" IP_FMT ">" , ip);
kernel/trace/trace_output.h +1 -0
@@ -16,6 +16,7 @@ extern int seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags); +extern void trace_seq_print_sym (struct trace_seq *s,unsigned long address,bool offset);extern int trace_print_context (struct trace_iterator *iter);extern int trace_print_lat_context (struct trace_iterator *iter);
kernel/trace/trace_recursion_record.c new file +236 -0
236 lines not on this page · raw message
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 12/17 fgraph: Make overruns 4 bytes in graph stack structure
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
Inspecting the data structures of the function graph tracer, I found that the overrun value is unsigned long, which is 8 bytes on a 64 bit machine, and not only that, the depth is an int (4 bytes). The overrun can be simply an unsigned int (4 bytes) and pack the ftrace_graph_ret structure better.
The depth is moved up next to the func, as it is used more often with func, and improves cache locality.
--- include/linux/ftrace.h | 4 ++-- kernel/trace/trace_entries.h | 4 ++-- kernel/trace/trace_functions_graph.c | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-)
include/linux/ftrace.h +2 -2
@@ -864,11 +864,11 @@ struct ftrace_graph_ent {*/ struct ftrace_graph_ret {unsigned long func;/* Current function */ +int depth;/* Number of functions that overran the depth limit for current task */ -unsigned long overrun; +unsigned int overrun;unsigned long long calltime;unsigned long long rettime; -int depth; } __packed;/* Type of the callback handlers for tracing function graph*/
kernel/trace/trace_entries.h +2 -2
@@ -93,10 +93,10 @@ FTRACE_ENTRY_PACKED(funcgraph_exit, ftrace_graph_ret_entry, F_STRUCT( __field_struct( struct ftrace_graph_ret, ret ) __field_packed( unsigned long, ret, func ) - __field_packed( unsigned long, ret, overrun ) + __field_packed( int, ret, depth ) + __field_packed( unsigned int, ret, overrun ) __field_packed( unsigned long long, ret, calltime) __field_packed( unsigned long long, ret, rettime ) - __field_packed( int, ret, depth ) ), F_printk("<-- %ps (%d) (start: %llx end: %llx) over: %d",
kernel/trace/trace_functions_graph.c +1 -1
@@ -957,7 +957,7 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,/* Overrun */ if (flags &TRACE_GRAPH_PRINT_OVERRUN ) -trace_seq_printf (s," (Overruns: %lu)\n" , +trace_seq_printf (s," (Overruns: %u)\n" , trace->overrun); print_graph_irq(iter, trace->func, TRACE_GRAPH_RET,
Signature · 1 line
2.28.0
RE: [for-next][PATCH 12/17] fgraph: Make overruns 4 bytes in graph stack structure
From: Steven Rostedt
Quoted 9 lines
Sent: 12 November 2020 00:33
Inspecting the data structures of the function graph tracer, I found that the overrun value is unsigned long, which is 8 bytes on a 64 bit machine, and not only that, the depth is an int (4 bytes). The overrun can be simply an unsigned int (4 bytes) and pack the
ftrace_graph_retstructure better.The depth is moved up next to the func, as it is used more often with func, and improves cache locality.
...
Quoted 1 line
}
__packed;
Does this many any/much difference given that the structure is marked __packed?
OTOH the __packed will (probably) kill performance on systems that don't support mis-aligned accesses.
David
-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)
Steven Rostedt
maintainerRe: [for-next][PATCH 12/17] fgraph: Make overruns 4 bytes in graph stack structure
Quoted 10 lines · On Thu, 12 Nov 2020 09:18:21 +0000 David Laight <[email protected]> wrote:
From: Steven Rostedt
Quoted 9 lines
Sent: 12 November 2020 00:33
Inspecting the data structures of the function graph tracer, I found that the overrun value is unsigned long, which is 8 bytes on a 64 bit machine, and not only that, the depth is an int (4 bytes). The overrun can be simply an unsigned int (4 bytes) and pack the
ftrace_graph_retstructure better.The depth is moved up next to the func, as it is used more often with func, and improves cache locality.
Quoted 9 lines
...
Quoted 1 line
}
__packed;Does this many any/much difference given that the structure is marked
__packed?OTOH the
__packedwill (probably) kill performance on systems that don't support mis-aligned accesses.
I think you answered your own question ;-)
That was why I try to keep 4 byte items together. But the point here was that overrun is hardly ever used (probably could just be a single byte), and there was no reason for it to be a long.
-- Steve
Steven Rostedt
maintainerPATCH 13/17 ftrace: Clean up the recursion code a bit
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
In trace_test_and_set_recursion(), current->trace_recursion is placed into a variable, and that variable should be used for the processing, as there's no reason to dereference current multiple times.
On trace_clear_recursion(), current->trace_recursion is modified and there's no reason to copy it over to a variable.
--- include/linux/trace_recursion.h | 22 +++++++--------------- 1 file changed, 7 insertions(+), 15 deletions(-)
include/linux/trace_recursion.h +7 -15
@@ -162,7 +162,7 @@ extern void ftrace_record_recursion(unsigned long ip, unsigned long parent_ip); static __always_inline int trace_test_and_set_recursion(unsigned long ip, unsigned long pip,int start,int max) { -unsigned int val = current->trace_recursion; +unsigned int val =READ_ONCE (current->trace_recursion);int bit;/* A previous recursion check was made */
@@ -176,18 +176,15 @@ static __always_inline int trace_test_and_set_recursion(unsigned long ip, unsign* a switch between contexts. Allow for a single recursion. */ bit =TRACE_TRANSITION_BIT ; -if (trace_recursion_test (bit)) { +if (val & (1 << bit)) {do_ftrace_record_recursion (ip, pip);return -1 ; } -trace_recursion_set (bit); -barrier (); -return bit +1 ; + }else { +/* Normal check passed, clear the transition to allow it again */ + val &= ~(1 <<TRACE_TRANSITION_BIT ); } -/* Normal check passed, clear the transition to allow it again */ -trace_recursion_clear (TRACE_TRANSITION_BIT ); - val |=1 << bit; current->trace_recursion = val;barrier ();
@@ -197,17 +194,12 @@ static __always_inline int trace_test_and_set_recursion(unsigned long ip, unsign static __always_inline void trace_clear_recursion(int bit) { -unsigned int val = current->trace_recursion; -if (!bit)return ; - bit--; - bit =1 << bit; - val &= ~bit; -barrier (); - current->trace_recursion = val; + bit--; +trace_recursion_clear (bit); }/**
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 14/17 ring-buffer: Add recording of ring buffer recursion into recursed_functions
In reply to Steven RostedtFrom: "Steven Rostedt (VMware)" <[email protected]>
Add a new config RING_BUFFER_RECORD_RECURSION that will place functions that recurse from the ring buffer into the ftrace recused_functions file.
--- kernel/trace/Kconfig | 14 ++++++++++++++ kernel/trace/ring_buffer.c | 12 +++++++++++- 2 files changed, 25 insertions(+), 1 deletion(-)
kernel/trace/Kconfig +14 -0
@@ -752,6 +752,20 @@ config FTRACE_RECORD_RECURSION_SIZE This file can be reset, but the limit can not change in size at runtime. +config RING_BUFFER_RECORD_RECURSION + bool "Record functions that recurse in the ring buffer" + depends on FTRACE_RECORD_RECURSION + # default y, because it is coupled with FTRACE_RECORD_RECURSION + default y + help + The ring buffer has its own internal recursion. Although when + recursion happens it wont cause harm because of the protection, + but it does cause an unwanted overhead. Enabling this option will + place where recursion was detected into the ftrace "recursed_functions" + file. + + This will add more overhead to cases that have recursion. + config GCOV_PROFILE_FTRACE bool "Enable GCOV profiling on ftrace subsystem" depends on GCOV_KERNEL
kernel/trace/ring_buffer.c +11 -1
@@ -4,6 +4,7 @@* * Copyright (C) 2008 Steven Rostedt <[email protected]> */ +#include <linux/trace_recursion.h> #include <linux/trace_events.h> #include <linux/ring_buffer.h> #include <linux/trace_clock.h>
@@ -3006,6 +3007,13 @@ rb_wakeups(struct trace_buffer *buffer, struct ring_buffer_per_cpu *cpu_buffer)irq_work_queue (&cpu_buffer->irq_work.work); } +#ifdef CONFIG_RING_BUFFER_RECORD_RECURSION +# define do_ring_buffer_record_recursion () \ + do_ftrace_record_recursion(_THIS_IP_, _RET_IP_) +#else +# define do_ring_buffer_record_recursion () do { } while (0) +#endif +/* * The lock and unlock are done within a preempt disable section. * The current_context per_cpu variable can only be modified
@@ -3088,8 +3096,10 @@ trace_recursive_lock(struct ring_buffer_per_cpu *cpu_buffer)* been updated yet. In this case, use the TRANSITION bit. */ bit =RB_CTX_TRANSITION ; -if (val & (1 << (bit + cpu_buffer->nest))) +if (val & (1 << (bit + cpu_buffer->nest))) { +do_ring_buffer_record_recursion ();return 1 ; + } } val |= (1 << (bit + cpu_buffer->nest));
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 15/17 ftrace: Remove unused varible ret
In reply to Steven RostedtFrom: Alex Shi <[email protected]>
'ret' in 2 functions are not used. and one of them is a void function. So remove them to avoid gcc warning:kernel/trace/ftrace.c:4166:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]kernel/trace/ftrace.c:5571:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
--- kernel/trace/ftrace.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
kernel/trace/ftrace.c +2 -4
@@ -4162,7 +4162,6 @@ static void process_mod_list(struct list_head *head, struct ftrace_ops *ops,struct ftrace_hash **orig_hash, *new_hash;LIST_HEAD (process_mods);char *func; -int ret;mutex_lock (&ops->func_hash->regex_lock);
@@ -4215,7 +4214,7 @@ static void process_mod_list(struct list_head *head, struct ftrace_ops *ops,mutex_lock (&ftrace_lock); - ret =ftrace_hash_move_and_update_ops (ops, orig_hash, +ftrace_hash_move_and_update_ops (ops, orig_hash, new_hash, enable);mutex_unlock (&ftrace_lock);
@@ -5567,7 +5566,6 @@ int ftrace_regex_release(struct inode *inode, struct file *file)struct ftrace_hash **orig_hash;struct trace_parser *parser;int filter_hash; -int ret;if (file->f_mode &FMODE_READ ) { iter = m->private;
@@ -5595,7 +5593,7 @@ int ftrace_regex_release(struct inode *inode, struct file *file) orig_hash = &iter->ops->func_hash->notrace_hash;mutex_lock (&ftrace_lock); - ret =ftrace_hash_move_and_update_ops (iter->ops, orig_hash, +ftrace_hash_move_and_update_ops (iter->ops, orig_hash, iter->hash, filter_hash);mutex_unlock (&ftrace_lock); }else {
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 16/17 tracing: Fix some typos in comments
In reply to Steven RostedtFrom: Qiujun Huang <[email protected]>
s/detetector/detector/
s/enfoced/enforced/
s/writen/written/
s/actualy/actually/
s/bascially/basically/
s/Regarldess/Regardless/
s/zeroes/zeros/
s/followd/followed/
s/incrememented/incremented/
s/separatelly/separately/
s/accesible/accessible/
s/sythetic/synthetic/
s/enabed/enabled/
s/heurisitc/heuristic/
s/assocated/associated/
s/otherwides/otherwise/
s/specfied/specified/
s/seaching/searching/
s/hierachry/hierarchy/
s/internel/internal/
s/Thise/This/
--- kernel/trace/blktrace.c | 4 ++-- kernel/trace/bpf_trace.c | 2 +- kernel/trace/trace.c | 2 +- kernel/trace/trace_benchmark.c | 6 +++--- kernel/trace/trace_dynevent.c | 2 +- kernel/trace/trace_dynevent.h | 6 +++--- kernel/trace/trace_entries.h | 2 +- kernel/trace/trace_events.c | 4 ++-- kernel/trace/trace_events_filter.c | 2 +- kernel/trace/trace_events_hist.c | 2 +- kernel/trace/trace_events_synth.c | 4 ++-- kernel/trace/trace_export.c | 2 +- kernel/trace/trace_hwlat.c | 4 ++-- kernel/trace/tracing_map.c | 6 +++--- kernel/trace/tracing_map.h | 2 +- 15 files changed, 25 insertions(+), 25 deletions(-)
kernel/trace/blktrace.c +2 -2
@@ -1343,7 +1343,7 @@ static void blk_log_action(struct trace_iterator *iter, const char *act,* ones now use the 64bit ino as the whole ID and * no longer use generation. * -* Regarldess of the content, always output +* Regardless of the content, always output * "LOW32,HIGH32" so that FILEID_INO32_GEN fid can * be mapped back to @id on both 64 and 32bit ino * setups. See __kernfs_fh_to_dentry().
@@ -1385,7 +1385,7 @@ static void blk_log_dump_pdu(struct trace_seq *s, i == 0 ? "" : " ", pdu_buf[i]);/* -* stop when the rest is just zeroes and indicate so +* stop when the rest is just zeros and indicate so * with a ".." appended */ if (i == end && end != pdu_len -1 ) {
kernel/trace/bpf_trace.c +1 -1
@@ -113,7 +113,7 @@ unsigned int trace_call_bpf(struct trace_event_call *call, void *ctx)* Instead of moving rcu_read_lock/rcu_dereference/rcu_read_unlock * to all call sites, we did a bpf_prog_array_valid() there to check * whether call->prog_array is empty or not, which is -* a heurisitc to speed up execution. +* a heuristic to speed up execution. * * If bpf_prog_array_valid() fetched prog_array was * non-NULL, we go into trace_call_bpf() and do the actual
kernel/trace/trace.c +1 -1
@@ -3118,7 +3118,7 @@ struct trace_buffer_struct {static struct trace_buffer_struct *trace_percpu_buffer;/* -* Thise allows for lockless recording. If we're nested too deeply, then +* This allows for lockless recording. If we're nested too deeply, then * this returns NULL. */ static char *get_trace_buf (void )
kernel/trace/trace_benchmark.c +3 -3
@@ -31,7 +31,7 @@ static bool ok_to_run;* it simply writes "START". As the first write is cold cache and * the rest is hot, we save off that time in bm_first and it is * reported as "first", which is shown in the second write to the -* tracepoint. The "first" field is writen within the statics from +* tracepoint. The "first" field is written within the statics from * then on but never changes. */ static void trace_do_benchmark (void )
@@ -112,7 +112,7 @@ static void trace_do_benchmark(void)int i =0 ;/* * stddev is the square of standard deviation but -* we want the actualy number. Use the average +* we want the actually number. Use the average * as our seed to find the std. * * The next try is:
@@ -155,7 +155,7 @@ static int benchmark_event_kthread(void *arg)/* * We don't go to sleep, but let others run as well. -* This is bascially a "yield()" to let any task that +* This is basically a "yield()" to let any task that * wants to run, schedule in, but if the CPU is idle, * we'll keep burning cycles. *
kernel/trace/trace_dynevent.c +1 -1
@@ -276,7 +276,7 @@ int dynevent_arg_add(struct dynevent_cmd *cmd,* arguments of the form 'type variable_name;' or 'x+y'. * * The lhs argument string will be appended to the current cmd string, -* followed by an operator, if applicable, followd by the rhs string, +* followed by an operator, if applicable, followed by the rhs string, * followed finally by a separator, if applicable. Before the * argument is added, the @check_arg function, if present, will be * used to check the sanity of the current arg strings.
kernel/trace/trace_dynevent.h +3 -3
@@ -29,10 +29,10 @@ struct dyn_event;* @show: Showing method. This is invoked when user reads the event definitions * via dynamic_events interface. * @is_busy: Check whether given event is busy so that it can not be deleted. -* Return true if it is busy, otherwides false. -* @free: Delete the given event. Return 0 if success, otherwides error. +* Return true if it is busy, otherwise false. +* @free: Delete the given event. Return 0 if success, otherwise error. * @match: Check whether given event and system name match this event. The argc -* and argv is used for exact match. Return true if it matches, otherwides +* and argv is used for exact match. Return true if it matches, otherwise * false. * * Except for @create, these methods are called under holding event_mutex.
kernel/trace/trace_entries.h +1 -1
@@ -32,7 +32,7 @@* to be deciphered for the format file. Although these macros * may become out of sync with the internal structure, they * will create a compile error if it happens. Since the -* internel structures are just tracing helpers, this is not +* internal structures are just tracing helpers, this is not * an issue. * * When an internal structure is used, it should use:
kernel/trace/trace_events.c +2 -2
@@ -2436,7 +2436,7 @@ void trace_event_eval_update(struct trace_eval_map **map, int len)/* * Since calls are grouped by systems, the likelyhood that the * next call in the iteration belongs to the same system as the -* previous call is high. As an optimization, we skip seaching +* previous call is high. As an optimization, we skip searching * for a map[] that matches the call's system if the last call * was from the same system. That's what last_i is for. If the * call has the same system as the previous call, then last_i
@@ -3271,7 +3271,7 @@ create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)* * When a new instance is created, it needs to set up its events * directory, as well as other files associated with events. It also -* creates the event hierachry in the @parent/events directory. +* creates the event hierarchy in the @parent/events directory. * * Returns 0 on success. *
kernel/trace/trace_events_filter.c +1 -1
@@ -1950,7 +1950,7 @@ static int __ftrace_function_set_filter(int filter, char *buf, int len,/* * The 'ip' field could have multiple filters set, separated * either by space or comma. We first cut the filter and apply -* all pieces separatelly. +* all pieces separately. */ re =ftrace_function_filter_re (buf, len, &re_cnt);if (!re)
kernel/trace/trace_events_hist.c +1 -1
@@ -3355,7 +3355,7 @@ trace_action_create_field_var(struct hist_trigger_data *hist_data, }else { field_var =NULL ;/* -* If no explicit system.event is specfied, default to +* If no explicit system.event is specified, default to * looking for fields on the onmatch(system.event.xxx) * event. */
kernel/trace/trace_events_synth.c +2 -2
@@ -1276,7 +1276,7 @@ static int __create_synth_event(int argc, const char *name, const char **argv)/** * synth_event_create - Create a new synthetic event -* @name: The name of the new sythetic event +* @name: The name of the new synthetic event * @fields: An array of type/name field descriptions * @n_fields: The number of field descriptions contained in the fields array * @mod: The module creating the event, NULL if not created from a module
@@ -1446,7 +1446,7 @@ __synth_event_trace_init(struct trace_event_file *file,* this code to be called, etc). Because this is called * directly by the user, we don't have that but we still need * to honor not logging when disabled. For the iterated -* trace case, we save the enabed state upon start and just +* trace case, we save the enabled state upon start and just * ignore the following data calls. */ if (!(file->flags & EVENT_FILE_FL_ENABLED) ||
kernel/trace/trace_export.c +1 -1
@@ -26,7 +26,7 @@ static int ftrace_event_register(struct trace_event_call *call,/* * The FTRACE_ENTRY_REG macro allows ftrace entry to define register -* function and thus become accesible via perf. +* function and thus become accessible via perf. */ #undef FTRACE_ENTRY_REG#define FTRACE_ENTRY_REG (name, struct_name, id, tstruct, print, regfn) \
kernel/trace/trace_hwlat.c +2 -2
@@ -485,11 +485,11 @@ hwlat_width_write(struct file *filp, const char __user *ubuf,* @ppos: The current position in @file * * This function provides a write implementation for the "window" interface -* to the hardware latency detetector. The window is the total time +* to the hardware latency detector. The window is the total time * in us that will be considered one sample period. Conceptually, windows * occur back-to-back and contain a sample width period during which * actual sampling occurs. Can be used to write a new total window size. It -* is enfoced that any value written must be greater than the sample width +* is enforced that any value written must be greater than the sample width * size, or an error results. */ static ssize_t
kernel/trace/tracing_map.c +3 -3
@@ -609,7 +609,7 @@ __tracing_map_insert(struct tracing_map *map, void *key, bool lookup_only)* signal that state. There are two user-visible tracing_map * variables, 'hits' and 'drops', which are updated by this function. * Every time an element is either successfully inserted or retrieved, -* the 'hits' value is incrememented. Every time an element insertion +* the 'hits' value is incremented. Every time an element insertion * fails, the 'drops' value is incremented. * * This is a lock-free tracing map insertion function implementing a
@@ -642,9 +642,9 @@ struct tracing_map_elt *tracing_map_insert(struct tracing_map *map, void *key)* tracing_map_elt. This is a lock-free lookup; see * tracing_map_insert() for details on tracing_map and how it works. * Every time an element is retrieved, the 'hits' value is -* incrememented. There is one user-visible tracing_map variable, +* incremented. There is one user-visible tracing_map variable, * 'hits', which is updated by this function. Every time an element -* is successfully retrieved, the 'hits' value is incrememented. The +* is successfully retrieved, the 'hits' value is incremented. The * 'drops' value is never updated by this function. * * Return: the tracing_map_elt pointer val associated with the key.
kernel/trace/tracing_map.h +1 -1
@@ -50,7 +50,7 @@ typedef int (*tracing_map_cmp_fn_t) (void *val_a, void *val_b);* an instance of tracing_map_elt, where 'elt' in the latter part of * that variable name is short for 'element'. The purpose of a * tracing_map_elt is to hold values specific to the particular -* 32-bit hashed key it's assocated with. Things such as the unique +* 32-bit hashed key it's associated with. Things such as the unique * set of aggregated sums associated with the 32-bit hashed key, along * with a copy of the full key associated with the entry, and which * was used to produce the 32-bit hashed key.
Signature · 1 line
2.28.0
Steven Rostedt
maintainerPATCH 17/17 MAINTAINERS: assign ./fs/tracefs to TRACING
In reply to Steven RostedtFrom: Lukas Bulwahn <[email protected]>
A check with ./scripts/get_maintainer.pl --letters -f fs/tracefs/ shows that the tracefs is not assigned to the TRACING section in MAINTAINERS.
Add the file pattern for the TRACING section to rectify that.
--- MAINTAINERS | 1 + 1 file changed, 1 insertion(+)
MAINTAINERS +1 -0
@@ -17751,6 +17751,7 @@ T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git perf/core F: Documentation/trace/ftrace.rst F: arch/*/*/*/ftrace.h F: arch/*/kernel/ftrace.c +F: fs/tracefs/ F: include/*/ftrace.h F: include/linux/trace*.h F: include/trace/
Signature · 1 line
2.28.0