Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Paul Mundt | 1319 | 99.25% | 2 | 33.33% |
Martin Kepplinger | 5 | 0.38% | 1 | 16.67% |
Alexey Dobriyan | 2 | 0.15% | 1 | 16.67% |
Kuninori Morimoto | 2 | 0.15% | 1 | 16.67% |
Harvey Harrison | 1 | 0.08% | 1 | 16.67% |
Total | 1329 | 6 |
// SPDX-License-Identifier: GPL-2.0 /* * arch/sh/kernel/cpu/sh5/unwind.c * * Copyright (C) 2004 Paul Mundt * Copyright (C) 2004 Richard Curnow */ #include <linux/kallsyms.h> #include <linux/kernel.h> #include <linux/types.h> #include <linux/errno.h> #include <asm/page.h> #include <asm/ptrace.h> #include <asm/processor.h> #include <asm/io.h> #include <asm/unwinder.h> #include <asm/stacktrace.h> static u8 regcache[63]; /* * Finding the previous stack frame isn't horribly straightforward as it is * on some other platforms. In the sh64 case, we don't have "linked" stack * frames, so we need to do a bit of work to determine the previous frame, * and in turn, the previous r14/r18 pair. * * There are generally a few cases which determine where we can find out * the r14/r18 values. In the general case, this can be determined by poking * around the prologue of the symbol PC is in (note that we absolutely must * have frame pointer support as well as the kernel symbol table mapped, * otherwise we can't even get this far). * * In other cases, such as the interrupt/exception path, we can poke around * the sp/fp. * * Notably, this entire approach is somewhat error prone, and in the event * that the previous frame cannot be determined, that's all we can do. * Either way, this still leaves us with a more correct backtrace then what * we would be able to come up with by walking the stack (which is garbage * for anything beyond the first frame). * -- PFM. */ static int lookup_prev_stack_frame(unsigned long fp, unsigned long pc, unsigned long *pprev_fp, unsigned long *pprev_pc, struct pt_regs *regs) { const char *sym; char namebuf[128]; unsigned long offset; unsigned long prologue = 0; unsigned long fp_displacement = 0; unsigned long fp_prev = 0; unsigned long offset_r14 = 0, offset_r18 = 0; int i, found_prologue_end = 0; sym = kallsyms_lookup(pc, NULL, &offset, NULL, namebuf); if (!sym) return -EINVAL; prologue = pc - offset; if (!prologue) return -EINVAL; /* Validate fp, to avoid risk of dereferencing a bad pointer later. Assume 128Mb since that's the amount of RAM on a Cayman. Modify when there is an SH-5 board with more. */ if ((fp < (unsigned long) phys_to_virt(__MEMORY_START)) || (fp >= (unsigned long)(phys_to_virt(__MEMORY_START)) + 128*1024*1024) || ((fp & 7) != 0)) { return -EINVAL; } /* * Depth to walk, depth is completely arbitrary. */ for (i = 0; i < 100; i++, prologue += sizeof(unsigned long)) { unsigned long op; u8 major, minor; u8 src, dest, disp; op = *(unsigned long *)prologue; major = (op >> 26) & 0x3f; src = (op >> 20) & 0x3f; minor = (op >> 16) & 0xf; disp = (op >> 10) & 0x3f; dest = (op >> 4) & 0x3f; /* * Stack frame creation happens in a number of ways.. in the * general case when the stack frame is less than 511 bytes, * it's generally created by an addi or addi.l: * * addi/addi.l r15, -FRAME_SIZE, r15 * * in the event that the frame size is bigger than this, it's * typically created using a movi/sub pair as follows: * * movi FRAME_SIZE, rX * sub r15, rX, r15 */ switch (major) { case (0x00 >> 2): switch (minor) { case 0x8: /* add.l */ case 0x9: /* add */ /* Look for r15, r63, r14 */ if (src == 15 && disp == 63 && dest == 14) found_prologue_end = 1; break; case 0xa: /* sub.l */ case 0xb: /* sub */ if (src != 15 || dest != 15) continue; fp_displacement -= regcache[disp]; fp_prev = fp - fp_displacement; break; } break; case (0xa8 >> 2): /* st.l */ if (src != 15) continue; switch (dest) { case 14: if (offset_r14 || fp_displacement == 0) continue; offset_r14 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54); offset_r14 *= sizeof(unsigned long); offset_r14 += fp_displacement; break; case 18: if (offset_r18 || fp_displacement == 0) continue; offset_r18 = (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54); offset_r18 *= sizeof(unsigned long); offset_r18 += fp_displacement; break; } break; case (0xcc >> 2): /* movi */ if (dest >= 63) { printk(KERN_NOTICE "%s: Invalid dest reg %d " "specified in movi handler. Failed " "opcode was 0x%lx: ", __func__, dest, op); continue; } /* Sign extend */ regcache[dest] = sign_extend64((((u64)op >> 10) & 0xffff), 9); break; case (0xd0 >> 2): /* addi */ case (0xd4 >> 2): /* addi.l */ /* Look for r15, -FRAME_SIZE, r15 */ if (src != 15 || dest != 15) continue; /* Sign extended frame size.. */ fp_displacement += (u64)(((((s64)op >> 10) & 0x3ff) << 54) >> 54); fp_prev = fp - fp_displacement; break; } if (found_prologue_end && offset_r14 && (offset_r18 || *pprev_pc) && fp_prev) break; } if (offset_r14 == 0 || fp_prev == 0) { if (!offset_r14) pr_debug("Unable to find r14 offset\n"); if (!fp_prev) pr_debug("Unable to find previous fp\n"); return -EINVAL; } /* For innermost leaf function, there might not be a offset_r18 */ if (!*pprev_pc && (offset_r18 == 0)) return -EINVAL; *pprev_fp = *(unsigned long *)(fp_prev + offset_r14); if (offset_r18) *pprev_pc = *(unsigned long *)(fp_prev + offset_r18); *pprev_pc &= ~1; return 0; } /* * Don't put this on the stack since we'll want to call in to * sh64_unwinder_dump() when we're close to underflowing the stack * anyway. */ static struct pt_regs here_regs; extern const char syscall_ret; extern const char ret_from_syscall; extern const char ret_from_exception; extern const char ret_from_irq; static void sh64_unwind_inner(const struct stacktrace_ops *ops, void *data, struct pt_regs *regs); static inline void unwind_nested(const struct stacktrace_ops *ops, void *data, unsigned long pc, unsigned long fp) { if ((fp >= __MEMORY_START) && ((fp & 7) == 0)) sh64_unwind_inner(ops, data, (struct pt_regs *)fp); } static void sh64_unwind_inner(const struct stacktrace_ops *ops, void *data, struct pt_regs *regs) { unsigned long pc, fp; int ofs = 0; int first_pass; pc = regs->pc & ~1; fp = regs->regs[14]; first_pass = 1; for (;;) { int cond; unsigned long next_fp, next_pc; if (pc == ((unsigned long)&syscall_ret & ~1)) { printk("SYSCALL\n"); unwind_nested(ops, data, pc, fp); return; } if (pc == ((unsigned long)&ret_from_syscall & ~1)) { printk("SYSCALL (PREEMPTED)\n"); unwind_nested(ops, data, pc, fp); return; } /* In this case, the PC is discovered by lookup_prev_stack_frame but it has 4 taken off it to look like the 'caller' */ if (pc == ((unsigned long)&ret_from_exception & ~1)) { printk("EXCEPTION\n"); unwind_nested(ops, data, pc, fp); return; } if (pc == ((unsigned long)&ret_from_irq & ~1)) { printk("IRQ\n"); unwind_nested(ops, data, pc, fp); return; } cond = ((pc >= __MEMORY_START) && (fp >= __MEMORY_START) && ((pc & 3) == 0) && ((fp & 7) == 0)); pc -= ofs; ops->address(data, pc, 1); if (first_pass) { /* If the innermost frame is a leaf function, it's * possible that r18 is never saved out to the stack. */ next_pc = regs->regs[18]; } else { next_pc = 0; } if (lookup_prev_stack_frame(fp, pc, &next_fp, &next_pc, regs) == 0) { ofs = sizeof(unsigned long); pc = next_pc & ~1; fp = next_fp; } else { printk("Unable to lookup previous stack frame\n"); break; } first_pass = 0; } printk("\n"); } static void sh64_unwinder_dump(struct task_struct *task, struct pt_regs *regs, unsigned long *sp, const struct stacktrace_ops *ops, void *data) { if (!regs) { /* * Fetch current regs if we have no other saved state to back * trace from. */ regs = &here_regs; __asm__ __volatile__ ("ori r14, 0, %0" : "=r" (regs->regs[14])); __asm__ __volatile__ ("ori r15, 0, %0" : "=r" (regs->regs[15])); __asm__ __volatile__ ("ori r18, 0, %0" : "=r" (regs->regs[18])); __asm__ __volatile__ ("gettr tr0, %0" : "=r" (regs->tregs[0])); __asm__ __volatile__ ("gettr tr1, %0" : "=r" (regs->tregs[1])); __asm__ __volatile__ ("gettr tr2, %0" : "=r" (regs->tregs[2])); __asm__ __volatile__ ("gettr tr3, %0" : "=r" (regs->tregs[3])); __asm__ __volatile__ ("gettr tr4, %0" : "=r" (regs->tregs[4])); __asm__ __volatile__ ("gettr tr5, %0" : "=r" (regs->tregs[5])); __asm__ __volatile__ ("gettr tr6, %0" : "=r" (regs->tregs[6])); __asm__ __volatile__ ("gettr tr7, %0" : "=r" (regs->tregs[7])); __asm__ __volatile__ ( "pta 0f, tr0\n\t" "blink tr0, %0\n\t" "0: nop" : "=r" (regs->pc) ); } sh64_unwind_inner(ops, data, regs); } static struct unwinder sh64_unwinder = { .name = "sh64-unwinder", .dump = sh64_unwinder_dump, .rating = 150, }; static int __init sh64_unwinder_init(void) { return unwinder_register(&sh64_unwinder); } early_initcall(sh64_unwinder_init);
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1