/* * * Function graph tracer. * Copyright (c) 2008-2009 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/slab.h>#include <linux/fs.h> #include "trace.h"#include "trace_output.h" /* When set, irq functions will be ignored */static int ftrace_graph_skip_irqs; struct fgraph_cpu_data {	pid_t		last_pid;	int		depth;	int		depth_irq;	int		ignore;	unsigned long	enter_funcs[FTRACE_RETFUNC_DEPTH];}; struct fgraph_data {	struct fgraph_cpu_data __percpu *cpu_data; 	/* Place to preserve last processed entry. */	struct ftrace_graph_ent_entry	ent;	struct ftrace_graph_ret_entry	ret;	int				failed;	int				cpu;}; #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#define TRACE_GRAPH_PRINT_DURATION	0x10#define TRACE_GRAPH_PRINT_ABS_TIME	0x20#define TRACE_GRAPH_PRINT_IRQS		0x40 static struct tracer_opt trace_opts[] = {	/* Display overruns? (for self-debug purpose) */	{ 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) },	/* Display duration of execution */	{ TRACER_OPT(funcgraph-duration, TRACE_GRAPH_PRINT_DURATION) },	/* Display absolute time of an entry */	{ TRACER_OPT(funcgraph-abstime, TRACE_GRAPH_PRINT_ABS_TIME) },	/* Display interrupts */	{ TRACER_OPT(funcgraph-irqs, TRACE_GRAPH_PRINT_IRQS) },	{ } /* 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 |	       TRACE_GRAPH_PRINT_DURATION | TRACE_GRAPH_PRINT_IRQS,	.opts = trace_opts}; static struct trace_array *graph_array; /* * DURATION column is being also used to display IRQ signs, * following values are used by print_graph_irq and others * to fill in space into DURATION column. */enum {	DURATION_FILL_FULL  = -1,	DURATION_FILL_START = -2,	DURATION_FILL_END   = -3,}; static enum print_line_tprint_graph_duration(unsigned long long duration, struct trace_seq *s,		     u32 flags); /* Add a function return address to the trace stack on thread info.*/intftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,			 unsigned long frame_pointer){	unsigned long long calltime;	int index; 	if (!current->ret_stack)		return -EBUSY; 	/*	 * We must make sure the ret_stack is tested before we read	 * anything else.	 */	smp_rmb(); 	/* The return trace stack is full */	if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {		atomic_inc(&current->trace_overrun);		return -EBUSY;	} 	calltime = trace_clock_local(); 	index = ++current->curr_ret_stack;	barrier();	current->ret_stack[index].ret = ret;	current->ret_stack[index].func = func;	current->ret_stack[index].calltime = calltime;	current->ret_stack[index].subtime = 0;	current->ret_stack[index].fp = frame_pointer;	*depth = index; 	return 0;} /* Retrieve a function return address to the trace stack on thread info.*/static voidftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret,			unsigned long frame_pointer){	int index; 	index = current->curr_ret_stack; 	if (unlikely(index < 0)) {		ftrace_graph_stop();		WARN_ON(1);		/* Might as well panic, otherwise we have no where to go */		*ret = (unsigned long)panic;		return;	} #if defined(CONFIG_HAVE_FUNCTION_GRAPH_FP_TEST) && !defined(CC_USING_FENTRY)	/*	 * The arch may choose to record the frame pointer used	 * and check it here to make sure that it is what we expect it	 * to be. If gcc does not set the place holder of the return	 * address in the frame pointer, and does a copy instead, then	 * the function graph trace will fail. This test detects this	 * case.	 *	 * Currently, x86_32 with optimize for size (-Os) makes the latest	 * gcc do the above.	 *	 * Note, -mfentry does not use frame pointers, and this test	 *  is not needed if CC_USING_FENTRY is set.	 */	if (unlikely(current->ret_stack[index].fp != frame_pointer)) {		ftrace_graph_stop();		WARN(1, "Bad frame pointer: expected %lx, received %lx\n"		     "  from func %ps return to %lx\n",		     current->ret_stack[index].fp,		     frame_pointer,		     (void *)current->ret_stack[index].func,		     current->ret_stack[index].ret);		*ret = (unsigned long)panic;		return;	}#endif 	*ret = current->ret_stack[index].ret;	trace->func = current->ret_stack[index].func;	trace->calltime = current->ret_stack[index].calltime;	trace->overrun = atomic_read(&current->trace_overrun);	trace->depth = index;} /* * Send the trace to the ring-buffer. * @return the original return address. */unsigned long ftrace_return_to_handler(unsigned long frame_pointer){	struct ftrace_graph_ret trace;	unsigned long ret; 	ftrace_pop_return_trace(&trace, &ret, frame_pointer);	trace.rettime = trace_clock_local();	ftrace_graph_return(&trace);	barrier();	current->curr_ret_stack--; 	if (unlikely(!ret)) {		ftrace_graph_stop();		WARN_ON(1);		/* Might as well panic. What else to do? */		ret = (unsigned long)panic;	} 	return ret;} int __trace_graph_entry(struct trace_array *tr,				struct ftrace_graph_ent *trace,				unsigned long flags,				int pc){	struct ftrace_event_call *call = &event_funcgraph_entry;	struct ring_buffer_event *event;	struct ring_buffer *buffer = tr->buffer;	struct ftrace_graph_ent_entry *entry; 	if (unlikely(__this_cpu_read(ftrace_cpu_disabled)))		return 0; 	event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_ENT,					  sizeof(*entry), flags, pc);	if (!event)		return 0;	entry	= ring_buffer_event_data(event);	entry->graph_ent			= *trace;	if (!filter_current_check_discard(buffer, call, entry, event))		__buffer_unlock_commit(buffer, event); 	return 1;} static inline int ftrace_graph_ignore_irqs(void){	if (!ftrace_graph_skip_irqs || trace_recursion_test(TRACE_IRQ_BIT))		return 0; 	return in_irq();} int trace_graph_entry(struct ftrace_graph_ent *trace){	struct trace_array *tr = graph_array;	struct trace_array_cpu *data;	unsigned long flags;	long disabled;	int ret;	int cpu;	int pc; 	if (!ftrace_trace_task(current))		return 0; 	/* trace it when it is-nested-in or is a function enabled. */	if (!(trace->depth || ftrace_graph_addr(trace->func)) ||	      ftrace_graph_ignore_irqs())		return 0; 	local_irq_save(flags);	cpu = raw_smp_processor_id();	data = tr->data[cpu];	disabled = atomic_inc_return(&data->disabled);	if (likely(disabled == 1)) {		pc = preempt_count();		ret = __trace_graph_entry(tr, trace, flags, pc);	} else {		ret = 0;	} 	atomic_dec(&data->disabled);	local_irq_restore(flags); 	return ret;} int trace_graph_thresh_entry(struct ftrace_graph_ent *trace){	if (tracing_thresh)		return 1;	else		return trace_graph_entry(trace);} static void__trace_graph_function(struct trace_array *tr,		unsigned long ip, unsigned long flags, int pc){	u64 time = trace_clock_local();	struct ftrace_graph_ent ent = {		.func  = ip,		.depth = 0,	};	struct ftrace_graph_ret ret = {		.func     = ip,		.depth    = 0,		.calltime = time,		.rettime  = time,	}; 	__trace_graph_entry(tr, &ent, flags, pc);	__trace_graph_return(tr, &ret, flags, pc);} voidtrace_graph_function(struct trace_array *tr,		unsigned long ip, unsigned long parent_ip,		unsigned long flags, int pc){	__trace_graph_function(tr, ip, flags, pc);} void __trace_graph_return(struct trace_array *tr,				struct ftrace_graph_ret *trace,				unsigned long flags,				int pc){	struct ftrace_event_call *call = &event_funcgraph_exit;	struct ring_buffer_event *event;	struct ring_buffer *buffer = tr->buffer;	struct ftrace_graph_ret_entry *entry; 	if (unlikely(__this_cpu_read(ftrace_cpu_disabled)))		return; 	event = trace_buffer_lock_reserve(buffer, TRACE_GRAPH_RET,					  sizeof(*entry), flags, pc);	if (!event)		return;	entry	= ring_buffer_event_data(event);	entry->ret				= *trace;	if (!filter_current_check_discard(buffer, call, entry, event))		__buffer_unlock_commit(buffer, event);} void trace_graph_return(struct ftrace_graph_ret *trace){	struct trace_array *tr = graph_array;	struct trace_array_cpu *data;	unsigned long flags;	long disabled;	int cpu;	int pc; 	local_irq_save(flags);	cpu = raw_smp_processor_id();	data = tr->data[cpu];	disabled = atomic_inc_return(&data->disabled);	if (likely(disabled == 1)) {		pc = preempt_count();		__trace_graph_return(tr, trace, flags, pc);	}	atomic_dec(&data->disabled);	local_irq_restore(flags);} void set_graph_array(struct trace_array *tr){	graph_array = tr; 	/* Make graph_array visible before we start tracing */ 	smp_mb();} void trace_graph_thresh_return(struct ftrace_graph_ret *trace){	if (tracing_thresh &&	    (trace->rettime - trace->calltime < tracing_thresh))		return;	else		trace_graph_return(trace);} static int graph_trace_init(struct trace_array *tr){	int ret; 	set_graph_array(tr);	if (tracing_thresh)		ret = register_ftrace_graph(&trace_graph_thresh_return,					    &trace_graph_thresh_entry);	else		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 int max_bytes_for_cpu; static enum print_line_tprint_graph_cpu(struct trace_seq *s, int cpu){	int ret; 	/*	 * 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, " %*d) ", max_bytes_for_cpu, cpu);	if (!ret)		return TRACE_TYPE_PARTIAL_LINE; 	return TRACE_TYPE_HANDLED;} #define TRACE_GRAPH_PROCINFO_LENGTH	14 static enum print_line_tprint_graph_proc(struct trace_seq *s, pid_t pid){	char comm[TASK_COMM_LEN];	/* sign + log10(MAX_INT) + '\0' */	char pid_str[11];	int spaces = 0;	int ret;	int len;	int i; 	trace_find_cmdline(pid, comm);	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;}  static enum print_line_tprint_graph_lat_fmt(struct trace_seq *s, struct trace_entry *entry){	if (!trace_seq_putc(s, ' '))		return 0; 	return trace_print_lat_fmt(s, entry);} /* If the pid changed since the last trace, output this event */static enum print_line_tverif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data){	pid_t prev_pid;	pid_t *last_pid;	int ret; 	if (!data)		return TRACE_TYPE_HANDLED; 	last_pid = &(per_cpu_ptr(data->cpu_data, cpu)->last_pid); 	if (*last_pid == pid)		return TRACE_TYPE_HANDLED; 	prev_pid = *last_pid;	*last_pid = pid; 	if (prev_pid == -1)		return TRACE_TYPE_HANDLED;/* * Context-switch trace line:  ------------------------------------------ | 1)  migration/0--1  =>  sshd-1755 ------------------------------------------  */	ret = trace_seq_printf(s,		" ------------------------------------------\n");	if (!ret)		return TRACE_TYPE_PARTIAL_LINE;

Lines 1–500 of 1477. Load more