1 /* 2 * Backtrace support for Microblaze 3 * 4 * Copyright (C) 2010 Digital Design Corporation 5 * 6 * Based on arch/sh/kernel/cpu/sh5/unwind.c code which is: 7 * Copyright (C) 2004 Paul Mundt 8 * Copyright (C) 2004 Richard Curnow 9 * 10 * This file is subject to the terms and conditions of the GNU General Public 11 * License. See the file "COPYING" in the main directory of this archive 12 * for more details. 13 */ 14 15 /* #define DEBUG 1 */ 16 #include <linux/export.h> 17 #include <linux/kallsyms.h> 18 #include <linux/kernel.h> 19 #include <linux/sched.h> 20 #include <linux/sched/task_stack.h> 21 #include <linux/stacktrace.h> 22 #include <linux/types.h> 23 #include <linux/errno.h> 24 #include <linux/io.h> 25 #include <asm/sections.h> 26 #include <asm/exceptions.h> 27 #include <asm/unwind.h> 28 #include <asm/switch_to.h> 29 30 struct stack_trace; 31 32 /* 33 * On Microblaze, finding the previous stack frame is a little tricky. 34 * At this writing (3/2010), Microblaze does not support CONFIG_FRAME_POINTERS, 35 * and even if it did, gcc (4.1.2) does not store the frame pointer at 36 * a consistent offset within each frame. To determine frame size, it is 37 * necessary to search for the assembly instruction that creates or reclaims 38 * the frame and extract the size from it. 39 * 40 * Microblaze stores the stack pointer in r1, and creates a frame via 41 * 42 * addik r1, r1, -FRAME_SIZE 43 * 44 * The frame is reclaimed via 45 * 46 * addik r1, r1, FRAME_SIZE 47 * 48 * Frame creation occurs at or near the top of a function. 49 * Depending on the compiler, reclaim may occur at the end, or before 50 * a mid-function return. 51 * 52 * A stack frame is usually not created in a leaf function. 53 * 54 */ 55 56 /** 57 * get_frame_size - Extract the stack adjustment from an 58 * "addik r1, r1, adjust" instruction 59 * @instr : Microblaze instruction 60 * 61 * Return - Number of stack bytes the instruction reserves or reclaims 62 */ 63 static inline long get_frame_size(unsigned long instr) 64 { 65 return abs((s16)(instr & 0xFFFF)); 66 } 67 68 /** 69 * find_frame_creation - Search backward to find the instruction that creates 70 * the stack frame (hopefully, for the same function the 71 * initial PC is in). 72 * @pc : Program counter at which to begin the search 73 * 74 * Return - PC at which stack frame creation occurs 75 * NULL if this cannot be found, i.e. a leaf function 76 */ 77 static unsigned long *find_frame_creation(unsigned long *pc) 78 { 79 int i; 80 81 /* NOTE: Distance to search is arbitrary 82 * 250 works well for most things, 83 * 750 picks up things like tcp_recvmsg(), 84 * 1000 needed for fat_fill_super() 85 */ 86 for (i = 0; i < 1000; i++, pc--) { 87 unsigned long instr; 88 s16 frame_size; 89 90 if (!kernel_text_address((unsigned long) pc)) 91 return NULL; 92 93 instr = *pc; 94 95 /* addik r1, r1, foo ? */ 96 if ((instr & 0xFFFF0000) != 0x30210000) 97 continue; /* No */ 98 99 frame_size = get_frame_size(instr); 100 if ((frame_size < 8) || (frame_size & 3)) { 101 pr_debug(" Invalid frame size %d at 0x%p\n", 102 frame_size, pc); 103 return NULL; 104 } 105 106 pr_debug(" Found frame creation at 0x%p, size %d\n", pc, 107 frame_size); 108 return pc; 109 } 110 111 return NULL; 112 } 113 114 /** 115 * lookup_prev_stack_frame - Find the stack frame of the previous function. 116 * @fp : Frame (stack) pointer for current function 117 * @pc : Program counter within current function 118 * @leaf_return : r15 value within current function. If the current function 119 * is a leaf, this is the caller's return address. 120 * @pprev_fp : On exit, set to frame (stack) pointer for previous function 121 * @pprev_pc : On exit, set to current function caller's return address 122 * 123 * Return - 0 on success, -EINVAL if the previous frame cannot be found 124 */ 125 static int lookup_prev_stack_frame(unsigned long fp, unsigned long pc, 126 unsigned long leaf_return, 127 unsigned long *pprev_fp, 128 unsigned long *pprev_pc) 129 { 130 unsigned long *prologue = NULL; 131 132 /* _switch_to is a special leaf function */ 133 if (pc != (unsigned long) &_switch_to) 134 prologue = find_frame_creation((unsigned long *)pc); 135 136 if (prologue) { 137 long frame_size = get_frame_size(*prologue); 138 139 *pprev_fp = fp + frame_size; 140 *pprev_pc = *(unsigned long *)fp; 141 } else { 142 if (!leaf_return) 143 return -EINVAL; 144 *pprev_pc = leaf_return; 145 *pprev_fp = fp; 146 } 147 148 /* NOTE: don't check kernel_text_address here, to allow display 149 * of userland return address 150 */ 151 return (!*pprev_pc || (*pprev_pc & 3)) ? -EINVAL : 0; 152 } 153 154 static void microblaze_unwind_inner(struct task_struct *task, 155 unsigned long pc, unsigned long fp, 156 unsigned long leaf_return, 157 struct stack_trace *trace); 158 159 /** 160 * unwind_trap - Unwind through a system trap, that stored previous state 161 * on the stack. 162 */ 163 #ifdef CONFIG_MMU 164 static inline void unwind_trap(struct task_struct *task, unsigned long pc, 165 unsigned long fp, struct stack_trace *trace) 166 { 167 /* To be implemented */ 168 } 169 #else 170 static inline void unwind_trap(struct task_struct *task, unsigned long pc, 171 unsigned long fp, struct stack_trace *trace) 172 { 173 const struct pt_regs *regs = (const struct pt_regs *) fp; 174 microblaze_unwind_inner(task, regs->pc, regs->r1, regs->r15, trace); 175 } 176 #endif 177 178 /** 179 * microblaze_unwind_inner - Unwind the stack from the specified point 180 * @task : Task whose stack we are to unwind (may be NULL) 181 * @pc : Program counter from which we start unwinding 182 * @fp : Frame (stack) pointer from which we start unwinding 183 * @leaf_return : Value of r15 at pc. If the function is a leaf, this is 184 * the caller's return address. 185 * @trace : Where to store stack backtrace (PC values). 186 * NULL == print backtrace to kernel log 187 */ 188 static void microblaze_unwind_inner(struct task_struct *task, 189 unsigned long pc, unsigned long fp, 190 unsigned long leaf_return, 191 struct stack_trace *trace) 192 { 193 int ofs = 0; 194 195 pr_debug(" Unwinding with PC=%p, FP=%p\n", (void *)pc, (void *)fp); 196 if (!pc || !fp || (pc & 3) || (fp & 3)) { 197 pr_debug(" Invalid state for unwind, aborting\n"); 198 return; 199 } 200 for (; pc != 0;) { 201 unsigned long next_fp, next_pc = 0; 202 unsigned long return_to = pc + 2 * sizeof(unsigned long); 203 const struct trap_handler_info *handler = 204 µblaze_trap_handlers; 205 206 /* Is previous function the HW exception handler? */ 207 if ((return_to >= (unsigned long)&_hw_exception_handler) 208 &&(return_to < (unsigned long)&ex_handler_unhandled)) { 209 /* 210 * HW exception handler doesn't save all registers, 211 * so we open-code a special case of unwind_trap() 212 */ 213 #ifndef CONFIG_MMU 214 const struct pt_regs *regs = 215 (const struct pt_regs *) fp; 216 #endif 217 pr_info("HW EXCEPTION\n"); 218 #ifndef CONFIG_MMU 219 microblaze_unwind_inner(task, regs->r17 - 4, 220 fp + EX_HANDLER_STACK_SIZ, 221 regs->r15, trace); 222 #endif 223 return; 224 } 225 226 /* Is previous function a trap handler? */ 227 for (; handler->start_addr; ++handler) { 228 if ((return_to >= handler->start_addr) 229 && (return_to <= handler->end_addr)) { 230 if (!trace) 231 pr_info("%s\n", handler->trap_name); 232 unwind_trap(task, pc, fp, trace); 233 return; 234 } 235 } 236 pc -= ofs; 237 238 if (trace) { 239 #ifdef CONFIG_STACKTRACE 240 if (trace->skip > 0) 241 trace->skip--; 242 else 243 trace->entries[trace->nr_entries++] = pc; 244 245 if (trace->nr_entries >= trace->max_entries) 246 break; 247 #endif 248 } else { 249 /* Have we reached userland? */ 250 if (unlikely(pc == task_pt_regs(task)->pc)) { 251 pr_info("[<%p>] PID %lu [%s]\n", 252 (void *) pc, 253 (unsigned long) task->pid, 254 task->comm); 255 break; 256 } else 257 print_ip_sym(pc); 258 } 259 260 /* Stop when we reach anything not part of the kernel */ 261 if (!kernel_text_address(pc)) 262 break; 263 264 if (lookup_prev_stack_frame(fp, pc, leaf_return, &next_fp, 265 &next_pc) == 0) { 266 ofs = sizeof(unsigned long); 267 pc = next_pc & ~3; 268 fp = next_fp; 269 leaf_return = 0; 270 } else { 271 pr_debug(" Failed to find previous stack frame\n"); 272 break; 273 } 274 275 pr_debug(" Next PC=%p, next FP=%p\n", 276 (void *)next_pc, (void *)next_fp); 277 } 278 } 279 280 /** 281 * microblaze_unwind - Stack unwinder for Microblaze (external entry point) 282 * @task : Task whose stack we are to unwind (NULL == current) 283 * @trace : Where to store stack backtrace (PC values). 284 * NULL == print backtrace to kernel log 285 */ 286 void microblaze_unwind(struct task_struct *task, struct stack_trace *trace) 287 { 288 if (task) { 289 if (task == current) { 290 const struct pt_regs *regs = task_pt_regs(task); 291 microblaze_unwind_inner(task, regs->pc, regs->r1, 292 regs->r15, trace); 293 } else { 294 struct thread_info *thread_info = 295 (struct thread_info *)(task->stack); 296 const struct cpu_context *cpu_context = 297 &thread_info->cpu_context; 298 299 microblaze_unwind_inner(task, 300 (unsigned long) &_switch_to, 301 cpu_context->r1, 302 cpu_context->r15, trace); 303 } 304 } else { 305 unsigned long pc, fp; 306 307 __asm__ __volatile__ ("or %0, r1, r0" : "=r" (fp)); 308 309 __asm__ __volatile__ ( 310 "brlid %0, 0f;" 311 "nop;" 312 "0:" 313 : "=r" (pc) 314 ); 315 316 /* Since we are not a leaf function, use leaf_return = 0 */ 317 microblaze_unwind_inner(current, pc, fp, 0, trace); 318 } 319 } 320 321