tracing: Keep instance main and snapshot buffers in sync
Subsystems (2)
Steven Rostedt
maintainerv2 cover tracing: Keep instance main and snapshot buffers in sync
Fix keeping instance buffers in sync. That is, when the main ring buffer size is updated, the size of the instance snapshot buffer also needs to be updated if it is allocated.
Changes since v1: https://lore.kernel.org/all/[email protected]/
- That was just patch 3 with the change log of patch 1. That patch just needs to be ignored.
Steven Rostedt (Google) (3):
tracing: Always update snapshot buffer size
tracing: Stop current tracer when resizing buffer
tracing: Disable snapshot buffer when stopping instance tracers
----
kernel/trace/trace.c | 123 ++++++++++++++++++--------------------------------- 1 file changed, 42 insertions(+), 81 deletions(-)
Steven Rostedt
maintainerPATCH v2 1/3 tracing: Always update snapshot buffer size
From: "Steven Rostedt (Google)" <[email protected]>
It use to be that only the top level instance had a snapshot buffer (for latency tracers like wakeup and irqsoff). The update of the ring buffer size would check if the instance was the top level and if so, it would also update the snapshot buffer as it needs to be the same as the main buffer.
Now that lower level instances also has a snapshot buffer, they too need to update their snapshot buffer sizes when the main buffer is changed, otherwise the following can be triggered:
# cd /sys/kernel/tracing # echo 1500 > buffer_size_kb # mkdir instances/foo # echo irqsoff > instances/foo/current_tracer # echo 1000 > instances/foo/buffer_size_kb
Produces:
WARNING: CPU: 2 PID: 856 at kernel/trace/trace.c:1938 update_max_tr_single.part.0+0x27d/0x320
Which is:
ret = ring_buffer_swap_cpu(tr->max_buffer.buffer, tr->array_buffer.buffer, cpu);
if (ret == -EBUSY) {
[..]
}
WARN_ON_ONCE(ret && ret != -EAGAIN && ret != -EBUSY); <== hereThat's because ring_buffer_swap_cpu() has:
int ret = -EINVAL; [..] /* At least make sure the two buffers are somewhat the same */ if (cpu_buffer_a->nr_pages != cpu_buffer_b->nr_pages) goto out; [..] out: return ret;
}
Instead, update all instances' snapshot buffer sizes when their main buffer size is updated.
--- kernel/trace/trace.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
kernel/trace/trace.c +1 -2
@@ -6392,8 +6392,7 @@ static int __tracing_resize_ring_buffer(struct trace_array *tr,return ret;#ifdef CONFIG_TRACER_MAX_TRACE -if (!(tr->flags &TRACE_ARRAY_FL_GLOBAL ) || - !tr->current_trace->use_max_tr) +if (!tr->current_trace->use_max_tr) goto out; ret =ring_buffer_resize (tr->max_buffer.buffer, size, cpu);
Signature · 1 line
2.42.0
Steven Rostedt
maintainerPATCH v2 2/3 tracing: Stop current tracer when resizing buffer
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
When the ring buffer is being resized, it can cause side effects to the running tracer. For instance, there's a race with irqsoff tracer that swaps individual per cpu buffers between the main buffer and the snapshot buffer. The resize operation modifies the main buffer and then the snapshot buffer. If a swap happens in between those two operations it will break the tracer.
Simply stop the running tracer before resizing the buffers and enable it again when finished.
--- kernel/trace/trace.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
kernel/trace/trace.c +7 -3
@@ -6387,9 +6387,12 @@ static int __tracing_resize_ring_buffer(struct trace_array *tr,if (!tr->array_buffer.buffer)return 0 ; +/* Do not allow tracing while resizng ring buffer */ +tracing_stop_tr (tr); + ret =ring_buffer_resize (tr->array_buffer.buffer, size, cpu);if (ret <0 ) -return ret; + goto out_start;#ifdef CONFIG_TRACER_MAX_TRACE if (!tr->current_trace->use_max_tr)
@@ -6417,7 +6420,7 @@ static int __tracing_resize_ring_buffer(struct trace_array *tr,WARN_ON (1 ); tracing_disabled =1 ; } -return ret; + goto out_start; }update_buffer_entries (&tr->max_buffer, cpu);
@@ -6426,7 +6429,8 @@ static int __tracing_resize_ring_buffer(struct trace_array *tr,#endif /* CONFIG_TRACER_MAX_TRACE */ update_buffer_entries (&tr->array_buffer, cpu); - + out_start: +tracing_start_tr (tr);return ret; }
Signature · 1 line
2.42.0
Steven Rostedt
maintainerPATCH v2 3/3 tracing: Disable snapshot buffer when stopping instance tracers
In reply to Steven RostedtFrom: "Steven Rostedt (Google)" <[email protected]>
It use to be that only the top level instance had a snapshot buffer (for latency tracers like wakeup and irqsoff). When stopping a tracer in an instance would not disable the snapshot buffer. This could have some unintended consequences if the irqsoff tracer is enabled.
Consolidate the tracing_start/stop() with tracing_start/stop_tr() so that all instances behave the same. The tracing_start/stop() functions will just call their respective tracing_start/stop_tr() with the global_array passed in.
--- kernel/trace/trace.c | 110 +++++++++++++------------------------------ 1 file changed, 34 insertions(+), 76 deletions(-)
kernel/trace/trace.c +34 -76
@@ -2360,13 +2360,7 @@ int is_tracing_stopped(void)return global_trace.stop_count; } -/** -* tracing_start - quick start of the tracer -* -* If tracing is enabled but was stopped by tracing_stop, -* this will start the tracer back up. -*/ -void tracing_start (void ) +static void tracing_start_tr (struct trace_array *tr) {struct trace_buffer *buffer;unsigned long flags;
@@ -2374,119 +2368,83 @@ void tracing_start(void)if (tracing_disabled)return ; -raw_spin_lock_irqsave (&global_trace.start_lock, flags); -if (--global_trace.stop_count) { -if (global_trace.stop_count <0 ) { +raw_spin_lock_irqsave (&tr->start_lock, flags); +if (--tr->stop_count) { +if (WARN_ON_ONCE (tr->stop_count <0 )) {/* Someone screwed up their debugging */ -WARN_ON_ONCE (1 ); - global_trace.stop_count =0 ; + tr->stop_count =0 ; } goto out; }/* Prevent the buffers from switching */ -arch_spin_lock (&global_trace.max_lock); +arch_spin_lock (&tr->max_lock); - buffer = global_trace.array_buffer.buffer; + buffer = tr->array_buffer.buffer;if (buffer)ring_buffer_record_enable (buffer);#ifdef CONFIG_TRACER_MAX_TRACE - buffer = global_trace.max_buffer.buffer; + buffer = tr->max_buffer.buffer;if (buffer)ring_buffer_record_enable (buffer);#endif -arch_spin_unlock (&global_trace.max_lock); - - out: -raw_spin_unlock_irqrestore (&global_trace.start_lock, flags); -} - -static void tracing_start_tr (struct trace_array *tr) -{ -struct trace_buffer *buffer; -unsigned long flags; - -if (tracing_disabled) -return ; - -/* If global, we need to also start the max tracer */ -if (tr->flags &TRACE_ARRAY_FL_GLOBAL ) -return tracing_start (); - -raw_spin_lock_irqsave (&tr->start_lock, flags); - -if (--tr->stop_count) { -if (tr->stop_count <0 ) { -/* Someone screwed up their debugging */ -WARN_ON_ONCE (1 ); - tr->stop_count =0 ; - } - goto out; - } - - buffer = tr->array_buffer.buffer; -if (buffer) -ring_buffer_record_enable (buffer); +arch_spin_unlock (&tr->max_lock); out:raw_spin_unlock_irqrestore (&tr->start_lock, flags); }/** -* tracing_stop - quick stop of the tracer +* tracing_start - quick start of the tracer * -* Light weight way to stop tracing. Use in conjunction with -* tracing_start. +* If tracing is enabled but was stopped by tracing_stop, +* this will start the tracer back up. */ -void tracing_stop (void ) +void tracing_start (void ) + +{ +return tracing_start_tr (&global_trace); +} + +static void tracing_stop_tr (struct trace_array *tr) {struct trace_buffer *buffer;unsigned long flags; -raw_spin_lock_irqsave (&global_trace.start_lock, flags); -if (global_trace.stop_count++) +raw_spin_lock_irqsave (&tr->start_lock, flags); +if (tr->stop_count++) goto out;/* Prevent the buffers from switching */ -arch_spin_lock (&global_trace.max_lock); +arch_spin_lock (&tr->max_lock); - buffer = global_trace.array_buffer.buffer; + buffer = tr->array_buffer.buffer;if (buffer)ring_buffer_record_disable (buffer);#ifdef CONFIG_TRACER_MAX_TRACE - buffer = global_trace.max_buffer.buffer; + buffer = tr->max_buffer.buffer;if (buffer)ring_buffer_record_disable (buffer);#endif -arch_spin_unlock (&global_trace.max_lock); +arch_spin_unlock (&tr->max_lock); out: -raw_spin_unlock_irqrestore (&global_trace.start_lock, flags); +raw_spin_unlock_irqrestore (&tr->start_lock, flags); } -static void tracing_stop_tr (struct trace_array *tr) +/** +* tracing_stop - quick stop of the tracer +* +* Light weight way to stop tracing. Use in conjunction with +* tracing_start. +*/ +void tracing_stop (void ) { -struct trace_buffer *buffer; -unsigned long flags; - -/* If global, we need to also stop the max tracer */ -if (tr->flags &TRACE_ARRAY_FL_GLOBAL ) -return tracing_stop (); - -raw_spin_lock_irqsave (&tr->start_lock, flags); -if (tr->stop_count++) - goto out; - - buffer = tr->array_buffer.buffer; -if (buffer) -ring_buffer_record_disable (buffer); - - out: -raw_spin_unlock_irqrestore (&tr->start_lock, flags); +return tracing_stop_tr (&global_trace); }static int trace_save_cmdline (struct task_struct *tsk)
Signature · 1 line
2.42.0