root/arch/nios2/kernel/traps.c

DEFINITIONS

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