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