PageRenderTime 29ms CodeModel.GetById 14ms app.highlight 11ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/parisc/kernel/ftrace.c

https://github.com/aicjofs/android_kernel_lge_v500_20d
C | 185 lines | 115 code | 37 blank | 33 comment | 18 complexity | 7eaba66a58869cdf157b25b7e5099a6c MD5 | raw file
  1/*
  2 * Code for tracing calls in Linux kernel.
  3 * Copyright (C) 2009 Helge Deller <deller@gmx.de>
  4 *
  5 * based on code for x86 which is:
  6 * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
  7 *
  8 * future possible enhancements:
  9 * 	- add CONFIG_DYNAMIC_FTRACE
 10 *	- add CONFIG_STACK_TRACER
 11 */
 12
 13#include <linux/init.h>
 14#include <linux/ftrace.h>
 15
 16#include <asm/sections.h>
 17#include <asm/ftrace.h>
 18
 19
 20
 21#ifdef CONFIG_FUNCTION_GRAPH_TRACER
 22
 23/* Add a function return address to the trace stack on thread info.*/
 24static int push_return_trace(unsigned long ret, unsigned long long time,
 25				unsigned long func, int *depth)
 26{
 27	int index;
 28
 29	if (!current->ret_stack)
 30		return -EBUSY;
 31
 32	/* The return trace stack is full */
 33	if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {
 34		atomic_inc(&current->trace_overrun);
 35		return -EBUSY;
 36	}
 37
 38	index = ++current->curr_ret_stack;
 39	barrier();
 40	current->ret_stack[index].ret = ret;
 41	current->ret_stack[index].func = func;
 42	current->ret_stack[index].calltime = time;
 43	*depth = index;
 44
 45	return 0;
 46}
 47
 48/* Retrieve a function return address to the trace stack on thread info.*/
 49static void pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret)
 50{
 51	int index;
 52
 53	index = current->curr_ret_stack;
 54
 55	if (unlikely(index < 0)) {
 56		ftrace_graph_stop();
 57		WARN_ON(1);
 58		/* Might as well panic, otherwise we have no where to go */
 59		*ret = (unsigned long)
 60			dereference_function_descriptor(&panic);
 61		return;
 62	}
 63
 64	*ret = current->ret_stack[index].ret;
 65	trace->func = current->ret_stack[index].func;
 66	trace->calltime = current->ret_stack[index].calltime;
 67	trace->overrun = atomic_read(&current->trace_overrun);
 68	trace->depth = index;
 69	barrier();
 70	current->curr_ret_stack--;
 71
 72}
 73
 74/*
 75 * Send the trace to the ring-buffer.
 76 * @return the original return address.
 77 */
 78unsigned long ftrace_return_to_handler(unsigned long retval0,
 79				       unsigned long retval1)
 80{
 81	struct ftrace_graph_ret trace;
 82	unsigned long ret;
 83
 84	pop_return_trace(&trace, &ret);
 85	trace.rettime = local_clock();
 86	ftrace_graph_return(&trace);
 87
 88	if (unlikely(!ret)) {
 89		ftrace_graph_stop();
 90		WARN_ON(1);
 91		/* Might as well panic. What else to do? */
 92		ret = (unsigned long)
 93			dereference_function_descriptor(&panic);
 94	}
 95
 96	/* HACK: we hand over the old functions' return values
 97	   in %r23 and %r24. Assembly in entry.S will take care
 98	   and move those to their final registers %ret0 and %ret1 */
 99	asm( "copy %0, %%r23 \n\t"
100	     "copy %1, %%r24 \n" : : "r" (retval0), "r" (retval1) );
101
102	return ret;
103}
104
105/*
106 * Hook the return address and push it in the stack of return addrs
107 * in current thread info.
108 */
109void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr)
110{
111	unsigned long old;
112	unsigned long long calltime;
113	struct ftrace_graph_ent trace;
114
115	if (unlikely(atomic_read(&current->tracing_graph_pause)))
116		return;
117
118	old = *parent;
119	*parent = (unsigned long)
120		  dereference_function_descriptor(&return_to_handler);
121
122	if (unlikely(!__kernel_text_address(old))) {
123		ftrace_graph_stop();
124		*parent = old;
125		WARN_ON(1);
126		return;
127	}
128
129	calltime = local_clock();
130
131	if (push_return_trace(old, calltime,
132				self_addr, &trace.depth) == -EBUSY) {
133		*parent = old;
134		return;
135	}
136
137	trace.func = self_addr;
138
139	/* Only trace if the calling function expects to */
140	if (!ftrace_graph_entry(&trace)) {
141		current->curr_ret_stack--;
142		*parent = old;
143	}
144}
145
146#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
147
148
149void ftrace_function_trampoline(unsigned long parent,
150				unsigned long self_addr,
151				unsigned long org_sp_gr3)
152{
153	extern ftrace_func_t ftrace_trace_function;
154
155	if (function_trace_stop)
156		return;
157
158	if (ftrace_trace_function != ftrace_stub) {
159		ftrace_trace_function(parent, self_addr);
160		return;
161	}
162#ifdef CONFIG_FUNCTION_GRAPH_TRACER
163	if (ftrace_graph_entry && ftrace_graph_return) {
164		unsigned long sp;
165		unsigned long *parent_rp;
166
167                asm volatile ("copy %%r30, %0" : "=r"(sp));
168		/* sanity check: is stack pointer which we got from
169		   assembler function in entry.S in a reasonable
170		   range compared to current stack pointer? */
171		if ((sp - org_sp_gr3) > 0x400)
172			return;
173
174		/* calculate pointer to %rp in stack */
175		parent_rp = (unsigned long *) org_sp_gr3 - 0x10;
176		/* sanity check: parent_rp should hold parent */
177		if (*parent_rp != parent)
178			return;
179		
180		prepare_ftrace_return(parent_rp, self_addr);
181		return;
182	}
183#endif
184}
185