Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Helper functions for trap handlers |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 4 | * Copyright (C) 2000-2007, Axis Communications AB. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 6 | * Authors: Bjorn Wesen |
| 7 | * Hans-Peter Nilsson |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | * |
| 9 | */ |
| 10 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | #include <linux/ptrace.h> |
Linus Torvalds | 7c0f6ba | 2016-12-24 11:46:01 -0800 | [diff] [blame] | 12 | #include <linux/uaccess.h> |
Ingo Molnar | b17b015 | 2017-02-08 18:51:35 +0100 | [diff] [blame] | 13 | #include <linux/sched/debug.h> |
| 14 | |
Jesper Nilsson | 556dcee | 2008-10-21 17:45:58 +0200 | [diff] [blame] | 15 | #include <arch/sv_addr_ag.h> |
David Howells | b1a154d | 2012-03-28 18:30:02 +0100 | [diff] [blame] | 16 | #include <arch/system.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 18 | void |
| 19 | show_registers(struct pt_regs *regs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | { |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 21 | /* |
| 22 | * It's possible to use either the USP register or current->thread.usp. |
| 23 | * USP might not correspond to the current process for all cases this |
| 24 | * function is called, and current->thread.usp isn't up to date for the |
| 25 | * current process. Experience shows that using USP is the way to go. |
| 26 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | unsigned long usp = rdusp(); |
| 28 | |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 29 | printk("IRP: %08lx SRP: %08lx DCCR: %08lx USP: %08lx MOF: %08lx\n", |
| 30 | regs->irp, regs->srp, regs->dccr, usp, regs->mof); |
| 31 | |
| 32 | printk(" r0: %08lx r1: %08lx r2: %08lx r3: %08lx\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | regs->r0, regs->r1, regs->r2, regs->r3); |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 34 | |
| 35 | printk(" r4: %08lx r5: %08lx r6: %08lx r7: %08lx\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | regs->r4, regs->r5, regs->r6, regs->r7); |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 37 | |
| 38 | printk(" r8: %08lx r9: %08lx r10: %08lx r11: %08lx\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 39 | regs->r8, regs->r9, regs->r10, regs->r11); |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 40 | |
| 41 | printk("r12: %08lx r13: %08lx oR10: %08lx sp: %08lx\n", |
| 42 | regs->r12, regs->r13, regs->orig_r10, (long unsigned)regs); |
| 43 | |
| 44 | printk("R_MMU_CAUSE: %08lx\n", (unsigned long)*R_MMU_CAUSE); |
| 45 | |
| 46 | printk("Process %s (pid: %d, stackpage=%08lx)\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | current->comm, current->pid, (unsigned long)current); |
| 48 | |
| 49 | /* |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 50 | * When in-kernel, we also print out the stack and code at the |
| 51 | * time of the fault.. |
| 52 | */ |
| 53 | if (!user_mode(regs)) { |
| 54 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 55 | |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 56 | show_stack(NULL, (unsigned long *)usp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 58 | /* |
| 59 | * If the previous stack-dump wasn't a kernel one, dump the |
| 60 | * kernel stack now. |
| 61 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | if (usp != 0) |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 63 | show_stack(NULL, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 65 | printk("\nCode: "); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 67 | if (regs->irp < PAGE_OFFSET) |
| 68 | goto bad_value; |
| 69 | |
| 70 | /* |
| 71 | * Quite often the value at regs->irp doesn't point to the |
| 72 | * interesting instruction, which often is the previous |
| 73 | * instruction. So dump at an offset large enough that the |
| 74 | * instruction decoding should be in sync at the interesting |
| 75 | * point, but small enough to fit on a row. The regs->irp |
| 76 | * location is pointed out in a ksymoops-friendly way by |
| 77 | * wrapping the byte for that address in parenthesises. |
| 78 | */ |
| 79 | for (i = -12; i < 12; i++) { |
| 80 | unsigned char c; |
| 81 | |
| 82 | if (__get_user(c, &((unsigned char *)regs->irp)[i])) { |
| 83 | bad_value: |
| 84 | printk(" Bad IP value."); |
| 85 | break; |
| 86 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | |
| 88 | if (i == 0) |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 89 | printk("(%02x) ", c); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | else |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 91 | printk("%02x ", c); |
| 92 | } |
| 93 | printk("\n"); |
| 94 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | } |
| 96 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | void |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 98 | arch_enable_nmi(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | { |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 100 | asm volatile ("setf m"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | } |
| 102 | |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 103 | extern void (*nmi_handler)(struct pt_regs *); |
| 104 | void handle_nmi(struct pt_regs *regs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | { |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 106 | if (nmi_handler) |
| 107 | nmi_handler(regs); |
| 108 | |
| 109 | /* Wait until nmi is no longer active. (We enable NMI immediately after |
| 110 | returning from this function, and we don't want it happening while |
| 111 | exiting from the NMI interrupt handler.) */ |
| 112 | while (*R_IRQ_MASK0_RD & IO_STATE(R_IRQ_MASK0_RD, nmi_pin, active)) |
| 113 | ; |
| 114 | } |
| 115 | |
| 116 | #ifdef CONFIG_DEBUG_BUGVERBOSE |
| 117 | void |
| 118 | handle_BUG(struct pt_regs *regs) |
| 119 | { |
| 120 | struct bug_frame f; |
| 121 | unsigned char c; |
| 122 | unsigned long irp = regs->irp; |
| 123 | |
| 124 | if (__copy_from_user(&f, (const void __user *)(irp - 8), sizeof f)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | return; |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 126 | if (f.prefix != BUG_PREFIX || f.magic != BUG_MAGIC) |
| 127 | return; |
| 128 | if (__get_user(c, f.filename)) |
| 129 | f.filename = "<bad filename>"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 131 | printk("kernel BUG at %s:%d!\n", f.filename, f.line); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | } |
Jesper Nilsson | 1e4cc2c | 2007-11-30 16:22:50 +0100 | [diff] [blame] | 133 | #endif |