1 files changed, 236 insertions, 117 deletions

diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index a6b8f9d7ac96..c04c433fbc59 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -18,6 +18,35 @@
 
 #include "trace.h"
 
+/* Global flag to disable all recording to ring buffers */
+static int ring_buffers_off __read_mostly;
+
+/**
+ * tracing_on - enable all tracing buffers
+ *
+ * This function enables all tracing buffers that may have been
+ * disabled with tracing_off.
+ */
+void tracing_on(void)
+{
+        ring_buffers_off = 0;
+}
+
+/**
+ * tracing_off - turn off all tracing buffers
+ *
+ * This function stops all tracing buffers from recording data.
+ * It does not disable any overhead the tracers themselves may
+ * be causing. This function simply causes all recording to
+ * the ring buffers to fail.
+ */
+void tracing_off(void)
+{
+        ring_buffers_off = 1;
+}
+
+#include "trace.h"
+
 /* Up this if you want to test the TIME_EXTENTS and normalization */
 #define DEBUG_SHIFT 0
 
@@ -154,6 +183,7 @@ static inline int test_time_stamp(u64 delta)
 struct ring_buffer_per_cpu {
         int                             cpu;
         struct ring_buffer              *buffer;
+        spinlock_t                      reader_lock; /* serialize readers */
         raw_spinlock_t                  lock;
         struct lock_class_key           lock_key;
         struct list_head                pages;
@@ -190,60 +220,14 @@ struct ring_buffer_iter {
 
 /* buffer may be either ring_buffer or ring_buffer_per_cpu */
 #define RB_WARN_ON(buffer, cond)                                \
-        do {                                                    \
-                if (unlikely(cond)) {                           \
+        ({                                                      \
+                int _____ret = unlikely(cond);                  \
+                if (_____ret) {                                 \
                         atomic_inc(&buffer->record_disabled);   \
                         WARN_ON(1);                             \
                 }                                               \
-        } while (0)
-
-#define RB_WARN_ON_RET(buffer, cond)                            \
-        do {                                                    \
-                if (unlikely(cond)) {                           \
-                        atomic_inc(&buffer->record_disabled);   \
-                        WARN_ON(1);                             \
-                        return;                                 \
-                }                                               \
-        } while (0)
-
-#define RB_WARN_ON_RET_INT(buffer, cond)                        \
-        do {                                                    \
-                if (unlikely(cond)) {                           \
-                        atomic_inc(&buffer->record_disabled);   \
-                        WARN_ON(1);                             \
-                        return -1;                              \
-                }                                               \
-        } while (0)
-
-#define RB_WARN_ON_RET_NULL(buffer, cond)                       \
-        do {                                                    \
-                if (unlikely(cond)) {                           \
-                        atomic_inc(&buffer->record_disabled);   \
-                        WARN_ON(1);                             \
-                        return NULL;                            \
-                }                                               \
-        } while (0)
-
-#define RB_WARN_ON_ONCE(buffer, cond)                           \
-        do {                                                    \
-                static int once;                                \
-                if (unlikely(cond) && !once) {                  \
-                        once++;                                 \
-                        atomic_inc(&buffer->record_disabled);   \
-                        WARN_ON(1);                             \
-                }                                               \
-        } while (0)
-
-/* buffer must be ring_buffer not per_cpu */
-#define RB_WARN_ON_UNLOCK(buffer, cond)                         \
-        do {                                                    \
-                if (unlikely(cond)) {                           \
-                        mutex_unlock(&buffer->mutex);           \
-                        atomic_inc(&buffer->record_disabled);   \
-                        WARN_ON(1);                             \
-                        return -1;                              \
-                }                                               \
-        } while (0)
+                _____ret;                                       \
+        })
 
 /**
  * check_pages - integrity check of buffer pages
@@ -257,14 +241,18 @@ static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer)
         struct list_head *head = &cpu_buffer->pages;
         struct buffer_page *page, *tmp;
 
-        RB_WARN_ON_RET_INT(cpu_buffer, head->next->prev != head);
-        RB_WARN_ON_RET_INT(cpu_buffer, head->prev->next != head);
+        if (RB_WARN_ON(cpu_buffer, head->next->prev != head))
+                return -1;
+        if (RB_WARN_ON(cpu_buffer, head->prev->next != head))
+                return -1;
 
         list_for_each_entry_safe(page, tmp, head, list) {
-                RB_WARN_ON_RET_INT(cpu_buffer,
-                               page->list.next->prev != &page->list);
-                RB_WARN_ON_RET_INT(cpu_buffer,
-                               page->list.prev->next != &page->list);
+                if (RB_WARN_ON(cpu_buffer,
+                               page->list.next->prev != &page->list))
+                        return -1;
+                if (RB_WARN_ON(cpu_buffer,
+                               page->list.prev->next != &page->list))
+                        return -1;
         }
 
         return 0;
@@ -321,6 +309,7 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
 
         cpu_buffer->cpu = cpu;
         cpu_buffer->buffer = buffer;
+        spin_lock_init(&cpu_buffer->reader_lock);
         cpu_buffer->lock = (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
         INIT_LIST_HEAD(&cpu_buffer->pages);
 
@@ -470,13 +459,15 @@ rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned nr_pages)
         synchronize_sched();
 
         for (i = 0; i < nr_pages; i++) {
-                RB_WARN_ON_RET(cpu_buffer, list_empty(&cpu_buffer->pages));
+                if (RB_WARN_ON(cpu_buffer, list_empty(&cpu_buffer->pages)))
+                        return;
                 p = cpu_buffer->pages.next;
                 page = list_entry(p, struct buffer_page, list);
                 list_del_init(&page->list);
                 free_buffer_page(page);
         }
-        RB_WARN_ON_RET(cpu_buffer, list_empty(&cpu_buffer->pages));
+        if (RB_WARN_ON(cpu_buffer, list_empty(&cpu_buffer->pages)))
+                return;
 
         rb_reset_cpu(cpu_buffer);
 
@@ -498,7 +489,8 @@ rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer,
         synchronize_sched();
 
         for (i = 0; i < nr_pages; i++) {
-                RB_WARN_ON_RET(cpu_buffer, list_empty(pages));
+                if (RB_WARN_ON(cpu_buffer, list_empty(pages)))
+                        return;
                 p = pages->next;
                 page = list_entry(p, struct buffer_page, list);
                 list_del_init(&page->list);
@@ -553,7 +545,10 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
         if (size < buffer_size) {
 
                 /* easy case, just free pages */
-                RB_WARN_ON_UNLOCK(buffer, nr_pages >= buffer->pages);
+                if (RB_WARN_ON(buffer, nr_pages >= buffer->pages)) {
+                        mutex_unlock(&buffer->mutex);
+                        return -1;
+                }
 
                 rm_pages = buffer->pages - nr_pages;
 
@@ -572,7 +567,10 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
          * add these pages to the cpu_buffers. Otherwise we just free
          * them all and return -ENOMEM;
          */
-        RB_WARN_ON_UNLOCK(buffer, nr_pages <= buffer->pages);
+        if (RB_WARN_ON(buffer, nr_pages <= buffer->pages)) {
+                mutex_unlock(&buffer->mutex);
+                return -1;
+        }
 
         new_pages = nr_pages - buffer->pages;
 
@@ -596,7 +594,10 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
                 rb_insert_pages(cpu_buffer, &pages, new_pages);
         }
 
-        RB_WARN_ON_UNLOCK(buffer, !list_empty(&pages));
+        if (RB_WARN_ON(buffer, !list_empty(&pages))) {
+                mutex_unlock(&buffer->mutex);
+                return -1;
+        }
 
  out:
         buffer->pages = nr_pages;
@@ -684,7 +685,8 @@ static void rb_update_overflow(struct ring_buffer_per_cpu *cpu_buffer)
              head += rb_event_length(event)) {
 
                 event = __rb_page_index(cpu_buffer->head_page, head);
-                RB_WARN_ON_RET(cpu_buffer, rb_null_event(event));
+                if (RB_WARN_ON(cpu_buffer, rb_null_event(event)))
+                        return;
                 /* Only count data entries */
                 if (event->type != RINGBUF_TYPE_DATA)
                         continue;
@@ -737,8 +739,9 @@ rb_set_commit_event(struct ring_buffer_per_cpu *cpu_buffer,
         addr &= PAGE_MASK;
 
         while (cpu_buffer->commit_page->page != (void *)addr) {
-                RB_WARN_ON(cpu_buffer,
-                           cpu_buffer->commit_page == cpu_buffer->tail_page);
+                if (RB_WARN_ON(cpu_buffer,
+                          cpu_buffer->commit_page == cpu_buffer->tail_page))
+                        return;
                 cpu_buffer->commit_page->commit =
                         cpu_buffer->commit_page->write;
                 rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
@@ -894,7 +897,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
                 reader_page = cpu_buffer->reader_page;
 
                 /* we grabbed the lock before incrementing */
-                RB_WARN_ON(cpu_buffer, next_page == reader_page);
+                if (RB_WARN_ON(cpu_buffer, next_page == reader_page))
+                        goto out_unlock;
 
                 /*
                  * If for some reason, we had an interrupt storm that made
@@ -971,7 +975,8 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
 
         /* We reserved something on the buffer */
 
-        RB_WARN_ON_RET_NULL(cpu_buffer, write > BUF_PAGE_SIZE);
+        if (RB_WARN_ON(cpu_buffer, write > BUF_PAGE_SIZE))
+                return NULL;
 
         event = __rb_page_index(tail_page, tail);
         rb_update_event(event, type, length);
@@ -1070,10 +1075,8 @@ rb_reserve_next_event(struct ring_buffer_per_cpu *cpu_buffer,
          * storm or we have something buggy.
          * Bail!
          */
-        if (unlikely(++nr_loops > 1000)) {
-                RB_WARN_ON(cpu_buffer, 1);
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 1000))
                 return NULL;
-        }
 
         ts = ring_buffer_time_stamp(cpu_buffer->cpu);
 
@@ -1169,6 +1172,9 @@ ring_buffer_lock_reserve(struct ring_buffer *buffer,
         struct ring_buffer_event *event;
         int cpu, resched;
 
+        if (ring_buffers_off)
+                return NULL;
+
         if (atomic_read(&buffer->record_disabled))
                 return NULL;
 
@@ -1278,6 +1284,9 @@ int ring_buffer_write(struct ring_buffer *buffer,
         int ret = -EBUSY;
         int cpu, resched;
 
+        if (ring_buffers_off)
+                return -EBUSY;
+
         if (atomic_read(&buffer->record_disabled))
                 return -EBUSY;
 
@@ -1476,6 +1485,9 @@ unsigned long ring_buffer_overruns(struct ring_buffer *buffer)
 void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
 {
         struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
 
         /* Iterator usage is expected to have record disabled */
         if (list_empty(&cpu_buffer->reader_page->list)) {
@@ -1489,6 +1501,8 @@ void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
                 iter->read_stamp = cpu_buffer->read_stamp;
         else
                 iter->read_stamp = iter->head_page->time_stamp;
+
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
 
 /**
@@ -1584,8 +1598,7 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
          * a case where we will loop three times. There should be no
          * reason to loop four times (that I know of).
          */
-        if (unlikely(++nr_loops > 3)) {
-                RB_WARN_ON(cpu_buffer, 1);
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 3)) {
                 reader = NULL;
                 goto out;
         }
@@ -1597,8 +1610,9 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
                 goto out;
 
         /* Never should we have an index greater than the size */
-        RB_WARN_ON(cpu_buffer,
-                   cpu_buffer->reader_page->read > rb_page_size(reader));
+        if (RB_WARN_ON(cpu_buffer,
+                       cpu_buffer->reader_page->read > rb_page_size(reader)))
+                goto out;
 
         /* check if we caught up to the tail */
         reader = NULL;
@@ -1652,7 +1666,8 @@ static void rb_advance_reader(struct ring_buffer_per_cpu *cpu_buffer)
         reader = rb_get_reader_page(cpu_buffer);
 
         /* This function should not be called when buffer is empty */
-        RB_WARN_ON_RET(cpu_buffer, !reader);
+        if (RB_WARN_ON(cpu_buffer, !reader))
+                return;
 
         event = rb_reader_event(cpu_buffer);
 
@@ -1679,8 +1694,9 @@ static void rb_advance_iter(struct ring_buffer_iter *iter)
          * Check if we are at the end of the buffer.
          */
         if (iter->head >= rb_page_size(iter->head_page)) {
-                RB_WARN_ON_RET(buffer,
-                               iter->head_page == cpu_buffer->commit_page);
+                if (RB_WARN_ON(buffer,
+                               iter->head_page == cpu_buffer->commit_page))
+                        return;
                 rb_inc_iter(iter);
                 return;
         }
@@ -1693,9 +1709,10 @@ static void rb_advance_iter(struct ring_buffer_iter *iter)
          * This should not be called to advance the header if we are
          * at the tail of the buffer.
          */
-        RB_WARN_ON_RET(cpu_buffer,
+        if (RB_WARN_ON(cpu_buffer,
                        (iter->head_page == cpu_buffer->commit_page) &&
-                       (iter->head + length > rb_commit_index(cpu_buffer)));
+                       (iter->head + length > rb_commit_index(cpu_buffer))))
+                return;
 
         rb_update_iter_read_stamp(iter, event);
 
@@ -1707,17 +1724,8 @@ static void rb_advance_iter(struct ring_buffer_iter *iter)
                 rb_advance_iter(iter);
 }
 
-/**
- * ring_buffer_peek - peek at the next event to be read
- * @buffer: The ring buffer to read
- * @cpu: The cpu to peak at
- * @ts: The timestamp counter of this event.
- *
- * This will return the event that will be read next, but does
- * not consume the data.
- */
-struct ring_buffer_event *
-ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
+static struct ring_buffer_event *
+rb_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
         struct ring_buffer_event *event;
@@ -1738,10 +1746,8 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
          * can have.  Nesting 10 deep of interrupts is clearly
          * an anomaly.
          */
-        if (unlikely(++nr_loops > 10)) {
-                RB_WARN_ON(cpu_buffer, 1);
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 10))
                 return NULL;
-        }
 
         reader = rb_get_reader_page(cpu_buffer);
         if (!reader)
@@ -1779,16 +1785,8 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
         return NULL;
 }
 
-/**
- * ring_buffer_iter_peek - peek at the next event to be read
- * @iter: The ring buffer iterator
- * @ts: The timestamp counter of this event.
- *
- * This will return the event that will be read next, but does
- * not increment the iterator.
- */
-struct ring_buffer_event *
-ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
+static struct ring_buffer_event *
+rb_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 {
         struct ring_buffer *buffer;
         struct ring_buffer_per_cpu *cpu_buffer;
@@ -1810,10 +1808,8 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
          * can have. Nesting 10 deep of interrupts is clearly
          * an anomaly.
          */
-        if (unlikely(++nr_loops > 10)) {
-                RB_WARN_ON(cpu_buffer, 1);
+        if (RB_WARN_ON(cpu_buffer, ++nr_loops > 10))
                 return NULL;
-        }
 
         if (rb_per_cpu_empty(cpu_buffer))
                 return NULL;
@@ -1850,6 +1846,51 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 }
 
 /**
+ * ring_buffer_peek - peek at the next event to be read
+ * @buffer: The ring buffer to read
+ * @cpu: The cpu to peak at
+ * @ts: The timestamp counter of this event.
+ *
+ * This will return the event that will be read next, but does
+ * not consume the data.
+ */
+struct ring_buffer_event *
+ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
+        struct ring_buffer_event *event;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_buffer_peek(buffer, cpu, ts);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+
+        return event;
+}
+
+/**
+ * ring_buffer_iter_peek - peek at the next event to be read
+ * @iter: The ring buffer iterator
+ * @ts: The timestamp counter of this event.
+ *
+ * This will return the event that will be read next, but does
+ * not increment the iterator.
+ */
+struct ring_buffer_event *
+ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
+{
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        struct ring_buffer_event *event;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_iter_peek(iter, ts);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+
+        return event;
+}
+
+/**
  * ring_buffer_consume - return an event and consume it
  * @buffer: The ring buffer to get the next event from
  *
@@ -1860,19 +1901,24 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
 struct ring_buffer_event *
 ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts)
 {
-        struct ring_buffer_per_cpu *cpu_buffer;
+        struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
         struct ring_buffer_event *event;
+        unsigned long flags;
 
         if (!cpu_isset(cpu, buffer->cpumask))
                 return NULL;
 
-        event = ring_buffer_peek(buffer, cpu, ts);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+
+        event = rb_buffer_peek(buffer, cpu, ts);
         if (!event)
-                return NULL;
+                goto out;
 
-        cpu_buffer = buffer->buffers[cpu];
         rb_advance_reader(cpu_buffer);
 
+ out:
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+
         return event;
 }
 
@@ -1909,11 +1955,11 @@ ring_buffer_read_start(struct ring_buffer *buffer, int cpu)
         atomic_inc(&cpu_buffer->record_disabled);
         synchronize_sched();
 
-        local_irq_save(flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
         __raw_spin_lock(&cpu_buffer->lock);
         ring_buffer_iter_reset(iter);
         __raw_spin_unlock(&cpu_buffer->lock);
-        local_irq_restore(flags);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         return iter;
 }
@@ -1945,12 +1991,17 @@ struct ring_buffer_event *
 ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
 {
         struct ring_buffer_event *event;
+        struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
+        unsigned long flags;
 
-        event = ring_buffer_iter_peek(iter, ts);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        event = rb_iter_peek(iter, ts);
         if (!event)
-                return NULL;
+                goto out;
 
         rb_advance_iter(iter);
+ out:
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         return event;
 }
@@ -1999,13 +2050,15 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
         if (!cpu_isset(cpu, buffer->cpumask))
                 return;
 
-        local_irq_save(flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+
         __raw_spin_lock(&cpu_buffer->lock);
 
         rb_reset_cpu(cpu_buffer);
 
         __raw_spin_unlock(&cpu_buffer->lock);
-        local_irq_restore(flags);
+
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
 
 /**
@@ -2103,3 +2156,69 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
         return 0;
 }
 
+static ssize_t
+rb_simple_read(struct file *filp, char __user *ubuf,
+               size_t cnt, loff_t *ppos)
+{
+        int *p = filp->private_data;
+        char buf[64];
+        int r;
+
+        /* !ring_buffers_off == tracing_on */
+        r = sprintf(buf, "%d\n", !*p);
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+}
+
+static ssize_t
+rb_simple_write(struct file *filp, const char __user *ubuf,
+                size_t cnt, loff_t *ppos)
+{
+        int *p = filp->private_data;
+        char buf[64];
+        long val;
+        int ret;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        ret = strict_strtoul(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        /* !ring_buffers_off == tracing_on */
+        *p = !val;
+
+        (*ppos)++;
+
+        return cnt;
+}
+
+static struct file_operations rb_simple_fops = {
+        .open           = tracing_open_generic,
+        .read           = rb_simple_read,
+        .write          = rb_simple_write,
+};
+
+
+static __init int rb_init_debugfs(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+
+        d_tracer = tracing_init_dentry();
+
+        entry = debugfs_create_file("tracing_on", 0644, d_tracer,
+                                    &ring_buffers_off, &rb_simple_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs 'tracing_on' entry\n");
+
+        return 0;
+}
+
+fs_initcall(rb_init_debugfs);