10 files changed, 135 insertions, 101 deletions

diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 973d41d81aa5..b2fcf472774e 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -1343,6 +1343,7 @@ static const struct {
 static enum print_line_t print_one_line(struct trace_iterator *iter,
                                         bool classic)
 {
+        struct trace_array *tr = iter->tr;
         struct trace_seq *s = &iter->seq;
         const struct blk_io_trace *t;
         u16 what;
@@ -1351,7 +1352,7 @@ static enum print_line_t print_one_line(struct trace_iterator *iter,
 
         t          = te_blk_io_trace(iter->ent);
         what       = t->action & ((1 << BLK_TC_SHIFT) - 1);
-        long_act   = !!(trace_flags & TRACE_ITER_VERBOSE);
+        long_act   = !!(tr->trace_flags & TRACE_ITER_VERBOSE);
         log_action = classic ? &blk_log_action_classic : &blk_log_action;
 
         if (t->action == BLK_TN_MESSAGE) {
@@ -1413,9 +1414,9 @@ blk_tracer_set_flag(struct trace_array *tr, u32 old_flags, u32 bit, int set)
         /* don't output context-info for blk_classic output */
         if (bit == TRACE_BLK_OPT_CLASSIC) {
                 if (set)
-                        trace_flags &= ~TRACE_ITER_CONTEXT_INFO;
+                        tr->trace_flags &= ~TRACE_ITER_CONTEXT_INFO;
                 else
-                        trace_flags |= TRACE_ITER_CONTEXT_INFO;
+                        tr->trace_flags |= TRACE_ITER_CONTEXT_INFO;
         }
         return 0;
 }
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index e26933c2edaa..4e82f4ad68dc 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -250,6 +250,14 @@ unsigned long long ns2usecs(cycle_t nsec)
         return nsec;
 }
 
+/* trace_flags holds trace_options default values */
+#define TRACE_DEFAULT_FLAGS                                             \
+        (FUNCTION_DEFAULT_FLAGS |                                       \
+         TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |                  \
+         TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO |                \
+         TRACE_ITER_RECORD_CMD | TRACE_ITER_OVERWRITE |                 \
+         TRACE_ITER_IRQ_INFO | TRACE_ITER_MARKERS)
+
 /*
  * The global_trace is the descriptor that holds the tracing
  * buffers for the live tracing. For each CPU, it contains
@@ -262,7 +270,9 @@ unsigned long long ns2usecs(cycle_t nsec)
  * pages for the buffer for that CPU. Each CPU has the same number
  * of pages allocated for its buffer.
  */
-static struct trace_array       global_trace;
+static struct trace_array global_trace = {
+        .trace_flags = TRACE_DEFAULT_FLAGS,
+};
 
 LIST_HEAD(ftrace_trace_arrays);
 
@@ -490,15 +500,6 @@ static inline void ftrace_trace_stack(struct ring_buffer *buffer,
 
 #endif
 
-/* trace_flags holds trace_options default values */
-unsigned long trace_flags =
-        FUNCTION_DEFAULT_FLAGS |
-        TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
-        TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO |
-        TRACE_ITER_RECORD_CMD | TRACE_ITER_OVERWRITE |
-        TRACE_ITER_IRQ_INFO | TRACE_ITER_MARKERS
-        ;
-
 static void tracer_tracing_on(struct trace_array *tr)
 {
         if (tr->trace_buffer.buffer)
@@ -543,7 +544,7 @@ int __trace_puts(unsigned long ip, const char *str, int size)
         int alloc;
         int pc;
 
-        if (!(trace_flags & TRACE_ITER_PRINTK))
+        if (!(global_trace.trace_flags & TRACE_ITER_PRINTK))
                 return 0;
 
         pc = preempt_count();
@@ -593,7 +594,7 @@ int __trace_bputs(unsigned long ip, const char *str)
         int size = sizeof(struct bputs_entry);
         int pc;
 
-        if (!(trace_flags & TRACE_ITER_PRINTK))
+        if (!(global_trace.trace_flags & TRACE_ITER_PRINTK))
                 return 0;
 
         pc = preempt_count();
@@ -1875,7 +1876,7 @@ static inline void ftrace_trace_stack(struct ring_buffer *buffer,
                                       unsigned long flags,
                                       int skip, int pc, struct pt_regs *regs)
 {
-        if (!(trace_flags & TRACE_ITER_STACKTRACE))
+        if (!(global_trace.trace_flags & TRACE_ITER_STACKTRACE))
                 return;
 
         __ftrace_trace_stack(buffer, flags, skip, pc, regs);
@@ -1919,7 +1920,7 @@ ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, int pc)
         struct userstack_entry *entry;
         struct stack_trace trace;
 
-        if (!(trace_flags & TRACE_ITER_USERSTACKTRACE))
+        if (!(global_trace.trace_flags & TRACE_ITER_USERSTACKTRACE))
                 return;
 
         /*
@@ -2236,7 +2237,7 @@ int trace_array_printk(struct trace_array *tr,
         int ret;
         va_list ap;
 
-        if (!(trace_flags & TRACE_ITER_PRINTK))
+        if (!(global_trace.trace_flags & TRACE_ITER_PRINTK))
                 return 0;
 
         va_start(ap, fmt);
@@ -2251,7 +2252,7 @@ int trace_array_printk_buf(struct ring_buffer *buffer,
         int ret;
         va_list ap;
 
-        if (!(trace_flags & TRACE_ITER_PRINTK))
+        if (!(global_trace.trace_flags & TRACE_ITER_PRINTK))
                 return 0;
 
         va_start(ap, fmt);
@@ -2592,7 +2593,7 @@ static void print_func_help_header_irq(struct trace_buffer *buf, struct seq_file
 void
 print_trace_header(struct seq_file *m, struct trace_iterator *iter)
 {
-        unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
+        unsigned long sym_flags = (global_trace.trace_flags & TRACE_ITER_SYM_MASK);
         struct trace_buffer *buf = iter->trace_buffer;
         struct trace_array_cpu *data = per_cpu_ptr(buf->data, buf->cpu);
         struct tracer *type = iter->trace;
@@ -2654,8 +2655,9 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter)
 static void test_cpu_buff_start(struct trace_iterator *iter)
 {
         struct trace_seq *s = &iter->seq;
+        struct trace_array *tr = iter->tr;
 
-        if (!(trace_flags & TRACE_ITER_ANNOTATE))
+        if (!(tr->trace_flags & TRACE_ITER_ANNOTATE))
                 return;
 
         if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))
@@ -2677,8 +2679,9 @@ static void test_cpu_buff_start(struct trace_iterator *iter)
 
 static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
 {
+        struct trace_array *tr = iter->tr;
         struct trace_seq *s = &iter->seq;
-        unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
+        unsigned long sym_flags = (tr->trace_flags & TRACE_ITER_SYM_MASK);
         struct trace_entry *entry;
         struct trace_event *event;
 
@@ -2688,7 +2691,7 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
 
         event = ftrace_find_event(entry->type);
 
-        if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
+        if (tr->trace_flags & TRACE_ITER_CONTEXT_INFO) {
                 if (iter->iter_flags & TRACE_FILE_LAT_FMT)
                         trace_print_lat_context(iter);
                 else
@@ -2708,13 +2711,14 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
 
 static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
 {
+        struct trace_array *tr = iter->tr;
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry;
         struct trace_event *event;
 
         entry = iter->ent;
 
-        if (trace_flags & TRACE_ITER_CONTEXT_INFO)
+        if (tr->trace_flags & TRACE_ITER_CONTEXT_INFO)
                 trace_seq_printf(s, "%d %d %llu ",
                                  entry->pid, iter->cpu, iter->ts);
 
@@ -2732,6 +2736,7 @@ static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
 
 static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
 {
+        struct trace_array *tr = iter->tr;
         struct trace_seq *s = &iter->seq;
         unsigned char newline = '\n';
         struct trace_entry *entry;
@@ -2739,7 +2744,7 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
 
         entry = iter->ent;
 
-        if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
+        if (tr->trace_flags & TRACE_ITER_CONTEXT_INFO) {
                 SEQ_PUT_HEX_FIELD(s, entry->pid);
                 SEQ_PUT_HEX_FIELD(s, iter->cpu);
                 SEQ_PUT_HEX_FIELD(s, iter->ts);
@@ -2761,13 +2766,14 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
 
 static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
 {
+        struct trace_array *tr = iter->tr;
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry;
         struct trace_event *event;
 
         entry = iter->ent;
 
-        if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
+        if (tr->trace_flags & TRACE_ITER_CONTEXT_INFO) {
                 SEQ_PUT_FIELD(s, entry->pid);
                 SEQ_PUT_FIELD(s, iter->cpu);
                 SEQ_PUT_FIELD(s, iter->ts);
@@ -2816,6 +2822,8 @@ int trace_empty(struct trace_iterator *iter)
 /*  Called with trace_event_read_lock() held. */
 enum print_line_t print_trace_line(struct trace_iterator *iter)
 {
+        struct trace_array *tr = iter->tr;
+        unsigned long trace_flags = tr->trace_flags;
         enum print_line_t ret;
 
         if (iter->lost_events) {
@@ -2861,6 +2869,7 @@ enum print_line_t print_trace_line(struct trace_iterator *iter)
 void trace_latency_header(struct seq_file *m)
 {
         struct trace_iterator *iter = m->private;
+        struct trace_array *tr = iter->tr;
 
         /* print nothing if the buffers are empty */
         if (trace_empty(iter))
@@ -2869,13 +2878,15 @@ void trace_latency_header(struct seq_file *m)
         if (iter->iter_flags & TRACE_FILE_LAT_FMT)
                 print_trace_header(m, iter);
 
-        if (!(trace_flags & TRACE_ITER_VERBOSE))
+        if (!(tr->trace_flags & TRACE_ITER_VERBOSE))
                 print_lat_help_header(m);
 }
 
 void trace_default_header(struct seq_file *m)
 {
         struct trace_iterator *iter = m->private;
+        struct trace_array *tr = iter->tr;
+        unsigned long trace_flags = tr->trace_flags;
 
         if (!(trace_flags & TRACE_ITER_CONTEXT_INFO))
                 return;
@@ -3220,7 +3231,7 @@ static int tracing_open(struct inode *inode, struct file *file)
                 iter = __tracing_open(inode, file, false);
                 if (IS_ERR(iter))
                         ret = PTR_ERR(iter);
-                else if (trace_flags & TRACE_ITER_LATENCY_FMT)
+                else if (tr->trace_flags & TRACE_ITER_LATENCY_FMT)
                         iter->iter_flags |= TRACE_FILE_LAT_FMT;
         }
 
@@ -3467,7 +3478,7 @@ static int tracing_trace_options_show(struct seq_file *m, void *v)
         trace_opts = tr->current_trace->flags->opts;
 
         for (i = 0; trace_options[i]; i++) {
-                if (trace_flags & (1 << i))
+                if (tr->trace_flags & (1 << i))
                         seq_printf(m, "%s\n", trace_options[i]);
                 else
                         seq_printf(m, "no%s\n", trace_options[i]);
@@ -3532,7 +3543,7 @@ int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set)
 int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled)
 {
         /* do nothing if flag is already set */
-        if (!!(trace_flags & mask) == !!enabled)
+        if (!!(tr->trace_flags & mask) == !!enabled)
                 return 0;
 
         /* Give the tracer a chance to approve the change */
@@ -3541,9 +3552,9 @@ int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled)
                         return -EINVAL;
 
         if (enabled)
-                trace_flags |= mask;
+                tr->trace_flags |= mask;
         else
-                trace_flags &= ~mask;
+                tr->trace_flags &= ~mask;
 
         if (mask == TRACE_ITER_RECORD_CMD)
                 trace_event_enable_cmd_record(enabled);
@@ -4558,7 +4569,7 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
         /* trace pipe does not show start of buffer */
         cpumask_setall(iter->started);
 
-        if (trace_flags & TRACE_ITER_LATENCY_FMT)
+        if (tr->trace_flags & TRACE_ITER_LATENCY_FMT)
                 iter->iter_flags |= TRACE_FILE_LAT_FMT;
 
         /* Output in nanoseconds only if we are using a clock in nanoseconds. */
@@ -4615,11 +4626,13 @@ static int tracing_release_pipe(struct inode *inode, struct file *file)
 static unsigned int
 trace_poll(struct trace_iterator *iter, struct file *filp, poll_table *poll_table)
 {
+        struct trace_array *tr = iter->tr;
+
         /* Iterators are static, they should be filled or empty */
         if (trace_buffer_iter(iter, iter->cpu_file))
                 return POLLIN | POLLRDNORM;
 
-        if (trace_flags & TRACE_ITER_BLOCK)
+        if (tr->trace_flags & TRACE_ITER_BLOCK)
                 /*
                  * Always select as readable when in blocking mode
                  */
@@ -5036,7 +5049,7 @@ tracing_free_buffer_release(struct inode *inode, struct file *filp)
         struct trace_array *tr = inode->i_private;
 
         /* disable tracing ? */
-        if (trace_flags & TRACE_ITER_STOP_ON_FREE)
+        if (tr->trace_flags & TRACE_ITER_STOP_ON_FREE)
                 tracer_tracing_off(tr);
         /* resize the ring buffer to 0 */
         tracing_resize_ring_buffer(tr, 0, RING_BUFFER_ALL_CPUS);
@@ -5069,7 +5082,7 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
         if (tracing_disabled)
                 return -EINVAL;
 
-        if (!(trace_flags & TRACE_ITER_MARKERS))
+        if (!(tr->trace_flags & TRACE_ITER_MARKERS))
                 return -EINVAL;
 
         if (cnt > TRACE_BUF_SIZE)
@@ -6180,7 +6193,7 @@ trace_options_core_read(struct file *filp, char __user *ubuf, size_t cnt,
         long index = (long)filp->private_data;
         char *buf;
 
-        if (trace_flags & (1 << index))
+        if (global_trace.trace_flags & (1 << index))
                 buf = "1\n";
         else
                 buf = "0\n";
@@ -6407,7 +6420,7 @@ allocate_trace_buffer(struct trace_array *tr, struct trace_buffer *buf, int size
 {
         enum ring_buffer_flags rb_flags;
 
-        rb_flags = trace_flags & TRACE_ITER_OVERWRITE ? RB_FL_OVERWRITE : 0;
+        rb_flags = tr->trace_flags & TRACE_ITER_OVERWRITE ? RB_FL_OVERWRITE : 0;
 
         buf->tr = tr;
 
@@ -6502,6 +6515,8 @@ static int instance_mkdir(const char *name)
         if (!alloc_cpumask_var(&tr->tracing_cpumask, GFP_KERNEL))
                 goto out_free_tr;
 
+        tr->trace_flags = global_trace.trace_flags;
+
         cpumask_copy(tr->tracing_cpumask, cpu_all_mask);
 
         raw_spin_lock_init(&tr->start_lock);
@@ -6938,6 +6953,7 @@ void ftrace_dump(enum ftrace_dump_mode oops_dump_mode)
         /* use static because iter can be a bit big for the stack */
         static struct trace_iterator iter;
         static atomic_t dump_running;
+        struct trace_array *tr = &global_trace;
         unsigned int old_userobj;
         unsigned long flags;
         int cnt = 0, cpu;
@@ -6967,10 +6983,10 @@ void ftrace_dump(enum ftrace_dump_mode oops_dump_mode)
                 atomic_inc(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
         }
 
-        old_userobj = trace_flags & TRACE_ITER_SYM_USEROBJ;
+        old_userobj = tr->trace_flags & TRACE_ITER_SYM_USEROBJ;
 
         /* don't look at user memory in panic mode */
-        trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
+        tr->trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
 
         switch (oops_dump_mode) {
         case DUMP_ALL:
@@ -7033,7 +7049,7 @@ void ftrace_dump(enum ftrace_dump_mode oops_dump_mode)
                 printk(KERN_TRACE "---------------------------------\n");
 
  out_enable:
-        trace_flags |= old_userobj;
+        tr->trace_flags |= old_userobj;
 
         for_each_tracing_cpu(cpu) {
                 atomic_dec(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 5219bf5f708a..eda4e6f8159b 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -217,6 +217,7 @@ struct trace_array {
         int                     stop_count;
         int                     clock_id;
         struct tracer           *current_trace;
+        unsigned int            trace_flags;
         unsigned int            flags;
         raw_spinlock_t          start_lock;
         struct dentry           *dir;
@@ -698,8 +699,6 @@ int trace_array_printk_buf(struct ring_buffer *buffer,
 void trace_printk_seq(struct trace_seq *s);
 enum print_line_t print_trace_line(struct trace_iterator *iter);
 
-extern unsigned long trace_flags;
-
 extern char trace_find_mark(unsigned long long duration);
 
 /* Standard output formatting function used for function return traces */
@@ -994,7 +993,7 @@ extern int enable_branch_tracing(struct trace_array *tr);
 extern void disable_branch_tracing(void);
 static inline int trace_branch_enable(struct trace_array *tr)
 {
-        if (trace_flags & TRACE_ITER_BRANCH)
+        if (tr->trace_flags & TRACE_ITER_BRANCH)
                 return enable_branch_tracing(tr);
         return 0;
 }
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index b2e3d8d80df8..0f394112a0a7 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -338,6 +338,7 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
                                          int enable, int soft_disable)
 {
         struct trace_event_call *call = file->event_call;
+        struct trace_array *tr = file->tr;
         int ret = 0;
         int disable;
 
@@ -401,7 +402,7 @@ static int __ftrace_event_enable_disable(struct trace_event_file *file,
                         if (soft_disable)
                                 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
 
-                        if (trace_flags & TRACE_ITER_RECORD_CMD) {
+                        if (tr->trace_flags & TRACE_ITER_RECORD_CMD) {
                                 tracing_start_cmdline_record();
                                 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
                         }
diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index 86e45c2658e4..92382af7a213 100644
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -112,8 +112,8 @@ enum {
 };
 
 static void
-print_graph_duration(unsigned long long duration, struct trace_seq *s,
-                     u32 flags);
+print_graph_duration(struct trace_array *tr, unsigned long long duration,
+                     struct trace_seq *s, u32 flags);
 
 /* Add a function return address to the trace stack on thread info.*/
 int
@@ -658,6 +658,7 @@ static void
 print_graph_irq(struct trace_iterator *iter, unsigned long addr,
                 enum trace_type type, int cpu, pid_t pid, u32 flags)
 {
+        struct trace_array *tr = iter->tr;
         struct trace_seq *s = &iter->seq;
         struct trace_entry *ent = iter->ent;
 
@@ -665,7 +666,7 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,
                 addr >= (unsigned long)__irqentry_text_end)
                 return;
 
-        if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
+        if (tr->trace_flags & TRACE_ITER_CONTEXT_INFO) {
                 /* Absolute time */
                 if (flags & TRACE_GRAPH_PRINT_ABS_TIME)
                         print_graph_abs_time(iter->ts, s);
@@ -681,19 +682,19 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,
                 }
 
                 /* Latency format */
-                if (trace_flags & TRACE_ITER_LATENCY_FMT)
+                if (tr->trace_flags & TRACE_ITER_LATENCY_FMT)
                         print_graph_lat_fmt(s, ent);
         }
 
         /* No overhead */
-        print_graph_duration(0, s, flags | FLAGS_FILL_START);
+        print_graph_duration(tr, 0, s, flags | FLAGS_FILL_START);
 
         if (type == TRACE_GRAPH_ENT)
                 trace_seq_puts(s, "==========>");
         else
                 trace_seq_puts(s, "<==========");
 
-        print_graph_duration(0, s, flags | FLAGS_FILL_END);
+        print_graph_duration(tr, 0, s, flags | FLAGS_FILL_END);
         trace_seq_putc(s, '\n');
 }
 
@@ -731,11 +732,11 @@ trace_print_graph_duration(unsigned long long duration, struct trace_seq *s)
 }
 
 static void
-print_graph_duration(unsigned long long duration, struct trace_seq *s,
-                     u32 flags)
+print_graph_duration(struct trace_array *tr, unsigned long long duration,
+                     struct trace_seq *s, u32 flags)
 {
         if (!(flags & TRACE_GRAPH_PRINT_DURATION) ||
-            !(trace_flags & TRACE_ITER_CONTEXT_INFO))
+            !(tr->trace_flags & TRACE_ITER_CONTEXT_INFO))
                 return;
 
         /* No real adata, just filling the column with spaces */
@@ -769,6 +770,7 @@ print_graph_entry_leaf(struct trace_iterator *iter,
                 struct trace_seq *s, u32 flags)
 {
         struct fgraph_data *data = iter->private;
+        struct trace_array *tr = iter->tr;
         struct ftrace_graph_ret *graph_ret;
         struct ftrace_graph_ent *call;
         unsigned long long duration;
@@ -797,7 +799,7 @@ print_graph_entry_leaf(struct trace_iterator *iter,
         }
 
         /* Overhead and duration */
-        print_graph_duration(duration, s, flags);
+        print_graph_duration(tr, duration, s, flags);
 
         /* Function */
         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++)
@@ -815,6 +817,7 @@ print_graph_entry_nested(struct trace_iterator *iter,
 {
         struct ftrace_graph_ent *call = &entry->graph_ent;
         struct fgraph_data *data = iter->private;
+        struct trace_array *tr = iter->tr;
         int i;
 
         if (data) {
@@ -830,7 +833,7 @@ print_graph_entry_nested(struct trace_iterator *iter,
         }
 
         /* No time */
-        print_graph_duration(0, s, flags | FLAGS_FILL_FULL);
+        print_graph_duration(tr, 0, s, flags | FLAGS_FILL_FULL);
 
         /* Function */
         for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++)
@@ -854,6 +857,7 @@ print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,
 {
         struct fgraph_data *data = iter->private;
         struct trace_entry *ent = iter->ent;
+        struct trace_array *tr = iter->tr;
         int cpu = iter->cpu;
 
         /* Pid */
@@ -863,7 +867,7 @@ print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,
                 /* Interrupt */
                 print_graph_irq(iter, addr, type, cpu, ent->pid, flags);
 
-        if (!(trace_flags & TRACE_ITER_CONTEXT_INFO))
+        if (!(tr->trace_flags & TRACE_ITER_CONTEXT_INFO))
                 return;
 
         /* Absolute time */
@@ -881,7 +885,7 @@ print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,
         }
 
         /* Latency format */
-        if (trace_flags & TRACE_ITER_LATENCY_FMT)
+        if (tr->trace_flags & TRACE_ITER_LATENCY_FMT)
                 print_graph_lat_fmt(s, ent);
 
         return;
@@ -1032,6 +1036,7 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
 {
         unsigned long long duration = trace->rettime - trace->calltime;
         struct fgraph_data *data = iter->private;
+        struct trace_array *tr = iter->tr;
         pid_t pid = ent->pid;
         int cpu = iter->cpu;
         int func_match = 1;
@@ -1063,7 +1068,7 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
         print_graph_prologue(iter, s, 0, 0, flags);
 
         /* Overhead and duration */
-        print_graph_duration(duration, s, flags);
+        print_graph_duration(tr, duration, s, flags);
 
         /* Closing brace */
         for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++)
@@ -1096,7 +1101,8 @@ static enum print_line_t
 print_graph_comment(struct trace_seq *s, struct trace_entry *ent,
                     struct trace_iterator *iter, u32 flags)
 {
-        unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
+        struct trace_array *tr = iter->tr;
+        unsigned long sym_flags = (tr->trace_flags & TRACE_ITER_SYM_MASK);
         struct fgraph_data *data = iter->private;
         struct trace_event *event;
         int depth = 0;
@@ -1109,7 +1115,7 @@ print_graph_comment(struct trace_seq *s, struct trace_entry *ent,
         print_graph_prologue(iter, s, 0, 0, flags);
 
         /* No time */
-        print_graph_duration(0, s, flags | FLAGS_FILL_FULL);
+        print_graph_duration(tr, 0, s, flags | FLAGS_FILL_FULL);
 
         /* Indentation */
         if (depth > 0)
@@ -1250,9 +1256,10 @@ static void print_lat_header(struct seq_file *s, u32 flags)
         seq_printf(s, "#%.*s||| /                      \n", size, spaces);
 }
 
-static void __print_graph_headers_flags(struct seq_file *s, u32 flags)
+static void __print_graph_headers_flags(struct trace_array *tr,
+                                        struct seq_file *s, u32 flags)
 {
-        int lat = trace_flags & TRACE_ITER_LATENCY_FMT;
+        int lat = tr->trace_flags & TRACE_ITER_LATENCY_FMT;
 
         if (lat)
                 print_lat_header(s, flags);
@@ -1294,11 +1301,12 @@ static void print_graph_headers(struct seq_file *s)
 void print_graph_headers_flags(struct seq_file *s, u32 flags)
 {
         struct trace_iterator *iter = s->private;
+        struct trace_array *tr = iter->tr;
 
-        if (!(trace_flags & TRACE_ITER_CONTEXT_INFO))
+        if (!(tr->trace_flags & TRACE_ITER_CONTEXT_INFO))
                 return;
 
-        if (trace_flags & TRACE_ITER_LATENCY_FMT) {
+        if (tr->trace_flags & TRACE_ITER_LATENCY_FMT) {
                 /* print nothing if the buffers are empty */
                 if (trace_empty(iter))
                         return;
@@ -1306,7 +1314,7 @@ void print_graph_headers_flags(struct seq_file *s, u32 flags)
                 print_trace_header(s, iter);
         }
 
-        __print_graph_headers_flags(s, flags);
+        __print_graph_headers_flags(tr, s, flags);
 }
 
 void graph_trace_open(struct trace_iterator *iter)
diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
index c834b95cbe0b..eaf5291bcf63 100644
--- a/kernel/trace/trace_irqsoff.c
+++ b/kernel/trace/trace_irqsoff.c
@@ -58,13 +58,13 @@ irq_trace(void)
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 static int irqsoff_display_graph(struct trace_array *tr, int set);
-# define is_graph() (trace_flags & TRACE_ITER_DISPLAY_GRAPH)
+# define is_graph(tr) ((tr)->trace_flags & TRACE_ITER_DISPLAY_GRAPH)
 #else
 static inline int irqsoff_display_graph(struct trace_array *tr, int set)
 {
         return -EINVAL;
 }
-# define is_graph() false
+# define is_graph(tr) false
 #endif
 
 /*
@@ -149,7 +149,7 @@ static int irqsoff_display_graph(struct trace_array *tr, int set)
 {
         int cpu;
 
-        if (!(is_graph() ^ set))
+        if (!(is_graph(tr) ^ set))
                 return 0;
 
         stop_irqsoff_tracer(irqsoff_trace, !set);
@@ -198,7 +198,7 @@ static void irqsoff_graph_return(struct ftrace_graph_ret *trace)
 
 static void irqsoff_trace_open(struct trace_iterator *iter)
 {
-        if (is_graph())
+        if (is_graph(iter->tr))
                 graph_trace_open(iter);
 
 }
@@ -220,7 +220,7 @@ static enum print_line_t irqsoff_print_line(struct trace_iterator *iter)
          * In graph mode call the graph tracer output function,
          * otherwise go with the TRACE_FN event handler
          */
-        if (is_graph())
+        if (is_graph(iter->tr))
                 return print_graph_function_flags(iter, GRAPH_TRACER_FLAGS);
 
         return TRACE_TYPE_UNHANDLED;
@@ -228,7 +228,9 @@ static enum print_line_t irqsoff_print_line(struct trace_iterator *iter)
 
 static void irqsoff_print_header(struct seq_file *s)
 {
-        if (is_graph())
+        struct trace_array *tr = irqsoff_trace;
+
+        if (is_graph(tr))
                 print_graph_headers_flags(s, GRAPH_TRACER_FLAGS);
         else
                 trace_default_header(s);
@@ -239,7 +241,7 @@ __trace_function(struct trace_array *tr,
                  unsigned long ip, unsigned long parent_ip,
                  unsigned long flags, int pc)
 {
-        if (is_graph())
+        if (is_graph(tr))
                 trace_graph_function(tr, ip, parent_ip, flags, pc);
         else
                 trace_function(tr, ip, parent_ip, flags, pc);
@@ -516,7 +518,7 @@ static int register_irqsoff_function(struct trace_array *tr, int graph, int set)
         int ret;
 
         /* 'set' is set if TRACE_ITER_FUNCTION is about to be set */
-        if (function_enabled || (!set && !(trace_flags & TRACE_ITER_FUNCTION)))
+        if (function_enabled || (!set && !(tr->trace_flags & TRACE_ITER_FUNCTION)))
                 return 0;
 
         if (graph)
@@ -550,9 +552,9 @@ static int irqsoff_function_set(struct trace_array *tr, u32 mask, int set)
                 return 0;
 
         if (set)
-                register_irqsoff_function(tr, is_graph(), 1);
+                register_irqsoff_function(tr, is_graph(tr), 1);
         else
-                unregister_irqsoff_function(tr, is_graph());
+                unregister_irqsoff_function(tr, is_graph(tr));
         return 1;
 }
 #else
@@ -610,7 +612,7 @@ static int __irqsoff_tracer_init(struct trace_array *tr)
         if (irqsoff_busy)
                 return -EBUSY;
 
-        save_flags = trace_flags;
+        save_flags = tr->trace_flags;
 
         /* non overwrite screws up the latency tracers */
         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, 1);
@@ -626,7 +628,7 @@ static int __irqsoff_tracer_init(struct trace_array *tr)
 
         /* Only toplevel instance supports graph tracing */
         if (start_irqsoff_tracer(tr, (tr->flags & TRACE_ARRAY_FL_GLOBAL &&
-                                      is_graph())))
+                                      is_graph(tr))))
                 printk(KERN_ERR "failed to start irqsoff tracer\n");
 
         irqsoff_busy = true;
@@ -638,7 +640,7 @@ static void irqsoff_tracer_reset(struct trace_array *tr)
         int lat_flag = save_flags & TRACE_ITER_LATENCY_FMT;
         int overwrite_flag = save_flags & TRACE_ITER_OVERWRITE;
 
-        stop_irqsoff_tracer(tr, is_graph());
+        stop_irqsoff_tracer(tr, is_graph(tr));
 
         set_tracer_flag(tr, TRACE_ITER_LATENCY_FMT, lat_flag);
         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, overwrite_flag);
diff --git a/kernel/trace/trace_kdb.c b/kernel/trace/trace_kdb.c
index 3ccf5c2c1320..57149bce6aad 100644
--- a/kernel/trace/trace_kdb.c
+++ b/kernel/trace/trace_kdb.c
@@ -21,20 +21,22 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)
         /* use static because iter can be a bit big for the stack */
         static struct trace_iterator iter;
         static struct ring_buffer_iter *buffer_iter[CONFIG_NR_CPUS];
+        struct trace_array *tr;
         unsigned int old_userobj;
         int cnt = 0, cpu;
 
         trace_init_global_iter(&iter);
         iter.buffer_iter = buffer_iter;
+        tr = iter.tr;
 
         for_each_tracing_cpu(cpu) {
                 atomic_inc(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
         }
 
-        old_userobj = trace_flags;
+        old_userobj = tr->trace_flags;
 
         /* don't look at user memory in panic mode */
-        trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
+        tr->trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
 
         kdb_printf("Dumping ftrace buffer:\n");
 
@@ -82,7 +84,7 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)
                 kdb_printf("---------------------------------\n");
 
 out:
-        trace_flags = old_userobj;
+        tr->trace_flags = old_userobj;
 
         for_each_tracing_cpu(cpu) {
                 atomic_dec(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index 3b5dcdf19dea..282982195e09 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -476,7 +476,8 @@ char trace_find_mark(unsigned long long d)
 static int
 lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
 {
-        unsigned long verbose = trace_flags & TRACE_ITER_VERBOSE;
+        struct trace_array *tr = iter->tr;
+        unsigned long verbose = tr->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->trace_buffer->time_start;
         unsigned long long rel_ts = next_ts - iter->ts;
@@ -519,6 +520,7 @@ lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
 
 int trace_print_context(struct trace_iterator *iter)
 {
+        struct trace_array *tr = iter->tr;
         struct trace_seq *s = &iter->seq;
         struct trace_entry *entry = iter->ent;
         unsigned long long t;
@@ -530,7 +532,7 @@ int trace_print_context(struct trace_iterator *iter)
         trace_seq_printf(s, "%16s-%-5d [%03d] ",
                                comm, entry->pid, iter->cpu);
 
-        if (trace_flags & TRACE_ITER_IRQ_INFO)
+        if (tr->trace_flags & TRACE_ITER_IRQ_INFO)
                 trace_print_lat_fmt(s, entry);
 
         if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) {
@@ -546,14 +548,15 @@ int trace_print_context(struct trace_iterator *iter)
 
 int trace_print_lat_context(struct trace_iterator *iter)
 {
-        u64 next_ts;
+        struct trace_array *tr = iter->tr;
         /* trace_find_next_entry will reset ent_size */
         int ent_size = iter->ent_size;
         struct trace_seq *s = &iter->seq;
+        u64 next_ts;
         struct trace_entry *entry = iter->ent,
                            *next_entry = trace_find_next_entry(iter, NULL,
                                                                &next_ts);
-        unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE);
+        unsigned long verbose = (tr->trace_flags & TRACE_ITER_VERBOSE);
 
         /* Restore the original ent_size */
         iter->ent_size = ent_size;
@@ -1035,6 +1038,7 @@ static struct trace_event trace_stack_event = {
 static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
                                                 int flags, struct trace_event *event)
 {
+        struct trace_array *tr = iter->tr;
         struct userstack_entry *field;
         struct trace_seq *s = &iter->seq;
         struct mm_struct *mm = NULL;
@@ -1044,7 +1048,7 @@ static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
 
         trace_seq_puts(s, "<user stack trace>\n");
 
-        if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
+        if (tr->trace_flags & TRACE_ITER_SYM_USEROBJ) {
                 struct task_struct *task;
                 /*
                  * we do the lookup on the thread group leader,
diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
index 4a20f61274d1..4661442de07d 100644
--- a/kernel/trace/trace_sched_wakeup.c
+++ b/kernel/trace/trace_sched_wakeup.c
@@ -39,13 +39,13 @@ static int save_flags;
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 static int wakeup_display_graph(struct trace_array *tr, int set);
-# define is_graph() (trace_flags & TRACE_ITER_DISPLAY_GRAPH)
+# define is_graph(tr) ((tr)->trace_flags & TRACE_ITER_DISPLAY_GRAPH)
 #else
 static inline int wakeup_display_graph(struct trace_array *tr, int set)
 {
         return 0;
 }
-# define is_graph() false
+# define is_graph(tr) false
 #endif
 
 
@@ -131,7 +131,7 @@ static int register_wakeup_function(struct trace_array *tr, int graph, int set)
         int ret;
 
         /* 'set' is set if TRACE_ITER_FUNCTION is about to be set */
-        if (function_enabled || (!set && !(trace_flags & TRACE_ITER_FUNCTION)))
+        if (function_enabled || (!set && !(tr->trace_flags & TRACE_ITER_FUNCTION)))
                 return 0;
 
         if (graph)
@@ -165,9 +165,9 @@ static int wakeup_function_set(struct trace_array *tr, u32 mask, int set)
                 return 0;
 
         if (set)
-                register_wakeup_function(tr, is_graph(), 1);
+                register_wakeup_function(tr, is_graph(tr), 1);
         else
-                unregister_wakeup_function(tr, is_graph());
+                unregister_wakeup_function(tr, is_graph(tr));
         return 1;
 }
 #else
@@ -221,7 +221,7 @@ static void stop_func_tracer(struct trace_array *tr, int graph)
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 static int wakeup_display_graph(struct trace_array *tr, int set)
 {
-        if (!(is_graph() ^ set))
+        if (!(is_graph(tr) ^ set))
                 return 0;
 
         stop_func_tracer(tr, !set);
@@ -270,7 +270,7 @@ static void wakeup_graph_return(struct ftrace_graph_ret *trace)
 
 static void wakeup_trace_open(struct trace_iterator *iter)
 {
-        if (is_graph())
+        if (is_graph(iter->tr))
                 graph_trace_open(iter);
 }
 
@@ -290,7 +290,7 @@ static enum print_line_t wakeup_print_line(struct trace_iterator *iter)
          * In graph mode call the graph tracer output function,
          * otherwise go with the TRACE_FN event handler
          */
-        if (is_graph())
+        if (is_graph(iter->tr))
                 return print_graph_function_flags(iter, GRAPH_TRACER_FLAGS);
 
         return TRACE_TYPE_UNHANDLED;
@@ -298,7 +298,7 @@ static enum print_line_t wakeup_print_line(struct trace_iterator *iter)
 
 static void wakeup_print_header(struct seq_file *s)
 {
-        if (is_graph())
+        if (is_graph(wakeup_trace))
                 print_graph_headers_flags(s, GRAPH_TRACER_FLAGS);
         else
                 trace_default_header(s);
@@ -309,7 +309,7 @@ __trace_function(struct trace_array *tr,
                  unsigned long ip, unsigned long parent_ip,
                  unsigned long flags, int pc)
 {
-        if (is_graph())
+        if (is_graph(tr))
                 trace_graph_function(tr, ip, parent_ip, flags, pc);
         else
                 trace_function(tr, ip, parent_ip, flags, pc);
@@ -639,7 +639,7 @@ static void start_wakeup_tracer(struct trace_array *tr)
          */
         smp_wmb();
 
-        if (start_func_tracer(tr, is_graph()))
+        if (start_func_tracer(tr, is_graph(tr)))
                 printk(KERN_ERR "failed to start wakeup tracer\n");
 
         return;
@@ -652,7 +652,7 @@ fail_deprobe:
 static void stop_wakeup_tracer(struct trace_array *tr)
 {
         tracer_enabled = 0;
-        stop_func_tracer(tr, is_graph());
+        stop_func_tracer(tr, is_graph(tr));
         unregister_trace_sched_switch(probe_wakeup_sched_switch, NULL);
         unregister_trace_sched_wakeup_new(probe_wakeup, NULL);
         unregister_trace_sched_wakeup(probe_wakeup, NULL);
@@ -663,7 +663,7 @@ static bool wakeup_busy;
 
 static int __wakeup_tracer_init(struct trace_array *tr)
 {
-        save_flags = trace_flags;
+        save_flags = tr->trace_flags;
 
         /* non overwrite screws up the latency tracers */
         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, 1);
diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
index 7d567a4b9fa7..0655afbea83f 100644
--- a/kernel/trace/trace_syscalls.c
+++ b/kernel/trace/trace_syscalls.c
@@ -110,6 +110,7 @@ static enum print_line_t
 print_syscall_enter(struct trace_iterator *iter, int flags,
                     struct trace_event *event)
 {
+        struct trace_array *tr = iter->tr;
         struct trace_seq *s = &iter->seq;
         struct trace_entry *ent = iter->ent;
         struct syscall_trace_enter *trace;
@@ -136,7 +137,7 @@ print_syscall_enter(struct trace_iterator *iter, int flags,
                         goto end;
 
                 /* parameter types */
-                if (trace_flags & TRACE_ITER_VERBOSE)
+                if (tr->trace_flags & TRACE_ITER_VERBOSE)
                         trace_seq_printf(s, "%s ", entry->types[i]);
 
                 /* parameter values */