Patched in Tegra support.

1 files changed, 297 insertions, 637 deletions

diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index ce8514feedc..731201bf4ac 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -23,8 +23,6 @@
 #include <asm/local.h>
 #include "trace.h"
 
-static void update_pages_handler(struct work_struct *work);
-
 /*
  * The ring buffer header is special. We must manually up keep it.
  */
@@ -156,12 +154,35 @@ enum {
 
 static unsigned long ring_buffer_flags __read_mostly = RB_BUFFERS_ON;
 
-/* Used for individual buffers (after the counter) */
-#define RB_BUFFER_OFF           (1 << 20)
-
 #define BUF_PAGE_HDR_SIZE offsetof(struct buffer_data_page, data)
 
 /**
+ * tracing_on - enable all tracing buffers
+ *
+ * This function enables all tracing buffers that may have been
+ * disabled with tracing_off.
+ */
+void tracing_on(void)
+{
+        set_bit(RB_BUFFERS_ON_BIT, &ring_buffer_flags);
+}
+EXPORT_SYMBOL_GPL(tracing_on);
+
+/**
+ * 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)
+{
+        clear_bit(RB_BUFFERS_ON_BIT, &ring_buffer_flags);
+}
+EXPORT_SYMBOL_GPL(tracing_off);
+
+/**
  * tracing_off_permanent - permanently disable ring buffers
  *
  * This function, once called, will disable all ring buffers
@@ -172,6 +193,15 @@ void tracing_off_permanent(void)
         set_bit(RB_BUFFERS_DISABLED_BIT, &ring_buffer_flags);
 }
 
+/**
+ * tracing_is_on - show state of ring buffers enabled
+ */
+int tracing_is_on(void)
+{
+        return ring_buffer_flags == RB_BUFFERS_ON;
+}
+EXPORT_SYMBOL_GPL(tracing_is_on);
+
 #define RB_EVNT_HDR_SIZE (offsetof(struct ring_buffer_event, array))
 #define RB_ALIGNMENT            4U
 #define RB_MAX_SMALL_DATA       (RB_ALIGNMENT * RINGBUF_TYPE_DATA_TYPE_LEN_MAX)
@@ -448,10 +478,9 @@ struct ring_buffer_per_cpu {
         int                             cpu;
         atomic_t                        record_disabled;
         struct ring_buffer              *buffer;
-        raw_spinlock_t                  reader_lock;    /* serialize readers */
+        spinlock_t                      reader_lock;    /* serialize readers */
         arch_spinlock_t                 lock;
         struct lock_class_key           lock_key;
-        unsigned int                    nr_pages;
         struct list_head                *pages;
         struct buffer_page              *head_page;     /* read from head */
         struct buffer_page              *tail_page;     /* write to tail */
@@ -459,29 +488,21 @@ struct ring_buffer_per_cpu {
         struct buffer_page              *reader_page;
         unsigned long                   lost_events;
         unsigned long                   last_overrun;
-        local_t                         entries_bytes;
-        local_t                         entries;
-        local_t                         overrun;
         local_t                         commit_overrun;
-        local_t                         dropped_events;
+        local_t                         overrun;
+        local_t                         entries;
         local_t                         committing;
         local_t                         commits;
         unsigned long                   read;
-        unsigned long                   read_bytes;
         u64                             write_stamp;
         u64                             read_stamp;
-        /* ring buffer pages to update, > 0 to add, < 0 to remove */
-        int                             nr_pages_to_update;
-        struct list_head                new_pages; /* new pages to add */
-        struct work_struct              update_pages_work;
-        struct completion               update_done;
 };
 
 struct ring_buffer {
+        unsigned                        pages;
         unsigned                        flags;
         int                             cpus;
         atomic_t                        record_disabled;
-        atomic_t                        resize_disabled;
         cpumask_var_t                   cpumask;
 
         struct lock_class_key           *reader_lock_key;
@@ -946,10 +967,6 @@ static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer)
         struct list_head *head = cpu_buffer->pages;
         struct buffer_page *bpage, *tmp;
 
-        /* Reset the head page if it exists */
-        if (cpu_buffer->head_page)
-                rb_set_head_page(cpu_buffer);
-
         rb_head_page_deactivate(cpu_buffer);
 
         if (RB_WARN_ON(cpu_buffer, head->next->prev != head))
@@ -976,10 +993,14 @@ static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer)
         return 0;
 }
 
-static int __rb_allocate_pages(int nr_pages, struct list_head *pages, int cpu)
+static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
+                             unsigned nr_pages)
 {
-        int i;
         struct buffer_page *bpage, *tmp;
+        LIST_HEAD(pages);
+        unsigned i;
+
+        WARN_ON(!nr_pages);
 
         for (i = 0; i < nr_pages; i++) {
                 struct page *page;
@@ -990,13 +1011,15 @@ static int __rb_allocate_pages(int nr_pages, struct list_head *pages, int cpu)
                  */
                 bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
                                     GFP_KERNEL | __GFP_NORETRY,
-                                    cpu_to_node(cpu));
+                                    cpu_to_node(cpu_buffer->cpu));
                 if (!bpage)
                         goto free_pages;
 
-                list_add(&bpage->list, pages);
+                rb_check_bpage(cpu_buffer, bpage);
 
-                page = alloc_pages_node(cpu_to_node(cpu),
+                list_add(&bpage->list, &pages);
+
+                page = alloc_pages_node(cpu_to_node(cpu_buffer->cpu),
                                         GFP_KERNEL | __GFP_NORETRY, 0);
                 if (!page)
                         goto free_pages;
@@ -1004,27 +1027,6 @@ static int __rb_allocate_pages(int nr_pages, struct list_head *pages, int cpu)
                 rb_init_page(bpage->page);
         }
 
-        return 0;
-
-free_pages:
-        list_for_each_entry_safe(bpage, tmp, pages, list) {
-                list_del_init(&bpage->list);
-                free_buffer_page(bpage);
-        }
-
-        return -ENOMEM;
-}
-
-static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
-                             unsigned nr_pages)
-{
-        LIST_HEAD(pages);
-
-        WARN_ON(!nr_pages);
-
-        if (__rb_allocate_pages(nr_pages, &pages, cpu_buffer->cpu))
-                return -ENOMEM;
-
         /*
          * The ring buffer page list is a circular list that does not
          * start and end with a list head. All page list items point to
@@ -1033,15 +1035,20 @@ static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
         cpu_buffer->pages = pages.next;
         list_del(&pages);
 
-        cpu_buffer->nr_pages = nr_pages;
-
         rb_check_pages(cpu_buffer);
 
         return 0;
+
+ free_pages:
+        list_for_each_entry_safe(bpage, tmp, &pages, list) {
+                list_del_init(&bpage->list);
+                free_buffer_page(bpage);
+        }
+        return -ENOMEM;
 }
 
 static struct ring_buffer_per_cpu *
-rb_allocate_cpu_buffer(struct ring_buffer *buffer, int nr_pages, int cpu)
+rb_allocate_cpu_buffer(struct ring_buffer *buffer, int cpu)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
         struct buffer_page *bpage;
@@ -1055,11 +1062,9 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int nr_pages, int cpu)
 
         cpu_buffer->cpu = cpu;
         cpu_buffer->buffer = buffer;
-        raw_spin_lock_init(&cpu_buffer->reader_lock);
+        spin_lock_init(&cpu_buffer->reader_lock);
         lockdep_set_class(&cpu_buffer->reader_lock, buffer->reader_lock_key);
         cpu_buffer->lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
-        INIT_WORK(&cpu_buffer->update_pages_work, update_pages_handler);
-        init_completion(&cpu_buffer->update_done);
 
         bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
                             GFP_KERNEL, cpu_to_node(cpu));
@@ -1076,9 +1081,8 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int nr_pages, int cpu)
         rb_init_page(bpage->page);
 
         INIT_LIST_HEAD(&cpu_buffer->reader_page->list);
-        INIT_LIST_HEAD(&cpu_buffer->new_pages);
 
-        ret = rb_allocate_pages(cpu_buffer, nr_pages);
+        ret = rb_allocate_pages(cpu_buffer, buffer->pages);
         if (ret < 0)
                 goto fail_free_reader;
 
@@ -1139,7 +1143,7 @@ struct ring_buffer *__ring_buffer_alloc(unsigned long size, unsigned flags,
 {
         struct ring_buffer *buffer;
         int bsize;
-        int cpu, nr_pages;
+        int cpu;
 
         /* keep it in its own cache line */
         buffer = kzalloc(ALIGN(sizeof(*buffer), cache_line_size()),
@@ -1150,14 +1154,14 @@ struct ring_buffer *__ring_buffer_alloc(unsigned long size, unsigned flags,
         if (!alloc_cpumask_var(&buffer->cpumask, GFP_KERNEL))
                 goto fail_free_buffer;
 
-        nr_pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
+        buffer->pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
         buffer->flags = flags;
         buffer->clock = trace_clock_local;
         buffer->reader_lock_key = key;
 
         /* need at least two pages */
-        if (nr_pages < 2)
-                nr_pages = 2;
+        if (buffer->pages < 2)
+                buffer->pages = 2;
 
         /*
          * In case of non-hotplug cpu, if the ring-buffer is allocated
@@ -1180,7 +1184,7 @@ struct ring_buffer *__ring_buffer_alloc(unsigned long size, unsigned flags,
 
         for_each_buffer_cpu(buffer, cpu) {
                 buffer->buffers[cpu] =
-                        rb_allocate_cpu_buffer(buffer, nr_pages, cpu);
+                        rb_allocate_cpu_buffer(buffer, cpu);
                 if (!buffer->buffers[cpu])
                         goto fail_free_buffers;
         }
@@ -1248,223 +1252,58 @@ void ring_buffer_set_clock(struct ring_buffer *buffer,
 
 static void rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer);
 
-static inline unsigned long rb_page_entries(struct buffer_page *bpage)
-{
-        return local_read(&bpage->entries) & RB_WRITE_MASK;
-}
-
-static inline unsigned long rb_page_write(struct buffer_page *bpage)
-{
-        return local_read(&bpage->write) & RB_WRITE_MASK;
-}
-
-static int
-rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned int nr_pages)
+static void
+rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned nr_pages)
 {
-        struct list_head *tail_page, *to_remove, *next_page;
-        struct buffer_page *to_remove_page, *tmp_iter_page;
-        struct buffer_page *last_page, *first_page;
-        unsigned int nr_removed;
-        unsigned long head_bit;
-        int page_entries;
-
-        head_bit = 0;
-
-        raw_spin_lock_irq(&cpu_buffer->reader_lock);
-        atomic_inc(&cpu_buffer->record_disabled);
-        /*
-         * We don't race with the readers since we have acquired the reader
-         * lock. We also don't race with writers after disabling recording.
-         * This makes it easy to figure out the first and the last page to be
-         * removed from the list. We unlink all the pages in between including
-         * the first and last pages. This is done in a busy loop so that we
-         * lose the least number of traces.
-         * The pages are freed after we restart recording and unlock readers.
-         */
-        tail_page = &cpu_buffer->tail_page->list;
-
-        /*
-         * tail page might be on reader page, we remove the next page
-         * from the ring buffer
-         */
-        if (cpu_buffer->tail_page == cpu_buffer->reader_page)
-                tail_page = rb_list_head(tail_page->next);
-        to_remove = tail_page;
+        struct buffer_page *bpage;
+        struct list_head *p;
+        unsigned i;
 
-        /* start of pages to remove */
-        first_page = list_entry(rb_list_head(to_remove->next),
-                                struct buffer_page, list);
+        spin_lock_irq(&cpu_buffer->reader_lock);
+        rb_head_page_deactivate(cpu_buffer);
 
-        for (nr_removed = 0; nr_removed < nr_pages; nr_removed++) {
-                to_remove = rb_list_head(to_remove)->next;
-                head_bit |= (unsigned long)to_remove & RB_PAGE_HEAD;
+        for (i = 0; i < nr_pages; i++) {
+                if (RB_WARN_ON(cpu_buffer, list_empty(cpu_buffer->pages)))
+                        goto out;
+                p = cpu_buffer->pages->next;
+                bpage = list_entry(p, struct buffer_page, list);
+                list_del_init(&bpage->list);
+                free_buffer_page(bpage);
         }
+        if (RB_WARN_ON(cpu_buffer, list_empty(cpu_buffer->pages)))
+                goto out;
 
-        next_page = rb_list_head(to_remove)->next;
-
-        /*
-         * Now we remove all pages between tail_page and next_page.
-         * Make sure that we have head_bit value preserved for the
-         * next page
-         */
-        tail_page->next = (struct list_head *)((unsigned long)next_page |
-                                                head_bit);
-        next_page = rb_list_head(next_page);
-        next_page->prev = tail_page;
-
-        /* make sure pages points to a valid page in the ring buffer */
-        cpu_buffer->pages = next_page;
-
-        /* update head page */
-        if (head_bit)
-                cpu_buffer->head_page = list_entry(next_page,
-                                                struct buffer_page, list);
-
-        /*
-         * change read pointer to make sure any read iterators reset
-         * themselves
-         */
-        cpu_buffer->read = 0;
-
-        /* pages are removed, resume tracing and then free the pages */
-        atomic_dec(&cpu_buffer->record_disabled);
-        raw_spin_unlock_irq(&cpu_buffer->reader_lock);
-
-        RB_WARN_ON(cpu_buffer, list_empty(cpu_buffer->pages));
-
-        /* last buffer page to remove */
-        last_page = list_entry(rb_list_head(to_remove), struct buffer_page,
-                                list);
-        tmp_iter_page = first_page;
-
-        do {
-                to_remove_page = tmp_iter_page;
-                rb_inc_page(cpu_buffer, &tmp_iter_page);
-
-                /* update the counters */
-                page_entries = rb_page_entries(to_remove_page);
-                if (page_entries) {
-                        /*
-                         * If something was added to this page, it was full
-                         * since it is not the tail page. So we deduct the
-                         * bytes consumed in ring buffer from here.
-                         * Increment overrun to account for the lost events.
-                         */
-                        local_add(page_entries, &cpu_buffer->overrun);
-                        local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
-                }
-
-                /*
-                 * We have already removed references to this list item, just
-                 * free up the buffer_page and its page
-                 */
-                free_buffer_page(to_remove_page);
-                nr_removed--;
-
-        } while (to_remove_page != last_page);
-
-        RB_WARN_ON(cpu_buffer, nr_removed);
+        rb_reset_cpu(cpu_buffer);
+        rb_check_pages(cpu_buffer);
 
-        return nr_removed == 0;
+out:
+        spin_unlock_irq(&cpu_buffer->reader_lock);
 }
 
-static int
-rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer)
+static void
+rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer,
+                struct list_head *pages, unsigned nr_pages)
 {
-        struct list_head *pages = &cpu_buffer->new_pages;
-        int retries, success;
-
-        raw_spin_lock_irq(&cpu_buffer->reader_lock);
-        /*
-         * We are holding the reader lock, so the reader page won't be swapped
-         * in the ring buffer. Now we are racing with the writer trying to
-         * move head page and the tail page.
-         * We are going to adapt the reader page update process where:
-         * 1. We first splice the start and end of list of new pages between
-         *    the head page and its previous page.
-         * 2. We cmpxchg the prev_page->next to point from head page to the
-         *    start of new pages list.
-         * 3. Finally, we update the head->prev to the end of new list.
-         *
-         * We will try this process 10 times, to make sure that we don't keep
-         * spinning.
-         */
-        retries = 10;
-        success = 0;
-        while (retries--) {
-                struct list_head *head_page, *prev_page, *r;
-                struct list_head *last_page, *first_page;
-                struct list_head *head_page_with_bit;
-
-                head_page = &rb_set_head_page(cpu_buffer)->list;
-                if (!head_page)
-                        break;
-                prev_page = head_page->prev;
-
-                first_page = pages->next;
-                last_page  = pages->prev;
-
-                head_page_with_bit = (struct list_head *)
-                                     ((unsigned long)head_page | RB_PAGE_HEAD);
-
-                last_page->next = head_page_with_bit;
-                first_page->prev = prev_page;
-
-                r = cmpxchg(&prev_page->next, head_page_with_bit, first_page);
+        struct buffer_page *bpage;
+        struct list_head *p;
+        unsigned i;
 
-                if (r == head_page_with_bit) {
-                        /*
-                         * yay, we replaced the page pointer to our new list,
-                         * now, we just have to update to head page's prev
-                         * pointer to point to end of list
-                         */
-                        head_page->prev = last_page;
-                        success = 1;
-                        break;
-                }
-        }
+        spin_lock_irq(&cpu_buffer->reader_lock);
+        rb_head_page_deactivate(cpu_buffer);
 
-        if (success)
-                INIT_LIST_HEAD(pages);
-        /*
-         * If we weren't successful in adding in new pages, warn and stop
-         * tracing
-         */
-        RB_WARN_ON(cpu_buffer, !success);
-        raw_spin_unlock_irq(&cpu_buffer->reader_lock);
-
-        /* free pages if they weren't inserted */
-        if (!success) {
-                struct buffer_page *bpage, *tmp;
-                list_for_each_entry_safe(bpage, tmp, &cpu_buffer->new_pages,
-                                         list) {
-                        list_del_init(&bpage->list);
-                        free_buffer_page(bpage);
-                }
+        for (i = 0; i < nr_pages; i++) {
+                if (RB_WARN_ON(cpu_buffer, list_empty(pages)))
+                        goto out;
+                p = pages->next;
+                bpage = list_entry(p, struct buffer_page, list);
+                list_del_init(&bpage->list);
+                list_add_tail(&bpage->list, cpu_buffer->pages);
         }
-        return success;
-}
-
-static void rb_update_pages(struct ring_buffer_per_cpu *cpu_buffer)
-{
-        int success;
-
-        if (cpu_buffer->nr_pages_to_update > 0)
-                success = rb_insert_pages(cpu_buffer);
-        else
-                success = rb_remove_pages(cpu_buffer,
-                                        -cpu_buffer->nr_pages_to_update);
-
-        if (success)
-                cpu_buffer->nr_pages += cpu_buffer->nr_pages_to_update;
-}
+        rb_reset_cpu(cpu_buffer);
+        rb_check_pages(cpu_buffer);
 
-static void update_pages_handler(struct work_struct *work)
-{
-        struct ring_buffer_per_cpu *cpu_buffer = container_of(work,
-                        struct ring_buffer_per_cpu, update_pages_work);
-        rb_update_pages(cpu_buffer);
-        complete(&cpu_buffer->update_done);
+out:
+        spin_unlock_irq(&cpu_buffer->reader_lock);
 }
 
 /**
@@ -1474,14 +1313,16 @@ static void update_pages_handler(struct work_struct *work)
  *
  * Minimum size is 2 * BUF_PAGE_SIZE.
  *
- * Returns 0 on success and < 0 on failure.
+ * Returns -1 on failure.
  */
-int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size,
-                        int cpu_id)
+int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
-        unsigned nr_pages;
-        int cpu, err = 0;
+        unsigned nr_pages, rm_pages, new_pages;
+        struct buffer_page *bpage, *tmp;
+        unsigned long buffer_size;
+        LIST_HEAD(pages);
+        int i, cpu;
 
         /*
          * Always succeed at resizing a non-existent buffer:
@@ -1489,165 +1330,115 @@ int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size,
         if (!buffer)
                 return size;
 
-        /* Make sure the requested buffer exists */
-        if (cpu_id != RING_BUFFER_ALL_CPUS &&
-            !cpumask_test_cpu(cpu_id, buffer->cpumask))
-                return size;
-
         size = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
         size *= BUF_PAGE_SIZE;
+        buffer_size = buffer->pages * BUF_PAGE_SIZE;
 
         /* we need a minimum of two pages */
         if (size < BUF_PAGE_SIZE * 2)
                 size = BUF_PAGE_SIZE * 2;
 
-        nr_pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
+        if (size == buffer_size)
+                return size;
 
-        /*
-         * Don't succeed if resizing is disabled, as a reader might be
-         * manipulating the ring buffer and is expecting a sane state while
-         * this is true.
-         */
-        if (atomic_read(&buffer->resize_disabled))
-                return -EBUSY;
+        atomic_inc(&buffer->record_disabled);
+
+        /* Make sure all writers are done with this buffer. */
+        synchronize_sched();
 
-        /* prevent another thread from changing buffer sizes */
         mutex_lock(&buffer->mutex);
+        get_online_cpus();
 
-        if (cpu_id == RING_BUFFER_ALL_CPUS) {
-                /* calculate the pages to update */
-                for_each_buffer_cpu(buffer, cpu) {
-                        cpu_buffer = buffer->buffers[cpu];
+        nr_pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
 
-                        cpu_buffer->nr_pages_to_update = nr_pages -
-                                                        cpu_buffer->nr_pages;
-                        /*
-                         * nothing more to do for removing pages or no update
-                         */
-                        if (cpu_buffer->nr_pages_to_update <= 0)
-                                continue;
-                        /*
-                         * to add pages, make sure all new pages can be
-                         * allocated without receiving ENOMEM
-                         */
-                        INIT_LIST_HEAD(&cpu_buffer->new_pages);
-                        if (__rb_allocate_pages(cpu_buffer->nr_pages_to_update,
-                                                &cpu_buffer->new_pages, cpu)) {
-                                /* not enough memory for new pages */
-                                err = -ENOMEM;
-                                goto out_err;
-                        }
-                }
+        if (size < buffer_size) {
 
-                get_online_cpus();
-                /*
-                 * Fire off all the required work handlers
-                 * We can't schedule on offline CPUs, but it's not necessary
-                 * since we can change their buffer sizes without any race.
-                 */
-                for_each_buffer_cpu(buffer, cpu) {
-                        cpu_buffer = buffer->buffers[cpu];
-                        if (!cpu_buffer->nr_pages_to_update)
-                                continue;
-
-                        if (cpu_online(cpu))
-                                schedule_work_on(cpu,
-                                                &cpu_buffer->update_pages_work);
-                        else
-                                rb_update_pages(cpu_buffer);
-                }
+                /* easy case, just free pages */
+                if (RB_WARN_ON(buffer, nr_pages >= buffer->pages))
+                        goto out_fail;
+
+                rm_pages = buffer->pages - nr_pages;
 
-                /* wait for all the updates to complete */
                 for_each_buffer_cpu(buffer, cpu) {
                         cpu_buffer = buffer->buffers[cpu];
-                        if (!cpu_buffer->nr_pages_to_update)
-                                continue;
-
-                        if (cpu_online(cpu))
-                                wait_for_completion(&cpu_buffer->update_done);
-                        cpu_buffer->nr_pages_to_update = 0;
+                        rb_remove_pages(cpu_buffer, rm_pages);
                 }
+                goto out;
+        }
 
-                put_online_cpus();
-        } else {
-                /* Make sure this CPU has been intitialized */
-                if (!cpumask_test_cpu(cpu_id, buffer->cpumask))
-                        goto out;
-
-                cpu_buffer = buffer->buffers[cpu_id];
-
-                if (nr_pages == cpu_buffer->nr_pages)
-                        goto out;
+        /*
+         * This is a bit more difficult. We only want to add pages
+         * when we can allocate enough for all CPUs. We do this
+         * by allocating all the pages and storing them on a local
+         * link list. If we succeed in our allocation, then we
+         * add these pages to the cpu_buffers. Otherwise we just free
+         * them all and return -ENOMEM;
+         */
+        if (RB_WARN_ON(buffer, nr_pages <= buffer->pages))
+                goto out_fail;
 
-                cpu_buffer->nr_pages_to_update = nr_pages -
-                                                cpu_buffer->nr_pages;
+        new_pages = nr_pages - buffer->pages;
 
-                INIT_LIST_HEAD(&cpu_buffer->new_pages);
-                if (cpu_buffer->nr_pages_to_update > 0 &&
-                        __rb_allocate_pages(cpu_buffer->nr_pages_to_update,
-                                            &cpu_buffer->new_pages, cpu_id)) {
-                        err = -ENOMEM;
-                        goto out_err;
+        for_each_buffer_cpu(buffer, cpu) {
+                for (i = 0; i < new_pages; i++) {
+                        struct page *page;
+                        /*
+                         * __GFP_NORETRY flag makes sure that the allocation
+                         * fails gracefully without invoking oom-killer and
+                         * the system is not destabilized.
+                         */
+                        bpage = kzalloc_node(ALIGN(sizeof(*bpage),
+                                                  cache_line_size()),
+                                            GFP_KERNEL | __GFP_NORETRY,
+                                            cpu_to_node(cpu));
+                        if (!bpage)
+                                goto free_pages;
+                        list_add(&bpage->list, &pages);
+                        page = alloc_pages_node(cpu_to_node(cpu),
+                                                GFP_KERNEL | __GFP_NORETRY, 0);
+                        if (!page)
+                                goto free_pages;
+                        bpage->page = page_address(page);
+                        rb_init_page(bpage->page);
                 }
-
-                get_online_cpus();
-
-                if (cpu_online(cpu_id)) {
-                        schedule_work_on(cpu_id,
-                                         &cpu_buffer->update_pages_work);
-                        wait_for_completion(&cpu_buffer->update_done);
-                } else
-                        rb_update_pages(cpu_buffer);
-
-                cpu_buffer->nr_pages_to_update = 0;
-                put_online_cpus();
         }
 
- out:
-        /*
-         * The ring buffer resize can happen with the ring buffer
-         * enabled, so that the update disturbs the tracing as little
-         * as possible. But if the buffer is disabled, we do not need
-         * to worry about that, and we can take the time to verify
-         * that the buffer is not corrupt.
-         */
-        if (atomic_read(&buffer->record_disabled)) {
-                atomic_inc(&buffer->record_disabled);
-                /*
-                 * Even though the buffer was disabled, we must make sure
-                 * that it is truly disabled before calling rb_check_pages.
-                 * There could have been a race between checking
-                 * record_disable and incrementing it.
-                 */
-                synchronize_sched();
-                for_each_buffer_cpu(buffer, cpu) {
-                        cpu_buffer = buffer->buffers[cpu];
-                        rb_check_pages(cpu_buffer);
-                }
-                atomic_dec(&buffer->record_disabled);
+        for_each_buffer_cpu(buffer, cpu) {
+                cpu_buffer = buffer->buffers[cpu];
+                rb_insert_pages(cpu_buffer, &pages, new_pages);
         }
 
-        mutex_unlock(&buffer->mutex);
-        return size;
+        if (RB_WARN_ON(buffer, !list_empty(&pages)))
+                goto out_fail;
 
- out_err:
-        for_each_buffer_cpu(buffer, cpu) {
-                struct buffer_page *bpage, *tmp;
+ out:
+        buffer->pages = nr_pages;
+        put_online_cpus();
+        mutex_unlock(&buffer->mutex);
 
-                cpu_buffer = buffer->buffers[cpu];
-                cpu_buffer->nr_pages_to_update = 0;
+        atomic_dec(&buffer->record_disabled);
 
-                if (list_empty(&cpu_buffer->new_pages))
-                        continue;
+        return size;
 
-                list_for_each_entry_safe(bpage, tmp, &cpu_buffer->new_pages,
-                                        list) {
-                        list_del_init(&bpage->list);
-                        free_buffer_page(bpage);
-                }
+ free_pages:
+        list_for_each_entry_safe(bpage, tmp, &pages, list) {
+                list_del_init(&bpage->list);
+                free_buffer_page(bpage);
         }
+        put_online_cpus();
         mutex_unlock(&buffer->mutex);
-        return err;
+        atomic_dec(&buffer->record_disabled);
+        return -ENOMEM;
+
+        /*
+         * Something went totally wrong, and we are too paranoid
+         * to even clean up the mess.
+         */
+ out_fail:
+        put_online_cpus();
+        mutex_unlock(&buffer->mutex);
+        atomic_dec(&buffer->record_disabled);
+        return -1;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_resize);
 
@@ -1686,11 +1477,21 @@ rb_iter_head_event(struct ring_buffer_iter *iter)
         return __rb_page_index(iter->head_page, iter->head);
 }
 
+static inline unsigned long rb_page_write(struct buffer_page *bpage)
+{
+        return local_read(&bpage->write) & RB_WRITE_MASK;
+}
+
 static inline unsigned rb_page_commit(struct buffer_page *bpage)
 {
         return local_read(&bpage->page->commit);
 }
 
+static inline unsigned long rb_page_entries(struct buffer_page *bpage)
+{
+        return local_read(&bpage->entries) & RB_WRITE_MASK;
+}
+
 /* Size is determined by what has been committed */
 static inline unsigned rb_page_size(struct buffer_page *bpage)
 {
@@ -1739,7 +1540,7 @@ rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
          * assign the commit to the tail.
          */
  again:
-        max_count = cpu_buffer->nr_pages * 100;
+        max_count = cpu_buffer->buffer->pages * 100;
 
         while (cpu_buffer->commit_page != cpu_buffer->tail_page) {
                 if (RB_WARN_ON(cpu_buffer, !(--max_count)))
@@ -1823,7 +1624,7 @@ rb_add_time_stamp(struct ring_buffer_event *event, u64 delta)
 }
 
 /**
- * rb_update_event - update event type and data
+ * ring_buffer_update_event - update event type and data
  * @event: the even to update
  * @type: the type of event
  * @length: the size of the event field in the ring buffer
@@ -1907,7 +1708,6 @@ rb_handle_head_page(struct ring_buffer_per_cpu *cpu_buffer,
                  * the counters.
                  */
                 local_add(entries, &cpu_buffer->overrun);
-                local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
 
                 /*
                  * The entries will be zeroed out when we move the
@@ -2063,9 +1863,6 @@ rb_reset_tail(struct ring_buffer_per_cpu *cpu_buffer,
         event = __rb_page_index(tail_page, tail);
         kmemcheck_annotate_bitfield(event, bitfield);
 
-        /* account for padding bytes */
-        local_add(BUF_PAGE_SIZE - tail, &cpu_buffer->entries_bytes);
-
         /*
          * Save the original length to the meta data.
          * This will be used by the reader to add lost event
@@ -2158,10 +1955,8 @@ rb_move_tail(struct ring_buffer_per_cpu *cpu_buffer,
                          * If we are not in overwrite mode,
                          * this is easy, just stop here.
                          */
-                        if (!(buffer->flags & RB_FL_OVERWRITE)) {
-                                local_inc(&cpu_buffer->dropped_events);
+                        if (!(buffer->flags & RB_FL_OVERWRITE))
                                 goto out_reset;
-                        }
 
                         ret = rb_handle_head_page(cpu_buffer,
                                                   tail_page,
@@ -2259,9 +2054,6 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
         if (!tail)
                 tail_page->page->time_stamp = ts;
 
-        /* account for these added bytes */
-        local_add(length, &cpu_buffer->entries_bytes);
-
         return event;
 }
 
@@ -2284,7 +2076,6 @@ rb_try_to_discard(struct ring_buffer_per_cpu *cpu_buffer,
         if (bpage->page == (void *)addr && rb_page_write(bpage) == old_index) {
                 unsigned long write_mask =
                         local_read(&bpage->write) & ~RB_WRITE_MASK;
-                unsigned long event_length = rb_event_length(event);
                 /*
                  * This is on the tail page. It is possible that
                  * a write could come in and move the tail page
@@ -2294,11 +2085,8 @@ rb_try_to_discard(struct ring_buffer_per_cpu *cpu_buffer,
                 old_index += write_mask;
                 new_index += write_mask;
                 index = local_cmpxchg(&bpage->write, old_index, new_index);
-                if (index == old_index) {
-                        /* update counters */
-                        local_sub(event_length, &cpu_buffer->entries_bytes);
+                if (index == old_index)
                         return 1;
-                }
         }
 
         /* could not discard */
@@ -2725,8 +2513,8 @@ EXPORT_SYMBOL_GPL(ring_buffer_discard_commit);
  * and not the length of the event which would hold the header.
  */
 int ring_buffer_write(struct ring_buffer *buffer,
-                      unsigned long length,
-                      void *data)
+                        unsigned long length,
+                        void *data)
 {
         struct ring_buffer_per_cpu *cpu_buffer;
         struct ring_buffer_event *event;
@@ -2818,63 +2606,6 @@ void ring_buffer_record_enable(struct ring_buffer *buffer)
 EXPORT_SYMBOL_GPL(ring_buffer_record_enable);
 
 /**
- * ring_buffer_record_off - stop all writes into the buffer
- * @buffer: The ring buffer to stop writes to.
- *
- * This prevents all writes to the buffer. Any attempt to write
- * to the buffer after this will fail and return NULL.
- *
- * This is different than ring_buffer_record_disable() as
- * it works like an on/off switch, where as the disable() version
- * must be paired with a enable().
- */
-void ring_buffer_record_off(struct ring_buffer *buffer)
-{
-        unsigned int rd;
-        unsigned int new_rd;
-
-        do {
-                rd = atomic_read(&buffer->record_disabled);
-                new_rd = rd | RB_BUFFER_OFF;
-        } while (atomic_cmpxchg(&buffer->record_disabled, rd, new_rd) != rd);
-}
-EXPORT_SYMBOL_GPL(ring_buffer_record_off);
-
-/**
- * ring_buffer_record_on - restart writes into the buffer
- * @buffer: The ring buffer to start writes to.
- *
- * This enables all writes to the buffer that was disabled by
- * ring_buffer_record_off().
- *
- * This is different than ring_buffer_record_enable() as
- * it works like an on/off switch, where as the enable() version
- * must be paired with a disable().
- */
-void ring_buffer_record_on(struct ring_buffer *buffer)
-{
-        unsigned int rd;
-        unsigned int new_rd;
-
-        do {
-                rd = atomic_read(&buffer->record_disabled);
-                new_rd = rd & ~RB_BUFFER_OFF;
-        } while (atomic_cmpxchg(&buffer->record_disabled, rd, new_rd) != rd);
-}
-EXPORT_SYMBOL_GPL(ring_buffer_record_on);
-
-/**
- * ring_buffer_record_is_on - return true if the ring buffer can write
- * @buffer: The ring buffer to see if write is enabled
- *
- * Returns true if the ring buffer is in a state that it accepts writes.
- */
-int ring_buffer_record_is_on(struct ring_buffer *buffer)
-{
-        return !atomic_read(&buffer->record_disabled);
-}
-
-/**
  * ring_buffer_record_disable_cpu - stop all writes into the cpu_buffer
  * @buffer: The ring buffer to stop writes to.
  * @cpu: The CPU buffer to stop
@@ -2930,59 +2661,6 @@ rb_num_of_entries(struct ring_buffer_per_cpu *cpu_buffer)
 }
 
 /**
- * ring_buffer_oldest_event_ts - get the oldest event timestamp from the buffer
- * @buffer: The ring buffer
- * @cpu: The per CPU buffer to read from.
- */
-u64 ring_buffer_oldest_event_ts(struct ring_buffer *buffer, int cpu)
-{
-        unsigned long flags;
-        struct ring_buffer_per_cpu *cpu_buffer;
-        struct buffer_page *bpage;
-        u64 ret = 0;
-
-        if (!cpumask_test_cpu(cpu, buffer->cpumask))
-                return 0;
-
-        cpu_buffer = buffer->buffers[cpu];
-        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
-        /*
-         * if the tail is on reader_page, oldest time stamp is on the reader
-         * page
-         */
-        if (cpu_buffer->tail_page == cpu_buffer->reader_page)
-                bpage = cpu_buffer->reader_page;
-        else
-                bpage = rb_set_head_page(cpu_buffer);
-        if (bpage)
-                ret = bpage->page->time_stamp;
-        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(ring_buffer_oldest_event_ts);
-
-/**
- * ring_buffer_bytes_cpu - get the number of bytes consumed in a cpu buffer
- * @buffer: The ring buffer
- * @cpu: The per CPU buffer to read from.
- */
-unsigned long ring_buffer_bytes_cpu(struct ring_buffer *buffer, int cpu)
-{
-        struct ring_buffer_per_cpu *cpu_buffer;
-        unsigned long ret;
-
-        if (!cpumask_test_cpu(cpu, buffer->cpumask))
-                return 0;
-
-        cpu_buffer = buffer->buffers[cpu];
-        ret = local_read(&cpu_buffer->entries_bytes) - cpu_buffer->read_bytes;
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(ring_buffer_bytes_cpu);
-
-/**
  * ring_buffer_entries_cpu - get the number of entries in a cpu buffer
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to get the entries from.
@@ -3001,8 +2679,7 @@ unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu)
 EXPORT_SYMBOL_GPL(ring_buffer_entries_cpu);
 
 /**
- * ring_buffer_overrun_cpu - get the number of overruns caused by the ring
- * buffer wrapping around (only if RB_FL_OVERWRITE is on).
+ * ring_buffer_overrun_cpu - get the number of overruns in a cpu_buffer
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to get the number of overruns from
  */
@@ -3022,9 +2699,7 @@ unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu)
 EXPORT_SYMBOL_GPL(ring_buffer_overrun_cpu);
 
 /**
- * ring_buffer_commit_overrun_cpu - get the number of overruns caused by
- * commits failing due to the buffer wrapping around while there are uncommitted
- * events, such as during an interrupt storm.
+ * ring_buffer_commit_overrun_cpu - get the number of overruns caused by commits
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to get the number of overruns from
  */
@@ -3045,28 +2720,6 @@ ring_buffer_commit_overrun_cpu(struct ring_buffer *buffer, int cpu)
 EXPORT_SYMBOL_GPL(ring_buffer_commit_overrun_cpu);
 
 /**
- * ring_buffer_dropped_events_cpu - get the number of dropped events caused by
- * the ring buffer filling up (only if RB_FL_OVERWRITE is off).
- * @buffer: The ring buffer
- * @cpu: The per CPU buffer to get the number of overruns from
- */
-unsigned long
-ring_buffer_dropped_events_cpu(struct ring_buffer *buffer, int cpu)
-{
-        struct ring_buffer_per_cpu *cpu_buffer;
-        unsigned long ret;
-
-        if (!cpumask_test_cpu(cpu, buffer->cpumask))
-                return 0;
-
-        cpu_buffer = buffer->buffers[cpu];
-        ret = local_read(&cpu_buffer->dropped_events);
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(ring_buffer_dropped_events_cpu);
-
-/**
  * ring_buffer_entries - get the number of entries in a buffer
  * @buffer: The ring buffer
  *
@@ -3151,9 +2804,9 @@ void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
 
         cpu_buffer = iter->cpu_buffer;
 
-        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
         rb_iter_reset(iter);
-        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
 EXPORT_SYMBOL_GPL(ring_buffer_iter_reset);
 
@@ -3274,10 +2927,6 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
         if (cpu_buffer->commit_page == cpu_buffer->reader_page)
                 goto out;
 
-        /* Don't bother swapping if the ring buffer is empty */
-        if (rb_num_of_entries(cpu_buffer) == 0)
-                goto out;
-
         /*
          * Reset the reader page to size zero.
          */
@@ -3291,8 +2940,6 @@ rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
          * Splice the empty reader page into the list around the head.
          */
         reader = rb_set_head_page(cpu_buffer);
-        if (!reader)
-                goto out;
         cpu_buffer->reader_page->list.next = rb_list_head(reader->list.next);
         cpu_buffer->reader_page->list.prev = reader->list.prev;
 
@@ -3618,12 +3265,12 @@ ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts,
  again:
         local_irq_save(flags);
         if (dolock)
-                raw_spin_lock(&cpu_buffer->reader_lock);
+                spin_lock(&cpu_buffer->reader_lock);
         event = rb_buffer_peek(cpu_buffer, ts, lost_events);
         if (event && event->type_len == RINGBUF_TYPE_PADDING)
                 rb_advance_reader(cpu_buffer);
         if (dolock)
-                raw_spin_unlock(&cpu_buffer->reader_lock);
+                spin_unlock(&cpu_buffer->reader_lock);
         local_irq_restore(flags);
 
         if (event && event->type_len == RINGBUF_TYPE_PADDING)
@@ -3648,9 +3295,9 @@ ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
         unsigned long flags;
 
  again:
-        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
         event = rb_iter_peek(iter, ts);
-        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         if (event && event->type_len == RINGBUF_TYPE_PADDING)
                 goto again;
@@ -3690,7 +3337,7 @@ ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts,
         cpu_buffer = buffer->buffers[cpu];
         local_irq_save(flags);
         if (dolock)
-                raw_spin_lock(&cpu_buffer->reader_lock);
+                spin_lock(&cpu_buffer->reader_lock);
 
         event = rb_buffer_peek(cpu_buffer, ts, lost_events);
         if (event) {
@@ -3699,7 +3346,7 @@ ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts,
         }
 
         if (dolock)
-                raw_spin_unlock(&cpu_buffer->reader_lock);
+                spin_unlock(&cpu_buffer->reader_lock);
         local_irq_restore(flags);
 
  out:
@@ -3749,7 +3396,6 @@ ring_buffer_read_prepare(struct ring_buffer *buffer, int cpu)
 
         iter->cpu_buffer = cpu_buffer;
 
-        atomic_inc(&buffer->resize_disabled);
         atomic_inc(&cpu_buffer->record_disabled);
 
         return iter;
@@ -3792,11 +3438,11 @@ ring_buffer_read_start(struct ring_buffer_iter *iter)
 
         cpu_buffer = iter->cpu_buffer;
 
-        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
         arch_spin_lock(&cpu_buffer->lock);
         rb_iter_reset(iter);
         arch_spin_unlock(&cpu_buffer->lock);
-        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 }
 EXPORT_SYMBOL_GPL(ring_buffer_read_start);
 
@@ -3811,20 +3457,8 @@ void
 ring_buffer_read_finish(struct ring_buffer_iter *iter)
 {
         struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
-        unsigned long flags;
-
-        /*
-         * Ring buffer is disabled from recording, here's a good place
-         * to check the integrity of the ring buffer.
-         * Must prevent readers from trying to read, as the check
-         * clears the HEAD page and readers require it.
-         */
-        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
-        rb_check_pages(cpu_buffer);
-        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         atomic_dec(&cpu_buffer->record_disabled);
-        atomic_dec(&cpu_buffer->buffer->resize_disabled);
         kfree(iter);
 }
 EXPORT_SYMBOL_GPL(ring_buffer_read_finish);
@@ -3843,7 +3477,7 @@ ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
         struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
         unsigned long flags;
 
-        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
  again:
         event = rb_iter_peek(iter, ts);
         if (!event)
@@ -3854,7 +3488,7 @@ ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
 
         rb_advance_iter(iter);
  out:
-        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         return event;
 }
@@ -3864,18 +3498,9 @@ EXPORT_SYMBOL_GPL(ring_buffer_read);
  * ring_buffer_size - return the size of the ring buffer (in bytes)
  * @buffer: The ring buffer.
  */
-unsigned long ring_buffer_size(struct ring_buffer *buffer, int cpu)
+unsigned long ring_buffer_size(struct ring_buffer *buffer)
 {
-        /*
-         * Earlier, this method returned
-         *      BUF_PAGE_SIZE * buffer->nr_pages
-         * Since the nr_pages field is now removed, we have converted this to
-         * return the per cpu buffer value.
-         */
-        if (!cpumask_test_cpu(cpu, buffer->cpumask))
-                return 0;
-
-        return BUF_PAGE_SIZE * buffer->buffers[cpu]->nr_pages;
+        return BUF_PAGE_SIZE * buffer->pages;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_size);
 
@@ -3896,21 +3521,17 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
         cpu_buffer->commit_page = cpu_buffer->head_page;
 
         INIT_LIST_HEAD(&cpu_buffer->reader_page->list);
-        INIT_LIST_HEAD(&cpu_buffer->new_pages);
         local_set(&cpu_buffer->reader_page->write, 0);
         local_set(&cpu_buffer->reader_page->entries, 0);
         local_set(&cpu_buffer->reader_page->page->commit, 0);
         cpu_buffer->reader_page->read = 0;
 
-        local_set(&cpu_buffer->entries_bytes, 0);
-        local_set(&cpu_buffer->overrun, 0);
         local_set(&cpu_buffer->commit_overrun, 0);
-        local_set(&cpu_buffer->dropped_events, 0);
+        local_set(&cpu_buffer->overrun, 0);
         local_set(&cpu_buffer->entries, 0);
         local_set(&cpu_buffer->committing, 0);
         local_set(&cpu_buffer->commits, 0);
         cpu_buffer->read = 0;
-        cpu_buffer->read_bytes = 0;
 
         cpu_buffer->write_stamp = 0;
         cpu_buffer->read_stamp = 0;
@@ -3934,13 +3555,9 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
         if (!cpumask_test_cpu(cpu, buffer->cpumask))
                 return;
 
-        atomic_inc(&buffer->resize_disabled);
         atomic_inc(&cpu_buffer->record_disabled);
 
-        /* Make sure all commits have finished */
-        synchronize_sched();
-
-        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
 
         if (RB_WARN_ON(cpu_buffer, local_read(&cpu_buffer->committing)))
                 goto out;
@@ -3952,10 +3569,9 @@ void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
         arch_spin_unlock(&cpu_buffer->lock);
 
  out:
-        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
         atomic_dec(&cpu_buffer->record_disabled);
-        atomic_dec(&buffer->resize_disabled);
 }
 EXPORT_SYMBOL_GPL(ring_buffer_reset_cpu);
 
@@ -3991,10 +3607,10 @@ int ring_buffer_empty(struct ring_buffer *buffer)
                 cpu_buffer = buffer->buffers[cpu];
                 local_irq_save(flags);
                 if (dolock)
-                        raw_spin_lock(&cpu_buffer->reader_lock);
+                        spin_lock(&cpu_buffer->reader_lock);
                 ret = rb_per_cpu_empty(cpu_buffer);
                 if (dolock)
-                        raw_spin_unlock(&cpu_buffer->reader_lock);
+                        spin_unlock(&cpu_buffer->reader_lock);
                 local_irq_restore(flags);
 
                 if (!ret)
@@ -4025,10 +3641,10 @@ int ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu)
         cpu_buffer = buffer->buffers[cpu];
         local_irq_save(flags);
         if (dolock)
-                raw_spin_lock(&cpu_buffer->reader_lock);
+                spin_lock(&cpu_buffer->reader_lock);
         ret = rb_per_cpu_empty(cpu_buffer);
         if (dolock)
-                raw_spin_unlock(&cpu_buffer->reader_lock);
+                spin_unlock(&cpu_buffer->reader_lock);
         local_irq_restore(flags);
 
         return ret;
@@ -4057,11 +3673,8 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
             !cpumask_test_cpu(cpu, buffer_b->cpumask))
                 goto out;
 
-        cpu_buffer_a = buffer_a->buffers[cpu];
-        cpu_buffer_b = buffer_b->buffers[cpu];
-
         /* At least make sure the two buffers are somewhat the same */
-        if (cpu_buffer_a->nr_pages != cpu_buffer_b->nr_pages)
+        if (buffer_a->pages != buffer_b->pages)
                 goto out;
 
         ret = -EAGAIN;
@@ -4075,6 +3688,9 @@ int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
         if (atomic_read(&buffer_b->record_disabled))
                 goto out;
 
+        cpu_buffer_a = buffer_a->buffers[cpu];
+        cpu_buffer_b = buffer_b->buffers[cpu];
+
         if (atomic_read(&cpu_buffer_a->record_disabled))
                 goto out;
 
@@ -4225,7 +3841,7 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
         if (!bpage)
                 goto out;
 
-        raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
+        spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
 
         reader = rb_get_reader_page(cpu_buffer);
         if (!reader)
@@ -4302,7 +3918,6 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
         } else {
                 /* update the entry counter */
                 cpu_buffer->read += rb_page_entries(reader);
-                cpu_buffer->read_bytes += BUF_PAGE_SIZE;
 
                 /* swap the pages */
                 rb_init_page(bpage);
@@ -4349,13 +3964,75 @@ int ring_buffer_read_page(struct ring_buffer *buffer,
                 memset(&bpage->data[commit], 0, BUF_PAGE_SIZE - commit);
 
  out_unlock:
-        raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
+        spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
 
  out:
         return ret;
 }
 EXPORT_SYMBOL_GPL(ring_buffer_read_page);
 
+#ifdef CONFIG_TRACING
+static ssize_t
+rb_simple_read(struct file *filp, char __user *ubuf,
+               size_t cnt, loff_t *ppos)
+{
+        unsigned long *p = filp->private_data;
+        char buf[64];
+        int r;
+
+        if (test_bit(RB_BUFFERS_DISABLED_BIT, p))
+                r = sprintf(buf, "permanently disabled\n");
+        else
+                r = sprintf(buf, "%d\n", test_bit(RB_BUFFERS_ON_BIT, 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)
+{
+        unsigned long *p = filp->private_data;
+        unsigned long val;
+        int ret;
+
+        ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
+        if (ret)
+                return ret;
+
+        if (val)
+                set_bit(RB_BUFFERS_ON_BIT, p);
+        else
+                clear_bit(RB_BUFFERS_ON_BIT, p);
+
+        (*ppos)++;
+
+        return cnt;
+}
+
+static const struct file_operations rb_simple_fops = {
+        .open           = tracing_open_generic,
+        .read           = rb_simple_read,
+        .write          = rb_simple_write,
+        .llseek         = default_llseek,
+};
+
+
+static __init int rb_init_debugfs(void)
+{
+        struct dentry *d_tracer;
+
+        d_tracer = tracing_init_dentry();
+
+        trace_create_file("tracing_on", 0644, d_tracer,
+                            &ring_buffer_flags, &rb_simple_fops);
+
+        return 0;
+}
+
+fs_initcall(rb_init_debugfs);
+#endif
+
 #ifdef CONFIG_HOTPLUG_CPU
 static int rb_cpu_notify(struct notifier_block *self,
                          unsigned long action, void *hcpu)
@@ -4363,8 +4040,6 @@ static int rb_cpu_notify(struct notifier_block *self,
         struct ring_buffer *buffer =
                 container_of(self, struct ring_buffer, cpu_notify);
         long cpu = (long)hcpu;
-        int cpu_i, nr_pages_same;
-        unsigned int nr_pages;
 
         switch (action) {
         case CPU_UP_PREPARE:
@@ -4372,23 +4047,8 @@ static int rb_cpu_notify(struct notifier_block *self,
                 if (cpumask_test_cpu(cpu, buffer->cpumask))
                         return NOTIFY_OK;
 
-                nr_pages = 0;
-                nr_pages_same = 1;
-                /* check if all cpu sizes are same */
-                for_each_buffer_cpu(buffer, cpu_i) {
-                        /* fill in the size from first enabled cpu */
-                        if (nr_pages == 0)
-                                nr_pages = buffer->buffers[cpu_i]->nr_pages;
-                        if (nr_pages != buffer->buffers[cpu_i]->nr_pages) {
-                                nr_pages_same = 0;
-                                break;
-                        }
-                }
-                /* allocate minimum pages, user can later expand it */
-                if (!nr_pages_same)
-                        nr_pages = 2;
                 buffer->buffers[cpu] =
-                        rb_allocate_cpu_buffer(buffer, nr_pages, cpu);
+                        rb_allocate_cpu_buffer(buffer, cpu);
                 if (!buffer->buffers[cpu]) {
                         WARN(1, "failed to allocate ring buffer on CPU %ld\n",
                              cpu);