lkml.org 
[lkml]   [2008]   [Oct]   [30]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Date
From
Subject[PATCH -v2] ring-buffer: add paranoid checks for loops
[
Changes since v1:

Updated comments to be more detailed.
]

While writing a new tracer, I had a bug where I caused the ring-buffer
to recurse in a bad way. The bug was with the tracer I was writing
and not the ring-buffer itself. But it took a long time to find the
problem.

This patch adds paranoid checks into the ring-buffer infrastructure
that will catch bugs of this nature.

Note: I put the bug back in the tracer and this patch showed the error
nicely and prevented the lockup.

Signed-off-by: Steven Rostedt <srostedt@redhat.com>
---
kernel/trace/ring_buffer.c | 58 +++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 58 insertions(+)
Index: linux-tip.git/kernel/trace/ring_buffer.c
===================================================================
--- linux-tip.git.orig/kernel/trace/ring_buffer.c 2008-10-30 11:22:43.000000000 -0400
+++ linux-tip.git/kernel/trace/ring_buffer.c 2008-10-30 22:50:53.000000000 -0400
@@ -1022,8 +1022,24 @@ rb_reserve_next_event(struct ring_buffer
struct ring_buffer_event *event;
u64 ts, delta;
int commit = 0;
+ int paranoid = 0;

again:
+ /*
+ * We allow for interrupts to reenter here and do a trace.
+ * If one does, it will cause this original code to loop
+ * back here. Even with heavy interrupts happening, this
+ * should only happen a few times in a row. If this happens
+ * 1000 times in a row, there must be either an interrupt
+ * storm or we have something buggy.
+ * Bail!
+ */
+ if (unlikely(paranoid > 1000)) {
+ RB_WARN_ON(cpu_buffer, 1);
+ return NULL;
+ }
+ paranoid++;
+
ts = ring_buffer_time_stamp(cpu_buffer->cpu);

/*
@@ -1532,10 +1548,24 @@ rb_get_reader_page(struct ring_buffer_pe
{
struct buffer_page *reader = NULL;
unsigned long flags;
+ int paranoid = 0;

spin_lock_irqsave(&cpu_buffer->lock, flags);

again:
+ /*
+ * This should normally only loop twice. But because the
+ * start of the reader inserts an empty page, it causes
+ * a case where we will loop three times. There should be no
+ * reason to loop four times (that I know of).
+ */
+ if (unlikely(paranoid > 2)) {
+ RB_WARN_ON(cpu_buffer, 1);
+ reader = NULL;
+ goto out;
+ }
+ paranoid++;
+
reader = cpu_buffer->reader_page;

/* If there's more to read, return this page */
@@ -1665,6 +1695,7 @@ ring_buffer_peek(struct ring_buffer *buf
struct ring_buffer_per_cpu *cpu_buffer;
struct ring_buffer_event *event;
struct buffer_page *reader;
+ int paranoid = 0;

if (!cpu_isset(cpu, buffer->cpumask))
return NULL;
@@ -1672,6 +1703,19 @@ ring_buffer_peek(struct ring_buffer *buf
cpu_buffer = buffer->buffers[cpu];

again:
+ /*
+ * We repeat when a timestamp is encountered. It is possible
+ * to get multiple timestamps from an interrupt entering just
+ * as one timestamp is about to be written. The max times
+ * that this can happen is the number of nested interrupts we
+ * can have. 10 should be more than enough.
+ */
+ if (unlikely(paranoid > 10)) {
+ RB_WARN_ON(cpu_buffer, 1);
+ return NULL;
+ }
+ paranoid++;
+
reader = rb_get_reader_page(cpu_buffer);
if (!reader)
return NULL;
@@ -1722,6 +1766,7 @@ ring_buffer_iter_peek(struct ring_buffer
struct ring_buffer *buffer;
struct ring_buffer_per_cpu *cpu_buffer;
struct ring_buffer_event *event;
+ int paranoid = 0;

if (ring_buffer_iter_empty(iter))
return NULL;
@@ -1730,6 +1775,19 @@ ring_buffer_iter_peek(struct ring_buffer
buffer = cpu_buffer->buffer;

again:
+ /*
+ * We repeat when a timestamp is encountered. It is possible
+ * to get multiple timestamps from an interrupt entering just
+ * as one timestamp is about to be written. The max times
+ * that this can happen is the number of nested interrupts we
+ * can have. 10 should be more than enough.
+ */
+ if (unlikely(paranoid > 10)) {
+ RB_WARN_ON(cpu_buffer, 1);
+ return NULL;
+ }
+ paranoid++;
+
if (rb_per_cpu_empty(cpu_buffer))
return NULL;




\
 
 \ /
  Last update: 2008-10-31 04:31    [from the cache]
©2003-2014 Jasper Spaans. Advertise on this site