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	 * 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
 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
108void __init trap_init(void)
109{
110	/* Nothing to do here */
111}
112
113/* Breakpoint handler */
114asmlinkage void breakpoint_c(struct pt_regs *fp)
115{
116	/*
117	 * The breakpoint entry code has moved the PC on by 4 bytes, so we must
118	 * move it back. This could be done on the host but we do it here
119	 * because monitor.S of JTAG gdbserver does it too.
120	 */
121	fp->ea -= 4;
122	_exception(SIGTRAP, fp, TRAP_BRKPT, fp->ea);
123}
124
125#ifndef CONFIG_NIOS2_ALIGNMENT_TRAP
126/* Alignment exception handler */
127asmlinkage void handle_unaligned_c(struct pt_regs *fp, int cause)
128{
129	unsigned long addr = RDCTL(CTL_BADADDR);
130
131	cause >>= 2;
132	fp->ea -= 4;
133
134	if (fixup_exception(fp))
135		return;
136
137	if (!user_mode(fp)) {
138		pr_alert("Unaligned access from kernel mode, this might be a hardware\n");
139		pr_alert("problem, dump registers and restart the instruction\n");
140		pr_alert("  BADADDR 0x%08lx\n", addr);
141		pr_alert("  cause   %d\n", cause);
142		pr_alert("  op-code 0x%08lx\n", *(unsigned long *)(fp->ea));
143		show_regs(fp);
144		return;
145	}
146
147	_exception(SIGBUS, fp, BUS_ADRALN, addr);
148}
149#endif /* CONFIG_NIOS2_ALIGNMENT_TRAP */
150
151/* Illegal instruction handler */
152asmlinkage void handle_illegal_c(struct pt_regs *fp)
153{
154	fp->ea -= 4;
155	_exception(SIGILL, fp, ILL_ILLOPC, fp->ea);
156}
157
158/* Supervisor instruction handler */
159asmlinkage void handle_supervisor_instr(struct pt_regs *fp)
160{
161	fp->ea -= 4;
162	_exception(SIGILL, fp, ILL_PRVOPC, fp->ea);
163}
164
165/* Division error handler */
166asmlinkage void handle_diverror_c(struct pt_regs *fp)
167{
168	fp->ea -= 4;
169	_exception(SIGFPE, fp, FPE_INTDIV, fp->ea);
170}
171
172/* Unhandled exception handler */
173asmlinkage void unhandled_exception(struct pt_regs *regs, int cause)
174{
175	unsigned long addr = RDCTL(CTL_BADADDR);
176
177	cause /= 4;
178
179	pr_emerg("Unhandled exception #%d in %s mode (badaddr=0x%08lx)\n",
180			cause, user_mode(regs) ? "user" : "kernel", addr);
181
182	regs->ea -= 4;
183	show_regs(regs);
184
185	pr_emerg("opcode: 0x%08lx\n", *(unsigned long *)(regs->ea));
186}
187
188asmlinkage void handle_trap_1_c(struct pt_regs *fp)
189{
190	_send_sig(SIGUSR1, 0, fp->ea);
191}
192
193asmlinkage void handle_trap_2_c(struct pt_regs *fp)
194{
195	_send_sig(SIGUSR2, 0, fp->ea);
196}
197
198asmlinkage void handle_trap_3_c(struct pt_regs *fp)
199{
200	_send_sig(SIGILL, ILL_ILLTRP, fp->ea);
201}