2 * Kernel and userspace stack tracing.
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
8 * Copyright (C) 2001 - 2013 Tensilica Inc.
9 * Copyright (C) 2015 Cadence Design Systems Inc.
11 #include <linux/export.h>
12 #include <linux/sched.h>
13 #include <linux/stacktrace.h>
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>
21 #if IS_ENABLED(CONFIG_PERF_EVENTS)
23 /* Address of common_exception_return, used to check the
24 * transition from kernel to user space.
26 extern int common_exception_return;
28 void xtensa_backtrace_user(struct pt_regs *regs, unsigned int depth,
29 int (*ufn)(struct stackframe *frame, void *data),
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;
46 if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
49 if (IS_ENABLED(CONFIG_USER_ABI_CALL0_ONLY) ||
50 (IS_ENABLED(CONFIG_USER_ABI_CALL0_PROBE) &&
51 !(regs->ps & PS_WOE_MASK)))
56 * 1. Look through the register window for the
57 * previous PCs in the call trace.
59 * 2. Look on the stack.
63 /* Rotate WINDOWSTART to move the bit corresponding to
64 * the current window to the bit #0.
66 windowstart = (windowstart << WSBITS | windowstart) >> windowbase;
68 /* Look for bits that are set, they correspond to
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.
78 a0 = regs->areg[index * 4];
79 a1 = regs->areg[index * 4 + 1];
84 if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
89 /* We are done with the register window, we need to
90 * look through the stack.
95 /* Start from the a1 register. */
96 /* a1 = regs->areg[1]; */
97 while (a0 != 0 && depth--) {
98 pc = MAKE_PC_FROM_RA(a0, pc);
100 /* Check if the region is OK to access. */
101 if (!access_ok(&SPILL_SLOT(a1, 0), 8))
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)))
111 if (pc == 0 || pc >= TASK_SIZE || ufn(&frame, data))
115 EXPORT_SYMBOL(xtensa_backtrace_user);
117 void 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),
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];
128 sp_start = a1 & ~(THREAD_SIZE - 1);
129 sp_end = sp_start + THREAD_SIZE;
131 /* Spill the register window to the stack first. */
134 /* Read the stack frames one by one and create the PC
135 * from the a0 and a1 registers saved there.
137 while (a1 > sp_start && a1 < sp_end && depth--) {
138 struct stackframe frame;
143 if (kernel_text_address(pc) && kfn(&frame, data))
146 if (pc == (unsigned long)&common_exception_return) {
147 regs = (struct pt_regs *)a1;
148 if (user_mode(regs)) {
151 xtensa_backtrace_user(regs, depth, ufn, data);
161 pc = MAKE_PC_FROM_RA(a0, pc);
162 a0 = SPILL_SLOT(a1, 0);
163 a1 = SPILL_SLOT(a1, 1);
166 EXPORT_SYMBOL(xtensa_backtrace_kernel);
170 void walk_stackframe(unsigned long *sp,
171 int (*fn)(struct stackframe *frame, void *data),
174 unsigned long a0, a1;
175 unsigned long sp_end;
177 a1 = (unsigned long)sp;
178 sp_end = ALIGN(a1, THREAD_SIZE);
182 while (a1 < sp_end) {
183 struct stackframe frame;
185 sp = (unsigned long *)a1;
187 a0 = SPILL_SLOT(a1, 0);
188 a1 = SPILL_SLOT(a1, 1);
190 if (a1 <= (unsigned long)sp)
193 frame.pc = MAKE_PC_FROM_RA(a0, _text);
196 if (fn(&frame, data))
201 #ifdef CONFIG_STACKTRACE
203 struct stack_trace_data {
204 struct stack_trace *trace;
208 static int stack_trace_cb(struct stackframe *frame, void *data)
210 struct stack_trace_data *trace_data = data;
211 struct stack_trace *trace = trace_data->trace;
213 if (trace_data->skip) {
217 if (!kernel_text_address(frame->pc))
220 trace->entries[trace->nr_entries++] = frame->pc;
221 return trace->nr_entries >= trace->max_entries;
224 void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace)
226 struct stack_trace_data trace_data = {
230 walk_stackframe(stack_pointer(task), stack_trace_cb, &trace_data);
232 EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
234 void save_stack_trace(struct stack_trace *trace)
236 save_stack_trace_tsk(current, trace);
238 EXPORT_SYMBOL_GPL(save_stack_trace);
242 struct return_addr_data {
247 static int return_address_cb(struct stackframe *frame, void *data)
249 struct return_addr_data *r = data;
255 if (!kernel_text_address(frame->pc))
262 * level == 0 is for the return address from the caller of this function,
263 * not from this function itself.
265 unsigned long return_address(unsigned level)
267 struct return_addr_data r = {
270 walk_stackframe(stack_pointer(NULL), return_address_cb, &r);
273 EXPORT_SYMBOL(return_address);