Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 983f938a authored by Steven Rostedt (Red Hat)'s avatar Steven Rostedt (Red Hat) Committed by Steven Rostedt
Browse files

tracing: Move trace_flags from global to a trace_array field 



In preparation to make trace options per instance, the global trace_flags
needs to be moved from being a global variable to a field within the trace
instance trace_array structure.

There's still more work to do, as there's some functions that use
trace_flags without passing in a way to get to the current_trace array. For
those, the global_trace is used directly (from trace.c). This includes
setting and clearing the trace_flags. This means that when a new instance is
created, it just gets the trace_flags of the global_trace and will not be
able to modify them. Depending on the functions that have access to the
trace_array, the flags of an instance may not affect parts of its trace,
where the global_trace is used. These will be fixed in future changes.

Signed-off-by: default avatarSteven Rostedt <rostedt@goodmis.org>
parent 55577204

kernel/trace/blktrace.c

+4 −3
Original line number Diff line number Diff line
@@ -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;

}

kernel/trace/trace.c

+54 −38
Original line number Diff line number Diff line
@@ -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);

kernel/trace/trace.h

+2 −3
Original line number Diff line number Diff line
@@ -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;

}

kernel/trace/trace_events.c

+2 −1
Original line number Diff line number Diff line
@@ -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);

			}

kernel/trace/trace_functions_graph.c

+29 −21
Original line number Diff line number Diff line
@@ -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)