tracing: Have graph flags passed in to ouput functions (d7a8d9e9) · Commits · 戴 / test

kernel/trace/trace.h

+4 −2

Original line number	Original line	Diff line number	Diff line
	@@ -491,7 +491,9 @@ extern int trace_clock_id;

	/* Standard output formatting function used for function return traces */		/* Standard output formatting function used for function return traces */
	#ifdef CONFIG_FUNCTION_GRAPH_TRACER		#ifdef CONFIG_FUNCTION_GRAPH_TRACER
	extern enum print_line_t print_graph_function(struct trace_iterator *iter);		extern enum print_line_t
			print_graph_function_flags(struct trace_iterator *iter, u32 flags);
			extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
	extern enum print_line_t		extern enum print_line_t
	trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);		trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);

	@@ -524,7 +526,7 @@ static inline int ftrace_graph_addr(unsigned long addr)
	#endif /* CONFIG_DYNAMIC_FTRACE */		#endif /* CONFIG_DYNAMIC_FTRACE */
	#else /* CONFIG_FUNCTION_GRAPH_TRACER */		#else /* CONFIG_FUNCTION_GRAPH_TRACER */
	static inline enum print_line_t		static inline enum print_line_t
	print_graph_function(struct trace_iterator *iter)		print_graph_function_flags(struct trace_iterator *iter, u32 flags)
	{		{
	return TRACE_TYPE_UNHANDLED;		return TRACE_TYPE_UNHANDLED;
	}		}

kernel/trace/trace_functions_graph.c

+69 −54

Original line number	Original line	Diff line number	Diff line
	@@ -527,17 +527,18 @@ get_return_for_leaf(struct trace_iterator *iter,

	/* Signal a overhead of time execution to the output */		/* Signal a overhead of time execution to the output */
	static int		static int
	print_graph_overhead(unsigned long long duration, struct trace_seq *s)		print_graph_overhead(unsigned long long duration, struct trace_seq *s,
			u32 flags)
	{		{
	/* If duration disappear, we don't need anything */		/* If duration disappear, we don't need anything */
	if (!(tracer_flags.val & TRACE_GRAPH_PRINT_DURATION))		if (!(flags & TRACE_GRAPH_PRINT_DURATION))
	return 1;		return 1;

	/* Non nested entry or return */		/* Non nested entry or return */
	if (duration == -1)		if (duration == -1)
	return trace_seq_printf(s, " ");		return trace_seq_printf(s, " ");

	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {		if (flags & TRACE_GRAPH_PRINT_OVERHEAD) {
	/* Duration exceeded 100 msecs */		/* Duration exceeded 100 msecs */
	if (duration > 100000ULL)		if (duration > 100000ULL)
	return trace_seq_printf(s, "! ");		return trace_seq_printf(s, "! ");
	@@ -563,7 +564,7 @@ static int print_graph_abs_time(u64 t, struct trace_seq *s)

	static enum print_line_t		static enum print_line_t
	print_graph_irq(struct trace_iterator *iter, unsigned long addr,		print_graph_irq(struct trace_iterator *iter, unsigned long addr,
	enum trace_type type, int cpu, pid_t pid)		enum trace_type type, int cpu, pid_t pid, u32 flags)
	{		{
	int ret;		int ret;
	struct trace_seq *s = &iter->seq;		struct trace_seq *s = &iter->seq;
	@@ -573,21 +574,21 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,
	return TRACE_TYPE_UNHANDLED;		return TRACE_TYPE_UNHANDLED;

	/* Absolute time */		/* Absolute time */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {		if (flags & TRACE_GRAPH_PRINT_ABS_TIME) {
	ret = print_graph_abs_time(iter->ts, s);		ret = print_graph_abs_time(iter->ts, s);
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	}		}

	/* Cpu */		/* Cpu */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {		if (flags & TRACE_GRAPH_PRINT_CPU) {
	ret = print_graph_cpu(s, cpu);		ret = print_graph_cpu(s, cpu);
	if (ret == TRACE_TYPE_PARTIAL_LINE)		if (ret == TRACE_TYPE_PARTIAL_LINE)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	}		}

	/* Proc */		/* Proc */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {		if (flags & TRACE_GRAPH_PRINT_PROC) {
	ret = print_graph_proc(s, pid);		ret = print_graph_proc(s, pid);
	if (ret == TRACE_TYPE_PARTIAL_LINE)		if (ret == TRACE_TYPE_PARTIAL_LINE)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	@@ -597,7 +598,7 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,
	}		}

	/* No overhead */		/* No overhead */
	ret = print_graph_overhead(-1, s);		ret = print_graph_overhead(-1, s, flags);
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	@@ -610,7 +611,7 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	/* Don't close the duration column if haven't one */		/* Don't close the duration column if haven't one */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)		if (flags & TRACE_GRAPH_PRINT_DURATION)
	trace_seq_printf(s, " \|");		trace_seq_printf(s, " \|");
	ret = trace_seq_printf(s, "\n");		ret = trace_seq_printf(s, "\n");

	@@ -680,7 +681,8 @@ print_graph_duration(unsigned long long duration, struct trace_seq *s)
	static enum print_line_t		static enum print_line_t
	print_graph_entry_leaf(struct trace_iterator *iter,		print_graph_entry_leaf(struct trace_iterator *iter,
	struct ftrace_graph_ent_entry *entry,		struct ftrace_graph_ent_entry *entry,
	struct ftrace_graph_ret_entry ret_entry, struct trace_seq s)		struct ftrace_graph_ret_entry *ret_entry,
			struct trace_seq *s, u32 flags)
	{		{
	struct fgraph_data *data = iter->private;		struct fgraph_data *data = iter->private;
	struct ftrace_graph_ret *graph_ret;		struct ftrace_graph_ret *graph_ret;
	@@ -712,12 +714,12 @@ print_graph_entry_leaf(struct trace_iterator *iter,
	}		}

	/* Overhead */		/* Overhead */
	ret = print_graph_overhead(duration, s);		ret = print_graph_overhead(duration, s, flags);
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	/* Duration */		/* Duration */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {		if (flags & TRACE_GRAPH_PRINT_DURATION) {
	ret = print_graph_duration(duration, s);		ret = print_graph_duration(duration, s);
	if (ret == TRACE_TYPE_PARTIAL_LINE)		if (ret == TRACE_TYPE_PARTIAL_LINE)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	@@ -740,7 +742,7 @@ print_graph_entry_leaf(struct trace_iterator *iter,
	static enum print_line_t		static enum print_line_t
	print_graph_entry_nested(struct trace_iterator *iter,		print_graph_entry_nested(struct trace_iterator *iter,
	struct ftrace_graph_ent_entry *entry,		struct ftrace_graph_ent_entry *entry,
	struct trace_seq *s, int cpu)		struct trace_seq *s, int cpu, u32 flags)
	{		{
	struct ftrace_graph_ent *call = &entry->graph_ent;		struct ftrace_graph_ent *call = &entry->graph_ent;
	struct fgraph_data *data = iter->private;		struct fgraph_data *data = iter->private;
	@@ -760,12 +762,12 @@ print_graph_entry_nested(struct trace_iterator *iter,
	}		}

	/* No overhead */		/* No overhead */
	ret = print_graph_overhead(-1, s);		ret = print_graph_overhead(-1, s, flags);
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	/* No time */		/* No time */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {		if (flags & TRACE_GRAPH_PRINT_DURATION) {
	ret = trace_seq_printf(s, " \| ");		ret = trace_seq_printf(s, " \| ");
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	@@ -791,7 +793,7 @@ print_graph_entry_nested(struct trace_iterator *iter,

	static enum print_line_t		static enum print_line_t
	print_graph_prologue(struct trace_iterator iter, struct trace_seq s,		print_graph_prologue(struct trace_iterator iter, struct trace_seq s,
	int type, unsigned long addr)		int type, unsigned long addr, u32 flags)
	{		{
	struct fgraph_data *data = iter->private;		struct fgraph_data *data = iter->private;
	struct trace_entry *ent = iter->ent;		struct trace_entry *ent = iter->ent;
	@@ -804,27 +806,27 @@ print_graph_prologue(struct trace_iterator iter, struct trace_seq s,

	if (type) {		if (type) {
	/* Interrupt */		/* Interrupt */
	ret = print_graph_irq(iter, addr, type, cpu, ent->pid);		ret = print_graph_irq(iter, addr, type, cpu, ent->pid, flags);
	if (ret == TRACE_TYPE_PARTIAL_LINE)		if (ret == TRACE_TYPE_PARTIAL_LINE)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	}		}

	/* Absolute time */		/* Absolute time */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {		if (flags & TRACE_GRAPH_PRINT_ABS_TIME) {
	ret = print_graph_abs_time(iter->ts, s);		ret = print_graph_abs_time(iter->ts, s);
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	}		}

	/* Cpu */		/* Cpu */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {		if (flags & TRACE_GRAPH_PRINT_CPU) {
	ret = print_graph_cpu(s, cpu);		ret = print_graph_cpu(s, cpu);
	if (ret == TRACE_TYPE_PARTIAL_LINE)		if (ret == TRACE_TYPE_PARTIAL_LINE)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	}		}

	/* Proc */		/* Proc */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {		if (flags & TRACE_GRAPH_PRINT_PROC) {
	ret = print_graph_proc(s, ent->pid);		ret = print_graph_proc(s, ent->pid);
	if (ret == TRACE_TYPE_PARTIAL_LINE)		if (ret == TRACE_TYPE_PARTIAL_LINE)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	@@ -846,7 +848,7 @@ print_graph_prologue(struct trace_iterator iter, struct trace_seq s,

	static enum print_line_t		static enum print_line_t
	print_graph_entry(struct ftrace_graph_ent_entry field, struct trace_seq s,		print_graph_entry(struct ftrace_graph_ent_entry field, struct trace_seq s,
	struct trace_iterator *iter)		struct trace_iterator *iter, u32 flags)
	{		{
	struct fgraph_data *data = iter->private;		struct fgraph_data *data = iter->private;
	struct ftrace_graph_ent *call = &field->graph_ent;		struct ftrace_graph_ent *call = &field->graph_ent;
	@@ -854,14 +856,14 @@ print_graph_entry(struct ftrace_graph_ent_entry field, struct trace_seq s,
	static enum print_line_t ret;		static enum print_line_t ret;
	int cpu = iter->cpu;		int cpu = iter->cpu;

	if (print_graph_prologue(iter, s, TRACE_GRAPH_ENT, call->func))		if (print_graph_prologue(iter, s, TRACE_GRAPH_ENT, call->func, flags))
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	leaf_ret = get_return_for_leaf(iter, field);		leaf_ret = get_return_for_leaf(iter, field);
	if (leaf_ret)		if (leaf_ret)
	ret = print_graph_entry_leaf(iter, field, leaf_ret, s);		ret = print_graph_entry_leaf(iter, field, leaf_ret, s, flags);
	else		else
	ret = print_graph_entry_nested(iter, field, s, cpu);		ret = print_graph_entry_nested(iter, field, s, cpu, flags);

	if (data) {		if (data) {
	/*		/*
	@@ -880,7 +882,8 @@ print_graph_entry(struct ftrace_graph_ent_entry field, struct trace_seq s,

	static enum print_line_t		static enum print_line_t
	print_graph_return(struct ftrace_graph_ret trace, struct trace_seq s,		print_graph_return(struct ftrace_graph_ret trace, struct trace_seq s,
	struct trace_entry ent, struct trace_iterator iter)		struct trace_entry ent, struct trace_iterator iter,
			u32 flags)
	{		{
	unsigned long long duration = trace->rettime - trace->calltime;		unsigned long long duration = trace->rettime - trace->calltime;
	struct fgraph_data *data = iter->private;		struct fgraph_data *data = iter->private;
	@@ -910,16 +913,16 @@ print_graph_return(struct ftrace_graph_ret trace, struct trace_seq s,
	}		}
	}		}

	if (print_graph_prologue(iter, s, 0, 0))		if (print_graph_prologue(iter, s, 0, 0, flags))
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	/* Overhead */		/* Overhead */
	ret = print_graph_overhead(duration, s);		ret = print_graph_overhead(duration, s, flags);
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	/* Duration */		/* Duration */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {		if (flags & TRACE_GRAPH_PRINT_DURATION) {
	ret = print_graph_duration(duration, s);		ret = print_graph_duration(duration, s);
	if (ret == TRACE_TYPE_PARTIAL_LINE)		if (ret == TRACE_TYPE_PARTIAL_LINE)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	@@ -949,14 +952,15 @@ print_graph_return(struct ftrace_graph_ret trace, struct trace_seq s,
	}		}

	/* Overrun */		/* Overrun */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERRUN) {		if (flags & TRACE_GRAPH_PRINT_OVERRUN) {
	ret = trace_seq_printf(s, " (Overruns: %lu)\n",		ret = trace_seq_printf(s, " (Overruns: %lu)\n",
	trace->overrun);		trace->overrun);
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	}		}

	ret = print_graph_irq(iter, trace->func, TRACE_GRAPH_RET, cpu, pid);		ret = print_graph_irq(iter, trace->func, TRACE_GRAPH_RET,
			cpu, pid, flags);
	if (ret == TRACE_TYPE_PARTIAL_LINE)		if (ret == TRACE_TYPE_PARTIAL_LINE)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	@@ -965,7 +969,7 @@ print_graph_return(struct ftrace_graph_ret trace, struct trace_seq s,

	static enum print_line_t		static enum print_line_t
	print_graph_comment(struct trace_seq s, struct trace_entry ent,		print_graph_comment(struct trace_seq s, struct trace_entry ent,
	struct trace_iterator *iter)		struct trace_iterator *iter, u32 flags)
	{		{
	unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);		unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
	struct fgraph_data *data = iter->private;		struct fgraph_data *data = iter->private;
	@@ -977,16 +981,16 @@ print_graph_comment(struct trace_seq s, struct trace_entry ent,
	if (data)		if (data)
	depth = per_cpu_ptr(data->cpu_data, iter->cpu)->depth;		depth = per_cpu_ptr(data->cpu_data, iter->cpu)->depth;

	if (print_graph_prologue(iter, s, 0, 0))		if (print_graph_prologue(iter, s, 0, 0, flags))
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	/* No overhead */		/* No overhead */
	ret = print_graph_overhead(-1, s);		ret = print_graph_overhead(-1, s, flags);
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;

	/* No time */		/* No time */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {		if (flags & TRACE_GRAPH_PRINT_DURATION) {
	ret = trace_seq_printf(s, " \| ");		ret = trace_seq_printf(s, " \| ");
	if (!ret)		if (!ret)
	return TRACE_TYPE_PARTIAL_LINE;		return TRACE_TYPE_PARTIAL_LINE;
	@@ -1041,7 +1045,7 @@ print_graph_comment(struct trace_seq s, struct trace_entry ent,


	enum print_line_t		enum print_line_t
	print_graph_function(struct trace_iterator *iter)		print_graph_function_flags(struct trace_iterator *iter, u32 flags)
	{		{
	struct ftrace_graph_ent_entry *field;		struct ftrace_graph_ent_entry *field;
	struct fgraph_data *data = iter->private;		struct fgraph_data *data = iter->private;
	@@ -1062,7 +1066,7 @@ print_graph_function(struct trace_iterator *iter)
	if (data && data->failed) {		if (data && data->failed) {
	field = &data->ent;		field = &data->ent;
	iter->cpu = data->cpu;		iter->cpu = data->cpu;
	ret = print_graph_entry(field, s, iter);		ret = print_graph_entry(field, s, iter, flags);
	if (ret == TRACE_TYPE_HANDLED && iter->cpu != cpu) {		if (ret == TRACE_TYPE_HANDLED && iter->cpu != cpu) {
	per_cpu_ptr(data->cpu_data, iter->cpu)->ignore = 1;		per_cpu_ptr(data->cpu_data, iter->cpu)->ignore = 1;
	ret = TRACE_TYPE_NO_CONSUME;		ret = TRACE_TYPE_NO_CONSUME;
	@@ -1082,38 +1086,44 @@ print_graph_function(struct trace_iterator *iter)
	struct ftrace_graph_ent_entry saved;		struct ftrace_graph_ent_entry saved;
	trace_assign_type(field, entry);		trace_assign_type(field, entry);
	saved = *field;		saved = *field;
	return print_graph_entry(&saved, s, iter);		return print_graph_entry(&saved, s, iter, flags);
	}		}
	case TRACE_GRAPH_RET: {		case TRACE_GRAPH_RET: {
	struct ftrace_graph_ret_entry *field;		struct ftrace_graph_ret_entry *field;
	trace_assign_type(field, entry);		trace_assign_type(field, entry);
	return print_graph_return(&field->ret, s, entry, iter);		return print_graph_return(&field->ret, s, entry, iter, flags);
	}		}
	default:		default:
	return print_graph_comment(s, entry, iter);		return print_graph_comment(s, entry, iter, flags);
	}		}

	return TRACE_TYPE_HANDLED;		return TRACE_TYPE_HANDLED;
	}		}

			static enum print_line_t
			print_graph_function(struct trace_iterator *iter)
			{
			return print_graph_function_flags(iter, tracer_flags.val);
			}

	static enum print_line_t		static enum print_line_t
	print_graph_function_event(struct trace_iterator *iter, int flags)		print_graph_function_event(struct trace_iterator *iter, int flags)
	{		{
	return print_graph_function(iter);		return print_graph_function(iter);
	}		}

	static void print_lat_header(struct seq_file *s)		static void print_lat_header(struct seq_file *s, u32 flags)
	{		{
	static const char spaces[] = " " /* 16 spaces */		static const char spaces[] = " " /* 16 spaces */
	" " /* 4 spaces */		" " /* 4 spaces */
	" "; /* 17 spaces */		" "; /* 17 spaces */
	int size = 0;		int size = 0;

	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)		if (flags & TRACE_GRAPH_PRINT_ABS_TIME)
	size += 16;		size += 16;
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)		if (flags & TRACE_GRAPH_PRINT_CPU)
	size += 4;		size += 4;
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)		if (flags & TRACE_GRAPH_PRINT_PROC)
	size += 17;		size += 17;

	seq_printf(s, "#%.*s _-----=> irqs-off \n", size, spaces);		seq_printf(s, "#%.*s _-----=> irqs-off \n", size, spaces);
	@@ -1124,42 +1134,47 @@ static void print_lat_header(struct seq_file *s)
	seq_printf(s, "#%.*s\|\|\|\| / \n", size, spaces);		seq_printf(s, "#%.*s\|\|\|\| / \n", size, spaces);
	}		}

	static void print_graph_headers(struct seq_file *s)		void print_graph_headers_flags(struct seq_file *s, u32 flags)
	{		{
	int lat = trace_flags & TRACE_ITER_LATENCY_FMT;		int lat = trace_flags & TRACE_ITER_LATENCY_FMT;

	if (lat)		if (lat)
	print_lat_header(s);		print_lat_header(s, flags);

	/* 1st line */		/* 1st line */
	seq_printf(s, "#");		seq_printf(s, "#");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)		if (flags & TRACE_GRAPH_PRINT_ABS_TIME)
	seq_printf(s, " TIME ");		seq_printf(s, " TIME ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)		if (flags & TRACE_GRAPH_PRINT_CPU)
	seq_printf(s, " CPU");		seq_printf(s, " CPU");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)		if (flags & TRACE_GRAPH_PRINT_PROC)
	seq_printf(s, " TASK/PID ");		seq_printf(s, " TASK/PID ");
	if (lat)		if (lat)
	seq_printf(s, "\|\|\|\|\|");		seq_printf(s, "\|\|\|\|\|");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)		if (flags & TRACE_GRAPH_PRINT_DURATION)
	seq_printf(s, " DURATION ");		seq_printf(s, " DURATION ");
	seq_printf(s, " FUNCTION CALLS\n");		seq_printf(s, " FUNCTION CALLS\n");

	/* 2nd line */		/* 2nd line */
	seq_printf(s, "#");		seq_printf(s, "#");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)		if (flags & TRACE_GRAPH_PRINT_ABS_TIME)
	seq_printf(s, " \| ");		seq_printf(s, " \| ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)		if (flags & TRACE_GRAPH_PRINT_CPU)
	seq_printf(s, " \| ");		seq_printf(s, " \| ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)		if (flags & TRACE_GRAPH_PRINT_PROC)
	seq_printf(s, " \| \| ");		seq_printf(s, " \| \| ");
	if (lat)		if (lat)
	seq_printf(s, "\|\|\|\|\|");		seq_printf(s, "\|\|\|\|\|");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)		if (flags & TRACE_GRAPH_PRINT_DURATION)
	seq_printf(s, " \| \| ");		seq_printf(s, " \| \| ");
	seq_printf(s, " \| \| \| \|\n");		seq_printf(s, " \| \| \| \|\n");
	}		}

			static void print_graph_headers(struct seq_file *s)
			{
			print_graph_headers_flags(s, tracer_flags.val);
			}

	static void graph_trace_open(struct trace_iterator *iter)		static void graph_trace_open(struct trace_iterator *iter)
	{		{
	/* pid and depth on the last trace processed */		/* pid and depth on the last trace processed */

Admin message