Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 4cd0332db7e8f57cc082bab11d82c064a9721737

Authored by Ingo Molnar 2009-02-19 19:13:33 +0800

Exists in master and in 7 other branches

Merge branch 'mainline/function-graph' of git://git.kernel.org/pub/scm/linux/ker…

…nel/git/rostedt/linux-2.6-trace into tracing/function-graph-tracer

Showing 5 changed files Inline Diff

arch/x86/include/asm/ftrace.h
arch/x86/kernel/dumpstack.c
arch/x86/kernel/ftrace.c
include/linux/ftrace.h
kernel/trace/trace_functions_graph.c

arch/x86/include/asm/ftrace.h

Diff comments View file @ 4cd0332

 #ifndef _ASM_X86_FTRACE_H
 #define _ASM_X86_FTRACE_H
 #ifdef __ASSEMBLY__
 	.macro MCOUNT_SAVE_FRAME
 	/* taken from glibc */
 	subq $0x38, %rsp
 	movq %rax, (%rsp)
 	movq %rcx, 8(%rsp)
 	movq %rdx, 16(%rsp)
 	movq %rsi, 24(%rsp)
 	movq %rdi, 32(%rsp)
 	movq %r8, 40(%rsp)
 	movq %r9, 48(%rsp)
 	.endm
 	.macro MCOUNT_RESTORE_FRAME
 	movq 48(%rsp), %r9
 	movq 40(%rsp), %r8
 	movq 32(%rsp), %rdi
 	movq 24(%rsp), %rsi
 	movq 16(%rsp), %rdx
 	movq 8(%rsp), %rcx
 	movq (%rsp), %rax
 	addq $0x38, %rsp
 	.endm
 #endif
 #ifdef CONFIG_FUNCTION_TRACER
 #define MCOUNT_ADDR		((long)(mcount))
 #define MCOUNT_INSN_SIZE	5 /* sizeof mcount call */
 #ifndef __ASSEMBLY__
 extern void mcount(void);
 static inline unsigned long ftrace_call_adjust(unsigned long addr)
 {
 	/*
 	 * call mcount is "e8 <4 byte offset>"
 	 * The addr points to the 4 byte offset and the caller of this
 	 * function wants the pointer to e8. Simply subtract one.
 	 */
 	return addr - 1;
 }
 #ifdef CONFIG_DYNAMIC_FTRACE
 struct dyn_arch_ftrace {
 	/* No extra data needed for x86 */
 };
 #endif /*  CONFIG_DYNAMIC_FTRACE */
 #endif /* __ASSEMBLY__ */
 #endif /* CONFIG_FUNCTION_TRACER */
-#ifdef CONFIG_FUNCTION_GRAPH_TRACER
-#ifndef __ASSEMBLY__
-/*
- * Stack of return addresses for functions
- * of a thread.
- * Used in struct thread_info
- */
-struct ftrace_ret_stack {
-	unsigned long ret;
-	unsigned long func;
-	unsigned long long calltime;
-};
-/*
- * Primary handler of a function return.
- * It relays on ftrace_return_to_handler.
- * Defined in entry_32/64.S
- */
-extern void return_to_handler(void);
-#endif /* __ASSEMBLY__ */
-#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 #endif /* _ASM_X86_FTRACE_H */

arch/x86/kernel/dumpstack.c

Diff comments View file @ 4cd0332

 /*
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *  Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
  */
 #include <linux/kallsyms.h>
 #include <linux/kprobes.h>
 #include <linux/uaccess.h>
 #include <linux/utsname.h>
 #include <linux/hardirq.h>
 #include <linux/kdebug.h>
 #include <linux/module.h>
 #include <linux/ptrace.h>
+#include <linux/ftrace.h>
 #include <linux/kexec.h>
 #include <linux/bug.h>
 #include <linux/nmi.h>
 #include <linux/sysfs.h>
 #include <linux/ftrace.h>
 #include <asm/stacktrace.h>
 #include "dumpstack.h"
 int panic_on_unrecovered_nmi;
 unsigned int code_bytes = 64;
 int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE;
 static int die_counter;
 void printk_address(unsigned long address, int reliable)
 {
 	printk(" [<%p>] %s%pS\n", (void *) address,
 			reliable ? "" : "? ", (void *) address);
 }
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 static void
 print_ftrace_graph_addr(unsigned long addr, void *data,
 			const struct stacktrace_ops *ops,
 			struct thread_info *tinfo, int *graph)
 {
 	struct task_struct *task = tinfo->task;
 	unsigned long ret_addr;
 	int index = task->curr_ret_stack;
 	if (addr != (unsigned long)return_to_handler)
 		return;
 	if (!task->ret_stack || index < *graph)
 		return;
 	index -= *graph;
 	ret_addr = task->ret_stack[index].ret;
 	ops->address(data, ret_addr, 1);
 	(*graph)++;
 }
 #else
 static inline void
 print_ftrace_graph_addr(unsigned long addr, void *data,
 			const struct stacktrace_ops *ops,
 			struct thread_info *tinfo, int *graph)
 { }
 #endif
 /*
  * x86-64 can have up to three kernel stacks:
  * process stack
  * interrupt stack
  * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
  */
 static inline int valid_stack_ptr(struct thread_info *tinfo,
 			void *p, unsigned int size, void *end)
 {
 	void *t = tinfo;
 	if (end) {
 		if (p < end && p >= (end-THREAD_SIZE))
 			return 1;
 		else
 			return 0;
 	}
 	return p > t && p < t + THREAD_SIZE - size;
 }
 unsigned long
 print_context_stack(struct thread_info *tinfo,
 		unsigned long *stack, unsigned long bp,
 		const struct stacktrace_ops *ops, void *data,
 		unsigned long *end, int *graph)
 {
 	struct stack_frame *frame = (struct stack_frame *)bp;
 	while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) {
 		unsigned long addr;
 		addr = *stack;
 		if (__kernel_text_address(addr)) {
 			if ((unsigned long) stack == bp + sizeof(long)) {
 				ops->address(data, addr, 1);
 				frame = frame->next_frame;
 				bp = (unsigned long) frame;
 			} else {
 				ops->address(data, addr, bp == 0);
 			}
 			print_ftrace_graph_addr(addr, data, ops, tinfo, graph);
 		}
 		stack++;
 	}
 	return bp;
 }
 static void
 print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
 {
 	printk(data);
 	print_symbol(msg, symbol);
 	printk("\n");
 }
 static void print_trace_warning(void *data, char *msg)
 {
 	printk("%s%s\n", (char *)data, msg);
 }
 static int print_trace_stack(void *data, char *name)
 {
 	printk("%s <%s> ", (char *)data, name);
 	return 0;
 }
 /*
  * Print one address/symbol entries per line.
  */
 static void print_trace_address(void *data, unsigned long addr, int reliable)
 {
 	touch_nmi_watchdog();
 	printk(data);
 	printk_address(addr, reliable);
 }
 static const struct stacktrace_ops print_trace_ops = {
 	.warning = print_trace_warning,
 	.warning_symbol = print_trace_warning_symbol,
 	.stack = print_trace_stack,
 	.address = print_trace_address,
 };
 void
 show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
 		unsigned long *stack, unsigned long bp, char *log_lvl)
 {
 	printk("%sCall Trace:\n", log_lvl);
 	dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl);
 }
 void show_trace(struct task_struct *task, struct pt_regs *regs,
 		unsigned long *stack, unsigned long bp)
 {
 	show_trace_log_lvl(task, regs, stack, bp, "");
 }
 void show_stack(struct task_struct *task, unsigned long *sp)
 {
 	show_stack_log_lvl(task, NULL, sp, 0, "");
 }
 /*
  * The architecture-independent dump_stack generator
  */
 void dump_stack(void)
 {
 	unsigned long bp = 0;
 	unsigned long stack;
 #ifdef CONFIG_FRAME_POINTER
 	if (!bp)
 		get_bp(bp);
 #endif
 	printk("Pid: %d, comm: %.20s %s %s %.*s\n",
 		current->pid, current->comm, print_tainted(),
 		init_utsname()->release,
 		(int)strcspn(init_utsname()->version, " "),
 		init_utsname()->version);
 	show_trace(NULL, NULL, &stack, bp);
 }
 EXPORT_SYMBOL(dump_stack);
 static raw_spinlock_t die_lock = __RAW_SPIN_LOCK_UNLOCKED;
 static int die_owner = -1;
 static unsigned int die_nest_count;
 unsigned __kprobes long oops_begin(void)
 {
 	int cpu;
 	unsigned long flags;
 	/* notify the hw-branch tracer so it may disable tracing and
 	   add the last trace to the trace buffer -
 	   the earlier this happens, the more useful the trace. */
 	trace_hw_branch_oops();
 	oops_enter();
 	/* racy, but better than risking deadlock. */
 	raw_local_irq_save(flags);
 	cpu = smp_processor_id();
 	if (!__raw_spin_trylock(&die_lock)) {
 		if (cpu == die_owner)
 			/* nested oops. should stop eventually */;
 		else
 			__raw_spin_lock(&die_lock);
 	}
 	die_nest_count++;
 	die_owner = cpu;
 	console_verbose();
 	bust_spinlocks(1);
 	return flags;
 }
 void __kprobes oops_end(unsigned long flags, struct pt_regs *regs, int signr)
 {
 	if (regs && kexec_should_crash(current))
 		crash_kexec(regs);
 	bust_spinlocks(0);
 	die_owner = -1;
 	add_taint(TAINT_DIE);
 	die_nest_count--;
 	if (!die_nest_count)
 		/* Nest count reaches zero, release the lock. */
 		__raw_spin_unlock(&die_lock);
 	raw_local_irq_restore(flags);
 	oops_exit();
 	if (!signr)
 		return;
 	if (in_interrupt())
 		panic("Fatal exception in interrupt");
 	if (panic_on_oops)
 		panic("Fatal exception");
 	do_exit(signr);
 }
 int __kprobes __die(const char *str, struct pt_regs *regs, long err)
 {
 #ifdef CONFIG_X86_32
 	unsigned short ss;
 	unsigned long sp;
 #endif
 	printk(KERN_EMERG "%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
 #ifdef CONFIG_PREEMPT
 	printk("PREEMPT ");
 #endif
 #ifdef CONFIG_SMP
 	printk("SMP ");
 #endif
 #ifdef CONFIG_DEBUG_PAGEALLOC
 	printk("DEBUG_PAGEALLOC");
 #endif
 	printk("\n");
 	sysfs_printk_last_file();
 	if (notify_die(DIE_OOPS, str, regs, err,
 			current->thread.trap_no, SIGSEGV) == NOTIFY_STOP)
 		return 1;
 	show_registers(regs);
 #ifdef CONFIG_X86_32
 	sp = (unsigned long) (&regs->sp);
 	savesegment(ss, ss);
 	if (user_mode(regs)) {
 		sp = regs->sp;
 		ss = regs->ss & 0xffff;
 	}
 	printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip);
 	print_symbol("%s", regs->ip);
 	printk(" SS:ESP %04x:%08lx\n", ss, sp);
 #else
 	/* Executive summary in case the oops scrolled away */
 	printk(KERN_ALERT "RIP ");
 	printk_address(regs->ip, 1);
 	printk(" RSP <%016lx>\n", regs->sp);
 #endif
 	return 0;
 }
 /*
  * This is gone through when something in the kernel has done something bad
  * and is about to be terminated:
  */
 void die(const char *str, struct pt_regs *regs, long err)
 {
 	unsigned long flags = oops_begin();
 	int sig = SIGSEGV;
 	if (!user_mode_vm(regs))
 		report_bug(regs->ip, regs);
 	if (__die(str, regs, err))
 		sig = 0;
 	oops_end(flags, regs, sig);
 }
 void notrace __kprobes
 die_nmi(char *str, struct pt_regs *regs, int do_panic)
 {
 	unsigned long flags;
 	if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP)
 		return;
 	/*
 	 * We are in trouble anyway, lets at least try
 	 * to get a message out.
 	 */
 	flags = oops_begin();
 	printk(KERN_EMERG "%s", str);
 	printk(" on CPU%d, ip %08lx, registers:\n",
 		smp_processor_id(), regs->ip);
 	show_registers(regs);
 	oops_end(flags, regs, 0);
 	if (do_panic || panic_on_oops)
 		panic("Non maskable interrupt");
 	nmi_exit();
 	local_irq_enable();
 	do_exit(SIGBUS);
 }
 static int __init oops_setup(char *s)
 {
 	if (!s)
 		return -EINVAL;
 	if (!strcmp(s, "panic"))
 		panic_on_oops = 1;
 	return 0;
 }
 early_param("oops", oops_setup);
 static int __init kstack_setup(char *s)
 {
 	if (!s)
 		return -EINVAL;
 	kstack_depth_to_print = simple_strtoul(s, NULL, 0);
 	return 0;
 }
 early_param("kstack", kstack_setup);
 static int __init code_bytes_setup(char *s)
 {
 	code_bytes = simple_strtoul(s, NULL, 0);
 	if (code_bytes > 8192)
 		code_bytes = 8192;
 	return 1;
 }
 __setup("code_bytes=", code_bytes_setup);

arch/x86/kernel/ftrace.c

Diff comments View file @ 4cd0332

 /*
  * Code for replacing ftrace calls with jumps.
  *
  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
  *
  * Thanks goes to Ingo Molnar, for suggesting the idea.
  * Mathieu Desnoyers, for suggesting postponing the modifications.
  * Arjan van de Ven, for keeping me straight, and explaining to me
  * the dangers of modifying code on the run.
  */
 #include <linux/spinlock.h>
 #include <linux/hardirq.h>
 #include <linux/uaccess.h>
 #include <linux/ftrace.h>
 #include <linux/percpu.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/list.h>
 #include <asm/ftrace.h>
 #include <linux/ftrace.h>
 #include <asm/nops.h>
 #include <asm/nmi.h>
 #ifdef CONFIG_DYNAMIC_FTRACE
 union ftrace_code_union {
 	char code[MCOUNT_INSN_SIZE];
 	struct {
 		char e8;
 		int offset;
 	} __attribute__((packed));
 };
 static int ftrace_calc_offset(long ip, long addr)
 {
 	return (int)(addr - ip);
 }
 static unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr)
 {
 	static union ftrace_code_union calc;
 	calc.e8		= 0xe8;
 	calc.offset	= ftrace_calc_offset(ip + MCOUNT_INSN_SIZE, addr);
 	/*
 	 * No locking needed, this must be called via kstop_machine
 	 * which in essence is like running on a uniprocessor machine.
 	 */
 	return calc.code;
 }
 /*
  * Modifying code must take extra care. On an SMP machine, if
  * the code being modified is also being executed on another CPU
  * that CPU will have undefined results and possibly take a GPF.
  * We use kstop_machine to stop other CPUS from exectuing code.
  * But this does not stop NMIs from happening. We still need
  * to protect against that. We separate out the modification of
  * the code to take care of this.
  *
  * Two buffers are added: An IP buffer and a "code" buffer.
  *
  * 1) Put the instruction pointer into the IP buffer
  *    and the new code into the "code" buffer.
  * 2) Set a flag that says we are modifying code
  * 3) Wait for any running NMIs to finish.
  * 4) Write the code
  * 5) clear the flag.
  * 6) Wait for any running NMIs to finish.
  *
  * If an NMI is executed, the first thing it does is to call
  * "ftrace_nmi_enter". This will check if the flag is set to write
  * and if it is, it will write what is in the IP and "code" buffers.
  *
  * The trick is, it does not matter if everyone is writing the same
  * content to the code location. Also, if a CPU is executing code
  * it is OK to write to that code location if the contents being written
  * are the same as what exists.
  */
 static atomic_t nmi_running = ATOMIC_INIT(0);
 static int mod_code_status;		/* holds return value of text write */
 static int mod_code_write;		/* set when NMI should do the write */
 static void *mod_code_ip;		/* holds the IP to write to */
 static void *mod_code_newcode;		/* holds the text to write to the IP */
 static unsigned nmi_wait_count;
 static atomic_t nmi_update_count = ATOMIC_INIT(0);
 int ftrace_arch_read_dyn_info(char *buf, int size)
 {
 	int r;
 	r = snprintf(buf, size, "%u %u",
 		     nmi_wait_count,
 		     atomic_read(&nmi_update_count));
 	return r;
 }
 static void ftrace_mod_code(void)
 {
 	/*
 	 * Yes, more than one CPU process can be writing to mod_code_status.
 	 *    (and the code itself)
 	 * But if one were to fail, then they all should, and if one were
 	 * to succeed, then they all should.
 	 */
 	mod_code_status = probe_kernel_write(mod_code_ip, mod_code_newcode,
 					     MCOUNT_INSN_SIZE);
 }
 void ftrace_nmi_enter(void)
 {
 	atomic_inc(&nmi_running);
 	/* Must have nmi_running seen before reading write flag */
 	smp_mb();
 	if (mod_code_write) {
 		ftrace_mod_code();
 		atomic_inc(&nmi_update_count);
 	}
 }
 void ftrace_nmi_exit(void)
 {
 	/* Finish all executions before clearing nmi_running */
 	smp_wmb();
 	atomic_dec(&nmi_running);
 }
 static void wait_for_nmi(void)
 {
 	if (!atomic_read(&nmi_running))
 		return;
 	do {
 		cpu_relax();
 	} while (atomic_read(&nmi_running));
 	nmi_wait_count++;
 }
 static int
 do_ftrace_mod_code(unsigned long ip, void *new_code)
 {
 	mod_code_ip = (void *)ip;
 	mod_code_newcode = new_code;
 	/* The buffers need to be visible before we let NMIs write them */
 	smp_wmb();
 	mod_code_write = 1;
 	/* Make sure write bit is visible before we wait on NMIs */
 	smp_mb();
 	wait_for_nmi();
 	/* Make sure all running NMIs have finished before we write the code */
 	smp_mb();
 	ftrace_mod_code();
 	/* Make sure the write happens before clearing the bit */
 	smp_wmb();
 	mod_code_write = 0;
 	/* make sure NMIs see the cleared bit */
 	smp_mb();
 	wait_for_nmi();
 	return mod_code_status;
 }
 static unsigned char ftrace_nop[MCOUNT_INSN_SIZE];
 static unsigned char *ftrace_nop_replace(void)
 {
 	return ftrace_nop;
 }
 static int
 ftrace_modify_code(unsigned long ip, unsigned char *old_code,
 		   unsigned char *new_code)
 {
 	unsigned char replaced[MCOUNT_INSN_SIZE];
 	/*
 	 * Note: Due to modules and __init, code can
 	 *  disappear and change, we need to protect against faulting
 	 *  as well as code changing. We do this by using the
 	 *  probe_kernel_* functions.
 	 *
 	 * No real locking needed, this code is run through
 	 * kstop_machine, or before SMP starts.
 	 */
 	/* read the text we want to modify */
 	if (probe_kernel_read(replaced, (void *)ip, MCOUNT_INSN_SIZE))
 		return -EFAULT;
 	/* Make sure it is what we expect it to be */
 	if (memcmp(replaced, old_code, MCOUNT_INSN_SIZE) != 0)
 		return -EINVAL;
 	/* replace the text with the new text */
 	if (do_ftrace_mod_code(ip, new_code))
 		return -EPERM;
 	sync_core();
 	return 0;
 }
 int ftrace_make_nop(struct module *mod,
 		    struct dyn_ftrace *rec, unsigned long addr)
 {
 	unsigned char *new, *old;
 	unsigned long ip = rec->ip;
 	old = ftrace_call_replace(ip, addr);
 	new = ftrace_nop_replace();
 	return ftrace_modify_code(rec->ip, old, new);
 }
 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 {
 	unsigned char *new, *old;
 	unsigned long ip = rec->ip;
 	old = ftrace_nop_replace();
 	new = ftrace_call_replace(ip, addr);
 	return ftrace_modify_code(rec->ip, old, new);
 }
 int ftrace_update_ftrace_func(ftrace_func_t func)
 {
 	unsigned long ip = (unsigned long)(&ftrace_call);
 	unsigned char old[MCOUNT_INSN_SIZE], *new;
 	int ret;
 	memcpy(old, &ftrace_call, MCOUNT_INSN_SIZE);
 	new = ftrace_call_replace(ip, (unsigned long)func);
 	ret = ftrace_modify_code(ip, old, new);
 	return ret;
 }
 int __init ftrace_dyn_arch_init(void *data)
 {
 	extern const unsigned char ftrace_test_p6nop[];
 	extern const unsigned char ftrace_test_nop5[];
 	extern const unsigned char ftrace_test_jmp[];
 	int faulted = 0;
 	/*
 	 * There is no good nop for all x86 archs.
 	 * We will default to using the P6_NOP5, but first we
 	 * will test to make sure that the nop will actually
 	 * work on this CPU. If it faults, we will then
 	 * go to a lesser efficient 5 byte nop. If that fails
 	 * we then just use a jmp as our nop. This isn't the most
 	 * efficient nop, but we can not use a multi part nop
 	 * since we would then risk being preempted in the middle
 	 * of that nop, and if we enabled tracing then, it might
 	 * cause a system crash.
 	 *
 	 * TODO: check the cpuid to determine the best nop.
 	 */
 	asm volatile (
 		"ftrace_test_jmp:"
 		"jmp ftrace_test_p6nop\n"
 		"nop\n"
 		"nop\n"
 		"nop\n"  /* 2 byte jmp + 3 bytes */
 		"ftrace_test_p6nop:"
 		P6_NOP5
 		"jmp 1f\n"
 		"ftrace_test_nop5:"
 		".byte 0x66,0x66,0x66,0x66,0x90\n"
 		"1:"
 		".section .fixup, \"ax\"\n"
 		"2:	movl $1, %0\n"
 		"	jmp ftrace_test_nop5\n"
 		"3:	movl $2, %0\n"
 		"	jmp 1b\n"
 		".previous\n"
 		_ASM_EXTABLE(ftrace_test_p6nop, 2b)
 		_ASM_EXTABLE(ftrace_test_nop5, 3b)
 		: "=r"(faulted) : "0" (faulted));
 	switch (faulted) {
 	case 0:
 		pr_info("ftrace: converting mcount calls to 0f 1f 44 00 00\n");
 		memcpy(ftrace_nop, ftrace_test_p6nop, MCOUNT_INSN_SIZE);
 		break;
 	case 1:
 		pr_info("ftrace: converting mcount calls to 66 66 66 66 90\n");
 		memcpy(ftrace_nop, ftrace_test_nop5, MCOUNT_INSN_SIZE);
 		break;
 	case 2:
 		pr_info("ftrace: converting mcount calls to jmp . + 5\n");
 		memcpy(ftrace_nop, ftrace_test_jmp, MCOUNT_INSN_SIZE);
 		break;
 	}
 	/* The return code is retured via data */
 	*(unsigned long *)data = 0;
 	return 0;
 }
 #endif
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 #ifdef CONFIG_DYNAMIC_FTRACE
 extern void ftrace_graph_call(void);
 static int ftrace_mod_jmp(unsigned long ip,
 			  int old_offset, int new_offset)
 {
 	unsigned char code[MCOUNT_INSN_SIZE];
 	if (probe_kernel_read(code, (void *)ip, MCOUNT_INSN_SIZE))
 		return -EFAULT;
 	if (code[0] != 0xe9 || old_offset != *(int *)(&code[1]))
 		return -EINVAL;
 	*(int *)(&code[1]) = new_offset;
 	if (do_ftrace_mod_code(ip, &code))
 		return -EPERM;
 	return 0;
 }
 int ftrace_enable_ftrace_graph_caller(void)
 {
 	unsigned long ip = (unsigned long)(&ftrace_graph_call);
 	int old_offset, new_offset;
 	old_offset = (unsigned long)(&ftrace_stub) - (ip + MCOUNT_INSN_SIZE);
 	new_offset = (unsigned long)(&ftrace_graph_caller) - (ip + MCOUNT_INSN_SIZE);
 	return ftrace_mod_jmp(ip, old_offset, new_offset);
 }
 int ftrace_disable_ftrace_graph_caller(void)
 {
 	unsigned long ip = (unsigned long)(&ftrace_graph_call);
 	int old_offset, new_offset;
 	old_offset = (unsigned long)(&ftrace_graph_caller) - (ip + MCOUNT_INSN_SIZE);
 	new_offset = (unsigned long)(&ftrace_stub) - (ip + MCOUNT_INSN_SIZE);
 	return ftrace_mod_jmp(ip, old_offset, new_offset);
 }
 #endif /* !CONFIG_DYNAMIC_FTRACE */
-/* Add a function return address to the trace stack on thread info.*/
-static int push_return_trace(unsigned long ret, unsigned long long time,
-				unsigned long func, int *depth)
-{
-	int index;
-	if (!current->ret_stack)
-		return -EBUSY;
-	/* The return trace stack is full */
-	if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {
-		atomic_inc(&current->trace_overrun);
-		return -EBUSY;
-	}
-	index = ++current->curr_ret_stack;
-	barrier();
-	current->ret_stack[index].ret = ret;
-	current->ret_stack[index].func = func;
-	current->ret_stack[index].calltime = time;
-	*depth = index;
-	return 0;
-}
-/* Retrieve a function return address to the trace stack on thread info.*/
-static void pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret)
-{
-	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;
-	}
-	*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;
-	barrier();
-	current->curr_ret_stack--;
-}
 /*
- * Send the trace to the ring-buffer.
- * @return the original return address.
- */
-unsigned long ftrace_return_to_handler(void)
-{
-	struct ftrace_graph_ret trace;
-	unsigned long ret;
-	pop_return_trace(&trace, &ret);
-	trace.rettime = cpu_clock(raw_smp_processor_id());
-	ftrace_graph_return(&trace);
-	if (unlikely(!ret)) {
-		ftrace_graph_stop();
-		WARN_ON(1);
-		/* Might as well panic. What else to do? */
-		ret = (unsigned long)panic;
-	}
-	return ret;
-}
-/*
  * Hook the return address and push it in the stack of return addrs
  * in current thread info.
  */
 void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr)
 {
 	unsigned long old;
 	unsigned long long calltime;
 	int faulted;
 	struct ftrace_graph_ent trace;
 	unsigned long return_hooker = (unsigned long)
 				&return_to_handler;
 	/* Nmi's are currently unsupported */
 	if (unlikely(in_nmi()))
 		return;
 	if (unlikely(atomic_read(&current->tracing_graph_pause)))
 		return;
 	/*
 	 * Protect against fault, even if it shouldn't
 	 * happen. This tool is too much intrusive to
 	 * ignore such a protection.
 	 */
 	asm volatile(
 		"1: " _ASM_MOV " (%[parent]), %[old]\n"
 		"2: " _ASM_MOV " %[return_hooker], (%[parent])\n"
 		"   movl $0, %[faulted]\n"
 		"3:\n"
 		".section .fixup, \"ax\"\n"
 		"4: movl $1, %[faulted]\n"
 		"   jmp 3b\n"
 		".previous\n"
 		_ASM_EXTABLE(1b, 4b)
 		_ASM_EXTABLE(2b, 4b)
 		: [old] "=r" (old), [faulted] "=r" (faulted)
 		: [parent] "r" (parent), [return_hooker] "r" (return_hooker)
 		: "memory"
 	);
 	if (unlikely(faulted)) {
 		ftrace_graph_stop();
 		WARN_ON(1);
 		return;
 	}
 	calltime = cpu_clock(raw_smp_processor_id());
-	if (push_return_trace(old, calltime,
+	if (ftrace_push_return_trace(old, calltime,
 				self_addr, &trace.depth) == -EBUSY) {
 		*parent = old;
 		return;
 	}
 	trace.func = self_addr;
 	/* Only trace if the calling function expects to */
 	if (!ftrace_graph_entry(&trace)) {
 		current->curr_ret_stack--;
 		*parent = old;
 	}
 }
 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */

include/linux/ftrace.h

Diff comments View file @ 4cd0332

 #ifndef _LINUX_FTRACE_H
 #define _LINUX_FTRACE_H
 #include <linux/linkage.h>
 #include <linux/fs.h>
 #include <linux/ktime.h>
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/kallsyms.h>
 #include <linux/bitops.h>
 #include <linux/sched.h>
 #ifdef CONFIG_FUNCTION_TRACER
 extern int ftrace_enabled;
 extern int
 ftrace_enable_sysctl(struct ctl_table *table, int write,
 		     struct file *filp, void __user *buffer, size_t *lenp,
 		     loff_t *ppos);
 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip);
 struct ftrace_ops {
 	ftrace_func_t	  func;
 	struct ftrace_ops *next;
 };
 extern int function_trace_stop;
 /*
  * Type of the current tracing.
  */
 enum ftrace_tracing_type_t {
 	FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
 	FTRACE_TYPE_RETURN,	/* Hook the return of the function */
 };
 /* Current tracing type, default is FTRACE_TYPE_ENTER */
 extern enum ftrace_tracing_type_t ftrace_tracing_type;
 /**
  * ftrace_stop - stop function tracer.
  *
  * A quick way to stop the function tracer. Note this an on off switch,
  * it is not something that is recursive like preempt_disable.
  * This does not disable the calling of mcount, it only stops the
  * calling of functions from mcount.
  */
 static inline void ftrace_stop(void)
 {
 	function_trace_stop = 1;
 }
 /**
  * ftrace_start - start the function tracer.
  *
  * This function is the inverse of ftrace_stop. This does not enable
  * the function tracing if the function tracer is disabled. This only
  * sets the function tracer flag to continue calling the functions
  * from mcount.
  */
 static inline void ftrace_start(void)
 {
 	function_trace_stop = 0;
 }
 /*
  * The ftrace_ops must be a static and should also
  * be read_mostly.  These functions do modify read_mostly variables
  * so use them sparely. Never free an ftrace_op or modify the
  * next pointer after it has been registered. Even after unregistering
  * it, the next pointer may still be used internally.
  */
 int register_ftrace_function(struct ftrace_ops *ops);
 int unregister_ftrace_function(struct ftrace_ops *ops);
 void clear_ftrace_function(void);
 extern void ftrace_stub(unsigned long a0, unsigned long a1);
 #else /* !CONFIG_FUNCTION_TRACER */
 # define register_ftrace_function(ops) do { } while (0)
 # define unregister_ftrace_function(ops) do { } while (0)
 # define clear_ftrace_function(ops) do { } while (0)
 static inline void ftrace_kill(void) { }
 static inline void ftrace_stop(void) { }
 static inline void ftrace_start(void) { }
 #endif /* CONFIG_FUNCTION_TRACER */
 #ifdef CONFIG_STACK_TRACER
 extern int stack_tracer_enabled;
 int
 stack_trace_sysctl(struct ctl_table *table, int write,
 		   struct file *file, void __user *buffer, size_t *lenp,
 		   loff_t *ppos);
 #endif
 struct ftrace_func_command {
 	struct list_head	list;
 	char			*name;
 	int			(*func)(char *func, char *cmd,
 					char *params, int enable);
 };
 #ifdef CONFIG_DYNAMIC_FTRACE
 /* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
 #include <asm/ftrace.h>
 struct seq_file;
 struct ftrace_probe_ops {
 	void			(*func)(unsigned long ip,
 					unsigned long parent_ip,
 					void **data);
 	int			(*callback)(unsigned long ip, void **data);
 	void			(*free)(void **data);
 	int			(*print)(struct seq_file *m,
 					 unsigned long ip,
 					 struct ftrace_probe_ops *ops,
 					 void *data);
 };
 extern int
 register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
 			      void *data);
 extern void
 unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops,
 				void *data);
 extern void
 unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops);
 extern void unregister_ftrace_function_probe_all(char *glob);
 enum {
 	FTRACE_FL_FREE		= (1 << 0),
 	FTRACE_FL_FAILED	= (1 << 1),
 	FTRACE_FL_FILTER	= (1 << 2),
 	FTRACE_FL_ENABLED	= (1 << 3),
 	FTRACE_FL_NOTRACE	= (1 << 4),
 	FTRACE_FL_CONVERTED	= (1 << 5),
 	FTRACE_FL_FROZEN	= (1 << 6),
 };
 struct dyn_ftrace {
 	struct list_head	list;
 	unsigned long		ip; /* address of mcount call-site */
 	unsigned long		flags;
 	struct dyn_arch_ftrace	arch;
 };
 int ftrace_force_update(void);
 void ftrace_set_filter(unsigned char *buf, int len, int reset);
 int register_ftrace_command(struct ftrace_func_command *cmd);
 int unregister_ftrace_command(struct ftrace_func_command *cmd);
 /* defined in arch */
 extern int ftrace_ip_converted(unsigned long ip);
 extern int ftrace_dyn_arch_init(void *data);
 extern int ftrace_update_ftrace_func(ftrace_func_t func);
 extern void ftrace_caller(void);
 extern void ftrace_call(void);
 extern void mcount_call(void);
 #ifndef FTRACE_ADDR
 #define FTRACE_ADDR ((unsigned long)ftrace_caller)
 #endif
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 extern void ftrace_graph_caller(void);
 extern int ftrace_enable_ftrace_graph_caller(void);
 extern int ftrace_disable_ftrace_graph_caller(void);
 #else
 static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
 static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
 #endif
 /**
  * ftrace_make_nop - convert code into nop
  * @mod: module structure if called by module load initialization
  * @rec: the mcount call site record
  * @addr: the address that the call site should be calling
  *
  * This is a very sensitive operation and great care needs
  * to be taken by the arch.  The operation should carefully
  * read the location, check to see if what is read is indeed
  * what we expect it to be, and then on success of the compare,
  * it should write to the location.
  *
  * The code segment at @rec->ip should be a caller to @addr
  *
  * Return must be:
  *  0 on success
  *  -EFAULT on error reading the location
  *  -EINVAL on a failed compare of the contents
  *  -EPERM  on error writing to the location
  * Any other value will be considered a failure.
  */
 extern int ftrace_make_nop(struct module *mod,
 			   struct dyn_ftrace *rec, unsigned long addr);
 /**
  * ftrace_make_call - convert a nop call site into a call to addr
  * @rec: the mcount call site record
  * @addr: the address that the call site should call
  *
  * This is a very sensitive operation and great care needs
  * to be taken by the arch.  The operation should carefully
  * read the location, check to see if what is read is indeed
  * what we expect it to be, and then on success of the compare,
  * it should write to the location.
  *
  * The code segment at @rec->ip should be a nop
  *
  * Return must be:
  *  0 on success
  *  -EFAULT on error reading the location
  *  -EINVAL on a failed compare of the contents
  *  -EPERM  on error writing to the location
  * Any other value will be considered a failure.
  */
 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
 /* May be defined in arch */
 extern int ftrace_arch_read_dyn_info(char *buf, int size);
 extern int skip_trace(unsigned long ip);
 extern void ftrace_release(void *start, unsigned long size);
 extern void ftrace_disable_daemon(void);
 extern void ftrace_enable_daemon(void);
 #else
 # define skip_trace(ip)				({ 0; })
 # define ftrace_force_update()			({ 0; })
 # define ftrace_set_filter(buf, len, reset)	do { } while (0)
 # define ftrace_disable_daemon()		do { } while (0)
 # define ftrace_enable_daemon()			do { } while (0)
 static inline void ftrace_release(void *start, unsigned long size) { }
 static inline int register_ftrace_command(struct ftrace_func_command *cmd)
 {
 	return -EINVAL;
 }
 static inline int unregister_ftrace_command(char *cmd_name)
 {
 	return -EINVAL;
 }
 #endif /* CONFIG_DYNAMIC_FTRACE */
 /* totally disable ftrace - can not re-enable after this */
 void ftrace_kill(void);
 static inline void tracer_disable(void)
 {
 #ifdef CONFIG_FUNCTION_TRACER
 	ftrace_enabled = 0;
 #endif
 }
 /*
  * Ftrace disable/restore without lock. Some synchronization mechanism
  * must be used to prevent ftrace_enabled to be changed between
  * disable/restore.
  */
 static inline int __ftrace_enabled_save(void)
 {
 #ifdef CONFIG_FUNCTION_TRACER
 	int saved_ftrace_enabled = ftrace_enabled;
 	ftrace_enabled = 0;
 	return saved_ftrace_enabled;
 #else
 	return 0;
 #endif
 }
 static inline void __ftrace_enabled_restore(int enabled)
 {
 #ifdef CONFIG_FUNCTION_TRACER
 	ftrace_enabled = enabled;
 #endif
 }
 #ifdef CONFIG_FRAME_POINTER
 /* TODO: need to fix this for ARM */
 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
 # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1))
 # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2))
 # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3))
 # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4))
 # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5))
 # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6))
 #else
 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0))
 # define CALLER_ADDR1 0UL
 # define CALLER_ADDR2 0UL
 # define CALLER_ADDR3 0UL
 # define CALLER_ADDR4 0UL
 # define CALLER_ADDR5 0UL
 # define CALLER_ADDR6 0UL
 #endif
 #ifdef CONFIG_IRQSOFF_TRACER
   extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
   extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
 #else
 # define time_hardirqs_on(a0, a1)		do { } while (0)
 # define time_hardirqs_off(a0, a1)		do { } while (0)
 #endif
 #ifdef CONFIG_PREEMPT_TRACER
   extern void trace_preempt_on(unsigned long a0, unsigned long a1);
   extern void trace_preempt_off(unsigned long a0, unsigned long a1);
 #else
 # define trace_preempt_on(a0, a1)		do { } while (0)
 # define trace_preempt_off(a0, a1)		do { } while (0)
 #endif
 #ifdef CONFIG_TRACING
 extern int ftrace_dump_on_oops;
 extern void tracing_start(void);
 extern void tracing_stop(void);
 extern void ftrace_off_permanent(void);
 extern void
 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
 /**
  * ftrace_printk - printf formatting in the ftrace buffer
  * @fmt: the printf format for printing
  *
  * Note: __ftrace_printk is an internal function for ftrace_printk and
  *       the @ip is passed in via the ftrace_printk macro.
  *
  * This function allows a kernel developer to debug fast path sections
  * that printk is not appropriate for. By scattering in various
  * printk like tracing in the code, a developer can quickly see
  * where problems are occurring.
  *
  * This is intended as a debugging tool for the developer only.
  * Please refrain from leaving ftrace_printks scattered around in
  * your code.
  */
 # define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt)
 extern int
 __ftrace_printk(unsigned long ip, const char *fmt, ...)
 	__attribute__ ((format (printf, 2, 3)));
 # define ftrace_vprintk(fmt, ap) __ftrace_printk(_THIS_IP_, fmt, ap)
 extern int
 __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
 extern void ftrace_dump(void);
 #else
 static inline void
 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
 static inline int
 ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
 static inline void tracing_start(void) { }
 static inline void tracing_stop(void) { }
 static inline void ftrace_off_permanent(void) { }
 static inline int
 ftrace_printk(const char *fmt, ...)
 {
 	return 0;
 }
 static inline int
 ftrace_vprintk(const char *fmt, va_list ap)
 {
 	return 0;
 }
 static inline void ftrace_dump(void) { }
 #endif
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 extern void ftrace_init(void);
 extern void ftrace_init_module(struct module *mod,
 			       unsigned long *start, unsigned long *end);
 #else
 static inline void ftrace_init(void) { }
 static inline void
 ftrace_init_module(struct module *mod,
 		   unsigned long *start, unsigned long *end) { }
 #endif
 /*
  * Structure that defines an entry function trace.
  */
 struct ftrace_graph_ent {
 	unsigned long func; /* Current function */
 	int depth;
 };
 /*
  * Structure that defines a return function trace.
  */
 struct ftrace_graph_ret {
 	unsigned long func; /* Current function */
 	unsigned long long calltime;
 	unsigned long long rettime;
 	/* Number of functions that overran the depth limit for current task */
 	unsigned long overrun;
 	int depth;
 };
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 /*
+ * Stack of return addresses for functions
+ * of a thread.
+ * Used in struct thread_info
+ */
+struct ftrace_ret_stack {
+	unsigned long ret;
+	unsigned long func;
+	unsigned long long calltime;
+};
+/*
+ * Primary handler of a function return.
+ * It relays on ftrace_return_to_handler.
+ * Defined in entry_32/64.S
+ */
+extern void return_to_handler(void);
+extern int
+ftrace_push_return_trace(unsigned long ret, unsigned long long time,
+			 unsigned long func, int *depth);
+extern void
+ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret);
+/*
  * Sometimes we don't want to trace a function with the function
  * graph tracer but we want them to keep traced by the usual function
  * tracer if the function graph tracer is not configured.
  */
 #define __notrace_funcgraph		notrace
 /*
  * We want to which function is an entrypoint of a hardirq.
  * That will help us to put a signal on output.
  */
 #define __irq_entry		 __attribute__((__section__(".irqentry.text")))
 /* Limits of hardirq entrypoints */
 extern char __irqentry_text_start[];
 extern char __irqentry_text_end[];
 #define FTRACE_RETFUNC_DEPTH 50
 #define FTRACE_RETSTACK_ALLOC_SIZE 32
 /* Type of the callback handlers for tracing function graph*/
 typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
 typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
 				trace_func_graph_ent_t entryfunc);
 extern void ftrace_graph_stop(void);
 /* The current handlers in use */
 extern trace_func_graph_ret_t ftrace_graph_return;
 extern trace_func_graph_ent_t ftrace_graph_entry;
 extern void unregister_ftrace_graph(void);
 extern void ftrace_graph_init_task(struct task_struct *t);
 extern void ftrace_graph_exit_task(struct task_struct *t);
 static inline int task_curr_ret_stack(struct task_struct *t)
 {
 	return t->curr_ret_stack;
 }
 static inline void pause_graph_tracing(void)
 {
 	atomic_inc(&current->tracing_graph_pause);
 }
 static inline void unpause_graph_tracing(void)
 {
 	atomic_dec(&current->tracing_graph_pause);
 }
 #else
 #define __notrace_funcgraph
 #define __irq_entry
 static inline void ftrace_graph_init_task(struct task_struct *t) { }
 static inline void ftrace_graph_exit_task(struct task_struct *t) { }
 static inline int task_curr_ret_stack(struct task_struct *tsk)
 {
 	return -1;
 }
 static inline void pause_graph_tracing(void) { }
 static inline void unpause_graph_tracing(void) { }
 #endif
 #ifdef CONFIG_TRACING
 #include <linux/sched.h>
 /* flags for current->trace */
 enum {
 	TSK_TRACE_FL_TRACE_BIT	= 0,
 	TSK_TRACE_FL_GRAPH_BIT	= 1,
 };
 enum {
 	TSK_TRACE_FL_TRACE	= 1 << TSK_TRACE_FL_TRACE_BIT,
 	TSK_TRACE_FL_GRAPH	= 1 << TSK_TRACE_FL_GRAPH_BIT,
 };
 static inline void set_tsk_trace_trace(struct task_struct *tsk)
 {
 	set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
 }
 static inline void clear_tsk_trace_trace(struct task_struct *tsk)
 {
 	clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
 }
 static inline int test_tsk_trace_trace(struct task_struct *tsk)
 {
 	return tsk->trace & TSK_TRACE_FL_TRACE;
 }
 static inline void set_tsk_trace_graph(struct task_struct *tsk)
 {
 	set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
 }
 static inline void clear_tsk_trace_graph(struct task_struct *tsk)
 {
 	clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
 }
 static inline int test_tsk_trace_graph(struct task_struct *tsk)
 {
 	return tsk->trace & TSK_TRACE_FL_GRAPH;
 }
 #endif /* CONFIG_TRACING */
 #ifdef CONFIG_HW_BRANCH_TRACER
 void trace_hw_branch(u64 from, u64 to);
 void trace_hw_branch_oops(void);
 #else /* CONFIG_HW_BRANCH_TRACER */
 static inline void trace_hw_branch(u64 from, u64 to) {}
 static inline void trace_hw_branch_oops(void) {}
 #endif /* CONFIG_HW_BRANCH_TRACER */
 #endif /* _LINUX_FTRACE_H */

kernel/trace/trace_functions_graph.c

Diff comments View file @ 4cd0332

 /*
  *
  * 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/fs.h>
 #include "trace.h"
 #include "trace_output.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
 #define TRACE_GRAPH_PRINT_DURATION	0x10
 #define TRACE_GRAPH_PRINT_ABS_TIME	0X20
 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) },
 	{ } /* 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,
 	.opts = trace_opts
 };
 /* pid on the last trace processed */
+/* Add a function return address to the trace stack on thread info.*/
+int
+ftrace_push_return_trace(unsigned long ret, unsigned long long time,
+			 unsigned long func, int *depth)
+{
+	int index;
+	if (!current->ret_stack)
+		return -EBUSY;
+	/* The return trace stack is full */
+	if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {
+		atomic_inc(&current->trace_overrun);
+		return -EBUSY;
+	}
+	index = ++current->curr_ret_stack;
+	barrier();
+	current->ret_stack[index].ret = ret;
+	current->ret_stack[index].func = func;
+	current->ret_stack[index].calltime = time;
+	*depth = index;
+	return 0;
+}
+/* Retrieve a function return address to the trace stack on thread info.*/
+void
+ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret)
+{
+	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;
+	}
+	*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;
+	barrier();
+	current->curr_ret_stack--;
+}
+/*
+ * Send the trace to the ring-buffer.
+ * @return the original return address.
+ */
+unsigned long ftrace_return_to_handler(void)
+{
+	struct ftrace_graph_ret trace;
+	unsigned long ret;
+	ftrace_pop_return_trace(&trace, &ret);
+	trace.rettime = cpu_clock(raw_smp_processor_id());
+	ftrace_graph_return(&trace);
+	if (unlikely(!ret)) {
+		ftrace_graph_stop();
+		WARN_ON(1);
+		/* Might as well panic. What else to do? */
+		ret = (unsigned long)panic;
+	}
+	return ret;
+}
 static int graph_trace_init(struct trace_array *tr)
 {
 	int 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(cpumask_weight(cpu_online_mask));
 	/*
 	 * 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 *last_pids_cpu)
 {
 	pid_t prev_pid;
 	pid_t *last_pid;
 	int ret;
 	if (!last_pids_cpu)
 		return TRACE_TYPE_HANDLED;
 	last_pid = per_cpu_ptr(last_pids_cpu, cpu);
 	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;
 	ret = print_graph_cpu(s, cpu);
 	if (ret == TRACE_TYPE_PARTIAL_LINE)
 		return TRACE_TYPE_PARTIAL_LINE;
 	ret = print_graph_proc(s, prev_pid);
 	if (ret == TRACE_TYPE_PARTIAL_LINE)
 		return TRACE_TYPE_PARTIAL_LINE;
 	ret = trace_seq_printf(s, " => ");
 	if (!ret)
 		return TRACE_TYPE_PARTIAL_LINE;
 	ret = print_graph_proc(s, pid);
 	if (ret == TRACE_TYPE_PARTIAL_LINE)
 		return TRACE_TYPE_PARTIAL_LINE;
 	ret = trace_seq_printf(s,
 		"\n ------------------------------------------\n\n");
 	if (!ret)
 		return TRACE_TYPE_PARTIAL_LINE;
 	return TRACE_TYPE_HANDLED;
 }
 static struct ftrace_graph_ret_entry *
 get_return_for_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];
 	/* First peek to compare current entry and the next one */
 	if (ring_iter)
 		event = ring_buffer_iter_peek(ring_iter, NULL);
 	else {
 	/* We need to consume the current entry to see the next one */
 		ring_buffer_consume(iter->tr->buffer, iter->cpu, NULL);
 		event = ring_buffer_peek(iter->tr->buffer, iter->cpu,
 					NULL);
 	}
 	if (!event)
 		return NULL;
 	next = ring_buffer_event_data(event);
 	if (next->ent.type != TRACE_GRAPH_RET)
 		return NULL;
 	if (curr->ent.pid != next->ent.pid ||
 			curr->graph_ent.func != next->ret.func)
 		return NULL;
 	/* this is a leaf, now advance the iterator */
 	if (ring_iter)
 		ring_buffer_read(ring_iter, NULL);
 	return next;
 }
 /* Signal a overhead of time execution to the output */
 static int
 print_graph_overhead(unsigned long long duration, struct trace_seq *s)
 {
 	/* If duration disappear, we don't need anything */
 	if (!(tracer_flags.val & TRACE_GRAPH_PRINT_DURATION))
 		return 1;
 	/* Non nested entry or return */
 	if (duration == -1)
 		return trace_seq_printf(s, "  ");
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
 		/* 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, "  ");
 }
 static enum print_line_t
 print_graph_irq(struct trace_seq *s, unsigned long addr,
 		enum trace_type type, int cpu, pid_t pid)
 {
 	int ret;
 	if (addr < (unsigned long)__irqentry_text_start ||
 		addr >= (unsigned long)__irqentry_text_end)
 		return TRACE_TYPE_UNHANDLED;
 	/* 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, 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 */
 	ret = print_graph_overhead(-1, s);
 	if (!ret)
 		return TRACE_TYPE_PARTIAL_LINE;
 	if (type == TRACE_GRAPH_ENT)
 		ret = trace_seq_printf(s, "==========>");
 	else
 		ret = trace_seq_printf(s, "<==========");
 	if (!ret)
 		return TRACE_TYPE_PARTIAL_LINE;
 	/* Don't close the duration column if haven't one */
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
 		trace_seq_printf(s, " |");
 	ret = trace_seq_printf(s, "\n");
 	if (!ret)
 		return TRACE_TYPE_PARTIAL_LINE;
 	return TRACE_TYPE_HANDLED;
 }
 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, "%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;
 }
 static int print_graph_abs_time(u64 t, struct trace_seq *s)
 {
 	unsigned long usecs_rem;
 	usecs_rem = do_div(t, 1000000000);
 	usecs_rem /= 1000;
 	return trace_seq_printf(s, "%5lu.%06lu |  ",
 			(unsigned long)t, usecs_rem);
 }
 /* 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 ftrace_graph_ret_entry *ret_entry, struct trace_seq *s)
 {
 	struct ftrace_graph_ret *graph_ret;
 	struct ftrace_graph_ent *call;
 	unsigned long long duration;
 	int ret;
 	int i;
 	graph_ret = &ret_entry->ret;
 	call = &entry->graph_ent;
 	duration = graph_ret->rettime - graph_ret->calltime;
 	/* Overhead */
 	ret = print_graph_overhead(duration, s);
 	if (!ret)
 		return TRACE_TYPE_PARTIAL_LINE;
 	/* Duration */
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_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, pid_t pid, int cpu)
 {
 	int i;
 	int ret;
 	struct ftrace_graph_ent *call = &entry->graph_ent;
 	/* No overhead */
 	ret = print_graph_overhead(-1, s);
 	if (!ret)
 		return TRACE_TYPE_PARTIAL_LINE;
 	/* No time */
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
 		ret = trace_seq_printf(s, "            |  ");
 		if (!ret)
 			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;
 	/*
 	 * we already consumed the current entry to check the next one
 	 * and see if this is a leaf.
 	 */
 	return TRACE_TYPE_NO_CONSUME;
 }
 static enum print_line_t
 print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
 			struct trace_iterator *iter)
 {
 	int ret;
 	int cpu = iter->cpu;
 	pid_t *last_entry = iter->private;
 	struct trace_entry *ent = iter->ent;
 	struct ftrace_graph_ent *call = &field->graph_ent;
 	struct ftrace_graph_ret_entry *leaf_ret;
 	/* Pid */
 	if (verif_pid(s, ent->pid, cpu, last_entry) == TRACE_TYPE_PARTIAL_LINE)
 		return TRACE_TYPE_PARTIAL_LINE;
 	/* Interrupt */
 	ret = print_graph_irq(s, call->func, TRACE_GRAPH_ENT, cpu, ent->pid);
 	if (ret == TRACE_TYPE_PARTIAL_LINE)
 		return TRACE_TYPE_PARTIAL_LINE;
 	/* Absolute time */
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
 		ret = print_graph_abs_time(iter->ts, s);
 		if (!ret)
 			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;
 	}
 	leaf_ret = get_return_for_leaf(iter, field);
 	if (leaf_ret)
 		return print_graph_entry_leaf(iter, field, leaf_ret, s);
 	else
 		return print_graph_entry_nested(field, s, iter->ent->pid, cpu);
 }
 static enum print_line_t
 print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
 		   struct trace_entry *ent, struct trace_iterator *iter)
 {
 	int i;
 	int ret;
 	int cpu = iter->cpu;
 	pid_t *last_pid = iter->private;
 	unsigned long long duration = trace->rettime - trace->calltime;
 	/* Pid */
 	if (verif_pid(s, ent->pid, cpu, last_pid) == TRACE_TYPE_PARTIAL_LINE)
 		return TRACE_TYPE_PARTIAL_LINE;
 	/* Absolute time */
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
 		ret = print_graph_abs_time(iter->ts, s);
 		if (!ret)
 			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 */
 	ret = print_graph_overhead(duration, s);
 	if (!ret)
 		return TRACE_TYPE_PARTIAL_LINE;
 	/* Duration */
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_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;
 	}
 	ret = print_graph_irq(s, trace->func, TRACE_GRAPH_RET, cpu, ent->pid);
 	if (ret == TRACE_TYPE_PARTIAL_LINE)
 		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;
 	int cpu = iter->cpu;
 	pid_t *last_pid = iter->private;
 	/* Absolute time */
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
 		ret = print_graph_abs_time(iter->ts, s);
 		if (!ret)
 			return TRACE_TYPE_PARTIAL_LINE;
 	}
 	/* Pid */
 	if (verif_pid(s, ent->pid, cpu, last_pid) == 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;
 	}
 	/* No overhead */
 	ret = print_graph_overhead(-1, s);
 	if (!ret)
 		return TRACE_TYPE_PARTIAL_LINE;
 	/* No time */
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
 		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;
 	/* Strip ending newline */
 	if (s->buffer[s->len - 1] == '\n') {
 		s->buffer[s->len - 1] = '\0';
 		s->len--;
 	}
 	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);
 	}
 	case TRACE_GRAPH_RET: {
 		struct ftrace_graph_ret_entry *field;
 		trace_assign_type(field, entry);
 		return print_graph_return(&field->ret, s, entry, iter);
 	}
 	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_ABS_TIME)
 		seq_printf(s, "     TIME       ");
 	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_DURATION)
 		seq_printf(s, "  DURATION   ");
 	seq_printf(s, "               FUNCTION CALLS\n");
 	/* 2nd line */
 	seq_printf(s, "# ");
 	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
 		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_DURATION)
 		seq_printf(s, "   |   |      ");
 	seq_printf(s, "               |   |   |   |\n");
 }
 static void graph_trace_open(struct trace_iterator *iter)
 {
 	/* pid on the last trace processed */
 	pid_t *last_pid = alloc_percpu(pid_t);
 	int cpu;
 	if (!last_pid)
 		pr_warning("function graph tracer: not enough memory\n");
 	else
 		for_each_possible_cpu(cpu) {
 			pid_t *pid = per_cpu_ptr(last_pid, cpu);
 			*pid = -1;
 		}
 	iter->private = last_pid;
 }
 static void graph_trace_close(struct trace_iterator *iter)
 {
 	percpu_free(iter->private);
 }
 static struct tracer graph_trace __read_mostly = {
 	.name	     	= "function_graph",
 	.open		= graph_trace_open,
 	.close		= graph_trace_close,
 	.wait_pipe	= poll_wait_pipe,
 	.init	     	= graph_trace_init,
 	.reset	     	= graph_trace_reset,
 	.print_line	= print_graph_function,
 	.print_header	= print_graph_headers,
 	.flags		= &tracer_flags,
 #ifdef CONFIG_FTRACE_SELFTEST
 	.selftest	= trace_selftest_startup_function_graph,
 #endif
 };
 static __init int init_graph_trace(void)
 {
 	return register_tracer(&graph_trace);
 }
 device_initcall(init_graph_trace);