[mirror_ubuntu-artful-kernel.git] / kernel / trace / trace_functions_graph.c

/*
 *
 * Function graph tracer.
 * Copyright (c) 2008 Frederic Weisbecker <fweisbec@gmail.com>
 * Mostly borrowed from function tracer which
 * is Copyright (c) Steven Rostedt <srostedt@redhat.com>
 *
 */
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include <linux/ftrace.h>
#include <linux/fs.h>

#include "trace.h"

#define TRACE_GRAPH_INDENT	2

/* Flag options */
#define TRACE_GRAPH_PRINT_OVERRUN	0x1
#define TRACE_GRAPH_PRINT_CPU		0x2
#define TRACE_GRAPH_PRINT_OVERHEAD	0x4
#define TRACE_GRAPH_PRINT_PROC		0x8

static struct tracer_opt trace_opts[] = {
	/* Display overruns ? */
	{ TRACER_OPT(funcgraph-overrun, TRACE_GRAPH_PRINT_OVERRUN) },
	/* Display CPU ? */
	{ TRACER_OPT(funcgraph-cpu, TRACE_GRAPH_PRINT_CPU) },
	/* Display Overhead ? */
	{ TRACER_OPT(funcgraph-overhead, TRACE_GRAPH_PRINT_OVERHEAD) },
	/* Display proc name/pid */
	{ TRACER_OPT(funcgraph-proc, TRACE_GRAPH_PRINT_PROC) },
	{ } /* Empty entry */
};

static struct tracer_flags tracer_flags = {
	/* Don't display overruns and proc by default */
	.val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD,
	.opts = trace_opts
};

/* pid on the last trace processed */
static pid_t last_pid[NR_CPUS] = { [0 ... NR_CPUS-1] = -1 };

static int graph_trace_init(struct trace_array *tr)
{
	int cpu, ret;

	for_each_online_cpu(cpu)
		tracing_reset(tr, cpu);

	ret = register_ftrace_graph(&trace_graph_return,
					&trace_graph_entry);
	if (ret)
		return ret;
	tracing_start_cmdline_record();

	return 0;
}

static void graph_trace_reset(struct trace_array *tr)
{
	tracing_stop_cmdline_record();
	unregister_ftrace_graph();
}

static inline int log10_cpu(int nb)
{
	if (nb / 100)
		return 3;
	if (nb / 10)
		return 2;
	return 1;
}

static enum print_line_t
print_graph_cpu(struct trace_seq *s, int cpu)
{
	int i;
	int ret;
	int log10_this = log10_cpu(cpu);
	int log10_all = log10_cpu(cpus_weight_nr(cpu_online_map));


	/*
	 * Start with a space character - to make it stand out
	 * to the right a bit when trace output is pasted into
	 * email:
	 */
	ret = trace_seq_printf(s, " ");

	/*
	 * Tricky - we space the CPU field according to the max
	 * number of online CPUs. On a 2-cpu system it would take
	 * a maximum of 1 digit - on a 128 cpu system it would
	 * take up to 3 digits:
	 */
	for (i = 0; i < log10_all - log10_this; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}
	ret = trace_seq_printf(s, "%d) ", cpu);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

#define TRACE_GRAPH_PROCINFO_LENGTH	14

static enum print_line_t
print_graph_proc(struct trace_seq *s, pid_t pid)
{
	int i;
	int ret;
	int len;
	char comm[8];
	int spaces = 0;
	/* sign + log10(MAX_INT) + '\0' */
	char pid_str[11];

	strncpy(comm, trace_find_cmdline(pid), 7);
	comm[7] = '\0';
	sprintf(pid_str, "%d", pid);

	/* 1 stands for the "-" character */
	len = strlen(comm) + strlen(pid_str) + 1;

	if (len < TRACE_GRAPH_PROCINFO_LENGTH)
		spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;

	/* First spaces to align center */
	for (i = 0; i < spaces / 2; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	ret = trace_seq_printf(s, "%s-%s", comm, pid_str);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Last spaces to align center */
	for (i = 0; i < spaces - (spaces / 2); i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}
	return TRACE_TYPE_HANDLED;
}


/* If the pid changed since the last trace, output this event */
static enum print_line_t
verif_pid(struct trace_seq *s, pid_t pid, int cpu)
{
	pid_t prev_pid;
	int ret;

	if (last_pid[cpu] != -1 && last_pid[cpu] == pid)
		return TRACE_TYPE_HANDLED;

	prev_pid = last_pid[cpu];
	last_pid[cpu] = pid;

/*
 * Context-switch trace line:

 ------------------------------------------
 | 1)  migration/0--1  =>  sshd-1755
 ------------------------------------------

 */
	ret = trace_seq_printf(s,
		" ------------------------------------------\n");
	if (!ret)
		TRACE_TYPE_PARTIAL_LINE;

	ret = print_graph_cpu(s, cpu);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
		TRACE_TYPE_PARTIAL_LINE;

	ret = print_graph_proc(s, prev_pid);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
		TRACE_TYPE_PARTIAL_LINE;

	ret = trace_seq_printf(s, " => ");
	if (!ret)
		TRACE_TYPE_PARTIAL_LINE;

	ret = print_graph_proc(s, pid);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
		TRACE_TYPE_PARTIAL_LINE;

	ret = trace_seq_printf(s,
		"\n ------------------------------------------\n\n");
	if (!ret)
		TRACE_TYPE_PARTIAL_LINE;

	return ret;
}

static bool
trace_branch_is_leaf(struct trace_iterator *iter,
		struct ftrace_graph_ent_entry *curr)
{
	struct ring_buffer_iter *ring_iter;
	struct ring_buffer_event *event;
	struct ftrace_graph_ret_entry *next;

	ring_iter = iter->buffer_iter[iter->cpu];

	if (!ring_iter)
		return false;

	event = ring_buffer_iter_peek(ring_iter, NULL);

	if (!event)
		return false;

	next = ring_buffer_event_data(event);

	if (next->ent.type != TRACE_GRAPH_RET)
		return false;

	if (curr->ent.pid != next->ent.pid ||
			curr->graph_ent.func != next->ret.func)
		return false;

	return true;
}


static enum print_line_t
print_graph_duration(unsigned long long duration, struct trace_seq *s)
{
	unsigned long nsecs_rem = do_div(duration, 1000);
	/* log10(ULONG_MAX) + '\0' */
	char msecs_str[21];
	char nsecs_str[5];
	int ret, len;
	int i;

	sprintf(msecs_str, "%lu", (unsigned long) duration);

	/* Print msecs */
	ret = trace_seq_printf(s, msecs_str);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	len = strlen(msecs_str);

	/* Print nsecs (we don't want to exceed 7 numbers) */
	if (len < 7) {
		snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
		ret = trace_seq_printf(s, ".%s", nsecs_str);
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
		len += strlen(nsecs_str);
	}

	ret = trace_seq_printf(s, " us ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Print remaining spaces to fit the row's width */
	for (i = len; i < 7; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	ret = trace_seq_printf(s, "|  ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
	return TRACE_TYPE_HANDLED;

}

/* Signal a overhead of time execution to the output */
static int
print_graph_overhead(unsigned long long duration, struct trace_seq *s)
{
	/* Duration exceeded 100 msecs */
	if (duration > 100000ULL)
		return trace_seq_printf(s, "! ");

	/* Duration exceeded 10 msecs */
	if (duration > 10000ULL)
		return trace_seq_printf(s, "+ ");

	return trace_seq_printf(s, "  ");
}

/* Case of a leaf function on its call entry */
static enum print_line_t
print_graph_entry_leaf(struct trace_iterator *iter,
		struct ftrace_graph_ent_entry *entry, struct trace_seq *s)
{
	struct ftrace_graph_ret_entry *ret_entry;
	struct ftrace_graph_ret *graph_ret;
	struct ring_buffer_event *event;
	struct ftrace_graph_ent *call;
	unsigned long long duration;
	int ret;
	int i;

	event = ring_buffer_read(iter->buffer_iter[iter->cpu], NULL);
	ret_entry = ring_buffer_event_data(event);
	graph_ret = &ret_entry->ret;
	call = &entry->graph_ent;
	duration = graph_ret->rettime - graph_ret->calltime;

	/* Overhead */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
		ret = print_graph_overhead(duration, s);
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* Duration */
	ret = print_graph_duration(duration, s);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Function */
	for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	ret = seq_print_ip_sym(s, call->func, 0);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	ret = trace_seq_printf(s, "();\n");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

static enum print_line_t
print_graph_entry_nested(struct ftrace_graph_ent_entry *entry,
			struct trace_seq *s)
{
	int i;
	int ret;
	struct ftrace_graph_ent *call = &entry->graph_ent;

	/* No overhead */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
		ret = trace_seq_printf(s, "  ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* No time */
	ret = trace_seq_printf(s, "            |  ");

	/* Function */
	for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	ret = seq_print_ip_sym(s, call->func, 0);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	ret = trace_seq_printf(s, "() {\n");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

static enum print_line_t
print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
			struct trace_iterator *iter, int cpu)
{
	int ret;
	struct trace_entry *ent = iter->ent;

	/* Pid */
	if (verif_pid(s, ent->pid, cpu) == TRACE_TYPE_PARTIAL_LINE)
		return TRACE_TYPE_PARTIAL_LINE;

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

	/* Proc */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
		ret = print_graph_proc(s, ent->pid);
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;

		ret = trace_seq_printf(s, " | ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	if (trace_branch_is_leaf(iter, field))
		return print_graph_entry_leaf(iter, field, s);
	else
		return print_graph_entry_nested(field, s);

}

static enum print_line_t
print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
		   struct trace_entry *ent, int cpu)
{
	int i;
	int ret;
	unsigned long long duration = trace->rettime - trace->calltime;

	/* Pid */
	if (verif_pid(s, ent->pid, cpu) == TRACE_TYPE_PARTIAL_LINE)
		return TRACE_TYPE_PARTIAL_LINE;

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

	/* Proc */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
		ret = print_graph_proc(s, ent->pid);
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;

		ret = trace_seq_printf(s, " | ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* Overhead */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
		ret = print_graph_overhead(duration, s);
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* Duration */
	ret = print_graph_duration(duration, s);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Closing brace */
	for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	ret = trace_seq_printf(s, "}\n");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

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

static enum print_line_t
print_graph_comment(struct print_entry *trace, struct trace_seq *s,
		   struct trace_entry *ent, struct trace_iterator *iter)
{
	int i;
	int ret;

	/* Pid */
	if (verif_pid(s, ent->pid, iter->cpu) == TRACE_TYPE_PARTIAL_LINE)
		return TRACE_TYPE_PARTIAL_LINE;

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

	/* Proc */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
		ret = print_graph_proc(s, ent->pid);
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;

		ret = trace_seq_printf(s, " | ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* No overhead */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
		ret = trace_seq_printf(s, "  ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* No time */
	ret = trace_seq_printf(s, "            |  ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Indentation */
	if (trace->depth > 0)
		for (i = 0; i < (trace->depth + 1) * TRACE_GRAPH_INDENT; i++) {
			ret = trace_seq_printf(s, " ");
			if (!ret)
				return TRACE_TYPE_PARTIAL_LINE;
		}

	/* The comment */
	ret = trace_seq_printf(s, "/* %s", trace->buf);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	if (ent->flags & TRACE_FLAG_CONT)
		trace_seq_print_cont(s, iter);

	ret = trace_seq_printf(s, " */\n");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}


enum print_line_t
print_graph_function(struct trace_iterator *iter)
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *entry = iter->ent;

	switch (entry->type) {
	case TRACE_GRAPH_ENT: {
		struct ftrace_graph_ent_entry *field;
		trace_assign_type(field, entry);
		return print_graph_entry(field, s, iter,
					 iter->cpu);
	}
	case TRACE_GRAPH_RET: {
		struct ftrace_graph_ret_entry *field;
		trace_assign_type(field, entry);
		return print_graph_return(&field->ret, s, entry, iter->cpu);
	}
	case TRACE_PRINT: {
		struct print_entry *field;
		trace_assign_type(field, entry);
		return print_graph_comment(field, s, entry, iter);
	}
	default:
		return TRACE_TYPE_UNHANDLED;
	}
}

static void print_graph_headers(struct seq_file *s)
{
	/* 1st line */
	seq_printf(s, "# ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
		seq_printf(s, "CPU ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
		seq_printf(s, "TASK/PID     ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD)
		seq_printf(s, "OVERHEAD/");
	seq_printf(s, "DURATION            FUNCTION CALLS\n");

	/* 2nd line */
	seq_printf(s, "# ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
		seq_printf(s, "|   ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
		seq_printf(s, "|      |     ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
		seq_printf(s, "|        ");
		seq_printf(s, "|                   |   |   |   |\n");
	} else
		seq_printf(s, "    |               |   |   |   |\n");
}
static struct tracer graph_trace __read_mostly = {
	.name	     	= "function_graph",
	.init	     	= graph_trace_init,
	.reset	     	= graph_trace_reset,
	.print_line	= print_graph_function,
	.print_header	= print_graph_headers,
	.flags		= &tracer_flags,
};

static __init int init_graph_trace(void)
{
	return register_tracer(&graph_trace);
}

device_initcall(init_graph_trace);
Commit	Line	Data
fb52607a FW	1	/*
	2	*
	3	* Function graph tracer.
	4	* Copyright (c) 2008 Frederic Weisbecker <fweisbec@gmail.com>
	5	* Mostly borrowed from function tracer which
	6	* is Copyright (c) Steven Rostedt <srostedt@redhat.com>
	7	*
	8	*/
	9	#include <linux/debugfs.h>
	10	#include <linux/uaccess.h>
	11	#include <linux/ftrace.h>
	12	#include <linux/fs.h>
	13
	14	#include "trace.h"
	15
287b6e68	16	#define TRACE_GRAPH_INDENT 2
fb52607a	17
1a056155	18	/* Flag options */
fb52607a	19	#define TRACE_GRAPH_PRINT_OVERRUN 0x1
1a056155 FW	20	#define TRACE_GRAPH_PRINT_CPU 0x2
1a056155 FW	21	#define TRACE_GRAPH_PRINT_OVERHEAD 0x4
11e84acc	22	#define TRACE_GRAPH_PRINT_PROC 0x8
1a056155	23
fb52607a	24	static struct tracer_opt trace_opts[] = {
1a056155 FW	25	/* Display overruns ? */
	26	{ TRACER_OPT(funcgraph-overrun, TRACE_GRAPH_PRINT_OVERRUN) },
	27	/* Display CPU ? */
	28	{ TRACER_OPT(funcgraph-cpu, TRACE_GRAPH_PRINT_CPU) },
	29	/* Display Overhead ? */
	30	{ TRACER_OPT(funcgraph-overhead, TRACE_GRAPH_PRINT_OVERHEAD) },
11e84acc FW	31	/* Display proc name/pid */
11e84acc FW	32	{ TRACER_OPT(funcgraph-proc, TRACE_GRAPH_PRINT_PROC) },
fb52607a FW	33	{ } /* Empty entry */
	34	};
	35
	36	static struct tracer_flags tracer_flags = {
11e84acc	37	/* Don't display overruns and proc by default */
1a056155	38	.val = TRACE_GRAPH_PRINT_CPU \| TRACE_GRAPH_PRINT_OVERHEAD,
fb52607a FW	39	.opts = trace_opts
	40	};
	41
287b6e68	42	/* pid on the last trace processed */
437f24fb	43	static pid_t last_pid[NR_CPUS] = { [0 ... NR_CPUS-1] = -1 };
fb52607a FW	44
	45	static int graph_trace_init(struct trace_array *tr)
	46	{
660c7f9b SR	47	int cpu, ret;
660c7f9b SR	48
fb52607a FW	49	for_each_online_cpu(cpu)
	50	tracing_reset(tr, cpu);
	51
660c7f9b	52	ret = register_ftrace_graph(&trace_graph_return,
287b6e68	53	&trace_graph_entry);
660c7f9b SR	54	if (ret)
	55	return ret;
	56	tracing_start_cmdline_record();
	57
	58	return 0;
fb52607a FW	59	}
	60
	61	static void graph_trace_reset(struct trace_array *tr)
	62	{
660c7f9b SR	63	tracing_stop_cmdline_record();
660c7f9b SR	64	unregister_ftrace_graph();
fb52607a FW	65	}
fb52607a FW	66
1a056155 FW	67	static inline int log10_cpu(int nb)
	68	{
	69	if (nb / 100)
	70	return 3;
	71	if (nb / 10)
	72	return 2;
	73	return 1;
	74	}
	75
	76	static enum print_line_t
	77	print_graph_cpu(struct trace_seq *s, int cpu)
	78	{
	79	int i;
	80	int ret;
	81	int log10_this = log10_cpu(cpu);
	82	int log10_all = log10_cpu(cpus_weight_nr(cpu_online_map));
	83
	84
d51090b3 IM	85	/*
	86	* Start with a space character - to make it stand out
	87	* to the right a bit when trace output is pasted into
	88	* email:
	89	*/
	90	ret = trace_seq_printf(s, " ");
	91
	92	/*
	93	* Tricky - we space the CPU field according to the max
	94	* number of online CPUs. On a 2-cpu system it would take
	95	* a maximum of 1 digit - on a 128 cpu system it would
	96	* take up to 3 digits:
	97	*/
1a056155 FW	98	for (i = 0; i < log10_all - log10_this; i++) {
	99	ret = trace_seq_printf(s, " ");
	100	if (!ret)
	101	return TRACE_TYPE_PARTIAL_LINE;
	102	}
	103	ret = trace_seq_printf(s, "%d) ", cpu);
	104	if (!ret)
d51090b3 IM	105	return TRACE_TYPE_PARTIAL_LINE;
d51090b3 IM	106
1a056155 FW	107	return TRACE_TYPE_HANDLED;
	108	}
	109
11e84acc FW	110	#define TRACE_GRAPH_PROCINFO_LENGTH 14
	111
	112	static enum print_line_t
	113	print_graph_proc(struct trace_seq *s, pid_t pid)
	114	{
	115	int i;
	116	int ret;
	117	int len;
	118	char comm[8];
	119	int spaces = 0;
	120	/* sign + log10(MAX_INT) + '\0' */
	121	char pid_str[11];
	122
	123	strncpy(comm, trace_find_cmdline(pid), 7);
	124	comm[7] = '\0';
	125	sprintf(pid_str, "%d", pid);
	126
	127	/* 1 stands for the "-" character */
	128	len = strlen(comm) + strlen(pid_str) + 1;
	129
	130	if (len < TRACE_GRAPH_PROCINFO_LENGTH)
	131	spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;
	132
	133	/* First spaces to align center */
	134	for (i = 0; i < spaces / 2; i++) {
	135	ret = trace_seq_printf(s, " ");
	136	if (!ret)
	137	return TRACE_TYPE_PARTIAL_LINE;
	138	}
	139
	140	ret = trace_seq_printf(s, "%s-%s", comm, pid_str);
	141	if (!ret)
	142	return TRACE_TYPE_PARTIAL_LINE;
	143
	144	/* Last spaces to align center */
	145	for (i = 0; i < spaces - (spaces / 2); i++) {
	146	ret = trace_seq_printf(s, " ");
	147	if (!ret)
	148	return TRACE_TYPE_PARTIAL_LINE;
	149	}
	150	return TRACE_TYPE_HANDLED;
	151	}
	152
1a056155	153
287b6e68	154	/* If the pid changed since the last trace, output this event */
11e84acc FW	155	static enum print_line_t
11e84acc FW	156	verif_pid(struct trace_seq *s, pid_t pid, int cpu)
287b6e68	157	{
d51090b3 IM	158	pid_t prev_pid;
d51090b3 IM	159	int ret;
660c7f9b	160
437f24fb	161	if (last_pid[cpu] != -1 && last_pid[cpu] == pid)
11e84acc	162	return TRACE_TYPE_HANDLED;
fb52607a	163
d51090b3	164	prev_pid = last_pid[cpu];
437f24fb	165	last_pid[cpu] = pid;
d51090b3	166
d51090b3 IM	167	/*
	168	* Context-switch trace line:
	169
	170	------------------------------------------
	171	\| 1) migration/0--1 => sshd-1755
	172	------------------------------------------
	173
	174	*/
	175	ret = trace_seq_printf(s,
1fd8f2a3	176	" ------------------------------------------\n");
11e84acc FW	177	if (!ret)
	178	TRACE_TYPE_PARTIAL_LINE;
	179
	180	ret = print_graph_cpu(s, cpu);
	181	if (ret == TRACE_TYPE_PARTIAL_LINE)
	182	TRACE_TYPE_PARTIAL_LINE;
	183
	184	ret = print_graph_proc(s, prev_pid);
	185	if (ret == TRACE_TYPE_PARTIAL_LINE)
	186	TRACE_TYPE_PARTIAL_LINE;
	187
	188	ret = trace_seq_printf(s, " => ");
	189	if (!ret)
	190	TRACE_TYPE_PARTIAL_LINE;
	191
	192	ret = print_graph_proc(s, pid);
	193	if (ret == TRACE_TYPE_PARTIAL_LINE)
	194	TRACE_TYPE_PARTIAL_LINE;
	195
	196	ret = trace_seq_printf(s,
	197	"\n ------------------------------------------\n\n");
	198	if (!ret)
	199	TRACE_TYPE_PARTIAL_LINE;
	200
d51090b3	201	return ret;
287b6e68 FW	202	}
287b6e68 FW	203
83a8df61 FW	204	static bool
	205	trace_branch_is_leaf(struct trace_iterator *iter,
	206	struct ftrace_graph_ent_entry *curr)
	207	{
	208	struct ring_buffer_iter *ring_iter;
	209	struct ring_buffer_event *event;
	210	struct ftrace_graph_ret_entry *next;
	211
	212	ring_iter = iter->buffer_iter[iter->cpu];
	213
	214	if (!ring_iter)
	215	return false;
	216
1a056155	217	event = ring_buffer_iter_peek(ring_iter, NULL);
83a8df61 FW	218
	219	if (!event)
	220	return false;
	221
	222	next = ring_buffer_event_data(event);
	223
	224	if (next->ent.type != TRACE_GRAPH_RET)
	225	return false;
	226
	227	if (curr->ent.pid != next->ent.pid \|\|
	228	curr->graph_ent.func != next->ret.func)
	229	return false;
	230
	231	return true;
	232	}
	233
	234
166d3c79	235	static enum print_line_t
83a8df61 FW	236	print_graph_duration(unsigned long long duration, struct trace_seq *s)
	237	{
	238	unsigned long nsecs_rem = do_div(duration, 1000);
166d3c79 FW	239	/* log10(ULONG_MAX) + '\0' */
	240	char msecs_str[21];
	241	char nsecs_str[5];
	242	int ret, len;
	243	int i;
	244
	245	sprintf(msecs_str, "%lu", (unsigned long) duration);
	246
	247	/* Print msecs */
	248	ret = trace_seq_printf(s, msecs_str);
	249	if (!ret)
	250	return TRACE_TYPE_PARTIAL_LINE;
	251
	252	len = strlen(msecs_str);
	253
	254	/* Print nsecs (we don't want to exceed 7 numbers) */
	255	if (len < 7) {
	256	snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
	257	ret = trace_seq_printf(s, ".%s", nsecs_str);
	258	if (!ret)
	259	return TRACE_TYPE_PARTIAL_LINE;
	260	len += strlen(nsecs_str);
	261	}
	262
	263	ret = trace_seq_printf(s, " us ");
	264	if (!ret)
	265	return TRACE_TYPE_PARTIAL_LINE;
	266
	267	/* Print remaining spaces to fit the row's width */
	268	for (i = len; i < 7; i++) {
	269	ret = trace_seq_printf(s, " ");
	270	if (!ret)
	271	return TRACE_TYPE_PARTIAL_LINE;
	272	}
	273
	274	ret = trace_seq_printf(s, "\| ");
	275	if (!ret)
	276	return TRACE_TYPE_PARTIAL_LINE;
	277	return TRACE_TYPE_HANDLED;
	278
83a8df61 FW	279	}
	280
	281	/* Signal a overhead of time execution to the output */
	282	static int
	283	print_graph_overhead(unsigned long long duration, struct trace_seq *s)
	284	{
	285	/* Duration exceeded 100 msecs */
	286	if (duration > 100000ULL)
	287	return trace_seq_printf(s, "! ");
	288
	289	/* Duration exceeded 10 msecs */
	290	if (duration > 10000ULL)
	291	return trace_seq_printf(s, "+ ");
	292
	293	return trace_seq_printf(s, " ");
	294	}
	295
	296	/* Case of a leaf function on its call entry */
287b6e68	297	static enum print_line_t
83a8df61 FW	298	print_graph_entry_leaf(struct trace_iterator *iter,
83a8df61 FW	299	struct ftrace_graph_ent_entry entry, struct trace_seq s)
fb52607a	300	{
83a8df61 FW	301	struct ftrace_graph_ret_entry *ret_entry;
	302	struct ftrace_graph_ret *graph_ret;
	303	struct ring_buffer_event *event;
	304	struct ftrace_graph_ent *call;
	305	unsigned long long duration;
fb52607a	306	int ret;
1a056155	307	int i;
fb52607a	308
83a8df61 FW	309	event = ring_buffer_read(iter->buffer_iter[iter->cpu], NULL);
	310	ret_entry = ring_buffer_event_data(event);
	311	graph_ret = &ret_entry->ret;
	312	call = &entry->graph_ent;
	313	duration = graph_ret->rettime - graph_ret->calltime;
	314
	315	/* Overhead */
1a056155 FW	316	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
	317	ret = print_graph_overhead(duration, s);
	318	if (!ret)
	319	return TRACE_TYPE_PARTIAL_LINE;
	320	}
	321
	322	/* Duration */
	323	ret = print_graph_duration(duration, s);
166d3c79	324	if (ret == TRACE_TYPE_PARTIAL_LINE)
437f24fb SR	325	return TRACE_TYPE_PARTIAL_LINE;
437f24fb SR	326
83a8df61 FW	327	/* Function */
	328	for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
	329	ret = trace_seq_printf(s, " ");
	330	if (!ret)
	331	return TRACE_TYPE_PARTIAL_LINE;
	332	}
	333
	334	ret = seq_print_ip_sym(s, call->func, 0);
	335	if (!ret)
	336	return TRACE_TYPE_PARTIAL_LINE;
	337
1a056155	338	ret = trace_seq_printf(s, "();\n");
83a8df61 FW	339	if (!ret)
	340	return TRACE_TYPE_PARTIAL_LINE;
	341
	342	return TRACE_TYPE_HANDLED;
	343	}
	344
	345	static enum print_line_t
	346	print_graph_entry_nested(struct ftrace_graph_ent_entry *entry,
	347	struct trace_seq *s)
	348	{
	349	int i;
	350	int ret;
	351	struct ftrace_graph_ent *call = &entry->graph_ent;
	352
	353	/* No overhead */
1a056155 FW	354	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
	355	ret = trace_seq_printf(s, " ");
	356	if (!ret)
	357	return TRACE_TYPE_PARTIAL_LINE;
	358	}
	359
	360	/* No time */
d51090b3	361	ret = trace_seq_printf(s, " \| ");
83a8df61 FW	362
83a8df61 FW	363	/* Function */
287b6e68 FW	364	for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
287b6e68 FW	365	ret = trace_seq_printf(s, " ");
fb52607a FW	366	if (!ret)
fb52607a FW	367	return TRACE_TYPE_PARTIAL_LINE;
287b6e68 FW	368	}
	369
	370	ret = seq_print_ip_sym(s, call->func, 0);
	371	if (!ret)
	372	return TRACE_TYPE_PARTIAL_LINE;
	373
1a056155	374	ret = trace_seq_printf(s, "() {\n");
83a8df61 FW	375	if (!ret)
	376	return TRACE_TYPE_PARTIAL_LINE;
	377
287b6e68 FW	378	return TRACE_TYPE_HANDLED;
	379	}
	380
83a8df61 FW	381	static enum print_line_t
	382	print_graph_entry(struct ftrace_graph_ent_entry field, struct trace_seq s,
	383	struct trace_iterator *iter, int cpu)
	384	{
	385	int ret;
	386	struct trace_entry *ent = iter->ent;
	387
1a056155	388	/* Pid */
11e84acc	389	if (verif_pid(s, ent->pid, cpu) == TRACE_TYPE_PARTIAL_LINE)
83a8df61 FW	390	return TRACE_TYPE_PARTIAL_LINE;
83a8df61 FW	391
1a056155 FW	392	/* Cpu */
	393	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
	394	ret = print_graph_cpu(s, cpu);
11e84acc FW	395	if (ret == TRACE_TYPE_PARTIAL_LINE)
	396	return TRACE_TYPE_PARTIAL_LINE;
	397	}
	398
	399	/* Proc */
	400	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
	401	ret = print_graph_proc(s, ent->pid);
	402	if (ret == TRACE_TYPE_PARTIAL_LINE)
	403	return TRACE_TYPE_PARTIAL_LINE;
	404
	405	ret = trace_seq_printf(s, " \| ");
1a056155 FW	406	if (!ret)
	407	return TRACE_TYPE_PARTIAL_LINE;
	408	}
83a8df61 FW	409
	410	if (trace_branch_is_leaf(iter, field))
	411	return print_graph_entry_leaf(iter, field, s);
	412	else
	413	return print_graph_entry_nested(field, s);
	414
	415	}
	416
287b6e68 FW	417	static enum print_line_t
287b6e68 FW	418	print_graph_return(struct ftrace_graph_ret trace, struct trace_seq s,
437f24fb	419	struct trace_entry *ent, int cpu)
287b6e68 FW	420	{
	421	int i;
	422	int ret;
83a8df61	423	unsigned long long duration = trace->rettime - trace->calltime;
287b6e68	424
83a8df61	425	/* Pid */
11e84acc	426	if (verif_pid(s, ent->pid, cpu) == TRACE_TYPE_PARTIAL_LINE)
437f24fb SR	427	return TRACE_TYPE_PARTIAL_LINE;
437f24fb SR	428
83a8df61	429	/* Cpu */
1a056155 FW	430	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
1a056155 FW	431	ret = print_graph_cpu(s, cpu);
11e84acc FW	432	if (ret == TRACE_TYPE_PARTIAL_LINE)
	433	return TRACE_TYPE_PARTIAL_LINE;
	434	}
	435
	436	/* Proc */
	437	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
	438	ret = print_graph_proc(s, ent->pid);
	439	if (ret == TRACE_TYPE_PARTIAL_LINE)
	440	return TRACE_TYPE_PARTIAL_LINE;
	441
	442	ret = trace_seq_printf(s, " \| ");
1a056155 FW	443	if (!ret)
	444	return TRACE_TYPE_PARTIAL_LINE;
	445	}
fb52607a	446
83a8df61	447	/* Overhead */
1a056155 FW	448	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
	449	ret = print_graph_overhead(duration, s);
	450	if (!ret)
	451	return TRACE_TYPE_PARTIAL_LINE;
	452	}
	453
	454	/* Duration */
	455	ret = print_graph_duration(duration, s);
166d3c79	456	if (ret == TRACE_TYPE_PARTIAL_LINE)
83a8df61 FW	457	return TRACE_TYPE_PARTIAL_LINE;
	458
	459	/* Closing brace */
287b6e68 FW	460	for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
287b6e68 FW	461	ret = trace_seq_printf(s, " ");
fb52607a FW	462	if (!ret)
fb52607a FW	463	return TRACE_TYPE_PARTIAL_LINE;
287b6e68 FW	464	}
287b6e68 FW	465
1a056155	466	ret = trace_seq_printf(s, "}\n");
287b6e68 FW	467	if (!ret)
287b6e68 FW	468	return TRACE_TYPE_PARTIAL_LINE;
fb52607a	469
83a8df61	470	/* Overrun */
287b6e68 FW	471	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERRUN) {
	472	ret = trace_seq_printf(s, " (Overruns: %lu)\n",
	473	trace->overrun);
fb52607a FW	474	if (!ret)
fb52607a FW	475	return TRACE_TYPE_PARTIAL_LINE;
287b6e68 FW	476	}
	477	return TRACE_TYPE_HANDLED;
	478	}
	479
1fd8f2a3 FW	480	static enum print_line_t
	481	print_graph_comment(struct print_entry trace, struct trace_seq s,
	482	struct trace_entry ent, struct trace_iterator iter)
	483	{
	484	int i;
	485	int ret;
	486
	487	/* Pid */
	488	if (verif_pid(s, ent->pid, iter->cpu) == TRACE_TYPE_PARTIAL_LINE)
	489	return TRACE_TYPE_PARTIAL_LINE;
	490
	491	/* Cpu */
	492	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
	493	ret = print_graph_cpu(s, iter->cpu);
	494	if (ret == TRACE_TYPE_PARTIAL_LINE)
	495	return TRACE_TYPE_PARTIAL_LINE;
	496	}
	497
	498	/* Proc */
	499	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
	500	ret = print_graph_proc(s, ent->pid);
	501	if (ret == TRACE_TYPE_PARTIAL_LINE)
	502	return TRACE_TYPE_PARTIAL_LINE;
	503
	504	ret = trace_seq_printf(s, " \| ");
	505	if (!ret)
	506	return TRACE_TYPE_PARTIAL_LINE;
	507	}
	508
	509	/* No overhead */
	510	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
	511	ret = trace_seq_printf(s, " ");
	512	if (!ret)
	513	return TRACE_TYPE_PARTIAL_LINE;
	514	}
	515
	516	/* No time */
	517	ret = trace_seq_printf(s, " \| ");
	518	if (!ret)
	519	return TRACE_TYPE_PARTIAL_LINE;
	520
	521	/* Indentation */
	522	if (trace->depth > 0)
	523	for (i = 0; i < (trace->depth + 1) * TRACE_GRAPH_INDENT; i++) {
	524	ret = trace_seq_printf(s, " ");
	525	if (!ret)
	526	return TRACE_TYPE_PARTIAL_LINE;
	527	}
	528
	529	/* The comment */
	530	ret = trace_seq_printf(s, "/* %s", trace->buf);
	531	if (!ret)
	532	return TRACE_TYPE_PARTIAL_LINE;
	533
	534	if (ent->flags & TRACE_FLAG_CONT)
	535	trace_seq_print_cont(s, iter);
	536
	537	ret = trace_seq_printf(s, " */\n");
	538	if (!ret)
	539	return TRACE_TYPE_PARTIAL_LINE;
	540
	541	return TRACE_TYPE_HANDLED;
	542	}
	543
544
287b6e68 FW	545	enum print_line_t
	546	print_graph_function(struct trace_iterator *iter)
	547	{
	548	struct trace_seq *s = &iter->seq;
	549	struct trace_entry *entry = iter->ent;
fb52607a	550
287b6e68 FW	551	switch (entry->type) {
	552	case TRACE_GRAPH_ENT: {
	553	struct ftrace_graph_ent_entry *field;
	554	trace_assign_type(field, entry);
83a8df61	555	return print_graph_entry(field, s, iter,
437f24fb	556	iter->cpu);
287b6e68 FW	557	}
	558	case TRACE_GRAPH_RET: {
	559	struct ftrace_graph_ret_entry *field;
	560	trace_assign_type(field, entry);
437f24fb	561	return print_graph_return(&field->ret, s, entry, iter->cpu);
287b6e68	562	}
1fd8f2a3 FW	563	case TRACE_PRINT: {
	564	struct print_entry *field;
	565	trace_assign_type(field, entry);
	566	return print_graph_comment(field, s, entry, iter);
	567	}
287b6e68 FW	568	default:
287b6e68 FW	569	return TRACE_TYPE_UNHANDLED;
fb52607a	570	}
fb52607a FW	571	}
fb52607a FW	572
decbec38 FW	573	static void print_graph_headers(struct seq_file *s)
	574	{
	575	/* 1st line */
	576	seq_printf(s, "# ");
	577	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
	578	seq_printf(s, "CPU ");
	579	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
	580	seq_printf(s, "TASK/PID ");
	581	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD)
	582	seq_printf(s, "OVERHEAD/");
	583	seq_printf(s, "DURATION FUNCTION CALLS\n");
	584
	585	/* 2nd line */
	586	seq_printf(s, "# ");
	587	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
	588	seq_printf(s, "\| ");
	589	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
	590	seq_printf(s, "\| \| ");
	591	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
	592	seq_printf(s, "\| ");
	593	seq_printf(s, "\| \| \| \| \|\n");
	594	} else
	595	seq_printf(s, " \| \| \| \| \|\n");
	596	}
fb52607a	597	static struct tracer graph_trace __read_mostly = {
decbec38 FW	598	.name = "function_graph",
	599	.init = graph_trace_init,
	600	.reset = graph_trace_reset,
	601	.print_line = print_graph_function,
	602	.print_header = print_graph_headers,
fb52607a FW	603	.flags = &tracer_flags,
	604	};
	605
	606	static __init int init_graph_trace(void)
	607	{
	608	return register_tracer(&graph_trace);
	609	}
	610
	611	device_initcall(init_graph_trace);