arch/nios2/kernel/traps.c

   1 /*
   2  * Hardware exception handling
   3  *
   4  * Copyright (C) 2010 Tobias Klauser <tklauser@distanz.ch>
   5  * Copyright (C) 2004 Microtronix Datacom Ltd.
   6  * Copyright (C) 2001 Vic Phillips
   7  *
   8  * This file is subject to the terms and conditions of the GNU General
   9  * Public License.  See the file COPYING in the main directory of this
  10  * archive for more details.
  11  */
  12
  13 #include <linux/sched.h>
  14 #include <linux/kernel.h>
  15 #include <linux/signal.h>
  16 #include <linux/export.h>
  17 #include <linux/mm.h>
  18 #include <linux/ptrace.h>
  19
  20 #include <asm/traps.h>
  21 #include <asm/sections.h>
  22 #include <asm/uaccess.h>
  23
  24 static DEFINE_SPINLOCK(die_lock);
  25
  26 static void _send_sig(int signo, int code, unsigned long addr)
  27 {
  28         siginfo_t info;
  29
  30         info.si_signo = signo;
  31         info.si_errno = 0;
  32         info.si_code = code;
  33         info.si_addr = (void __user *) addr;
  34         force_sig_info(signo, &info, current);
  35 }
  36
  37 void die(const char *str, struct pt_regs *regs, long err)
  38 {
  39         console_verbose();
  40         spin_lock_irq(&die_lock);
  41         pr_warn("Oops: %s, sig: %ld\n", str, err);
  42         show_regs(regs);
  43         spin_unlock_irq(&die_lock);
  44         /*
  45          * do_exit() should take care of panic'ing from an interrupt
  46          * context so we don't handle it here
  47          */
  48         do_exit(err);
  49 }
  50
  51 void _exception(int signo, struct pt_regs *regs, int code, unsigned long addr)
  52 {
  53         if (!user_mode(regs))
  54                 die("Exception in kernel mode", regs, signo);
  55
  56         _send_sig(signo, code, addr);
  57 }
  58
  59 /*
  60  * The show_stack is an external API which we do not use ourselves.
  61  */
  62
  63 int kstack_depth_to_print = 48;
  64
  65 void show_stack(struct task_struct *task, unsigned long *stack)
  66 {
  67         unsigned long *endstack, addr;
  68         int i;
  69
  70         if (!stack) {
  71                 if (task)
  72                         stack = (unsigned long *)task->thread.ksp;
  73                 else
  74                         stack = (unsigned long *)&stack;
  75         }
  76
  77         addr = (unsigned long) stack;
  78         endstack = (unsigned long *) PAGE_ALIGN(addr);
  79
  80         pr_emerg("Stack from %08lx:", (unsigned long)stack);
  81         for (i = 0; i < kstack_depth_to_print; i++) {
  82                 if (stack + 1 > endstack)
  83                         break;
  84                 if (i % 8 == 0)
  85                         pr_emerg("\n       ");
  86                 pr_emerg(" %08lx", *stack++);
  87         }
  88
  89         pr_emerg("\nCall Trace:");
  90         i = 0;
  91         while (stack + 1 <= endstack) {
  92                 addr = *stack++;
  93                 /*
  94                  * If the address is either in the text segment of the
  95                  * kernel, or in the region which contains vmalloc'ed
  96                  * memory, it *may* be the address of a calling
  97                  * routine; if so, print it so that someone tracing
  98                  * down the cause of the crash will be able to figure
  99                  * out the call path that was taken.
 100                  */
 101                 if (((addr >= (unsigned long) _stext) &&
 102                      (addr <= (unsigned long) _etext))) {
 103                         if (i % 4 == 0)
 104                                 pr_emerg("\n       ");
 105                         pr_emerg(" [<%08lx>]", addr);
 106                         i++;
 107                 }
 108         }
 109         pr_emerg("\n");
 110 }
 111
 112 void __init trap_init(void)
 113 {
 114         /* Nothing to do here */
 115 }
 116
 117 /* Breakpoint handler */
 118 asmlinkage void breakpoint_c(struct pt_regs *fp)
 119 {
 120         /*
 121          * The breakpoint entry code has moved the PC on by 4 bytes, so we must
 122          * move it back. This could be done on the host but we do it here
 123          * because monitor.S of JTAG gdbserver does it too.
 124          */
 125         fp->ea -= 4;
 126         _exception(SIGTRAP, fp, TRAP_BRKPT, fp->ea);
 127 }
 128
 129 #ifndef CONFIG_NIOS2_ALIGNMENT_TRAP
 130 /* Alignment exception handler */
 131 asmlinkage void handle_unaligned_c(struct pt_regs *fp, int cause)
 132 {
 133         unsigned long addr = RDCTL(CTL_BADADDR);
 134
 135         cause >>= 2;
 136         fp->ea -= 4;
 137
 138         if (fixup_exception(fp))
 139                 return;
 140
 141         if (!user_mode(fp)) {
 142                 pr_alert("Unaligned access from kernel mode, this might be a hardware\n");
 143                 pr_alert("problem, dump registers and restart the instruction\n");
 144                 pr_alert("  BADADDR 0x%08lx\n", addr);
 145                 pr_alert("  cause   %d\n", cause);
 146                 pr_alert("  op-code 0x%08lx\n", *(unsigned long *)(fp->ea));
 147                 show_regs(fp);
 148                 return;
 149         }
 150
 151         _exception(SIGBUS, fp, BUS_ADRALN, addr);
 152 }
 153 #endif /* CONFIG_NIOS2_ALIGNMENT_TRAP */
 154
 155 /* Illegal instruction handler */
 156 asmlinkage void handle_illegal_c(struct pt_regs *fp)
 157 {
 158         fp->ea -= 4;
 159         _exception(SIGILL, fp, ILL_ILLOPC, fp->ea);
 160 }
 161
 162 /* Supervisor instruction handler */
 163 asmlinkage void handle_supervisor_instr(struct pt_regs *fp)
 164 {
 165         fp->ea -= 4;
 166         _exception(SIGILL, fp, ILL_PRVOPC, fp->ea);
 167 }
 168
 169 /* Division error handler */
 170 asmlinkage void handle_diverror_c(struct pt_regs *fp)
 171 {
 172         fp->ea -= 4;
 173         _exception(SIGFPE, fp, FPE_INTDIV, fp->ea);
 174 }
 175
 176 /* Unhandled exception handler */
 177 asmlinkage void unhandled_exception(struct pt_regs *regs, int cause)
 178 {
 179         unsigned long addr = RDCTL(CTL_BADADDR);
 180
 181         cause /= 4;
 182
 183         pr_emerg("Unhandled exception #%d in %s mode (badaddr=0x%08lx)\n",
 184                         cause, user_mode(regs) ? "user" : "kernel", addr);
 185
 186         regs->ea -= 4;
 187         show_regs(regs);
 188
 189         pr_emerg("opcode: 0x%08lx\n", *(unsigned long *)(regs->ea));
 190 }
 191
 192 asmlinkage void handle_trap_1_c(struct pt_regs *fp)
 193 {
 194         _send_sig(SIGUSR1, 0, fp->ea);
 195 }
 196
 197 asmlinkage void handle_trap_2_c(struct pt_regs *fp)
 198 {
 199         _send_sig(SIGUSR2, 0, fp->ea);
 200 }
 201
 202 asmlinkage void handle_trap_3_c(struct pt_regs *fp)
 203 {
 204         _send_sig(SIGILL, ILL_ILLTRP, fp->ea);
 205 }