[deliverable/linux.git] / arch / hexagon / kernel / traps.c

/*
 * Kernel traps/events for Hexagon processor
 *
 * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#include <linux/init.h>
#include <linux/sched.h>
#include <linux/module.h>
#include <linux/kallsyms.h>
#include <linux/kdebug.h>
#include <linux/syscalls.h>
#include <linux/signal.h>
#include <linux/tracehook.h>
#include <asm/traps.h>
#include <asm/vm_fault.h>
#include <asm/syscall.h>
#include <asm/registers.h>
#include <asm/unistd.h>
#include <asm/sections.h>
#ifdef CONFIG_KGDB
# include <linux/kgdb.h>
#endif

#define TRAP_SYSCALL	1
#define TRAP_DEBUG	0xdb

void __init trap_init(void)
{
}

#ifdef CONFIG_GENERIC_BUG
/* Maybe should resemble arch/sh/kernel/traps.c ?? */
int is_valid_bugaddr(unsigned long addr)
{
	return 1;
}
#endif /* CONFIG_GENERIC_BUG */

static const char *ex_name(int ex)
{
	switch (ex) {
	case HVM_GE_C_XPROT:
	case HVM_GE_C_XUSER:
		return "Execute protection fault";
	case HVM_GE_C_RPROT:
	case HVM_GE_C_RUSER:
		return "Read protection fault";
	case HVM_GE_C_WPROT:
	case HVM_GE_C_WUSER:
		return "Write protection fault";
	case HVM_GE_C_XMAL:
		return "Misaligned instruction";
	case HVM_GE_C_RMAL:
		return "Misaligned data load";
	case HVM_GE_C_WMAL:
		return "Misaligned data store";
	case HVM_GE_C_INVI:
	case HVM_GE_C_PRIVI:
		return "Illegal instruction";
	case HVM_GE_C_BUS:
		return "Precise bus error";
	case HVM_GE_C_CACHE:
		return "Cache error";

	case 0xdb:
		return "Debugger trap";

	default:
		return "Unrecognized exception";
	}
}

static void do_show_stack(struct task_struct *task, unsigned long *fp,
			  unsigned long ip)
{
	int kstack_depth_to_print = 24;
	unsigned long offset, size;
	const char *name = NULL;
	unsigned long *newfp;
	unsigned long low, high;
	char tmpstr[128];
	char *modname;
	int i;

	if (task == NULL)
		task = current;

	printk(KERN_INFO "CPU#%d, %s/%d, Call Trace:\n",
	       raw_smp_processor_id(), task->comm,
	       task_pid_nr(task));

	if (fp == NULL) {
		if (task == current) {
			asm("%0 = r30" : "=r" (fp));
		} else {
			fp = (unsigned long *)
			     ((struct hexagon_switch_stack *)
			     task->thread.switch_sp)->fp;
		}
	}

	if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) {
		printk(KERN_INFO "-- Corrupt frame pointer %p\n", fp);
		return;
	}

	/* Saved link reg is one word above FP */
	if (!ip)
		ip = *(fp+1);

	/* Expect kernel stack to be in-bounds */
	low = (unsigned long)task_stack_page(task);
	high = low + THREAD_SIZE - 8;
	low += sizeof(struct thread_info);

	for (i = 0; i < kstack_depth_to_print; i++) {

		name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);

		printk(KERN_INFO "[%p] 0x%lx: %s + 0x%lx", fp, ip, name,
			offset);
		if (((unsigned long) fp < low) || (high < (unsigned long) fp))
			printk(KERN_CONT " (FP out of bounds!)");
		if (modname)
			printk(KERN_CONT " [%s] ", modname);
		printk(KERN_CONT "\n");

		newfp = (unsigned long *) *fp;

		if (((unsigned long) newfp) & 0x3) {
			printk(KERN_INFO "-- Corrupt frame pointer %p\n",
				newfp);
			break;
		}

		/* Attempt to continue past exception. */
		if (0 == newfp) {
			struct pt_regs *regs = (struct pt_regs *) (((void *)fp)
						+ 8);

			if (regs->syscall_nr != -1) {
				printk(KERN_INFO "-- trap0 -- syscall_nr: %ld",
					regs->syscall_nr);
				printk(KERN_CONT "  psp: %lx  elr: %lx\n",
					 pt_psp(regs), pt_elr(regs));
				break;
			} else {
				/* really want to see more ... */
				kstack_depth_to_print += 6;
				printk(KERN_INFO "-- %s (0x%lx)  badva: %lx\n",
					ex_name(pt_cause(regs)), pt_cause(regs),
					pt_badva(regs));
			}

			newfp = (unsigned long *) regs->r30;
			ip = pt_elr(regs);
		} else {
			ip = *(newfp + 1);
		}

		/* If link reg is null, we are done. */
		if (ip == 0x0)
			break;

		/* If newfp isn't larger, we're tracing garbage. */
		if (newfp > fp)
			fp = newfp;
		else
			break;
	}
}

void show_stack(struct task_struct *task, unsigned long *fp)
{
	/* Saved link reg is one word above FP */
	do_show_stack(task, fp, 0);
}

void dump_stack(void)
{
	unsigned long *fp;
	asm("%0 = r30" : "=r" (fp));
	show_stack(current, fp);
}
EXPORT_SYMBOL(dump_stack);

int die(const char *str, struct pt_regs *regs, long err)
{
	static struct {
		spinlock_t lock;
		int counter;
	} die = {
		.lock = __SPIN_LOCK_UNLOCKED(die.lock),
		.counter = 0
	};

	console_verbose();
	oops_enter();

	spin_lock_irq(&die.lock);
	bust_spinlocks(1);
	printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);

	if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
	    NOTIFY_STOP)
		return 1;

	print_modules();
	show_regs(regs);
	do_show_stack(current, &regs->r30, pt_elr(regs));

	bust_spinlocks(0);
	add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);

	spin_unlock_irq(&die.lock);

	if (in_interrupt())
		panic("Fatal exception in interrupt");

	if (panic_on_oops)
		panic("Fatal exception");

	oops_exit();
	do_exit(err);
	return 0;
}

int die_if_kernel(char *str, struct pt_regs *regs, long err)
{
	if (!user_mode(regs))
		return die(str, regs, err);
	else
		return 0;
}

/*
 * It's not clear that misaligned fetches are ever recoverable.
 */
static void misaligned_instruction(struct pt_regs *regs)
{
	die_if_kernel("Misaligned Instruction", regs, 0);
	force_sig(SIGBUS, current);
}

/*
 * Misaligned loads and stores, on the other hand, can be
 * emulated, and probably should be, some day.  But for now
 * they will be considered fatal.
 */
static void misaligned_data_load(struct pt_regs *regs)
{
	die_if_kernel("Misaligned Data Load", regs, 0);
	force_sig(SIGBUS, current);
}

static void misaligned_data_store(struct pt_regs *regs)
{
	die_if_kernel("Misaligned Data Store", regs, 0);
	force_sig(SIGBUS, current);
}

static void illegal_instruction(struct pt_regs *regs)
{
	die_if_kernel("Illegal Instruction", regs, 0);
	force_sig(SIGILL, current);
}

/*
 * Precise bus errors may be recoverable with a a retry,
 * but for now, treat them as irrecoverable.
 */
static void precise_bus_error(struct pt_regs *regs)
{
	die_if_kernel("Precise Bus Error", regs, 0);
	force_sig(SIGBUS, current);
}

/*
 * If anything is to be done here other than panic,
 * it will probably be complex and migrate to another
 * source module.  For now, just die.
 */
static void cache_error(struct pt_regs *regs)
{
	die("Cache Error", regs, 0);
}

/*
 * General exception handler
 */
void do_genex(struct pt_regs *regs)
{
	/*
	 * Decode Cause and Dispatch
	 */
	switch (pt_cause(regs)) {
	case HVM_GE_C_XPROT:
	case HVM_GE_C_XUSER:
		execute_protection_fault(regs);
		break;
	case HVM_GE_C_RPROT:
	case HVM_GE_C_RUSER:
		read_protection_fault(regs);
		break;
	case HVM_GE_C_WPROT:
	case HVM_GE_C_WUSER:
		write_protection_fault(regs);
		break;
	case HVM_GE_C_XMAL:
		misaligned_instruction(regs);
		break;
	case HVM_GE_C_RMAL:
		misaligned_data_load(regs);
		break;
	case HVM_GE_C_WMAL:
		misaligned_data_store(regs);
		break;
	case HVM_GE_C_INVI:
	case HVM_GE_C_PRIVI:
		illegal_instruction(regs);
		break;
	case HVM_GE_C_BUS:
		precise_bus_error(regs);
		break;
	case HVM_GE_C_CACHE:
		cache_error(regs);
		break;
	default:
		/* Halt and catch fire */
		panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
		break;
	}
}

/* Indirect system call dispatch */
long sys_syscall(void)
{
	printk(KERN_ERR "sys_syscall invoked!\n");
	return -ENOSYS;
}

void do_trap0(struct pt_regs *regs)
{
	unsigned long syscallret = 0;
	syscall_fn syscall;

	switch (pt_cause(regs)) {
	case TRAP_SYSCALL:
		/* System call is trap0 #1 */

		/* allow strace to catch syscall args  */
		if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
			tracehook_report_syscall_entry(regs)))
			return;  /*  return -ENOSYS somewhere?  */

		/* Interrupts should be re-enabled for syscall processing */
		__vmsetie(VM_INT_ENABLE);

		/*
		 * System call number is in r6, arguments in r0..r5.
		 * Fortunately, no Linux syscall has more than 6 arguments,
		 * and Hexagon ABI passes first 6 arguments in registers.
		 * 64-bit arguments are passed in odd/even register pairs.
		 * Fortunately, we have no system calls that take more
		 * than three arguments with more than one 64-bit value.
		 * Should that change, we'd need to redesign to copy
		 * between user and kernel stacks.
		 */
		regs->syscall_nr = regs->r06;

		/*
		 * GPR R0 carries the first parameter, and is also used
		 * to report the return value.  We need a backup of
		 * the user's value in case we need to do a late restart
		 * of the system call.
		 */
		regs->restart_r0 = regs->r00;

		if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
			regs->r00 = -1;
		} else {
			syscall = (syscall_fn)
				  (sys_call_table[regs->syscall_nr]);
			syscallret = syscall(regs->r00, regs->r01,
				   regs->r02, regs->r03,
				   regs->r04, regs->r05);
		}

		/*
		 * If it was a sigreturn system call, don't overwrite
		 * r0 value in stack frame with return value.
		 *
		 * __NR_sigreturn doesn't seem to exist in new unistd.h
		 */

		if (regs->syscall_nr != __NR_rt_sigreturn)
			regs->r00 = syscallret;

		/* allow strace to get the syscall return state  */
		if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
			tracehook_report_syscall_exit(regs, 0);

		break;
	case TRAP_DEBUG:
		/* Trap0 0xdb is debug breakpoint */
		if (user_mode(regs)) {
			struct siginfo info;

			info.si_signo = SIGTRAP;
			info.si_errno = 0;
			/*
			 * Some architecures add some per-thread state
			 * to distinguish between breakpoint traps and
			 * trace traps.  We may want to do that, and
			 * set the si_code value appropriately, or we
			 * may want to use a different trap0 flavor.
			 */
			info.si_code = TRAP_BRKPT;
			info.si_addr = (void __user *) pt_elr(regs);
			send_sig_info(SIGTRAP, &info, current);
		} else {
#ifdef CONFIG_KGDB
			kgdb_handle_exception(pt_cause(regs), SIGTRAP,
					      TRAP_BRKPT, regs);
#endif
		}
		break;
	}
	/* Ignore other trap0 codes for now, especially 0 (Angel calls) */
}

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