14 files changed, 365 insertions, 286 deletions

diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index d6964244e567..d84c4a575514 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -8,6 +8,7 @@
 #include <linux/perf_event.h>
 
 struct trace_array;
+struct trace_buffer;
 struct tracer;
 struct dentry;
 
@@ -67,6 +68,7 @@ struct trace_entry {
 struct trace_iterator {
         struct trace_array      *tr;
         struct tracer           *trace;
+        struct trace_buffer     *trace_buffer;
         void                    *private;
         int                     cpu_file;
         struct mutex            mutex;
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 71259e2b6b61..90a55054744c 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -72,7 +72,7 @@ static void trace_note(struct blk_trace *bt, pid_t pid, int action,
         bool blk_tracer = blk_tracer_enabled;
 
         if (blk_tracer) {
-                buffer = blk_tr->buffer;
+                buffer = blk_tr->trace_buffer.buffer;
                 pc = preempt_count();
                 event = trace_buffer_lock_reserve(buffer, TRACE_BLK,
                                                   sizeof(*t) + len,
@@ -218,7 +218,7 @@ static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
         if (blk_tracer) {
                 tracing_record_cmdline(current);
 
-                buffer = blk_tr->buffer;
+                buffer = blk_tr->trace_buffer.buffer;
                 pc = preempt_count();
                 event = trace_buffer_lock_reserve(buffer, TRACE_BLK,
                                                   sizeof(*t) + pdu_len,
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index c8a852a55db4..a08c127db865 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -195,27 +195,15 @@ cycle_t ftrace_now(int cpu)
         u64 ts;
 
         /* Early boot up does not have a buffer yet */
-        if (!global_trace.buffer)
+        if (!global_trace.trace_buffer.buffer)
                 return trace_clock_local();
 
-        ts = ring_buffer_time_stamp(global_trace.buffer, cpu);
-        ring_buffer_normalize_time_stamp(global_trace.buffer, cpu, &ts);
+        ts = ring_buffer_time_stamp(global_trace.trace_buffer.buffer, cpu);
+        ring_buffer_normalize_time_stamp(global_trace.trace_buffer.buffer, cpu, &ts);
 
         return ts;
 }
 
-/*
- * The max_tr is used to snapshot the global_trace when a maximum
- * latency is reached. Some tracers will use this to store a maximum
- * trace while it continues examining live traces.
- *
- * The buffers for the max_tr are set up the same as the global_trace.
- * When a snapshot is taken, the link list of the max_tr is swapped
- * with the link list of the global_trace and the buffers are reset for
- * the global_trace so the tracing can continue.
- */
-static struct trace_array       max_tr;
-
 int tracing_is_enabled(void)
 {
         return tracing_is_on();
@@ -339,8 +327,8 @@ unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
  */
 void tracing_on(void)
 {
-        if (global_trace.buffer)
-                ring_buffer_record_on(global_trace.buffer);
+        if (global_trace.trace_buffer.buffer)
+                ring_buffer_record_on(global_trace.trace_buffer.buffer);
         /*
          * This flag is only looked at when buffers haven't been
          * allocated yet. We don't really care about the race
@@ -361,8 +349,8 @@ EXPORT_SYMBOL_GPL(tracing_on);
  */
 void tracing_off(void)
 {
-        if (global_trace.buffer)
-                ring_buffer_record_off(global_trace.buffer);
+        if (global_trace.trace_buffer.buffer)
+                ring_buffer_record_off(global_trace.trace_buffer.buffer);
         /*
          * This flag is only looked at when buffers haven't been
          * allocated yet. We don't really care about the race
@@ -378,8 +366,8 @@ EXPORT_SYMBOL_GPL(tracing_off);
  */
 int tracing_is_on(void)
 {
-        if (global_trace.buffer)
-                return ring_buffer_record_is_on(global_trace.buffer);
+        if (global_trace.trace_buffer.buffer)
+                return ring_buffer_record_is_on(global_trace.trace_buffer.buffer);
         return !global_trace.buffer_disabled;
 }
 EXPORT_SYMBOL_GPL(tracing_is_on);
@@ -637,13 +625,14 @@ unsigned long __read_mostly	tracing_max_latency;
 static void
 __update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
 {
-        struct trace_array_cpu *data = per_cpu_ptr(tr->data, cpu);
-        struct trace_array_cpu *max_data;
+        struct trace_buffer *trace_buf = &tr->trace_buffer;
+        struct trace_buffer *max_buf = &tr->max_buffer;
+        struct trace_array_cpu *data = per_cpu_ptr(trace_buf->data, cpu);
+        struct trace_array_cpu *max_data = per_cpu_ptr(max_buf->data, cpu);
 
-        max_tr.cpu = cpu;
-        max_tr.time_start = data->preempt_timestamp;
+        max_buf->cpu = cpu;
+        max_buf->time_start = data->preempt_timestamp;
 
-        max_data = per_cpu_ptr(max_tr.data, cpu);
         max_data->saved_latency = tracing_max_latency;
         max_data->critical_start = data->critical_start;
         max_data->critical_end = data->critical_end;
@@ -686,9 +675,9 @@ update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
 
         arch_spin_lock(&ftrace_max_lock);
 
-        buf = tr->buffer;
-        tr->buffer = max_tr.buffer;
-        max_tr.buffer = buf;
+        buf = tr->trace_buffer.buffer;
+        tr->trace_buffer.buffer = tr->max_buffer.buffer;
+        tr->max_buffer.buffer = buf;
 
         __update_max_tr(tr, tsk, cpu);
         arch_spin_unlock(&ftrace_max_lock);
@@ -716,7 +705,7 @@ update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
 
         arch_spin_lock(&ftrace_max_lock);
 
-        ret = ring_buffer_swap_cpu(max_tr.buffer, tr->buffer, cpu);
+        ret = ring_buffer_swap_cpu(tr->max_buffer.buffer, tr->trace_buffer.buffer, cpu);
 
         if (ret == -EBUSY) {
                 /*
@@ -725,7 +714,7 @@ update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
                  * the max trace buffer (no one writes directly to it)
                  * and flag that it failed.
                  */
-                trace_array_printk(&max_tr, _THIS_IP_,
+                trace_array_printk_buf(tr->max_buffer.buffer, _THIS_IP_,
                         "Failed to swap buffers due to commit in progress\n");
         }
 
@@ -742,7 +731,7 @@ static void default_wait_pipe(struct trace_iterator *iter)
         if (trace_buffer_iter(iter, iter->cpu_file))
                 return;
 
-        ring_buffer_wait(iter->tr->buffer, iter->cpu_file);
+        ring_buffer_wait(iter->trace_buffer->buffer, iter->cpu_file);
 }
 
 /**
@@ -803,17 +792,19 @@ int register_tracer(struct tracer *type)
                  * internal tracing to verify that everything is in order.
                  * If we fail, we do not register this tracer.
                  */
-                tracing_reset_online_cpus(tr);
+                tracing_reset_online_cpus(&tr->trace_buffer);
 
                 tr->current_trace = type;
 
+#ifdef CONFIG_TRACER_MAX_TRACE
                 if (type->use_max_tr) {
                         /* If we expanded the buffers, make sure the max is expanded too */
                         if (ring_buffer_expanded)
-                                ring_buffer_resize(max_tr.buffer, trace_buf_size,
+                                ring_buffer_resize(tr->max_buffer.buffer, trace_buf_size,
                                                    RING_BUFFER_ALL_CPUS);
                         type->allocated_snapshot = true;
                 }
+#endif
 
                 /* the test is responsible for initializing and enabling */
                 pr_info("Testing tracer %s: ", type->name);
@@ -827,16 +818,18 @@ int register_tracer(struct tracer *type)
                         goto out;
                 }
                 /* Only reset on passing, to avoid touching corrupted buffers */
-                tracing_reset_online_cpus(tr);
+                tracing_reset_online_cpus(&tr->trace_buffer);
 
+#ifdef CONFIG_TRACER_MAX_TRACE
                 if (type->use_max_tr) {
                         type->allocated_snapshot = false;
 
                         /* Shrink the max buffer again */
                         if (ring_buffer_expanded)
-                                ring_buffer_resize(max_tr.buffer, 1,
+                                ring_buffer_resize(tr->max_buffer.buffer, 1,
                                                    RING_BUFFER_ALL_CPUS);
                 }
+#endif
 
                 printk(KERN_CONT "PASSED\n");
         }
@@ -870,9 +863,9 @@ int register_tracer(struct tracer *type)
         return ret;
 }
 
-void tracing_reset(struct trace_array *tr, int cpu)
+void tracing_reset(struct trace_buffer *buf, int cpu)
 {
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = buf->buffer;
 
         if (!buffer)
                 return;
@@ -886,9 +879,9 @@ void tracing_reset(struct trace_array *tr, int cpu)
         ring_buffer_record_enable(buffer);
 }
 
-void tracing_reset_online_cpus(struct trace_array *tr)
+void tracing_reset_online_cpus(struct trace_buffer *buf)
 {
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = buf->buffer;
         int cpu;
 
         if (!buffer)
@@ -899,7 +892,7 @@ void tracing_reset_online_cpus(struct trace_array *tr)
         /* Make sure all commits have finished */
         synchronize_sched();
 
-        tr->time_start = ftrace_now(tr->cpu);
+        buf->time_start = ftrace_now(buf->cpu);
 
         for_each_online_cpu(cpu)
                 ring_buffer_reset_cpu(buffer, cpu);
@@ -909,7 +902,7 @@ void tracing_reset_online_cpus(struct trace_array *tr)
 
 void tracing_reset_current(int cpu)
 {
-        tracing_reset(&global_trace, cpu);
+        tracing_reset(&global_trace.trace_buffer, cpu);
 }
 
 void tracing_reset_all_online_cpus(void)
@@ -918,7 +911,10 @@ void tracing_reset_all_online_cpus(void)
 
         mutex_lock(&trace_types_lock);
         list_for_each_entry(tr, &ftrace_trace_arrays, list) {
-                tracing_reset_online_cpus(tr);
+                tracing_reset_online_cpus(&tr->trace_buffer);
+#ifdef CONFIG_TRACER_MAX_TRACE
+                tracing_reset_online_cpus(&tr->max_buffer);
+#endif
         }
         mutex_unlock(&trace_types_lock);
 }
@@ -988,13 +984,15 @@ void tracing_start(void)
         /* Prevent the buffers from switching */
         arch_spin_lock(&ftrace_max_lock);
 
-        buffer = global_trace.buffer;
+        buffer = global_trace.trace_buffer.buffer;
         if (buffer)
                 ring_buffer_record_enable(buffer);
 
-        buffer = max_tr.buffer;
+#ifdef CONFIG_TRACER_MAX_TRACE
+        buffer = global_trace.max_buffer.buffer;
         if (buffer)
                 ring_buffer_record_enable(buffer);
+#endif
 
         arch_spin_unlock(&ftrace_max_lock);
 
@@ -1026,7 +1024,7 @@ static void tracing_start_tr(struct trace_array *tr)
                 goto out;
         }
 
-        buffer = tr->buffer;
+        buffer = tr->trace_buffer.buffer;
         if (buffer)
                 ring_buffer_record_enable(buffer);
 
@@ -1053,13 +1051,15 @@ void tracing_stop(void)
         /* Prevent the buffers from switching */
         arch_spin_lock(&ftrace_max_lock);
 
-        buffer = global_trace.buffer;
+        buffer = global_trace.trace_buffer.buffer;
         if (buffer)
                 ring_buffer_record_disable(buffer);
 
-        buffer = max_tr.buffer;
+#ifdef CONFIG_TRACER_MAX_TRACE
+        buffer = global_trace.max_buffer.buffer;
         if (buffer)
                 ring_buffer_record_disable(buffer);
+#endif
 
         arch_spin_unlock(&ftrace_max_lock);
 
@@ -1080,7 +1080,7 @@ static void tracing_stop_tr(struct trace_array *tr)
         if (tr->stop_count++)
                 goto out;
 
-        buffer = tr->buffer;
+        buffer = tr->trace_buffer.buffer;
         if (buffer)
                 ring_buffer_record_disable(buffer);
 
@@ -1246,7 +1246,7 @@ trace_event_buffer_lock_reserve(struct ring_buffer **current_rb,
                           int type, unsigned long len,
                           unsigned long flags, int pc)
 {
-        *current_rb = ftrace_file->tr->buffer;
+        *current_rb = ftrace_file->tr->trace_buffer.buffer;
         return trace_buffer_lock_reserve(*current_rb,
                                          type, len, flags, pc);
 }
@@ -1257,7 +1257,7 @@ trace_current_buffer_lock_reserve(struct ring_buffer **current_rb,
                                   int type, unsigned long len,
                                   unsigned long flags, int pc)
 {
-        *current_rb = global_trace.buffer;
+        *current_rb = global_trace.trace_buffer.buffer;
         return trace_buffer_lock_reserve(*current_rb,
                                          type, len, flags, pc);
 }
@@ -1296,7 +1296,7 @@ trace_function(struct trace_array *tr,
                int pc)
 {
         struct ftrace_event_call *call = &event_function;
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
         struct ring_buffer_event *event;
         struct ftrace_entry *entry;
 
@@ -1437,7 +1437,7 @@ void ftrace_trace_stack(struct ring_buffer *buffer, unsigned long flags,
 void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
                    int pc)
 {
-        __ftrace_trace_stack(tr->buffer, flags, skip, pc, NULL);
+        __ftrace_trace_stack(tr->trace_buffer.buffer, flags, skip, pc, NULL);
 }
 
 /**
@@ -1453,7 +1453,8 @@ void trace_dump_stack(void)
         local_save_flags(flags);
 
         /* skipping 3 traces, seems to get us at the caller of this function */
-        __ftrace_trace_stack(global_trace.buffer, flags, 3, preempt_count(), NULL);
+        __ftrace_trace_stack(global_trace.trace_buffer.buffer, flags, 3,
+                             preempt_count(), NULL);
 }
 
 static DEFINE_PER_CPU(int, user_stack_count);
@@ -1623,7 +1624,7 @@ void trace_printk_init_buffers(void)
          * directly here. If the global_trace.buffer is already
          * allocated here, then this was called by module code.
          */
-        if (global_trace.buffer)
+        if (global_trace.trace_buffer.buffer)
                 tracing_start_cmdline_record();
 }
 
@@ -1683,7 +1684,7 @@ int trace_vbprintk(unsigned long ip, const char *fmt, va_list args)
 
         local_save_flags(flags);
         size = sizeof(*entry) + sizeof(u32) * len;
-        buffer = tr->buffer;
+        buffer = tr->trace_buffer.buffer;
         event = trace_buffer_lock_reserve(buffer, TRACE_BPRINT, size,
                                           flags, pc);
         if (!event)
@@ -1706,27 +1707,12 @@ out:
 }
 EXPORT_SYMBOL_GPL(trace_vbprintk);
 
-int trace_array_printk(struct trace_array *tr,
-                       unsigned long ip, const char *fmt, ...)
-{
-        int ret;
-        va_list ap;
-
-        if (!(trace_flags & TRACE_ITER_PRINTK))
-                return 0;
-
-        va_start(ap, fmt);
-        ret = trace_array_vprintk(tr, ip, fmt, ap);
-        va_end(ap);
-        return ret;
-}
-
-int trace_array_vprintk(struct trace_array *tr,
-                        unsigned long ip, const char *fmt, va_list args)
+static int
+__trace_array_vprintk(struct ring_buffer *buffer,
+                      unsigned long ip, const char *fmt, va_list args)
 {
         struct ftrace_event_call *call = &event_print;
         struct ring_buffer_event *event;
-        struct ring_buffer *buffer;
         int len = 0, size, pc;
         struct print_entry *entry;
         unsigned long flags;
@@ -1754,7 +1740,6 @@ int trace_array_vprintk(struct trace_array *tr,
 
         local_save_flags(flags);
         size = sizeof(*entry) + len + 1;
-        buffer = tr->buffer;
         event = trace_buffer_lock_reserve(buffer, TRACE_PRINT, size,
                                           flags, pc);
         if (!event)
@@ -1775,6 +1760,42 @@ int trace_array_vprintk(struct trace_array *tr,
         return len;
 }
 
+int trace_array_vprintk(struct trace_array *tr,
+                        unsigned long ip, const char *fmt, va_list args)
+{
+        return __trace_array_vprintk(tr->trace_buffer.buffer, ip, fmt, args);
+}
+
+int trace_array_printk(struct trace_array *tr,
+                       unsigned long ip, const char *fmt, ...)
+{
+        int ret;
+        va_list ap;
+
+        if (!(trace_flags & TRACE_ITER_PRINTK))
+                return 0;
+
+        va_start(ap, fmt);
+        ret = trace_array_vprintk(tr, ip, fmt, ap);
+        va_end(ap);
+        return ret;
+}
+
+int trace_array_printk_buf(struct ring_buffer *buffer,
+                           unsigned long ip, const char *fmt, ...)
+{
+        int ret;
+        va_list ap;
+
+        if (!(trace_flags & TRACE_ITER_PRINTK))
+                return 0;
+
+        va_start(ap, fmt);
+        ret = __trace_array_vprintk(buffer, ip, fmt, ap);
+        va_end(ap);
+        return ret;
+}
+
 int trace_vprintk(unsigned long ip, const char *fmt, va_list args)
 {
         return trace_array_vprintk(&global_trace, ip, fmt, args);
@@ -1800,7 +1821,7 @@ peek_next_entry(struct trace_iterator *iter, int cpu, u64 *ts,
         if (buf_iter)
                 event = ring_buffer_iter_peek(buf_iter, ts);
         else
-                event = ring_buffer_peek(iter->tr->buffer, cpu, ts,
+                event = ring_buffer_peek(iter->trace_buffer->buffer, cpu, ts,
                                          lost_events);
 
         if (event) {
@@ -1815,7 +1836,7 @@ static struct trace_entry *
 __find_next_entry(struct trace_iterator *iter, int *ent_cpu,
                   unsigned long *missing_events, u64 *ent_ts)
 {
-        struct ring_buffer *buffer = iter->tr->buffer;
+        struct ring_buffer *buffer = iter->trace_buffer->buffer;
         struct trace_entry *ent, *next = NULL;
         unsigned long lost_events = 0, next_lost = 0;
         int cpu_file = iter->cpu_file;
@@ -1892,7 +1913,7 @@ void *trace_find_next_entry_inc(struct trace_iterator *iter)
 
 static void trace_consume(struct trace_iterator *iter)
 {
-        ring_buffer_consume(iter->tr->buffer, iter->cpu, &iter->ts,
+        ring_buffer_consume(iter->trace_buffer->buffer, iter->cpu, &iter->ts,
                             &iter->lost_events);
 }
 
@@ -1925,13 +1946,12 @@ static void *s_next(struct seq_file *m, void *v, loff_t *pos)
 
 void tracing_iter_reset(struct trace_iterator *iter, int cpu)
 {
-        struct trace_array *tr = iter->tr;
         struct ring_buffer_event *event;
         struct ring_buffer_iter *buf_iter;
         unsigned long entries = 0;
         u64 ts;
 
-        per_cpu_ptr(tr->data, cpu)->skipped_entries = 0;
+        per_cpu_ptr(iter->trace_buffer->data, cpu)->skipped_entries = 0;
 
         buf_iter = trace_buffer_iter(iter, cpu);
         if (!buf_iter)
@@ -1945,13 +1965,13 @@ void tracing_iter_reset(struct trace_iterator *iter, int cpu)
          * by the timestamp being before the start of the buffer.
          */
         while ((event = ring_buffer_iter_peek(buf_iter, &ts))) {
-                if (ts >= iter->tr->time_start)
+                if (ts >= iter->trace_buffer->time_start)
                         break;
                 entries++;
                 ring_buffer_read(buf_iter, NULL);
         }
 
-        per_cpu_ptr(tr->data, cpu)->skipped_entries = entries;
+        per_cpu_ptr(iter->trace_buffer->data, cpu)->skipped_entries = entries;
 }
 
 /*
@@ -1978,8 +1998,10 @@ static void *s_start(struct seq_file *m, loff_t *pos)
                 *iter->trace = *tr->current_trace;
         mutex_unlock(&trace_types_lock);
 
+#ifdef CONFIG_TRACER_MAX_TRACE
         if (iter->snapshot && iter->trace->use_max_tr)
                 return ERR_PTR(-EBUSY);
+#endif
 
         if (!iter->snapshot)
                 atomic_inc(&trace_record_cmdline_disabled);
@@ -2021,17 +2043,21 @@ static void s_stop(struct seq_file *m, void *p)
 {
         struct trace_iterator *iter = m->private;
 
+#ifdef CONFIG_TRACER_MAX_TRACE
         if (iter->snapshot && iter->trace->use_max_tr)
                 return;
+#endif
 
         if (!iter->snapshot)
                 atomic_dec(&trace_record_cmdline_disabled);
+
         trace_access_unlock(iter->cpu_file);
         trace_event_read_unlock();
 }
 
 static void
-get_total_entries(struct trace_array *tr, unsigned long *total, unsigned long *entries)
+get_total_entries(struct trace_buffer *buf,
+                  unsigned long *total, unsigned long *entries)
 {
         unsigned long count;
         int cpu;
@@ -2040,19 +2066,19 @@ get_total_entries(struct trace_array *tr, unsigned long *total, unsigned long *e
         *entries = 0;
 
         for_each_tracing_cpu(cpu) {
-                count = ring_buffer_entries_cpu(tr->buffer, cpu);
+                count = ring_buffer_entries_cpu(buf->buffer, cpu);
                 /*
                  * If this buffer has skipped entries, then we hold all
                  * entries for the trace and we need to ignore the
                  * ones before the time stamp.
                  */
-                if (per_cpu_ptr(tr->data, cpu)->skipped_entries) {
-                        count -= per_cpu_ptr(tr->data, cpu)->skipped_entries;
+                if (per_cpu_ptr(buf->data, cpu)->skipped_entries) {
+                        count -= per_cpu_ptr(buf->data, cpu)->skipped_entries;
                         /* total is the same as the entries */
                         *total += count;
                 } else
                         *total += count +
-                                ring_buffer_overrun_cpu(tr->buffer, cpu);
+                                ring_buffer_overrun_cpu(buf->buffer, cpu);
                 *entries += count;
         }
 }
@@ -2069,27 +2095,27 @@ static void print_lat_help_header(struct seq_file *m)
         seq_puts(m, "#     \\   /      |||||  \\    |   /           \n");
 }
 
-static void print_event_info(struct trace_array *tr, struct seq_file *m)
+static void print_event_info(struct trace_buffer *buf, struct seq_file *m)
 {
         unsigned long total;
         unsigned long entries;
 
-        get_total_entries(tr, &total, &entries);
+        get_total_entries(buf, &total, &entries);
         seq_printf(m, "# entries-in-buffer/entries-written: %lu/%lu   #P:%d\n",
                    entries, total, num_online_cpus());
         seq_puts(m, "#\n");
 }
 
-static void print_func_help_header(struct trace_array *tr, struct seq_file *m)
+static void print_func_help_header(struct trace_buffer *buf, struct seq_file *m)
 {
-        print_event_info(tr, m);
+        print_event_info(buf, m);
         seq_puts(m, "#           TASK-PID   CPU#      TIMESTAMP  FUNCTION\n");
         seq_puts(m, "#              | |       |          |         |\n");
 }
 
-static void print_func_help_header_irq(struct trace_array *tr, struct seq_file *m)
+static void print_func_help_header_irq(struct trace_buffer *buf, struct seq_file *m)
 {
-        print_event_info(tr, m);
+        print_event_info(buf, m);
         seq_puts(m, "#                              _-----=> irqs-off\n");
         seq_puts(m, "#                             / _----=> need-resched\n");
         seq_puts(m, "#                            | / _---=> hardirq/softirq\n");
@@ -2103,8 +2129,8 @@ void
 print_trace_header(struct seq_file *m, struct trace_iterator *iter)
 {
         unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
-        struct trace_array *tr = iter->tr;
-        struct trace_array_cpu *data = per_cpu_ptr(tr->data, tr->cpu);
+        struct trace_buffer *buf = iter->trace_buffer;
+        struct trace_array_cpu *data = per_cpu_ptr(buf->data, buf->cpu);
         struct tracer *type = iter->trace;
         unsigned long entries;
         unsigned long total;
@@ -2112,7 +2138,7 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)
 
         name = type->name;
 
-        get_total_entries(tr, &total, &entries);
+        get_total_entries(buf, &total, &entries);
 
         seq_printf(m, "# %s latency trace v1.1.5 on %s\n",
                    name, UTS_RELEASE);
@@ -2123,7 +2149,7 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)
                    nsecs_to_usecs(data->saved_latency),
                    entries,
                    total,
-                   tr->cpu,
+                   buf->cpu,
 #if defined(CONFIG_PREEMPT_NONE)
                    "server",
 #elif defined(CONFIG_PREEMPT_VOLUNTARY)
@@ -2174,7 +2200,7 @@ static void test_cpu_buff_start(struct trace_iterator *iter)
         if (cpumask_test_cpu(iter->cpu, iter->started))
                 return;
 
-        if (per_cpu_ptr(iter->tr->data, iter->cpu)->skipped_entries)
+        if (per_cpu_ptr(iter->trace_buffer->data, iter->cpu)->skipped_entries)
                 return;
 
         cpumask_set_cpu(iter->cpu, iter->started);
@@ -2304,7 +2330,7 @@ int trace_empty(struct trace_iterator *iter)
                         if (!ring_buffer_iter_empty(buf_iter))
                                 return 0;
                 } else {
-                        if (!ring_buffer_empty_cpu(iter->tr->buffer, cpu))
+                        if (!ring_buffer_empty_cpu(iter->trace_buffer->buffer, cpu))
                                 return 0;
                 }
                 return 1;
@@ -2316,7 +2342,7 @@ int trace_empty(struct trace_iterator *iter)
                         if (!ring_buffer_iter_empty(buf_iter))
                                 return 0;
                 } else {
-                        if (!ring_buffer_empty_cpu(iter->tr->buffer, cpu))
+                        if (!ring_buffer_empty_cpu(iter->trace_buffer->buffer, cpu))
                                 return 0;
                 }
         }
@@ -2394,9 +2420,9 @@ void trace_default_header(struct seq_file *m)
         } else {
                 if (!(trace_flags & TRACE_ITER_VERBOSE)) {
                         if (trace_flags & TRACE_ITER_IRQ_INFO)
-                                print_func_help_header_irq(iter->tr, m);
+                                print_func_help_header_irq(iter->trace_buffer, m);
                         else
-                                print_func_help_header(iter->tr, m);
+                                print_func_help_header(iter->trace_buffer, m);
                 }
         }
 }
@@ -2515,11 +2541,15 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot)
         if (!zalloc_cpumask_var(&iter->started, GFP_KERNEL))
                 goto fail;
 
+        iter->tr = tr;
+
+#ifdef CONFIG_TRACER_MAX_TRACE
         /* Currently only the top directory has a snapshot */
         if (tr->current_trace->print_max || snapshot)
-                iter->tr = &max_tr;
+                iter->trace_buffer = &tr->max_buffer;
         else
-                iter->tr = tr;
+#endif
+                iter->trace_buffer = &tr->trace_buffer;
         iter->snapshot = snapshot;
         iter->pos = -1;
         mutex_init(&iter->mutex);
@@ -2530,7 +2560,7 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot)
                 iter->trace->open(iter);
 
         /* Annotate start of buffers if we had overruns */
-        if (ring_buffer_overruns(iter->tr->buffer))
+        if (ring_buffer_overruns(iter->trace_buffer->buffer))
                 iter->iter_flags |= TRACE_FILE_ANNOTATE;
 
         /* Output in nanoseconds only if we are using a clock in nanoseconds. */
@@ -2544,7 +2574,7 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot)
         if (iter->cpu_file == RING_BUFFER_ALL_CPUS) {
                 for_each_tracing_cpu(cpu) {
                         iter->buffer_iter[cpu] =
-                                ring_buffer_read_prepare(iter->tr->buffer, cpu);
+                                ring_buffer_read_prepare(iter->trace_buffer->buffer, cpu);
                 }
                 ring_buffer_read_prepare_sync();
                 for_each_tracing_cpu(cpu) {
@@ -2554,7 +2584,7 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot)
         } else {
                 cpu = iter->cpu_file;
                 iter->buffer_iter[cpu] =
-                        ring_buffer_read_prepare(iter->tr->buffer, cpu);
+                        ring_buffer_read_prepare(iter->trace_buffer->buffer, cpu);
                 ring_buffer_read_prepare_sync();
                 ring_buffer_read_start(iter->buffer_iter[cpu]);
                 tracing_iter_reset(iter, cpu);
@@ -2593,12 +2623,7 @@ static int tracing_release(struct inode *inode, struct file *file)
                 return 0;
 
         iter = m->private;
-
-        /* Only the global tracer has a matching max_tr */
-        if (iter->tr == &max_tr)
-                tr = &global_trace;
-        else
-                tr = iter->tr;
+        tr = iter->tr;
 
         mutex_lock(&trace_types_lock);
         for_each_tracing_cpu(cpu) {
@@ -2634,9 +2659,9 @@ static int tracing_open(struct inode *inode, struct file *file)
                 struct trace_array *tr = tc->tr;
 
                 if (tc->cpu == RING_BUFFER_ALL_CPUS)
-                        tracing_reset_online_cpus(tr);
+                        tracing_reset_online_cpus(&tr->trace_buffer);
                 else
-                        tracing_reset(tr, tc->cpu);
+                        tracing_reset(&tr->trace_buffer, tc->cpu);
         }
 
         if (file->f_mode & FMODE_READ) {
@@ -2805,13 +2830,13 @@ tracing_cpumask_write(struct file *filp, const char __user *ubuf,
                  */
                 if (cpumask_test_cpu(cpu, tracing_cpumask) &&
                                 !cpumask_test_cpu(cpu, tracing_cpumask_new)) {
-                        atomic_inc(&per_cpu_ptr(tr->data, cpu)->disabled);
-                        ring_buffer_record_disable_cpu(tr->buffer, cpu);
+                        atomic_inc(&per_cpu_ptr(tr->trace_buffer.data, cpu)->disabled);
+                        ring_buffer_record_disable_cpu(tr->trace_buffer.buffer, cpu);
                 }
                 if (!cpumask_test_cpu(cpu, tracing_cpumask) &&
                                 cpumask_test_cpu(cpu, tracing_cpumask_new)) {
-                        atomic_dec(&per_cpu_ptr(tr->data, cpu)->disabled);
-                        ring_buffer_record_enable_cpu(tr->buffer, cpu);
+                        atomic_dec(&per_cpu_ptr(tr->trace_buffer.data, cpu)->disabled);
+                        ring_buffer_record_enable_cpu(tr->trace_buffer.buffer, cpu);
                 }
         }
         arch_spin_unlock(&ftrace_max_lock);
@@ -2930,9 +2955,9 @@ int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled)
                 trace_event_enable_cmd_record(enabled);
 
         if (mask == TRACE_ITER_OVERWRITE) {
-                ring_buffer_change_overwrite(global_trace.buffer, enabled);
+                ring_buffer_change_overwrite(tr->trace_buffer.buffer, enabled);
 #ifdef CONFIG_TRACER_MAX_TRACE
-                ring_buffer_change_overwrite(max_tr.buffer, enabled);
+                ring_buffer_change_overwrite(tr->max_buffer.buffer, enabled);
 #endif
         }
 
@@ -3116,42 +3141,44 @@ tracing_set_trace_read(struct file *filp, char __user *ubuf,
 
 int tracer_init(struct tracer *t, struct trace_array *tr)
 {
-        tracing_reset_online_cpus(tr);
+        tracing_reset_online_cpus(&tr->trace_buffer);
         return t->init(tr);
 }
 
-static void set_buffer_entries(struct trace_array *tr, unsigned long val)
+static void set_buffer_entries(struct trace_buffer *buf, unsigned long val)
 {
         int cpu;
         for_each_tracing_cpu(cpu)
-                per_cpu_ptr(tr->data, cpu)->entries = val;
+                per_cpu_ptr(buf->data, cpu)->entries = val;
 }
 
+#ifdef CONFIG_TRACER_MAX_TRACE
 /* resize @tr's buffer to the size of @size_tr's entries */
-static int resize_buffer_duplicate_size(struct trace_array *tr,
-                                        struct trace_array *size_tr, int cpu_id)
+static int resize_buffer_duplicate_size(struct trace_buffer *trace_buf,
+                                        struct trace_buffer *size_buf, int cpu_id)
 {
         int cpu, ret = 0;
 
         if (cpu_id == RING_BUFFER_ALL_CPUS) {
                 for_each_tracing_cpu(cpu) {
-                        ret = ring_buffer_resize(tr->buffer,
-                                 per_cpu_ptr(size_tr->data, cpu)->entries, cpu);
+                        ret = ring_buffer_resize(trace_buf->buffer,
+                                 per_cpu_ptr(size_buf->data, cpu)->entries, cpu);
                         if (ret < 0)
                                 break;
-                        per_cpu_ptr(tr->data, cpu)->entries =
-                                per_cpu_ptr(size_tr->data, cpu)->entries;
+                        per_cpu_ptr(trace_buf->data, cpu)->entries =
+                                per_cpu_ptr(size_buf->data, cpu)->entries;
                 }
         } else {
-                ret = ring_buffer_resize(tr->buffer,
-                                 per_cpu_ptr(size_tr->data, cpu_id)->entries, cpu_id);
+                ret = ring_buffer_resize(trace_buf->buffer,
+                                 per_cpu_ptr(size_buf->data, cpu_id)->entries, cpu_id);
                 if (ret == 0)
-                        per_cpu_ptr(tr->data, cpu_id)->entries =
-                                per_cpu_ptr(size_tr->data, cpu_id)->entries;
+                        per_cpu_ptr(trace_buf->data, cpu_id)->entries =
+                                per_cpu_ptr(size_buf->data, cpu_id)->entries;
         }
 
         return ret;
 }
+#endif /* CONFIG_TRACER_MAX_TRACE */
 
 static int __tracing_resize_ring_buffer(struct trace_array *tr,
                                         unsigned long size, int cpu)
@@ -3166,20 +3193,22 @@ static int __tracing_resize_ring_buffer(struct trace_array *tr,
         ring_buffer_expanded = 1;
 
         /* May be called before buffers are initialized */
-        if (!tr->buffer)
+        if (!tr->trace_buffer.buffer)
                 return 0;
 
-        ret = ring_buffer_resize(tr->buffer, size, cpu);
+        ret = ring_buffer_resize(tr->trace_buffer.buffer, size, cpu);
         if (ret < 0)
                 return ret;
 
+#ifdef CONFIG_TRACER_MAX_TRACE
         if (!(tr->flags & TRACE_ARRAY_FL_GLOBAL) ||
             !tr->current_trace->use_max_tr)
                 goto out;
 
-        ret = ring_buffer_resize(max_tr.buffer, size, cpu);
+        ret = ring_buffer_resize(tr->max_buffer.buffer, size, cpu);
         if (ret < 0) {
-                int r = resize_buffer_duplicate_size(tr, tr, cpu);
+                int r = resize_buffer_duplicate_size(&tr->trace_buffer,
+                                                     &tr->trace_buffer, cpu);
                 if (r < 0) {
                         /*
                          * AARGH! We are left with different
@@ -3202,15 +3231,17 @@ static int __tracing_resize_ring_buffer(struct trace_array *tr,
         }
 
         if (cpu == RING_BUFFER_ALL_CPUS)
-                set_buffer_entries(&max_tr, size);
+                set_buffer_entries(&tr->max_buffer, size);
         else
-                per_cpu_ptr(max_tr.data, cpu)->entries = size;
+                per_cpu_ptr(tr->max_buffer.data, cpu)->entries = size;
 
  out:
+#endif /* CONFIG_TRACER_MAX_TRACE */
+
         if (cpu == RING_BUFFER_ALL_CPUS)
-                set_buffer_entries(tr, size);
+                set_buffer_entries(&tr->trace_buffer, size);
         else
-                per_cpu_ptr(tr->data, cpu)->entries = size;
+                per_cpu_ptr(tr->trace_buffer.data, cpu)->entries = size;
 
         return ret;
 }
@@ -3277,7 +3308,9 @@ static int tracing_set_tracer(const char *buf)
         static struct trace_option_dentry *topts;
         struct trace_array *tr = &global_trace;
         struct tracer *t;
+#ifdef CONFIG_TRACER_MAX_TRACE
         bool had_max_tr;
+#endif
         int ret = 0;
 
         mutex_lock(&trace_types_lock);
@@ -3308,7 +3341,10 @@ static int tracing_set_tracer(const char *buf)
         if (tr->current_trace->reset)
                 tr->current_trace->reset(tr);
 
+#ifdef CONFIG_TRACER_MAX_TRACE
         had_max_tr = tr->current_trace->allocated_snapshot;
+
+        /* Current trace needs to be nop_trace before synchronize_sched */
         tr->current_trace = &nop_trace;
 
         if (had_max_tr && !t->use_max_tr) {
@@ -3325,22 +3361,28 @@ static int tracing_set_tracer(const char *buf)
                  * The max_tr ring buffer has some state (e.g. ring->clock) and
                  * we want preserve it.
                  */
-                ring_buffer_resize(max_tr.buffer, 1, RING_BUFFER_ALL_CPUS);
-                set_buffer_entries(&max_tr, 1);
-                tracing_reset_online_cpus(&max_tr);
+                ring_buffer_resize(tr->max_buffer.buffer, 1, RING_BUFFER_ALL_CPUS);
+                set_buffer_entries(&tr->max_buffer, 1);
+                tracing_reset_online_cpus(&tr->max_buffer);
                 tr->current_trace->allocated_snapshot = false;
         }
+#else
+        tr->current_trace = &nop_trace;
+#endif
         destroy_trace_option_files(topts);
 
         topts = create_trace_option_files(tr, t);
+
+#ifdef CONFIG_TRACER_MAX_TRACE
         if (t->use_max_tr && !had_max_tr) {
                 /* we need to make per cpu buffer sizes equivalent */
-                ret = resize_buffer_duplicate_size(&max_tr, &global_trace,
+                ret = resize_buffer_duplicate_size(&tr->max_buffer, &tr->trace_buffer,
                                                    RING_BUFFER_ALL_CPUS);
                 if (ret < 0)
                         goto out;
                 t->allocated_snapshot = true;
         }
+#endif
 
         if (t->init) {
                 ret = tracer_init(t, tr);
@@ -3468,6 +3510,7 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
 
         iter->cpu_file = tc->cpu;
         iter->tr = tc->tr;
+        iter->trace_buffer = &tc->tr->trace_buffer;
         mutex_init(&iter->mutex);
         filp->private_data = iter;
 
@@ -3518,7 +3561,7 @@ trace_poll(struct trace_iterator *iter, struct file *filp, poll_table *poll_tabl
                  */
                 return POLLIN | POLLRDNORM;
         else
-                return ring_buffer_poll_wait(iter->tr->buffer, iter->cpu_file,
+                return ring_buffer_poll_wait(iter->trace_buffer->buffer, iter->cpu_file,
                                              filp, poll_table);
 }
 
@@ -3857,8 +3900,8 @@ tracing_entries_read(struct file *filp, char __user *ubuf,
                 for_each_tracing_cpu(cpu) {
                         /* fill in the size from first enabled cpu */
                         if (size == 0)
-                                size = per_cpu_ptr(tr->data, cpu)->entries;
-                        if (size != per_cpu_ptr(tr->data, cpu)->entries) {
+                                size = per_cpu_ptr(tr->trace_buffer.data, cpu)->entries;
+                        if (size != per_cpu_ptr(tr->trace_buffer.data, cpu)->entries) {
                                 buf_size_same = 0;
                                 break;
                         }
@@ -3874,7 +3917,7 @@ tracing_entries_read(struct file *filp, char __user *ubuf,
                 } else
                         r = sprintf(buf, "X\n");
         } else
-                r = sprintf(buf, "%lu\n", per_cpu_ptr(tr->data, tc->cpu)->entries >> 10);
+                r = sprintf(buf, "%lu\n", per_cpu_ptr(tr->trace_buffer.data, tc->cpu)->entries >> 10);
 
         mutex_unlock(&trace_types_lock);
 
@@ -3921,7 +3964,7 @@ tracing_total_entries_read(struct file *filp, char __user *ubuf,
 
         mutex_lock(&trace_types_lock);
         for_each_tracing_cpu(cpu) {
-                size += per_cpu_ptr(tr->data, cpu)->entries >> 10;
+                size += per_cpu_ptr(tr->trace_buffer.data, cpu)->entries >> 10;
                 if (!ring_buffer_expanded)
                         expanded_size += trace_buf_size >> 10;
         }
@@ -4026,7 +4069,7 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
 
         local_save_flags(irq_flags);
         size = sizeof(*entry) + cnt + 2; /* possible \n added */
-        buffer = global_trace.buffer;
+        buffer = global_trace.trace_buffer.buffer;
         event = trace_buffer_lock_reserve(buffer, TRACE_PRINT, size,
                                           irq_flags, preempt_count());
         if (!event) {
@@ -4111,16 +4154,19 @@ static ssize_t tracing_clock_write(struct file *filp, const char __user *ubuf,
 
         tr->clock_id = i;
 
-        ring_buffer_set_clock(tr->buffer, trace_clocks[i].func);
-        if (tr->flags & TRACE_ARRAY_FL_GLOBAL && max_tr.buffer)
-                ring_buffer_set_clock(max_tr.buffer, trace_clocks[i].func);
+        ring_buffer_set_clock(tr->trace_buffer.buffer, trace_clocks[i].func);
 
         /*
          * New clock may not be consistent with the previous clock.
          * Reset the buffer so that it doesn't have incomparable timestamps.
          */
-        tracing_reset_online_cpus(&global_trace);
-        tracing_reset_online_cpus(&max_tr);
+        tracing_reset_online_cpus(&global_trace.trace_buffer);
+
+#ifdef CONFIG_TRACER_MAX_TRACE
+        if (tr->flags & TRACE_ARRAY_FL_GLOBAL && tr->max_buffer.buffer)
+                ring_buffer_set_clock(tr->max_buffer.buffer, trace_clocks[i].func);
+        tracing_reset_online_cpus(&global_trace.max_buffer);
+#endif
 
         mutex_unlock(&trace_types_lock);
 
@@ -4160,6 +4206,7 @@ static int tracing_snapshot_open(struct inode *inode, struct file *file)
                         return -ENOMEM;
                 }
                 iter->tr = tc->tr;
+                iter->trace_buffer = &tc->tr->max_buffer;
                 m->private = iter;
                 file->private_data = m;
         }
@@ -4196,18 +4243,18 @@ tracing_snapshot_write(struct file *filp, const char __user *ubuf, size_t cnt,
         case 0:
                 if (tr->current_trace->allocated_snapshot) {
                         /* free spare buffer */
-                        ring_buffer_resize(max_tr.buffer, 1,
+                        ring_buffer_resize(tr->max_buffer.buffer, 1,
                                            RING_BUFFER_ALL_CPUS);
-                        set_buffer_entries(&max_tr, 1);
-                        tracing_reset_online_cpus(&max_tr);
+                        set_buffer_entries(&tr->max_buffer, 1);
+                        tracing_reset_online_cpus(&tr->max_buffer);
                         tr->current_trace->allocated_snapshot = false;
                 }
                 break;
         case 1:
                 if (!tr->current_trace->allocated_snapshot) {
                         /* allocate spare buffer */
-                        ret = resize_buffer_duplicate_size(&max_tr,
-                                        &global_trace, RING_BUFFER_ALL_CPUS);
+                        ret = resize_buffer_duplicate_size(&tr->max_buffer,
+                                        &tr->trace_buffer, RING_BUFFER_ALL_CPUS);
                         if (ret < 0)
                                 break;
                         tr->current_trace->allocated_snapshot = true;
@@ -4220,7 +4267,7 @@ tracing_snapshot_write(struct file *filp, const char __user *ubuf, size_t cnt,
                 break;
         default:
                 if (tr->current_trace->allocated_snapshot)
-                        tracing_reset_online_cpus(&max_tr);
+                        tracing_reset_online_cpus(&tr->max_buffer);
                 break;
         }
 
@@ -4338,6 +4385,7 @@ static int tracing_buffers_open(struct inode *inode, struct file *filp)
         info->iter.tr           = tr;
         info->iter.cpu_file     = tc->cpu;
         info->iter.trace        = tr->current_trace;
+        info->iter.trace_buffer = &tr->trace_buffer;
         info->spare             = NULL;
         /* Force reading ring buffer for first read */
         info->read              = (unsigned int)-1;
@@ -4369,7 +4417,8 @@ tracing_buffers_read(struct file *filp, char __user *ubuf,
                 return 0;
 
         if (!info->spare)
-                info->spare = ring_buffer_alloc_read_page(iter->tr->buffer, iter->cpu_file);
+                info->spare = ring_buffer_alloc_read_page(iter->trace_buffer->buffer,
+                                                          iter->cpu_file);
         if (!info->spare)
                 return -ENOMEM;
 
@@ -4379,7 +4428,7 @@ tracing_buffers_read(struct file *filp, char __user *ubuf,
 
  again:
         trace_access_lock(iter->cpu_file);
-        ret = ring_buffer_read_page(iter->tr->buffer,
+        ret = ring_buffer_read_page(iter->trace_buffer->buffer,
                                     &info->spare,
                                     count,
                                     iter->cpu_file, 0);
@@ -4421,7 +4470,7 @@ static int tracing_buffers_release(struct inode *inode, struct file *file)
         struct trace_iterator *iter = &info->iter;
 
         if (info->spare)
-                ring_buffer_free_read_page(iter->tr->buffer, info->spare);
+                ring_buffer_free_read_page(iter->trace_buffer->buffer, info->spare);
         kfree(info);
 
         return 0;
@@ -4521,7 +4570,7 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
 
  again:
         trace_access_lock(iter->cpu_file);
-        entries = ring_buffer_entries_cpu(iter->tr->buffer, iter->cpu_file);
+        entries = ring_buffer_entries_cpu(iter->trace_buffer->buffer, iter->cpu_file);
 
         for (i = 0; i < pipe->buffers && len && entries; i++, len -= PAGE_SIZE) {
                 struct page *page;
@@ -4532,7 +4581,7 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
                         break;
 
                 ref->ref = 1;
-                ref->buffer = iter->tr->buffer;
+                ref->buffer = iter->trace_buffer->buffer;
                 ref->page = ring_buffer_alloc_read_page(ref->buffer, iter->cpu_file);
                 if (!ref->page) {
                         kfree(ref);
@@ -4564,7 +4613,7 @@ tracing_buffers_splice_read(struct file *file, loff_t *ppos,
                 spd.nr_pages++;
                 *ppos += PAGE_SIZE;
 
-                entries = ring_buffer_entries_cpu(iter->tr->buffer, iter->cpu_file);
+                entries = ring_buffer_entries_cpu(iter->trace_buffer->buffer, iter->cpu_file);
         }
 
         trace_access_unlock(iter->cpu_file);
@@ -4605,6 +4654,7 @@ tracing_stats_read(struct file *filp, char __user *ubuf,
 {
         struct trace_cpu *tc = filp->private_data;
         struct trace_array *tr = tc->tr;
+        struct trace_buffer *trace_buf = &tr->trace_buffer;
         struct trace_seq *s;
         unsigned long cnt;
         unsigned long long t;
@@ -4617,41 +4667,41 @@ tracing_stats_read(struct file *filp, char __user *ubuf,
 
         trace_seq_init(s);
 
-        cnt = ring_buffer_entries_cpu(tr->buffer, cpu);
+        cnt = ring_buffer_entries_cpu(trace_buf->buffer, cpu);
         trace_seq_printf(s, "entries: %ld\n", cnt);
 
-        cnt = ring_buffer_overrun_cpu(tr->buffer, cpu);
+        cnt = ring_buffer_overrun_cpu(trace_buf->buffer, cpu);
         trace_seq_printf(s, "overrun: %ld\n", cnt);
 
-        cnt = ring_buffer_commit_overrun_cpu(tr->buffer, cpu);
+        cnt = ring_buffer_commit_overrun_cpu(trace_buf->buffer, cpu);
         trace_seq_printf(s, "commit overrun: %ld\n", cnt);
 
-        cnt = ring_buffer_bytes_cpu(tr->buffer, cpu);
+        cnt = ring_buffer_bytes_cpu(trace_buf->buffer, cpu);
         trace_seq_printf(s, "bytes: %ld\n", cnt);
 
         if (trace_clocks[trace_clock_id].in_ns) {
                 /* local or global for trace_clock */
-                t = ns2usecs(ring_buffer_oldest_event_ts(tr->buffer, cpu));
+                t = ns2usecs(ring_buffer_oldest_event_ts(trace_buf->buffer, cpu));
                 usec_rem = do_div(t, USEC_PER_SEC);
                 trace_seq_printf(s, "oldest event ts: %5llu.%06lu\n",
                                                                 t, usec_rem);
 
-                t = ns2usecs(ring_buffer_time_stamp(tr->buffer, cpu));
+                t = ns2usecs(ring_buffer_time_stamp(trace_buf->buffer, cpu));
                 usec_rem = do_div(t, USEC_PER_SEC);
                 trace_seq_printf(s, "now ts: %5llu.%06lu\n", t, usec_rem);
         } else {
                 /* counter or tsc mode for trace_clock */
                 trace_seq_printf(s, "oldest event ts: %llu\n",
-                                ring_buffer_oldest_event_ts(tr->buffer, cpu));
+                                ring_buffer_oldest_event_ts(trace_buf->buffer, cpu));
 
                 trace_seq_printf(s, "now ts: %llu\n",
-                                ring_buffer_time_stamp(tr->buffer, cpu));
+                                ring_buffer_time_stamp(trace_buf->buffer, cpu));
         }
 
-        cnt = ring_buffer_dropped_events_cpu(tr->buffer, cpu);
+        cnt = ring_buffer_dropped_events_cpu(trace_buf->buffer, cpu);
         trace_seq_printf(s, "dropped events: %ld\n", cnt);
 
-        cnt = ring_buffer_read_events_cpu(tr->buffer, cpu);
+        cnt = ring_buffer_read_events_cpu(trace_buf->buffer, cpu);
         trace_seq_printf(s, "read events: %ld\n", cnt);
 
         count = simple_read_from_buffer(ubuf, count, ppos, s->buffer, s->len);
@@ -4754,7 +4804,7 @@ static struct dentry *tracing_dentry_percpu(struct trace_array *tr, int cpu)
 static void
 tracing_init_debugfs_percpu(struct trace_array *tr, long cpu)
 {
-        struct trace_array_cpu *data = per_cpu_ptr(tr->data, cpu);
+        struct trace_array_cpu *data = per_cpu_ptr(tr->trace_buffer.data, cpu);
         struct dentry *d_percpu = tracing_dentry_percpu(tr, cpu);
         struct dentry *d_cpu;
         char cpu_dir[30]; /* 30 characters should be more than enough */
@@ -5038,7 +5088,7 @@ rb_simple_read(struct file *filp, char __user *ubuf,
                size_t cnt, loff_t *ppos)
 {
         struct trace_array *tr = filp->private_data;
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
         char buf[64];
         int r;
 
@@ -5057,7 +5107,7 @@ rb_simple_write(struct file *filp, const char __user *ubuf,
                 size_t cnt, loff_t *ppos)
 {
         struct trace_array *tr = filp->private_data;
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
         unsigned long val;
         int ret;
 
@@ -5129,18 +5179,18 @@ static int new_instance_create(const char *name)
 
         rb_flags = trace_flags & TRACE_ITER_OVERWRITE ? RB_FL_OVERWRITE : 0;
 
-        tr->buffer = ring_buffer_alloc(trace_buf_size, rb_flags);
-        if (!tr->buffer)
+        tr->trace_buffer.buffer = ring_buffer_alloc(trace_buf_size, rb_flags);
+        if (!tr->trace_buffer.buffer)
                 goto out_free_tr;
 
-        tr->data = alloc_percpu(struct trace_array_cpu);
-        if (!tr->data)
+        tr->trace_buffer.data = alloc_percpu(struct trace_array_cpu);
+        if (!tr->trace_buffer.data)
                 goto out_free_tr;
 
         for_each_tracing_cpu(i) {
-                memset(per_cpu_ptr(tr->data, i), 0, sizeof(struct trace_array_cpu));
-                per_cpu_ptr(tr->data, i)->trace_cpu.cpu = i;
-                per_cpu_ptr(tr->data, i)->trace_cpu.tr = tr;
+                memset(per_cpu_ptr(tr->trace_buffer.data, i), 0, sizeof(struct trace_array_cpu));
+                per_cpu_ptr(tr->trace_buffer.data, i)->trace_cpu.cpu = i;
+                per_cpu_ptr(tr->trace_buffer.data, i)->trace_cpu.tr = tr;
         }
 
         /* Holder for file callbacks */
@@ -5164,8 +5214,8 @@ static int new_instance_create(const char *name)
         return 0;
 
  out_free_tr:
-        if (tr->buffer)
-                ring_buffer_free(tr->buffer);
+        if (tr->trace_buffer.buffer)
+                ring_buffer_free(tr->trace_buffer.buffer);
         kfree(tr->name);
         kfree(tr);
 
@@ -5198,8 +5248,8 @@ static int instance_delete(const char *name)
 
         event_trace_del_tracer(tr);
         debugfs_remove_recursive(tr->dir);
-        free_percpu(tr->data);
-        ring_buffer_free(tr->buffer);
+        free_percpu(tr->trace_buffer.data);
+        ring_buffer_free(tr->trace_buffer.buffer);
 
         kfree(tr->name);
         kfree(tr);
@@ -5439,6 +5489,7 @@ void trace_init_global_iter(struct trace_iterator *iter)
         iter->tr = &global_trace;
         iter->trace = iter->tr->current_trace;
         iter->cpu_file = RING_BUFFER_ALL_CPUS;
+        iter->trace_buffer = &global_trace.trace_buffer;
 }
 
 static void
@@ -5476,7 +5527,7 @@ __ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode)
         trace_init_global_iter(&iter);
 
         for_each_tracing_cpu(cpu) {
-                atomic_inc(&per_cpu_ptr(iter.tr->data, cpu)->disabled);
+                atomic_inc(&per_cpu_ptr(iter.tr->trace_buffer.data, cpu)->disabled);
         }
 
         old_userobj = trace_flags & TRACE_ITER_SYM_USEROBJ;
@@ -5544,7 +5595,7 @@ __ftrace_dump(bool disable_tracing, enum ftrace_dump_mode oops_dump_mode)
                 trace_flags |= old_userobj;
 
                 for_each_tracing_cpu(cpu) {
-                        atomic_dec(&per_cpu_ptr(iter.tr->data, cpu)->disabled);
+                        atomic_dec(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
                 }
                 tracing_on();
         }
@@ -5594,58 +5645,59 @@ __init static int tracer_alloc_buffers(void)
         raw_spin_lock_init(&global_trace.start_lock);
 
         /* TODO: make the number of buffers hot pluggable with CPUS */
-        global_trace.buffer = ring_buffer_alloc(ring_buf_size, rb_flags);
-        if (!global_trace.buffer) {
+        global_trace.trace_buffer.buffer = ring_buffer_alloc(ring_buf_size, rb_flags);
+        if (!global_trace.trace_buffer.buffer) {
                 printk(KERN_ERR "tracer: failed to allocate ring buffer!\n");
                 WARN_ON(1);
                 goto out_free_cpumask;
         }
 
-        global_trace.data = alloc_percpu(struct trace_array_cpu);
+        global_trace.trace_buffer.data = alloc_percpu(struct trace_array_cpu);
 
-        if (!global_trace.data) {
+        if (!global_trace.trace_buffer.data) {
                 printk(KERN_ERR "tracer: failed to allocate percpu memory!\n");
                 WARN_ON(1);
                 goto out_free_cpumask;
         }
 
         for_each_tracing_cpu(i) {
-                memset(per_cpu_ptr(global_trace.data, i), 0, sizeof(struct trace_array_cpu));
-                per_cpu_ptr(global_trace.data, i)->trace_cpu.cpu = i;
-                per_cpu_ptr(global_trace.data, i)->trace_cpu.tr = &global_trace;
+                memset(per_cpu_ptr(global_trace.trace_buffer.data, i), 0,
+                       sizeof(struct trace_array_cpu));
+                per_cpu_ptr(global_trace.trace_buffer.data, i)->trace_cpu.cpu = i;
+                per_cpu_ptr(global_trace.trace_buffer.data, i)->trace_cpu.tr = &global_trace;
         }
 
         if (global_trace.buffer_disabled)
                 tracing_off();
 
 #ifdef CONFIG_TRACER_MAX_TRACE
-        max_tr.data = alloc_percpu(struct trace_array_cpu);
-        if (!max_tr.data) {
+        global_trace.max_buffer.data = alloc_percpu(struct trace_array_cpu);
+        if (!global_trace.max_buffer.data) {
                 printk(KERN_ERR "tracer: failed to allocate percpu memory!\n");
                 WARN_ON(1);
                 goto out_free_cpumask;
         }
-        max_tr.buffer = ring_buffer_alloc(1, rb_flags);
-        raw_spin_lock_init(&max_tr.start_lock);
-        if (!max_tr.buffer) {
+        global_trace.max_buffer.buffer = ring_buffer_alloc(1, rb_flags);
+        if (!global_trace.max_buffer.buffer) {
                 printk(KERN_ERR "tracer: failed to allocate max ring buffer!\n");
                 WARN_ON(1);
-                ring_buffer_free(global_trace.buffer);
+                ring_buffer_free(global_trace.trace_buffer.buffer);
                 goto out_free_cpumask;
         }
 
         for_each_tracing_cpu(i) {
-                memset(per_cpu_ptr(max_tr.data, i), 0, sizeof(struct trace_array_cpu));
-                per_cpu_ptr(max_tr.data, i)->trace_cpu.cpu = i;
-                per_cpu_ptr(max_tr.data, i)->trace_cpu.tr = &max_tr;
+                memset(per_cpu_ptr(global_trace.max_buffer.data, i), 0,
+                       sizeof(struct trace_array_cpu));
+                per_cpu_ptr(global_trace.max_buffer.data, i)->trace_cpu.cpu = i;
+                per_cpu_ptr(global_trace.max_buffer.data, i)->trace_cpu.tr = &global_trace;
         }
 #endif
 
         /* Allocate the first page for all buffers */
-        set_buffer_entries(&global_trace,
-                           ring_buffer_size(global_trace.buffer, 0));
+        set_buffer_entries(&global_trace.trace_buffer,
+                           ring_buffer_size(global_trace.trace_buffer.buffer, 0));
 #ifdef CONFIG_TRACER_MAX_TRACE
-        set_buffer_entries(&max_tr, 1);
+        set_buffer_entries(&global_trace.max_buffer, 1);
 #endif
 
         trace_init_cmdlines();
@@ -5682,8 +5734,10 @@ __init static int tracer_alloc_buffers(void)
         return 0;
 
 out_free_cpumask:
-        free_percpu(global_trace.data);
-        free_percpu(max_tr.data);
+        free_percpu(global_trace.trace_buffer.data);
+#ifdef CONFIG_TRACER_MAX_TRACE
+        free_percpu(global_trace.max_buffer.data);
+#endif
         free_cpumask_var(tracing_cpumask);
 out_free_buffer_mask:
         free_cpumask_var(tracing_buffer_mask);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index fa60b2977524..986834f1f4dd 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -167,16 +167,37 @@ struct trace_array_cpu {
 
 struct tracer;
 
+struct trace_buffer {
+        struct trace_array              *tr;
+        struct ring_buffer              *buffer;
+        struct trace_array_cpu __percpu *data;
+        cycle_t                         time_start;
+        int                             cpu;
+};
+
 /*
  * The trace array - an array of per-CPU trace arrays. This is the
  * highest level data structure that individual tracers deal with.
  * They have on/off state as well:
  */
 struct trace_array {
-        struct ring_buffer      *buffer;
         struct list_head        list;
         char                    *name;
-        int                     cpu;
+        struct trace_buffer     trace_buffer;
+#ifdef CONFIG_TRACER_MAX_TRACE
+        /*
+         * The max_buffer is used to snapshot the trace when a maximum
+         * latency is reached, or when the user initiates a snapshot.
+         * Some tracers will use this to store a maximum trace while
+         * it continues examining live traces.
+         *
+         * The buffers for the max_buffer are set up the same as the trace_buffer
+         * When a snapshot is taken, the buffer of the max_buffer is swapped
+         * with the buffer of the trace_buffer and the buffers are reset for
+         * the trace_buffer so the tracing can continue.
+         */
+        struct trace_buffer     max_buffer;
+#endif
         int                     buffer_disabled;
         struct trace_cpu        trace_cpu;      /* place holder */
 #ifdef CONFIG_FTRACE_SYSCALLS
@@ -189,7 +210,6 @@ struct trace_array {
         int                     clock_id;
         struct tracer           *current_trace;
         unsigned int            flags;
-        cycle_t                 time_start;
         raw_spinlock_t          start_lock;
         struct dentry           *dir;
         struct dentry           *options;
@@ -198,7 +218,6 @@ struct trace_array {
         struct list_head        systems;
         struct list_head        events;
         struct task_struct      *waiter;
-        struct trace_array_cpu __percpu *data;
 };
 
 enum {
@@ -345,9 +364,11 @@ struct tracer {
         struct tracer           *next;
         struct tracer_flags     *flags;
         bool                    print_max;
+        bool                    enabled;
+#ifdef CONFIG_TRACER_MAX_TRACE
         bool                    use_max_tr;
         bool                    allocated_snapshot;
-        bool                    enabled;
+#endif
 };
 
 
@@ -493,8 +514,8 @@ trace_buffer_iter(struct trace_iterator *iter, int cpu)
 
 int tracer_init(struct tracer *t, struct trace_array *tr);
 int tracing_is_enabled(void);
-void tracing_reset(struct trace_array *tr, int cpu);
-void tracing_reset_online_cpus(struct trace_array *tr);
+void tracing_reset(struct trace_buffer *buf, int cpu);
+void tracing_reset_online_cpus(struct trace_buffer *buf);
 void tracing_reset_current(int cpu);
 void tracing_reset_all_online_cpus(void);
 int tracing_open_generic(struct inode *inode, struct file *filp);
@@ -674,6 +695,8 @@ trace_array_vprintk(struct trace_array *tr,
                     unsigned long ip, const char *fmt, va_list args);
 int trace_array_printk(struct trace_array *tr,
                        unsigned long ip, const char *fmt, ...);
+int trace_array_printk_buf(struct ring_buffer *buffer,
+                           unsigned long ip, const char *fmt, ...);
 void trace_printk_seq(struct trace_seq *s);
 enum print_line_t print_trace_line(struct trace_iterator *iter);
 
diff --git a/kernel/trace/trace_functions.c b/kernel/trace/trace_functions.c
index 9d73861efc6a..e467c0c7bdd5 100644
--- a/kernel/trace/trace_functions.c
+++ b/kernel/trace/trace_functions.c
@@ -28,7 +28,7 @@ static void tracing_stop_function_trace(void);
 static int function_trace_init(struct trace_array *tr)
 {
         func_trace = tr;
-        tr->cpu = get_cpu();
+        tr->trace_buffer.cpu = get_cpu();
         put_cpu();
 
         tracing_start_cmdline_record();
@@ -44,7 +44,7 @@ static void function_trace_reset(struct trace_array *tr)
 
 static void function_trace_start(struct trace_array *tr)
 {
-        tracing_reset_online_cpus(tr);
+        tracing_reset_online_cpus(&tr->trace_buffer);
 }
 
 /* Our option */
@@ -76,7 +76,7 @@ function_trace_call(unsigned long ip, unsigned long parent_ip,
                 goto out;
 
         cpu = smp_processor_id();
-        data = per_cpu_ptr(tr->data, cpu);
+        data = per_cpu_ptr(tr->trace_buffer.data, cpu);
         if (!atomic_read(&data->disabled)) {
                 local_save_flags(flags);
                 trace_function(tr, ip, parent_ip, flags, pc);
@@ -107,7 +107,7 @@ function_stack_trace_call(unsigned long ip, unsigned long parent_ip,
          */
         local_irq_save(flags);
         cpu = raw_smp_processor_id();
-        data = per_cpu_ptr(tr->data, cpu);
+        data = per_cpu_ptr(tr->trace_buffer.data, cpu);
         disabled = atomic_inc_return(&data->disabled);
 
         if (likely(disabled == 1)) {
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index ca986d61a282..8388bc99f2ee 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -218,7 +218,7 @@ int __trace_graph_entry(struct trace_array *tr,
 {
         struct ftrace_event_call *call = &event_funcgraph_entry;
         struct ring_buffer_event *event;
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
         struct ftrace_graph_ent_entry *entry;
 
         if (unlikely(__this_cpu_read(ftrace_cpu_disabled)))
@@ -265,7 +265,7 @@ int trace_graph_entry(struct ftrace_graph_ent *trace)
 
         local_irq_save(flags);
         cpu = raw_smp_processor_id();
-        data = per_cpu_ptr(tr->data, cpu);
+        data = per_cpu_ptr(tr->trace_buffer.data, cpu);
         disabled = atomic_inc_return(&data->disabled);
         if (likely(disabled == 1)) {
                 pc = preempt_count();
@@ -323,7 +323,7 @@ void __trace_graph_return(struct trace_array *tr,
 {
         struct ftrace_event_call *call = &event_funcgraph_exit;
         struct ring_buffer_event *event;
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
         struct ftrace_graph_ret_entry *entry;
 
         if (unlikely(__this_cpu_read(ftrace_cpu_disabled)))
@@ -350,7 +350,7 @@ void trace_graph_return(struct ftrace_graph_ret *trace)
 
         local_irq_save(flags);
         cpu = raw_smp_processor_id();
-        data = per_cpu_ptr(tr->data, cpu);
+        data = per_cpu_ptr(tr->trace_buffer.data, cpu);
         disabled = atomic_inc_return(&data->disabled);
         if (likely(disabled == 1)) {
                 pc = preempt_count();
@@ -560,9 +560,9 @@ get_return_for_leaf(struct trace_iterator *iter,
                          * We need to consume the current entry to see
                          * the next one.
                          */
-                        ring_buffer_consume(iter->tr->buffer, iter->cpu,
+                        ring_buffer_consume(iter->trace_buffer->buffer, iter->cpu,
                                             NULL, NULL);
-                        event = ring_buffer_peek(iter->tr->buffer, iter->cpu,
+                        event = ring_buffer_peek(iter->trace_buffer->buffer, iter->cpu,
                                                  NULL, NULL);
                 }
 
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index 9b52f9cf7a0d..5aa40ab72b57 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -121,7 +121,7 @@ static int func_prolog_dec(struct trace_array *tr,
         if (!irqs_disabled_flags(*flags))
                 return 0;
 
-        *data = per_cpu_ptr(tr->data, cpu);
+        *data = per_cpu_ptr(tr->trace_buffer.data, cpu);
         disabled = atomic_inc_return(&(*data)->disabled);
 
         if (likely(disabled == 1))
@@ -175,7 +175,7 @@ static int irqsoff_set_flag(u32 old_flags, u32 bit, int set)
                 per_cpu(tracing_cpu, cpu) = 0;
 
         tracing_max_latency = 0;
-        tracing_reset_online_cpus(irqsoff_trace);
+        tracing_reset_online_cpus(&irqsoff_trace->trace_buffer);
 
         return start_irqsoff_tracer(irqsoff_trace, set);
 }
@@ -380,7 +380,7 @@ start_critical_timing(unsigned long ip, unsigned long parent_ip)
         if (per_cpu(tracing_cpu, cpu))
                 return;
 
-        data = per_cpu_ptr(tr->data, cpu);
+        data = per_cpu_ptr(tr->trace_buffer.data, cpu);
 
         if (unlikely(!data) || atomic_read(&data->disabled))
                 return;
@@ -418,7 +418,7 @@ stop_critical_timing(unsigned long ip, unsigned long parent_ip)
         if (!tracer_enabled)
                 return;
 
-        data = per_cpu_ptr(tr->data, cpu);
+        data = per_cpu_ptr(tr->trace_buffer.data, cpu);
 
         if (unlikely(!data) ||
             !data->critical_start || atomic_read(&data->disabled))
@@ -568,7 +568,7 @@ static void __irqsoff_tracer_init(struct trace_array *tr)
         irqsoff_trace = tr;
         /* make sure that the tracer is visible */
         smp_wmb();
-        tracing_reset_online_cpus(tr);
+        tracing_reset_online_cpus(&tr->trace_buffer);
 
         if (start_irqsoff_tracer(tr, is_graph()))
                 printk(KERN_ERR "failed to start irqsoff tracer\n");
diff --git a/kernel/trace/trace_kdb.c b/kernel/trace/trace_kdb.c
index 349f6941e8f2..bd90e1b06088 100644
--- a/kernel/trace/trace_kdb.c
+++ b/kernel/trace/trace_kdb.c
@@ -26,7 +26,7 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)
         trace_init_global_iter(&iter);
 
         for_each_tracing_cpu(cpu) {
-                atomic_inc(&per_cpu_ptr(iter.tr->data, cpu)->disabled);
+                atomic_inc(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
         }
 
         old_userobj = trace_flags;
@@ -46,14 +46,14 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)
         if (cpu_file == RING_BUFFER_ALL_CPUS) {
                 for_each_tracing_cpu(cpu) {
                         iter.buffer_iter[cpu] =
-                        ring_buffer_read_prepare(iter.tr->buffer, cpu);
+                        ring_buffer_read_prepare(iter.trace_buffer->buffer, cpu);
                         ring_buffer_read_start(iter.buffer_iter[cpu]);
                         tracing_iter_reset(&iter, cpu);
                 }
         } else {
                 iter.cpu_file = cpu_file;
                 iter.buffer_iter[cpu_file] =
-                        ring_buffer_read_prepare(iter.tr->buffer, cpu_file);
+                        ring_buffer_read_prepare(iter.trace_buffer->buffer, cpu_file);
                 ring_buffer_read_start(iter.buffer_iter[cpu_file]);
                 tracing_iter_reset(&iter, cpu_file);
         }
@@ -83,7 +83,7 @@ out:
         trace_flags = old_userobj;
 
         for_each_tracing_cpu(cpu) {
-                atomic_dec(&per_cpu_ptr(iter.tr->data, cpu)->disabled);
+                atomic_dec(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
         }
 
         for_each_tracing_cpu(cpu)
diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
index 2472f6f76b50..a5e8f4878bfa 100644
--- a/kernel/trace/trace_mmiotrace.c
+++ b/kernel/trace/trace_mmiotrace.c
@@ -31,7 +31,7 @@ static void mmio_reset_data(struct trace_array *tr)
         overrun_detected = false;
         prev_overruns = 0;
 
-        tracing_reset_online_cpus(tr);
+        tracing_reset_online_cpus(&tr->trace_buffer);
 }
 
 static int mmio_trace_init(struct trace_array *tr)
@@ -128,7 +128,7 @@ static void mmio_close(struct trace_iterator *iter)
 static unsigned long count_overruns(struct trace_iterator *iter)
 {
         unsigned long cnt = atomic_xchg(&dropped_count, 0);
-        unsigned long over = ring_buffer_overruns(iter->tr->buffer);
+        unsigned long over = ring_buffer_overruns(iter->trace_buffer->buffer);
 
         if (over > prev_overruns)
                 cnt += over - prev_overruns;
@@ -309,7 +309,7 @@ static void __trace_mmiotrace_rw(struct trace_array *tr,
                                 struct mmiotrace_rw *rw)
 {
         struct ftrace_event_call *call = &event_mmiotrace_rw;
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
         struct ring_buffer_event *event;
         struct trace_mmiotrace_rw *entry;
         int pc = preempt_count();
@@ -330,7 +330,7 @@ static void __trace_mmiotrace_rw(struct trace_array *tr,
 void mmio_trace_rw(struct mmiotrace_rw *rw)
 {
         struct trace_array *tr = mmio_trace_array;
-        struct trace_array_cpu *data = per_cpu_ptr(tr->data, smp_processor_id());
+        struct trace_array_cpu *data = per_cpu_ptr(tr->trace_buffer.data, smp_processor_id());
         __trace_mmiotrace_rw(tr, data, rw);
 }
 
@@ -339,7 +339,7 @@ static void __trace_mmiotrace_map(struct trace_array *tr,
                                 struct mmiotrace_map *map)
 {
         struct ftrace_event_call *call = &event_mmiotrace_map;
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
         struct ring_buffer_event *event;
         struct trace_mmiotrace_map *entry;
         int pc = preempt_count();
@@ -363,7 +363,7 @@ void mmio_trace_mapping(struct mmiotrace_map *map)
         struct trace_array_cpu *data;
 
         preempt_disable();
-        data = per_cpu_ptr(tr->data, smp_processor_id());
+        data = per_cpu_ptr(tr->trace_buffer.data, smp_processor_id());
         __trace_mmiotrace_map(tr, data, map);
         preempt_enable();
 }
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index aa92ac322ba2..2edc7220d017 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -643,7 +643,7 @@ lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
 {
         unsigned long verbose = trace_flags & TRACE_ITER_VERBOSE;
         unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS;
-        unsigned long long abs_ts = iter->ts - iter->tr->time_start;
+        unsigned long long abs_ts = iter->ts - iter->trace_buffer->time_start;
         unsigned long long rel_ts = next_ts - iter->ts;
         struct trace_seq *s = &iter->seq;
 
diff --git a/kernel/trace/trace_sched_switch.c b/kernel/trace/trace_sched_switch.c
index 1ffe39abd6fc..4e98e3b257a3 100644
--- a/kernel/trace/trace_sched_switch.c
+++ b/kernel/trace/trace_sched_switch.c
@@ -28,7 +28,7 @@ tracing_sched_switch_trace(struct trace_array *tr,
                            unsigned long flags, int pc)
 {
         struct ftrace_event_call *call = &event_context_switch;
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
         struct ring_buffer_event *event;
         struct ctx_switch_entry *entry;
 
@@ -69,7 +69,7 @@ probe_sched_switch(void *ignore, struct task_struct *prev, struct task_struct *n
         pc = preempt_count();
         local_irq_save(flags);
         cpu = raw_smp_processor_id();
-        data = per_cpu_ptr(ctx_trace->data, cpu);
+        data = per_cpu_ptr(ctx_trace->trace_buffer.data, cpu);
 
         if (likely(!atomic_read(&data->disabled)))
                 tracing_sched_switch_trace(ctx_trace, prev, next, flags, pc);
@@ -86,7 +86,7 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
         struct ftrace_event_call *call = &event_wakeup;
         struct ring_buffer_event *event;
         struct ctx_switch_entry *entry;
-        struct ring_buffer *buffer = tr->buffer;
+        struct ring_buffer *buffer = tr->trace_buffer.buffer;
 
         event = trace_buffer_lock_reserve(buffer, TRACE_WAKE,
                                           sizeof(*entry), flags, pc);
@@ -123,7 +123,7 @@ probe_sched_wakeup(void *ignore, struct task_struct *wakee, int success)
         pc = preempt_count();
         local_irq_save(flags);
         cpu = raw_smp_processor_id();
-        data = per_cpu_ptr(ctx_trace->data, cpu);
+        data = per_cpu_ptr(ctx_trace->trace_buffer.data, cpu);
 
         if (likely(!atomic_read(&data->disabled)))
                 tracing_sched_wakeup_trace(ctx_trace, wakee, current,
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index f9ceb75a95b7..c16f8cd63c3c 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -89,7 +89,7 @@ func_prolog_preempt_disable(struct trace_array *tr,
         if (cpu != wakeup_current_cpu)
                 goto out_enable;
 
-        *data = per_cpu_ptr(tr->data, cpu);
+        *data = per_cpu_ptr(tr->trace_buffer.data, cpu);
         disabled = atomic_inc_return(&(*data)->disabled);
         if (unlikely(disabled != 1))
                 goto out;
@@ -353,7 +353,7 @@ probe_wakeup_sched_switch(void *ignore,
 
         /* disable local data, not wakeup_cpu data */
         cpu = raw_smp_processor_id();
-        disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->data, cpu)->disabled);
+        disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
         if (likely(disabled != 1))
                 goto out;
 
@@ -365,7 +365,7 @@ probe_wakeup_sched_switch(void *ignore,
                 goto out_unlock;
 
         /* The task we are waiting for is waking up */
-        data = per_cpu_ptr(wakeup_trace->data, wakeup_cpu);
+        data = per_cpu_ptr(wakeup_trace->trace_buffer.data, wakeup_cpu);
 
         __trace_function(wakeup_trace, CALLER_ADDR0, CALLER_ADDR1, flags, pc);
         tracing_sched_switch_trace(wakeup_trace, prev, next, flags, pc);
@@ -387,7 +387,7 @@ out_unlock:
         arch_spin_unlock(&wakeup_lock);
         local_irq_restore(flags);
 out:
-        atomic_dec(&per_cpu_ptr(wakeup_trace->data, cpu)->disabled);
+        atomic_dec(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
 }
 
 static void __wakeup_reset(struct trace_array *tr)
@@ -405,7 +405,7 @@ static void wakeup_reset(struct trace_array *tr)
 {
         unsigned long flags;
 
-        tracing_reset_online_cpus(tr);
+        tracing_reset_online_cpus(&tr->trace_buffer);
 
         local_irq_save(flags);
         arch_spin_lock(&wakeup_lock);
@@ -435,7 +435,7 @@ probe_wakeup(void *ignore, struct task_struct *p, int success)
                 return;
 
         pc = preempt_count();
-        disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->data, cpu)->disabled);
+        disabled = atomic_inc_return(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
         if (unlikely(disabled != 1))
                 goto out;
 
@@ -458,7 +458,7 @@ probe_wakeup(void *ignore, struct task_struct *p, int success)
 
         local_save_flags(flags);
 
-        data = per_cpu_ptr(wakeup_trace->data, wakeup_cpu);
+        data = per_cpu_ptr(wakeup_trace->trace_buffer.data, wakeup_cpu);
         data->preempt_timestamp = ftrace_now(cpu);
         tracing_sched_wakeup_trace(wakeup_trace, p, current, flags, pc);
 
@@ -472,7 +472,7 @@ probe_wakeup(void *ignore, struct task_struct *p, int success)
 out_locked:
         arch_spin_unlock(&wakeup_lock);
 out:
-        atomic_dec(&per_cpu_ptr(wakeup_trace->data, cpu)->disabled);
+        atomic_dec(&per_cpu_ptr(wakeup_trace->trace_buffer.data, cpu)->disabled);
 }
 
 static void start_wakeup_tracer(struct trace_array *tr)
diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c
index 51c819c12c29..8672c40cb153 100644
--- a/kernel/trace/trace_selftest.c
+++ b/kernel/trace/trace_selftest.c
@@ -21,13 +21,13 @@ static inline int trace_valid_entry(struct trace_entry *entry)
         return 0;
 }
 
-static int trace_test_buffer_cpu(struct trace_array *tr, int cpu)
+static int trace_test_buffer_cpu(struct trace_buffer *buf, int cpu)
 {
         struct ring_buffer_event *event;
         struct trace_entry *entry;
         unsigned int loops = 0;
 
-        while ((event = ring_buffer_consume(tr->buffer, cpu, NULL, NULL))) {
+        while ((event = ring_buffer_consume(buf->buffer, cpu, NULL, NULL))) {
                 entry = ring_buffer_event_data(event);
 
                 /*
@@ -58,7 +58,7 @@ static int trace_test_buffer_cpu(struct trace_array *tr, int cpu)
  * Test the trace buffer to see if all the elements
  * are still sane.
  */
-static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
+static int trace_test_buffer(struct trace_buffer *buf, unsigned long *count)
 {
         unsigned long flags, cnt = 0;
         int cpu, ret = 0;
@@ -67,7 +67,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
         local_irq_save(flags);
         arch_spin_lock(&ftrace_max_lock);
 
-        cnt = ring_buffer_entries(tr->buffer);
+        cnt = ring_buffer_entries(buf->buffer);
 
         /*
          * The trace_test_buffer_cpu runs a while loop to consume all data.
@@ -78,7 +78,7 @@ static int trace_test_buffer(struct trace_array *tr, unsigned long *count)
          */
         tracing_off();
         for_each_possible_cpu(cpu) {
-                ret = trace_test_buffer_cpu(tr, cpu);
+                ret = trace_test_buffer_cpu(buf, cpu);
                 if (ret)
                         break;
         }
@@ -355,7 +355,7 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
         msleep(100);
 
         /* we should have nothing in the buffer */
-        ret = trace_test_buffer(tr, &count);
+        ret = trace_test_buffer(&tr->trace_buffer, &count);
         if (ret)
                 goto out;
 
@@ -376,7 +376,7 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
         ftrace_enabled = 0;
 
         /* check the trace buffer */
-        ret = trace_test_buffer(tr, &count);
+        ret = trace_test_buffer(&tr->trace_buffer, &count);
         tracing_start();
 
         /* we should only have one item */
@@ -666,7 +666,7 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
         ftrace_enabled = 0;
 
         /* check the trace buffer */
-        ret = trace_test_buffer(tr, &count);
+        ret = trace_test_buffer(&tr->trace_buffer, &count);
         trace->reset(tr);
         tracing_start();
 
@@ -737,7 +737,7 @@ trace_selftest_startup_function_graph(struct tracer *trace,
          * Simulate the init() callback but we attach a watchdog callback
          * to detect and recover from possible hangs
          */
-        tracing_reset_online_cpus(tr);
+        tracing_reset_online_cpus(&tr->trace_buffer);
         set_graph_array(tr);
         ret = register_ftrace_graph(&trace_graph_return,
                                     &trace_graph_entry_watchdog);
@@ -760,7 +760,7 @@ trace_selftest_startup_function_graph(struct tracer *trace,
         tracing_stop();
 
         /* check the trace buffer */
-        ret = trace_test_buffer(tr, &count);
+        ret = trace_test_buffer(&tr->trace_buffer, &count);
 
         trace->reset(tr);
         tracing_start();
@@ -815,9 +815,9 @@ trace_selftest_startup_irqsoff(struct tracer *trace, struct trace_array *tr)
         /* stop the tracing. */
         tracing_stop();
         /* check both trace buffers */
-        ret = trace_test_buffer(tr, NULL);
+        ret = trace_test_buffer(&tr->trace_buffer, NULL);
         if (!ret)
-                ret = trace_test_buffer(&max_tr, &count);
+                ret = trace_test_buffer(&tr->max_buffer, &count);
         trace->reset(tr);
         tracing_start();
 
@@ -877,9 +877,9 @@ trace_selftest_startup_preemptoff(struct tracer *trace, struct trace_array *tr)
         /* stop the tracing. */
         tracing_stop();
         /* check both trace buffers */
-        ret = trace_test_buffer(tr, NULL);
+        ret = trace_test_buffer(&tr->trace_buffer, NULL);
         if (!ret)
-                ret = trace_test_buffer(&max_tr, &count);
+                ret = trace_test_buffer(&tr->max_buffer, &count);
         trace->reset(tr);
         tracing_start();
 
@@ -943,11 +943,11 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
         /* stop the tracing. */
         tracing_stop();
         /* check both trace buffers */
-        ret = trace_test_buffer(tr, NULL);
+        ret = trace_test_buffer(&tr->trace_buffer, NULL);
         if (ret)
                 goto out;
 
-        ret = trace_test_buffer(&max_tr, &count);
+        ret = trace_test_buffer(&tr->max_buffer, &count);
         if (ret)
                 goto out;
 
@@ -973,11 +973,11 @@ trace_selftest_startup_preemptirqsoff(struct tracer *trace, struct trace_array *
         /* stop the tracing. */
         tracing_stop();
         /* check both trace buffers */
-        ret = trace_test_buffer(tr, NULL);
+        ret = trace_test_buffer(&tr->trace_buffer, NULL);
         if (ret)
                 goto out;
 
-        ret = trace_test_buffer(&max_tr, &count);
+        ret = trace_test_buffer(&tr->max_buffer, &count);
 
         if (!ret && !count) {
                 printk(KERN_CONT ".. no entries found ..");
@@ -1084,10 +1084,10 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
         /* stop the tracing. */
         tracing_stop();
         /* check both trace buffers */
-        ret = trace_test_buffer(tr, NULL);
+        ret = trace_test_buffer(&tr->trace_buffer, NULL);
         printk("ret = %d\n", ret);
         if (!ret)
-                ret = trace_test_buffer(&max_tr, &count);
+                ret = trace_test_buffer(&tr->max_buffer, &count);
 
 
         trace->reset(tr);
@@ -1126,7 +1126,7 @@ trace_selftest_startup_sched_switch(struct tracer *trace, struct trace_array *tr
         /* stop the tracing. */
         tracing_stop();
         /* check the trace buffer */
-        ret = trace_test_buffer(tr, &count);
+        ret = trace_test_buffer(&tr->trace_buffer, &count);
         trace->reset(tr);
         tracing_start();
 
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
index 1cd37ffb4093..68f3f344be65 100644
--- a/kernel/trace/trace_syscalls.c
+++ b/kernel/trace/trace_syscalls.c
@@ -321,7 +321,7 @@ static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id)
 
         size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
 
-        buffer = tr->buffer;
+        buffer = tr->trace_buffer.buffer;
         event = trace_buffer_lock_reserve(buffer,
                         sys_data->enter_event->event.type, size, 0, 0);
         if (!event)
@@ -355,7 +355,7 @@ static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret)
         if (!sys_data)
                 return;
 
-        buffer = tr->buffer;
+        buffer = tr->trace_buffer.buffer;
         event = trace_buffer_lock_reserve(buffer,
                         sys_data->exit_event->event.type, sizeof(*entry), 0, 0);
         if (!event)