[linux-2.6-block.git] / arch / hexagon / kernel / traps.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Kernel traps/events for Hexagon processor
 *
 * Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
 */

#include <linux/init.h>
#include <linux/sched/signal.h>
#include <linux/sched/debug.h>
#include <linux/sched/task_stack.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_WREG:
		return "Multiple writes to same register in packet";
	case HVM_GE_C_PCAL:
		return "Program counter values that are not properly aligned";
	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);
}

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_WREG:
		illegal_instruction(regs);
		break;
	case HVM_GE_C_PCAL:
		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)
{
	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]);
			regs->r00 = syscall(regs->r00, regs->r01,
				   regs->r02, regs->r03,
				   regs->r04, regs->r05);
		}

		/* 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)) {
			/*
			 * 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.
			 */
			force_sig_fault(SIGTRAP, TRAP_BRKPT,
					(void __user *) pt_elr(regs), 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();
}

/*
 * Treat this like the old 0xdb trap.
 */

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