ftrace: updates for tip
Subsystems (4)
Steven Rostedt
maintainercover ftrace: updates for tip
Ingo,
The following patches are in:
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace.git
branch: tip/devel
Steven Rostedt (2):
ring-buffer: add NMI protection for spinlocks
ring-buffer: allow tracing_off to be used in core kernel code
----
arch/x86/Kconfig | 1 + arch/x86/kernel/ftrace.c | 8 +++--- include/linux/ftrace_irq.h | 10 ++++++++- include/linux/ring_buffer.h | 9 ++++++++ kernel/trace/Kconfig | 8 +++++++ kernel/trace/ring_buffer.c | 48 +++++++++++++++++++++++++++++++++++++++++- 6 files changed, 77 insertions(+), 7 deletions(-)
Steven Rostedt
maintainerPATCH 1/2 ring-buffer: add NMI protection for spinlocks
From: Steven Rostedt <[email protected]>
Impact: prevent deadlock in NMI
The ring buffers are not yet totally lockless with writing to the buffer. When a writer crosses a page, it grabs a per cpu spinlock to protect against a reader. The spinlocks taken by a writer are not to protect against other writers, since a writer can only write to its own per cpu buffer. The spinlocks protect against readers that can touch any cpu buffer. The writers are made to be reentrant with the spinlocks disabling interrupts.
The problem arises when an NMI writes to the buffer, and that write crosses a page boundary. If it grabs a spinlock, it can be racing with another writer (since disabling interrupts does not protect against NMIs) or with a reader on the same CPU. Luckily, most of the users are not reentrant and protects against this issue. But if a user of the ring buffer becomes reentrant (which is what the ring buffers do allow), if the NMI also writes to the ring buffer then we risk the chance of a deadlock.
This patch moves the ftrace_nmi_enter called by nmi_enter() to the ring buffer code. It replaces the current ftrace_nmi_enter that is used by arch specific code to arch_ftrace_nmi_enter and updates the Kconfig to handle it.
When an NMI is called, it will set a per cpu variable in the ring buffer code and will clear it when the NMI exits. If a write to the ring buffer crosses page boundaries inside an NMI, a trylock is used on the spin lock instead. If the spinlock fails to be acquired, then the entry is discarded.
This bug appeared in the ftrace work in the RT tree, where event tracing is reentrant. This workaround solved the deadlocks that appeared there.
--- arch/x86/Kconfig | 1 + arch/x86/kernel/ftrace.c | 8 +++--- include/linux/ftrace_irq.h | 10 ++++++++- kernel/trace/Kconfig | 8 +++++++ kernel/trace/ring_buffer.c | 48 ++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 68 insertions(+), 7 deletions(-)
arch/x86/Kconfig +1 -0
@@ -34,6 +34,7 @@ config X86 select HAVE_FUNCTION_TRACER select HAVE_FUNCTION_GRAPH_TRACER select HAVE_FUNCTION_TRACE_MCOUNT_TEST + select HAVE_FTRACE_NMI_ENTER if DYNAMIC_FTRACE || FUNCTION_GRAPH_TRACER select HAVE_KVM select HAVE_ARCH_KGDB select HAVE_ARCH_TRACEHOOK
arch/x86/kernel/ftrace.c +4 -4
@@ -113,7 +113,7 @@ static void ftrace_mod_code(void) MCOUNT_INSN_SIZE); } -void ftrace_nmi_enter (void ) +void arch_ftrace_nmi_enter (void ) {atomic_inc (&in_nmi);/* Must have in_nmi seen before reading write flag */
@@ -124,7 +124,7 @@ void ftrace_nmi_enter(void) } } -void ftrace_nmi_exit (void ) +void arch_ftrace_nmi_exit (void ) {/* Finish all executions before clearing in_nmi */ smp_wmb ();
@@ -376,12 +376,12 @@ int ftrace_disable_ftrace_graph_caller(void)*/ static atomic_t in_nmi; -void ftrace_nmi_enter (void ) +void arch_ftrace_nmi_enter (void ) {atomic_inc (&in_nmi); } -void ftrace_nmi_exit (void ) +void arch_ftrace_nmi_exit (void ) {atomic_dec (&in_nmi); }
include/linux/ftrace_irq.h +9 -1
@@ -2,7 +2,15 @@#define _LINUX_FTRACE_IRQ_H -#if defined(CONFIG_DYNAMIC_FTRACE ) || defined(CONFIG_FUNCTION_GRAPH_TRACER ) +#ifdef CONFIG_FTRACE_NMI_ENTER +extern void arch_ftrace_nmi_enter (void ); +extern void arch_ftrace_nmi_exit (void ); +#else +static inline void arch_ftrace_nmi_enter (void ) { } +static inline void arch_ftrace_nmi_exit (void ) { } +#endif + +#ifdef CONFIG_RING_BUFFER extern void ftrace_nmi_enter (void );extern void ftrace_nmi_exit (void );#else
kernel/trace/Kconfig +8 -0
@@ -9,6 +9,9 @@ config USER_STACKTRACE_SUPPORT config NOP_TRACER bool +config HAVE_FTRACE_NMI_ENTER + bool + config HAVE_FUNCTION_TRACER bool
@@ -37,6 +40,11 @@ config TRACER_MAX_TRACE config RING_BUFFER bool +config FTRACE_NMI_ENTER + bool + depends on HAVE_FTRACE_NMI_ENTER + default y + config TRACING bool select DEBUG_FS
kernel/trace/ring_buffer.c +46 -2
78 lines not on this page · raw message
Signature · 3 lines
1.5.6.5 --
Re: [PATCH 1/2] ring-buffer: add NMI protection for spinlocks
Quoted 61 lines · On Thu, 05 Feb 2009 20:13:16 -0500 Steven Rostedt <[email protected]> wrote:
From: Steven Rostedt <[email protected]>
Impact: prevent deadlock in NMI
The ring buffers are not yet totally lockless with writing to the buffer. When a writer crosses a page, it grabs a per cpu spinlock to protect against a reader. The spinlocks taken by a writer are not to protect against other writers, since a writer can only write to its own per cpu buffer. The spinlocks protect against readers that can touch any cpu buffer. The writers are made to be reentrant with the spinlocks disabling interrupts.
The problem arises when an NMI writes to the buffer, and that write crosses a page boundary. If it grabs a spinlock, it can be racing with another writer (since disabling interrupts does not protect against NMIs) or with a reader on the same CPU. Luckily, most of the users are not reentrant and protects against this issue. But if a user of the ring buffer becomes reentrant (which is what the ring buffers do allow), if the NMI also writes to the ring buffer then we risk the chance of a deadlock.
This patch moves the
ftrace_nmi_entercalled bynmi_enter()to the ring buffer code. It replaces the currentftrace_nmi_enterthat is used by arch specific code toarch_ftrace_nmi_enterand updates theKconfigto handle it.When an NMI is called, it will set a per cpu variable in the ring buffer code and will clear it when the NMI exits. If a write to the ring buffer crosses page boundaries inside an NMI, a trylock is used on the spin lock instead. If the spinlock fails to be acquired, then the entry is discarded.
This bug appeared in the ftrace work in the RT tree, where event tracing is reentrant. This workaround solved the deadlocks that appeared there.
Signed-off-by Steven Rostedt <[email protected]>--- arch/x86/Kconfig | 1 + arch/x86/kernel/ftrace.c | 8 +++--- include/linux/ftrace_irq.h | 10 ++++++++- kernel/trace/Kconfig | 8 +++++++ kernel/trace/ring_buffer.c | 48 ++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 68 insertions(+), 7 deletions(-)arch/x86/Kconfig +1
-0@@ -34,6 +34,7 @@ config X86 select HAVE_FUNCTION_TRACER select HAVE_FUNCTION_GRAPH_TRACER select HAVE_FUNCTION_TRACE_MCOUNT_TEST + select HAVE_FTRACE_NMI_ENTER if DYNAMIC_FTRACE || FUNCTION_GRAPH_TRACER select HAVE_KVM select HAVE_ARCH_KGDB select HAVE_ARCH_TRACEHOOKarch/x86/kernel/ftrace.c +0
-0
arch/x86/kernel/ftrace.c static void ftrace_mod_code(void) · line 118
Quoted 7 lines
arch/x86/kernel/ftrace.c +1
-1@@ -113,7 +113,7 @@ static void ftrace_mod_code(void) MCOUNT_INSN_SIZE); } -void ftrace_nmi_enter (void ) +void arch_ftrace_nmi_enter (void ) {atomic_inc (&in_nmi);
This in_nmi thing looks a bit awkward. It's not very clear from the code what it does or why it exists, but it looks like I'm going to have to get used to that...
Surely it is buggy? It's incremented by _any_ cpu, so code which reads it (eg, prepare_ftrace_return()) will bale out if some other CPU happened to be in the middle of taking an NMI.
Would it not be better to make in_nmi a per-cpu thing, make it a piece of first-class kernel infrastructure, add a nice interface to it, hoist it up into generic code, call that code from arch NMI handlers, call that interface from ftrace, etc? Or perhaps it could be implemented in task_struct, alongside in_irq(), in_softirq(), etc. There are three bits left in ->preempt_count.
This approach would remove the duplication which this patch is attempting to add.
Plus there's already quite a bit of duplication in arch/x86/kernel/ftrace.c between the CONFIG_DYNAMIC_FTRACE/!CONFIG_DYNAMIC_FTRACE hunks. Two definitions of in_nmi, duplicated inc/dec thereof?
Steven Rostedt
maintainerRe: [PATCH 1/2] ring-buffer: add NMI protection for spinlocks
[ added Arjan ]
Quoted 17 lines · Andrew Morton
arch/x86/kernel/ftrace.c static void ftrace_mod_code(void) · line 118
Quoted 12 lines
arch/x86/kernel/ftrace.c +1
-1@@ -113,7 +113,7 @@ static void ftrace_mod_code(void) MCOUNT_INSN_SIZE); } -void ftrace_nmi_enter (void ) +void arch_ftrace_nmi_enter (void ) {atomic_inc (&in_nmi);This
in_nmithing looks a bit awkward. It's not very clear from the code what it does or why it exists, but it looks like I'm going to have to get used to that...
Quoted 3 lines
Surely it is buggy? It's incremented by _any_ cpu, so code which reads it (eg,
prepare_ftrace_return()) will bale out if some other CPU happened to be in the middle of taking an NMI.
And that is exactly what we want it to do ;-)
This is code modification. If you modify code that another cpu is executing with, the result is undefined. In my tests to cause this type of error, I usually get a general protection fault.
To modify code safely, you must act like a uniprocessor. That is, the code you modify must not be executing on another CPU. We use stop_machine to help us out here, but under NMI stress tests, we found that we can crash, because the NMI will execute code being modified. Stop_machine does not disable NMIs on other CPUS.
To solve this, we sync up the modification with the NMI with a couple of variables. That's what all those memory barriers are for.
When we go to modify a line of code, we set a variable that we are doing so, wait for all NMIs to finish, then modify the code, wait for NMIs again, and repeat on the next line to modify.
If the NMI goes off on any CPU, it increments the in_nmi counter. If the mod code flag is set, the NMI modifies the code.
The trick here is that the crash only occurs if the code is modified as it is being executed on. But it will not crash if the code is written to with the same data as it was. In other words, it is fine to write the code and execute it, if what you are writing is what is already there. No modification being done.
All NMIs that go off will modify the same code. Even if the code being modified is in a NMI code path, only the first NMI that goes off will actually modify it, the rest will just be writting the same data to the location. Even the main code will be writing the same data. No races.
Quoted 7 lines
Would it not be better to make
in_nmia per-cpu thing, make it a piece of first-class kernel infrastructure, add a nice interface to it, hoist it up into generic code, call that code from arch NMI handlers, call that interface from ftrace, etc? Or perhaps it could be implemented intask_struct, alongsidein_irq(),in_softirq(), etc. There are three bits left in ->preempt_count.
I agree, we should have a per cpu nmi code. I can write that up and use it for the ring buffer. But the call back for the ftrace code that I explained here must still be made. We need a "global" nmi counter for it to work.
-- Steve
Quoted 13 lines
This approach would remove the duplication which this patch is attempting to add.
Plus there's already quite a bit of duplication in
arch/x86/kernel/ftrace.cbetween the CONFIG_DYNAMIC_FTRACE/!CONFIG_DYNAMIC_FTRACE hunks. Two definitions ofin_nmi, duplicated inc/dec thereof?
Steven Rostedt
maintainerRe: [PATCH 1/2] ring-buffer: add NMI protection for spinlocks
Quoted 24 lines · Steven Rostedt
[ added Arjan ]
Quoted 20 lines · Andrew Morton
arch/x86/kernel/ftrace.c static void ftrace_mod_code(void) · line 118
Quoted 12 lines
arch/x86/kernel/ftrace.c +1
-1@@ -113,7 +113,7 @@ static void ftrace_mod_code(void) MCOUNT_INSN_SIZE); } -void ftrace_nmi_enter (void ) +void arch_ftrace_nmi_enter (void ) {atomic_inc (&in_nmi);This
in_nmithing looks a bit awkward. It's not very clear from the code what it does or why it exists, but it looks like I'm going to have to get used to that...Surely it is buggy? It's incremented by _any_ cpu, so code which reads it (eg,
prepare_ftrace_return()) will bale out if some other CPU happened to be in the middle of taking an NMI.
Arg! Completely ignore this. I did not look at the function you mentioned. I was thinking about the code modification.
Yes! It is buggy :-p
The prepare_ftrace_return only wants to bail if it is in an nmi on the current CPU.
/me goes to write a patch.
-- Steve
Quoted 65 lines
And that is exactly what we want it to do ;-)
This is code modification. If you modify code that another cpu is executing with, the result is undefined. In my tests to cause this type of error, I usually get a general protection fault.
To modify code safely, you must act like a uniprocessor. That is, the code you modify must not be executing on another CPU. We use
stop_machineto help us out here, but under NMI stress tests, we found that we can crash, because the NMI will execute code being modified.Stop_machinedoes not disable NMIs on other CPUS.To solve this, we sync up the modification with the NMI with a couple of variables. That's what all those memory barriers are for.
When we go to modify a line of code, we set a variable that we are doing so, wait for all NMIs to finish, then modify the code, wait for NMIs again, and repeat on the next line to modify.
If the NMI goes off on any CPU, it increments the
in_nmicounter. If the mod code flag is set, the NMI modifies the code.The trick here is that the crash only occurs if the code is modified as it is being executed on. But it will not crash if the code is written to with the same data as it was. In other words, it is fine to write the code and execute it, if what you are writing is what is already there. No modification being done.
All NMIs that go off will modify the same code. Even if the code being modified is in a NMI code path, only the first NMI that goes off will actually modify it, the rest will just be writting the same data to the location. Even the main code will be writing the same data. No races.
Quoted 7 lines
Would it not be better to make
in_nmia per-cpu thing, make it a piece of first-class kernel infrastructure, add a nice interface to it, hoist it up into generic code, call that code from arch NMI handlers, call that interface from ftrace, etc? Or perhaps it could be implemented intask_struct, alongsidein_irq(),in_softirq(), etc. There are three bits left in ->preempt_count.I agree, we should have a per cpu nmi code. I can write that up and use it for the ring buffer. But the call back for the ftrace code that I explained here must still be made. We need a "global" nmi counter for it to work.
-- Steve
Quoted 13 lines
This approach would remove the duplication which this patch is attempting to add.
Plus there's already quite a bit of duplication in
arch/x86/kernel/ftrace.cbetween the CONFIG_DYNAMIC_FTRACE/!CONFIG_DYNAMIC_FTRACE hunks. Two definitions ofin_nmi, duplicated inc/dec thereof?
Steven Rostedt
maintainerPATCH 2/2 ring-buffer: allow tracing_off to be used in core kernel code
In reply to Steven RostedtFrom: Steven Rostedt <[email protected]>
tracing_off() is the fastest way to stop recording to the ring buffers. This may be used in places like panic and die, just before the ftrace_dump is called.
This patch adds the appropriate CPP conditionals to make it a stub function when the ring buffer is not configured it.
--- include/linux/ring_buffer.h | 9 +++++++++ 1 files changed, 9 insertions(+), 0 deletions(-)
include/linux/ring_buffer.h +9 -0
@@ -124,9 +124,18 @@ unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu);u64 ring_buffer_time_stamp (int cpu);void ring_buffer_normalize_time_stamp (int cpu,u64 *ts); +/* +* The below functions are fine to use outside the tracing facility. +*/ +#ifdef CONFIG_RING_BUFFER void tracing_on (void );void tracing_off (void );void tracing_off_permanent (void ); +#else +static inline void tracing_on (void ) { } +static inline void tracing_off (void ) { } +static inline void tracing_off_permanent (void ) { } +#endif void *ring_buffer_alloc_read_page (struct ring_buffer *buffer);void ring_buffer_free_read_page (struct ring_buffer *buffer,void *data);
Signature · 3 lines
1.5.6.5 --