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