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
_send_sig(int signo,int code,unsigned long addr)27 static void _send_sig(int signo, int code, unsigned long addr)
28 {
29 force_sig_fault(signo, code, (void __user *) addr);
30 }
31
die(const char * str,struct pt_regs * regs,long err)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 * make_task_dead() should take care of panic'ing from an interrupt
41 * context so we don't handle it here
42 */
43 make_task_dead(err);
44 }
45
_exception(int signo,struct pt_regs * regs,int code,unsigned long addr)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
show_stack(struct task_struct * task,unsigned long * stack)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
trap_init(void)107 void __init trap_init(void)
108 {
109 /* Nothing to do here */
110 }
111
112 /* Breakpoint handler */
breakpoint_c(struct pt_regs * fp)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 */
handle_unaligned_c(struct pt_regs * fp,int cause)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 */
handle_illegal_c(struct pt_regs * fp)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 */
handle_supervisor_instr(struct pt_regs * fp)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 */
handle_diverror_c(struct pt_regs * fp)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 */
unhandled_exception(struct pt_regs * regs,int cause)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
handle_trap_1_c(struct pt_regs * fp)187 asmlinkage void handle_trap_1_c(struct pt_regs *fp)
188 {
189 _send_sig(SIGUSR1, 0, fp->ea);
190 }
191
handle_trap_2_c(struct pt_regs * fp)192 asmlinkage void handle_trap_2_c(struct pt_regs *fp)
193 {
194 _send_sig(SIGUSR2, 0, fp->ea);
195 }
196
handle_trap_3_c(struct pt_regs * fp)197 asmlinkage void handle_trap_3_c(struct pt_regs *fp)
198 {
199 _send_sig(SIGILL, ILL_ILLTRP, fp->ea);
200 }
201