1/*
2 * Kernel traps/events for Hexagon processor
3 *
4 * Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 and
8 * only version 2 as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 * 02110-1301, USA.
19 */
20
21#include <linux/init.h>
22#include <linux/sched.h>
23#include <linux/module.h>
24#include <linux/kallsyms.h>
25#include <linux/kdebug.h>
26#include <linux/syscalls.h>
27#include <linux/signal.h>
28#include <linux/tracehook.h>
29#include <asm/traps.h>
30#include <asm/vm_fault.h>
31#include <asm/syscall.h>
32#include <asm/registers.h>
33#include <asm/unistd.h>
34#include <asm/sections.h>
35#ifdef CONFIG_KGDB
36# include <linux/kgdb.h>
37#endif
38
39#define TRAP_SYSCALL	1
40#define TRAP_DEBUG	0xdb
41
42void __init trap_init(void)
43{
44}
45
46#ifdef CONFIG_GENERIC_BUG
47/* Maybe should resemble arch/sh/kernel/traps.c ?? */
48int is_valid_bugaddr(unsigned long addr)
49{
50	return 1;
51}
52#endif /* CONFIG_GENERIC_BUG */
53
54static const char *ex_name(int ex)
55{
56	switch (ex) {
57	case HVM_GE_C_XPROT:
58	case HVM_GE_C_XUSER:
59		return "Execute protection fault";
60	case HVM_GE_C_RPROT:
61	case HVM_GE_C_RUSER:
62		return "Read protection fault";
63	case HVM_GE_C_WPROT:
64	case HVM_GE_C_WUSER:
65		return "Write protection fault";
66	case HVM_GE_C_XMAL:
67		return "Misaligned instruction";
68	case HVM_GE_C_WREG:
69		return "Multiple writes to same register in packet";
70	case HVM_GE_C_PCAL:
71		return "Program counter values that are not properly aligned";
72	case HVM_GE_C_RMAL:
73		return "Misaligned data load";
74	case HVM_GE_C_WMAL:
75		return "Misaligned data store";
76	case HVM_GE_C_INVI:
77	case HVM_GE_C_PRIVI:
78		return "Illegal instruction";
79	case HVM_GE_C_BUS:
80		return "Precise bus error";
81	case HVM_GE_C_CACHE:
82		return "Cache error";
83
84	case 0xdb:
85		return "Debugger trap";
86
87	default:
88		return "Unrecognized exception";
89	}
90}
91
92static void do_show_stack(struct task_struct *task, unsigned long *fp,
93			  unsigned long ip)
94{
95	int kstack_depth_to_print = 24;
96	unsigned long offset, size;
97	const char *name = NULL;
98	unsigned long *newfp;
99	unsigned long low, high;
100	char tmpstr[128];
101	char *modname;
102	int i;
103
104	if (task == NULL)
105		task = current;
106
107	printk(KERN_INFO "CPU#%d, %s/%d, Call Trace:\n",
108	       raw_smp_processor_id(), task->comm,
109	       task_pid_nr(task));
110
111	if (fp == NULL) {
112		if (task == current) {
113			asm("%0 = r30" : "=r" (fp));
114		} else {
115			fp = (unsigned long *)
116			     ((struct hexagon_switch_stack *)
117			     task->thread.switch_sp)->fp;
118		}
119	}
120
121	if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) {
122		printk(KERN_INFO "-- Corrupt frame pointer %p\n", fp);
123		return;
124	}
125
126	/* Saved link reg is one word above FP */
127	if (!ip)
128		ip = *(fp+1);
129
130	/* Expect kernel stack to be in-bounds */
131	low = (unsigned long)task_stack_page(task);
132	high = low + THREAD_SIZE - 8;
133	low += sizeof(struct thread_info);
134
135	for (i = 0; i < kstack_depth_to_print; i++) {
136
137		name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);
138
139		printk(KERN_INFO "[%p] 0x%lx: %s + 0x%lx", fp, ip, name,
140			offset);
141		if (((unsigned long) fp < low) || (high < (unsigned long) fp))
142			printk(KERN_CONT " (FP out of bounds!)");
143		if (modname)
144			printk(KERN_CONT " [%s] ", modname);
145		printk(KERN_CONT "\n");
146
147		newfp = (unsigned long *) *fp;
148
149		if (((unsigned long) newfp) & 0x3) {
150			printk(KERN_INFO "-- Corrupt frame pointer %p\n",
151				newfp);
152			break;
153		}
154
155		/* Attempt to continue past exception. */
156		if (0 == newfp) {
157			struct pt_regs *regs = (struct pt_regs *) (((void *)fp)
158						+ 8);
159
160			if (regs->syscall_nr != -1) {
161				printk(KERN_INFO "-- trap0 -- syscall_nr: %ld",
162					regs->syscall_nr);
163				printk(KERN_CONT "  psp: %lx  elr: %lx\n",
164					 pt_psp(regs), pt_elr(regs));
165				break;
166			} else {
167				/* really want to see more ... */
168				kstack_depth_to_print += 6;
169				printk(KERN_INFO "-- %s (0x%lx)  badva: %lx\n",
170					ex_name(pt_cause(regs)), pt_cause(regs),
171					pt_badva(regs));
172			}
173
174			newfp = (unsigned long *) regs->r30;
175			ip = pt_elr(regs);
176		} else {
177			ip = *(newfp + 1);
178		}
179
180		/* If link reg is null, we are done. */
181		if (ip == 0x0)
182			break;
183
184		/* If newfp isn't larger, we're tracing garbage. */
185		if (newfp > fp)
186			fp = newfp;
187		else
188			break;
189	}
190}
191
192void show_stack(struct task_struct *task, unsigned long *fp)
193{
194	/* Saved link reg is one word above FP */
195	do_show_stack(task, fp, 0);
196}
197
198int die(const char *str, struct pt_regs *regs, long err)
199{
200	static struct {
201		spinlock_t lock;
202		int counter;
203	} die = {
204		.lock = __SPIN_LOCK_UNLOCKED(die.lock),
205		.counter = 0
206	};
207
208	console_verbose();
209	oops_enter();
210
211	spin_lock_irq(&die.lock);
212	bust_spinlocks(1);
213	printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);
214
215	if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
216	    NOTIFY_STOP)
217		return 1;
218
219	print_modules();
220	show_regs(regs);
221	do_show_stack(current, &regs->r30, pt_elr(regs));
222
223	bust_spinlocks(0);
224	add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
225
226	spin_unlock_irq(&die.lock);
227
228	if (in_interrupt())
229		panic("Fatal exception in interrupt");
230
231	if (panic_on_oops)
232		panic("Fatal exception");
233
234	oops_exit();
235	do_exit(err);
236	return 0;
237}
238
239int die_if_kernel(char *str, struct pt_regs *regs, long err)
240{
241	if (!user_mode(regs))
242		return die(str, regs, err);
243	else
244		return 0;
245}
246
247/*
248 * It's not clear that misaligned fetches are ever recoverable.
249 */
250static void misaligned_instruction(struct pt_regs *regs)
251{
252	die_if_kernel("Misaligned Instruction", regs, 0);
253	force_sig(SIGBUS, current);
254}
255
256/*
257 * Misaligned loads and stores, on the other hand, can be
258 * emulated, and probably should be, some day.  But for now
259 * they will be considered fatal.
260 */
261static void misaligned_data_load(struct pt_regs *regs)
262{
263	die_if_kernel("Misaligned Data Load", regs, 0);
264	force_sig(SIGBUS, current);
265}
266
267static void misaligned_data_store(struct pt_regs *regs)
268{
269	die_if_kernel("Misaligned Data Store", regs, 0);
270	force_sig(SIGBUS, current);
271}
272
273static void illegal_instruction(struct pt_regs *regs)
274{
275	die_if_kernel("Illegal Instruction", regs, 0);
276	force_sig(SIGILL, current);
277}
278
279/*
280 * Precise bus errors may be recoverable with a a retry,
281 * but for now, treat them as irrecoverable.
282 */
283static void precise_bus_error(struct pt_regs *regs)
284{
285	die_if_kernel("Precise Bus Error", regs, 0);
286	force_sig(SIGBUS, current);
287}
288
289/*
290 * If anything is to be done here other than panic,
291 * it will probably be complex and migrate to another
292 * source module.  For now, just die.
293 */
294static void cache_error(struct pt_regs *regs)
295{
296	die("Cache Error", regs, 0);
297}
298
299/*
300 * General exception handler
301 */
302void do_genex(struct pt_regs *regs)
303{
304	/*
305	 * Decode Cause and Dispatch
306	 */
307	switch (pt_cause(regs)) {
308	case HVM_GE_C_XPROT:
309	case HVM_GE_C_XUSER:
310		execute_protection_fault(regs);
311		break;
312	case HVM_GE_C_RPROT:
313	case HVM_GE_C_RUSER:
314		read_protection_fault(regs);
315		break;
316	case HVM_GE_C_WPROT:
317	case HVM_GE_C_WUSER:
318		write_protection_fault(regs);
319		break;
320	case HVM_GE_C_XMAL:
321		misaligned_instruction(regs);
322		break;
323	case HVM_GE_C_WREG:
324		illegal_instruction(regs);
325		break;
326	case HVM_GE_C_PCAL:
327		misaligned_instruction(regs);
328		break;
329	case HVM_GE_C_RMAL:
330		misaligned_data_load(regs);
331		break;
332	case HVM_GE_C_WMAL:
333		misaligned_data_store(regs);
334		break;
335	case HVM_GE_C_INVI:
336	case HVM_GE_C_PRIVI:
337		illegal_instruction(regs);
338		break;
339	case HVM_GE_C_BUS:
340		precise_bus_error(regs);
341		break;
342	case HVM_GE_C_CACHE:
343		cache_error(regs);
344		break;
345	default:
346		/* Halt and catch fire */
347		panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
348		break;
349	}
350}
351
352/* Indirect system call dispatch */
353long sys_syscall(void)
354{
355	printk(KERN_ERR "sys_syscall invoked!\n");
356	return -ENOSYS;
357}
358
359void do_trap0(struct pt_regs *regs)
360{
361	syscall_fn syscall;
362
363	switch (pt_cause(regs)) {
364	case TRAP_SYSCALL:
365		/* System call is trap0 #1 */
366
367		/* allow strace to catch syscall args  */
368		if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
369			tracehook_report_syscall_entry(regs)))
370			return;  /*  return -ENOSYS somewhere?  */
371
372		/* Interrupts should be re-enabled for syscall processing */
373		__vmsetie(VM_INT_ENABLE);
374
375		/*
376		 * System call number is in r6, arguments in r0..r5.
377		 * Fortunately, no Linux syscall has more than 6 arguments,
378		 * and Hexagon ABI passes first 6 arguments in registers.
379		 * 64-bit arguments are passed in odd/even register pairs.
380		 * Fortunately, we have no system calls that take more
381		 * than three arguments with more than one 64-bit value.
382		 * Should that change, we'd need to redesign to copy
383		 * between user and kernel stacks.
384		 */
385		regs->syscall_nr = regs->r06;
386
387		/*
388		 * GPR R0 carries the first parameter, and is also used
389		 * to report the return value.  We need a backup of
390		 * the user's value in case we need to do a late restart
391		 * of the system call.
392		 */
393		regs->restart_r0 = regs->r00;
394
395		if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
396			regs->r00 = -1;
397		} else {
398			syscall = (syscall_fn)
399				  (sys_call_table[regs->syscall_nr]);
400			regs->r00 = syscall(regs->r00, regs->r01,
401				   regs->r02, regs->r03,
402				   regs->r04, regs->r05);
403		}
404
405		/* allow strace to get the syscall return state  */
406		if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
407			tracehook_report_syscall_exit(regs, 0);
408
409		break;
410	case TRAP_DEBUG:
411		/* Trap0 0xdb is debug breakpoint */
412		if (user_mode(regs)) {
413			struct siginfo info;
414
415			info.si_signo = SIGTRAP;
416			info.si_errno = 0;
417			/*
418			 * Some architecures add some per-thread state
419			 * to distinguish between breakpoint traps and
420			 * trace traps.  We may want to do that, and
421			 * set the si_code value appropriately, or we
422			 * may want to use a different trap0 flavor.
423			 */
424			info.si_code = TRAP_BRKPT;
425			info.si_addr = (void __user *) pt_elr(regs);
426			force_sig_info(SIGTRAP, &info, current);
427		} else {
428#ifdef CONFIG_KGDB
429			kgdb_handle_exception(pt_cause(regs), SIGTRAP,
430					      TRAP_BRKPT, regs);
431#endif
432		}
433		break;
434	}
435	/* Ignore other trap0 codes for now, especially 0 (Angel calls) */
436}
437
438/*
439 * Machine check exception handler
440 */
441void do_machcheck(struct pt_regs *regs)
442{
443	/* Halt and catch fire */
444	__vmstop();
445}
446
447/*
448 * Treat this like the old 0xdb trap.
449 */
450
451void do_debug_exception(struct pt_regs *regs)
452{
453	regs->hvmer.vmest &= ~HVM_VMEST_CAUSE_MSK;
454	regs->hvmer.vmest |= (TRAP_DEBUG << HVM_VMEST_CAUSE_SFT);
455	do_trap0(regs);
456}
457