1/*
2 * Kernel and userspace stack tracing.
3 *
4 * This file is subject to the terms and conditions of the GNU General Public
5 * License.  See the file "COPYING" in the main directory of this archive
6 * for more details.
7 *
8 * Copyright (C) 2001 - 2013 Tensilica Inc.
9 * Copyright (C) 2015 Cadence Design Systems Inc.
10 */
11#include <linux/export.h>
12#include <linux/sched.h>
13#include <linux/stacktrace.h>
14
15#include <asm/ftrace.h>
16#include <asm/sections.h>
17#include <asm/stacktrace.h>
18#include <asm/traps.h>
19#include <linux/uaccess.h>
20
21#if IS_ENABLED(CONFIG_PERF_EVENTS)
22
23/* Address of common_exception_return, used to check the
24 * transition from kernel to user space.
25 */
26extern int common_exception_return;
27
28void xtensa_backtrace_user(struct pt_regs *regs, unsigned int depth,
29			   int (*ufn)(struct stackframe *frame, void *data),
30			   void *data)
31{
32	unsigned long windowstart = regs->windowstart;
33	unsigned long windowbase = regs->windowbase;
34	unsigned long a0 = regs->areg[0];
35	unsigned long a1 = regs->areg[1];
36	unsigned long pc = regs->pc;
37	struct stackframe frame;
38	int index;
39
40	if (!depth--)
41		return;
42
43	frame.pc = pc;
44	frame.sp = a1;
45
46	if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
47		return;
48
49	if (IS_ENABLED(CONFIG_USER_ABI_CALL0_ONLY) ||
50	    (IS_ENABLED(CONFIG_USER_ABI_CALL0_PROBE) &&
51	     !(regs->ps & PS_WOE_MASK)))
52		return;
53
54	/* Two steps:
55	 *
56	 * 1. Look through the register window for the
57	 * previous PCs in the call trace.
58	 *
59	 * 2. Look on the stack.
60	 */
61
62	/* Step 1.  */
63	/* Rotate WINDOWSTART to move the bit corresponding to
64	 * the current window to the bit #0.
65	 */
66	windowstart = (windowstart << WSBITS | windowstart) >> windowbase;
67
68	/* Look for bits that are set, they correspond to
69	 * valid windows.
70	 */
71	for (index = WSBITS - 1; (index > 0) && depth; depth--, index--)
72		if (windowstart & (1 << index)) {
73			/* Get the PC from a0 and a1. */
74			pc = MAKE_PC_FROM_RA(a0, pc);
75			/* Read a0 and a1 from the
76			 * corresponding position in AREGs.
77			 */
78			a0 = regs->areg[index * 4];
79			a1 = regs->areg[index * 4 + 1];
80
81			frame.pc = pc;
82			frame.sp = a1;
83
84			if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
85				return;
86		}
87
88	/* Step 2. */
89	/* We are done with the register window, we need to
90	 * look through the stack.
91	 */
92	if (!depth)
93		return;
94
95	/* Start from the a1 register. */
96	/* a1 = regs->areg[1]; */
97	while (a0 != 0 && depth--) {
98		pc = MAKE_PC_FROM_RA(a0, pc);
99
100		/* Check if the region is OK to access. */
101		if (!access_ok(&SPILL_SLOT(a1, 0), 8))
102			return;
103		/* Copy a1, a0 from user space stack frame. */
104		if (__get_user(a0, &SPILL_SLOT(a1, 0)) ||
105		    __get_user(a1, &SPILL_SLOT(a1, 1)))
106			return;
107
108		frame.pc = pc;
109		frame.sp = a1;
110
111		if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
112			return;
113	}
114}
115EXPORT_SYMBOL(xtensa_backtrace_user);
116
117void xtensa_backtrace_kernel(struct pt_regs *regs, unsigned int depth,
118			     int (*kfn)(struct stackframe *frame, void *data),
119			     int (*ufn)(struct stackframe *frame, void *data),
120			     void *data)
121{
122	unsigned long pc = regs->depc > VALID_DOUBLE_EXCEPTION_ADDRESS ?
123		regs->depc : regs->pc;
124	unsigned long sp_start, sp_end;
125	unsigned long a0 = regs->areg[0];
126	unsigned long a1 = regs->areg[1];
127
128	sp_start = a1 & ~(THREAD_SIZE - 1);
129	sp_end = sp_start + THREAD_SIZE;
130
131	/* Spill the register window to the stack first. */
132	spill_registers();
133
134	/* Read the stack frames one by one and create the PC
135	 * from the a0 and a1 registers saved there.
136	 */
137	while (a1 > sp_start && a1 < sp_end && depth--) {
138		struct stackframe frame;
139
140		frame.pc = pc;
141		frame.sp = a1;
142
143		if (kernel_text_address(pc) && kfn(&frame, data))
144			return;
145
146		if (pc == (unsigned long)&common_exception_return) {
147			regs = (struct pt_regs *)a1;
148			if (user_mode(regs)) {
149				if (ufn == NULL)
150					return;
151				xtensa_backtrace_user(regs, depth, ufn, data);
152				return;
153			}
154			a0 = regs->areg[0];
155			a1 = regs->areg[1];
156			continue;
157		}
158
159		sp_start = a1;
160
161		pc = MAKE_PC_FROM_RA(a0, pc);
162		a0 = SPILL_SLOT(a1, 0);
163		a1 = SPILL_SLOT(a1, 1);
164	}
165}
166EXPORT_SYMBOL(xtensa_backtrace_kernel);
167
168#endif
169
170void walk_stackframe(unsigned long *sp,
171		int (*fn)(struct stackframe *frame, void *data),
172		void *data)
173{
174	unsigned long a0, a1;
175	unsigned long sp_end;
176
177	a1 = (unsigned long)sp;
178	sp_end = ALIGN(a1, THREAD_SIZE);
179
180	spill_registers();
181
182	while (a1 < sp_end) {
183		struct stackframe frame;
184
185		sp = (unsigned long *)a1;
186
187		a0 = SPILL_SLOT(a1, 0);
188		a1 = SPILL_SLOT(a1, 1);
189
190		if (a1 <= (unsigned long)sp)
191			break;
192
193		frame.pc = MAKE_PC_FROM_RA(a0, _text);
194		frame.sp = a1;
195
196		if (fn(&frame, data))
197			return;
198	}
199}
200
201#ifdef CONFIG_STACKTRACE
202
203struct stack_trace_data {
204	struct stack_trace *trace;
205	unsigned skip;
206};
207
208static int stack_trace_cb(struct stackframe *frame, void *data)
209{
210	struct stack_trace_data *trace_data = data;
211	struct stack_trace *trace = trace_data->trace;
212
213	if (trace_data->skip) {
214		--trace_data->skip;
215		return 0;
216	}
217	if (!kernel_text_address(frame->pc))
218		return 0;
219
220	trace->entries[trace->nr_entries++] = frame->pc;
221	return trace->nr_entries >= trace->max_entries;
222}
223
224void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
225{
226	struct stack_trace_data trace_data = {
227		.trace = trace,
228		.skip = trace->skip,
229	};
230	walk_stackframe(stack_pointer(task), stack_trace_cb, &trace_data);
231}
232EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
233
234void save_stack_trace(struct stack_trace *trace)
235{
236	save_stack_trace_tsk(current, trace);
237}
238EXPORT_SYMBOL_GPL(save_stack_trace);
239
240#endif
241
242struct return_addr_data {
243	unsigned long addr;
244	unsigned skip;
245};
246
247static int return_address_cb(struct stackframe *frame, void *data)
248{
249	struct return_addr_data *r = data;
250
251	if (r->skip) {
252		--r->skip;
253		return 0;
254	}
255	if (!kernel_text_address(frame->pc))
256		return 0;
257	r->addr = frame->pc;
258	return 1;
259}
260
261/*
262 * level == 0 is for the return address from the caller of this function,
263 * not from this function itself.
264 */
265unsigned long return_address(unsigned level)
266{
267	struct return_addr_data r = {
268		.skip = level,
269	};
270	walk_stackframe(stack_pointer(NULL), return_address_cb, &r);
271	return r.addr;
272}
273EXPORT_SYMBOL(return_address);
274