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 const char *loglvl); 159 160 /** 161 * unwind_trap - Unwind through a system trap, that stored previous state 162 * on the stack. 163 */ 164 static inline void unwind_trap(struct task_struct *task, unsigned long pc, 165 unsigned long fp, struct stack_trace *trace, 166 const char *loglvl) 167 { 168 /* To be implemented */ 169 } 170 171 /** 172 * microblaze_unwind_inner - Unwind the stack from the specified point 173 * @task : Task whose stack we are to unwind (may be NULL) 174 * @pc : Program counter from which we start unwinding 175 * @fp : Frame (stack) pointer from which we start unwinding 176 * @leaf_return : Value of r15 at pc. If the function is a leaf, this is 177 * the caller's return address. 178 * @trace : Where to store stack backtrace (PC values). 179 * NULL == print backtrace to kernel log 180 * @loglvl : Used for printk log level if (trace == NULL). 181 */ 182 static void microblaze_unwind_inner(struct task_struct *task, 183 unsigned long pc, unsigned long fp, 184 unsigned long leaf_return, 185 struct stack_trace *trace, 186 const char *loglvl) 187 { 188 int ofs = 0; 189 190 pr_debug(" Unwinding with PC=%p, FP=%p\n", (void *)pc, (void *)fp); 191 if (!pc || !fp || (pc & 3) || (fp & 3)) { 192 pr_debug(" Invalid state for unwind, aborting\n"); 193 return; 194 } 195 for (; pc != 0;) { 196 unsigned long next_fp, next_pc = 0; 197 unsigned long return_to = pc + 2 * sizeof(unsigned long); 198 const struct trap_handler_info *handler = 199 µblaze_trap_handlers; 200 201 /* Is previous function the HW exception handler? */ 202 if ((return_to >= (unsigned long)&_hw_exception_handler) 203 &&(return_to < (unsigned long)&ex_handler_unhandled)) { 204 /* 205 * HW exception handler doesn't save all registers, 206 * so we open-code a special case of unwind_trap() 207 */ 208 printk("%sHW EXCEPTION\n", loglvl); 209 return; 210 } 211 212 /* Is previous function a trap handler? */ 213 for (; handler->start_addr; ++handler) { 214 if ((return_to >= handler->start_addr) 215 && (return_to <= handler->end_addr)) { 216 if (!trace) 217 printk("%s%s\n", loglvl, handler->trap_name); 218 unwind_trap(task, pc, fp, trace, loglvl); 219 return; 220 } 221 } 222 pc -= ofs; 223 224 if (trace) { 225 #ifdef CONFIG_STACKTRACE 226 if (trace->skip > 0) 227 trace->skip--; 228 else 229 trace->entries[trace->nr_entries++] = pc; 230 231 if (trace->nr_entries >= trace->max_entries) 232 break; 233 #endif 234 } else { 235 /* Have we reached userland? */ 236 if (unlikely(pc == task_pt_regs(task)->pc)) { 237 printk("%s[<%p>] PID %lu [%s]\n", 238 loglvl, (void *) pc, 239 (unsigned long) task->pid, 240 task->comm); 241 break; 242 } else 243 print_ip_sym(loglvl, pc); 244 } 245 246 /* Stop when we reach anything not part of the kernel */ 247 if (!kernel_text_address(pc)) 248 break; 249 250 if (lookup_prev_stack_frame(fp, pc, leaf_return, &next_fp, 251 &next_pc) == 0) { 252 ofs = sizeof(unsigned long); 253 pc = next_pc & ~3; 254 fp = next_fp; 255 leaf_return = 0; 256 } else { 257 pr_debug(" Failed to find previous stack frame\n"); 258 break; 259 } 260 261 pr_debug(" Next PC=%p, next FP=%p\n", 262 (void *)next_pc, (void *)next_fp); 263 } 264 } 265 266 /** 267 * microblaze_unwind - Stack unwinder for Microblaze (external entry point) 268 * @task : Task whose stack we are to unwind (NULL == current) 269 * @trace : Where to store stack backtrace (PC values). 270 * NULL == print backtrace to kernel log 271 * @loglvl : Used for printk log level if (trace == NULL). 272 */ 273 void microblaze_unwind(struct task_struct *task, struct stack_trace *trace, 274 const char *loglvl) 275 { 276 if (task) { 277 if (task == current) { 278 const struct pt_regs *regs = task_pt_regs(task); 279 microblaze_unwind_inner(task, regs->pc, regs->r1, 280 regs->r15, trace, loglvl); 281 } else { 282 struct thread_info *thread_info = 283 (struct thread_info *)(task->stack); 284 const struct cpu_context *cpu_context = 285 &thread_info->cpu_context; 286 287 microblaze_unwind_inner(task, 288 (unsigned long) &_switch_to, 289 cpu_context->r1, 290 cpu_context->r15, 291 trace, loglvl); 292 } 293 } else { 294 unsigned long pc, fp; 295 296 __asm__ __volatile__ ("or %0, r1, r0" : "=r" (fp)); 297 298 __asm__ __volatile__ ( 299 "brlid %0, 0f;" 300 "nop;" 301 "0:" 302 : "=r" (pc) 303 ); 304 305 /* Since we are not a leaf function, use leaf_return = 0 */ 306 microblaze_unwind_inner(current, pc, fp, 0, trace, loglvl); 307 } 308 } 309 310