[mirror_ubuntu-bionic-kernel.git] / arch / tile / kernel / traps.c

/*
 * Copyright 2010 Tilera Corporation. 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
 *   as published by the Free Software Foundation, version 2.
 *
 *   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, GOOD TITLE or
 *   NON INFRINGEMENT.  See the GNU General Public License for
 *   more details.
 */

#include <linux/sched.h>
#include <linux/sched/debug.h>
#include <linux/kernel.h>
#include <linux/kprobes.h>
#include <linux/kdebug.h>
#include <linux/module.h>
#include <linux/reboot.h>
#include <linux/uaccess.h>
#include <linux/ptrace.h>
#include <linux/hardirq.h>
#include <linux/nmi.h>
#include <asm/stack.h>
#include <asm/traps.h>
#include <asm/setup.h>

#include <arch/interrupts.h>
#include <arch/spr_def.h>
#include <arch/opcode.h>

void __init trap_init(void)
{
	/* Nothing needed here since we link code at .intrpt */
}

int unaligned_fixup = 1;

static int __init setup_unaligned_fixup(char *str)
{
	/*
	 * Say "=-1" to completely disable it.  If you just do "=0", we
	 * will still parse the instruction, then fire a SIGBUS with
	 * the correct address from inside the single_step code.
	 */
	if (kstrtoint(str, 0, &unaligned_fixup) != 0)
		return 0;

	pr_info("Fixups for unaligned data accesses are %s\n",
		unaligned_fixup >= 0 ?
		(unaligned_fixup ? "enabled" : "disabled") :
		"completely disabled");
	return 1;
}
__setup("unaligned_fixup=", setup_unaligned_fixup);

#if CHIP_HAS_TILE_DMA()

static int dma_disabled;

static int __init nodma(char *str)
{
	pr_info("User-space DMA is disabled\n");
	dma_disabled = 1;
	return 1;
}
__setup("nodma", nodma);

/* How to decode SPR_GPV_REASON */
#define IRET_ERROR (1U << 31)
#define MT_ERROR   (1U << 30)
#define MF_ERROR   (1U << 29)
#define SPR_INDEX  ((1U << 15) - 1)
#define SPR_MPL_SHIFT  9  /* starting bit position for MPL encoded in SPR */

/*
 * See if this GPV is just to notify the kernel of SPR use and we can
 * retry the user instruction after adjusting some MPLs suitably.
 */
static int retry_gpv(unsigned int gpv_reason)
{
	int mpl;

	if (gpv_reason & IRET_ERROR)
		return 0;

	BUG_ON((gpv_reason & (MT_ERROR|MF_ERROR)) == 0);
	mpl = (gpv_reason & SPR_INDEX) >> SPR_MPL_SHIFT;
	if (mpl == INT_DMA_NOTIFY && !dma_disabled) {
		/* User is turning on DMA. Allow it and retry. */
		printk(KERN_DEBUG "Process %d/%s is now enabled for DMA\n",
		       current->pid, current->comm);
		BUG_ON(current->thread.tile_dma_state.enabled);
		current->thread.tile_dma_state.enabled = 1;
		grant_dma_mpls();
		return 1;
	}

	return 0;
}

#endif /* CHIP_HAS_TILE_DMA() */

extern tile_bundle_bits bpt_code;

asm(".pushsection .rodata.bpt_code,\"a\";"
    ".align 8;"
    "bpt_code: bpt;"
    ".size bpt_code,.-bpt_code;"
    ".popsection");

static int special_ill(tile_bundle_bits bundle, int *sigp, int *codep)
{
	int sig, code, maxcode;

	if (bundle == bpt_code) {
		*sigp = SIGTRAP;
		*codep = TRAP_BRKPT;
		return 1;
	}

	/* If it's a "raise" bundle, then "ill" must be in pipe X1. */
#ifdef __tilegx__
	if ((bundle & TILEGX_BUNDLE_MODE_MASK) != 0)
		return 0;
	if (get_Opcode_X1(bundle) != RRR_0_OPCODE_X1)
		return 0;
	if (get_RRROpcodeExtension_X1(bundle) != UNARY_RRR_0_OPCODE_X1)
		return 0;
	if (get_UnaryOpcodeExtension_X1(bundle) != ILL_UNARY_OPCODE_X1)
		return 0;
#else
	if (bundle & TILEPRO_BUNDLE_Y_ENCODING_MASK)
		return 0;
	if (get_Opcode_X1(bundle) != SHUN_0_OPCODE_X1)
		return 0;
	if (get_UnShOpcodeExtension_X1(bundle) != UN_0_SHUN_0_OPCODE_X1)
		return 0;
	if (get_UnOpcodeExtension_X1(bundle) != ILL_UN_0_SHUN_0_OPCODE_X1)
		return 0;
#endif

	/* Check that the magic distinguishers are set to mean "raise". */
	if (get_Dest_X1(bundle) != 29 || get_SrcA_X1(bundle) != 37)
		return 0;

	/* There must be an "addli zero, zero, VAL" in X0. */
	if (get_Opcode_X0(bundle) != ADDLI_OPCODE_X0)
		return 0;
	if (get_Dest_X0(bundle) != TREG_ZERO)
		return 0;
	if (get_SrcA_X0(bundle) != TREG_ZERO)
		return 0;

	/*
	 * Validate the proposed signal number and si_code value.
	 * Note that we embed these in the static instruction itself
	 * so that we perturb the register state as little as possible
	 * at the time of the actual fault; it's unlikely you'd ever
	 * need to dynamically choose which kind of fault to raise
	 * from user space.
	 */
	sig = get_Imm16_X0(bundle) & 0x3f;
	switch (sig) {
	case SIGILL:
		maxcode = NSIGILL;
		break;
	case SIGFPE:
		maxcode = NSIGFPE;
		break;
	case SIGSEGV:
		maxcode = NSIGSEGV;
		break;
	case SIGBUS:
		maxcode = NSIGBUS;
		break;
	case SIGTRAP:
		maxcode = NSIGTRAP;
		break;
	default:
		return 0;
	}
	code = (get_Imm16_X0(bundle) >> 6) & 0xf;
	if (code <= 0 || code > maxcode)
		return 0;

	/* Make it the requested signal. */
	*sigp = sig;
	*codep = code | __SI_FAULT;
	return 1;
}

static const char *const int_name[] = {
	[INT_MEM_ERROR] = "Memory error",
	[INT_ILL] = "Illegal instruction",
	[INT_GPV] = "General protection violation",
	[INT_UDN_ACCESS] = "UDN access",
	[INT_IDN_ACCESS] = "IDN access",
#if CHIP_HAS_SN()
	[INT_SN_ACCESS] = "SN access",
#endif
	[INT_SWINT_3] = "Software interrupt 3",
	[INT_SWINT_2] = "Software interrupt 2",
	[INT_SWINT_0] = "Software interrupt 0",
	[INT_UNALIGN_DATA] = "Unaligned data",
	[INT_DOUBLE_FAULT] = "Double fault",
#ifdef __tilegx__
	[INT_ILL_TRANS] = "Illegal virtual address",
#endif
};

static int do_bpt(struct pt_regs *regs)
{
	unsigned long bundle, bcode, bpt;

	bundle = *(unsigned long *)instruction_pointer(regs);

	/*
	 * bpt shoule be { bpt; nop }, which is 0x286a44ae51485000ULL.
	 * we encode the unused least significant bits for other purpose.
	 */
	bpt = bundle & ~((1ULL << 12) - 1);
	if (bpt != TILE_BPT_BUNDLE)
		return 0;

	bcode = bundle & ((1ULL << 12) - 1);
	/*
	 * notify the kprobe handlers, if instruction is likely to
	 * pertain to them.
	 */
	switch (bcode) {
	/* breakpoint_insn */
	case 0:
		notify_die(DIE_BREAK, "debug", regs, bundle,
			INT_ILL, SIGTRAP);
		break;
	/* compiled_bpt */
	case DIE_COMPILED_BPT:
		notify_die(DIE_COMPILED_BPT, "debug", regs, bundle,
			INT_ILL, SIGTRAP);
		break;
	/* breakpoint2_insn */
	case DIE_SSTEPBP:
		notify_die(DIE_SSTEPBP, "single_step", regs, bundle,
			INT_ILL, SIGTRAP);
		break;
	default:
		return 0;
	}

	return 1;
}

void __kprobes do_trap(struct pt_regs *regs, int fault_num,
		       unsigned long reason)
{
	siginfo_t info = { 0 };
	int signo, code;
	unsigned long address = 0;
	tile_bundle_bits instr;
	int is_kernel = !user_mode(regs);

	/* Handle breakpoints, etc. */
	if (is_kernel && fault_num == INT_ILL && do_bpt(regs))
		return;

	/* Re-enable interrupts, if they were previously enabled. */
	if (!(regs->flags & PT_FLAGS_DISABLE_IRQ))
		local_irq_enable();

	/*
	 * If it hits in kernel mode and we can't fix it up, just exit the
	 * current process and hope for the best.
	 */
	if (is_kernel) {
		const char *name;
		char buf[100];
		if (fixup_exception(regs))  /* ILL_TRANS or UNALIGN_DATA */
			return;
		if (fault_num >= 0 &&
		    fault_num < ARRAY_SIZE(int_name) &&
		    int_name[fault_num] != NULL)
			name = int_name[fault_num];
		else
			name = "Unknown interrupt";
		if (fault_num == INT_GPV)
			snprintf(buf, sizeof(buf), "; GPV_REASON %#lx", reason);
#ifdef __tilegx__
		else if (fault_num == INT_ILL_TRANS)
			snprintf(buf, sizeof(buf), "; address %#lx", reason);
#endif
		else
			buf[0] = '\0';
		pr_alert("Kernel took bad trap %d (%s) at PC %#lx%s\n",
			 fault_num, name, regs->pc, buf);
		show_regs(regs);
		do_exit(SIGKILL);  /* FIXME: implement i386 die() */
	}

	switch (fault_num) {
	case INT_MEM_ERROR:
		signo = SIGBUS;
		code = BUS_OBJERR;
		break;
	case INT_ILL:
		if (copy_from_user(&instr, (void __user *)regs->pc,
				   sizeof(instr))) {
			pr_err("Unreadable instruction for INT_ILL: %#lx\n",
			       regs->pc);
			do_exit(SIGKILL);
		}
		if (!special_ill(instr, &signo, &code)) {
			signo = SIGILL;
			code = ILL_ILLOPC;
		}
		address = regs->pc;
		break;
	case INT_GPV:
#if CHIP_HAS_TILE_DMA()
		if (retry_gpv(reason))
			return;
#endif
		/*FALLTHROUGH*/
	case INT_UDN_ACCESS:
	case INT_IDN_ACCESS:
#if CHIP_HAS_SN()
	case INT_SN_ACCESS:
#endif
		signo = SIGILL;
		code = ILL_PRVREG;
		address = regs->pc;
		break;
	case INT_SWINT_3:
	case INT_SWINT_2:
	case INT_SWINT_0:
		signo = SIGILL;
		code = ILL_ILLTRP;
		address = regs->pc;
		break;
	case INT_UNALIGN_DATA:
#ifndef __tilegx__  /* Emulated support for single step debugging */
		if (unaligned_fixup >= 0) {
			struct single_step_state *state =
				current_thread_info()->step_state;
			if (!state ||
			    (void __user *)(regs->pc) != state->buffer) {
				single_step_once(regs);
				return;
			}
		}
#endif
		signo = SIGBUS;
		code = BUS_ADRALN;
		address = 0;
		break;
	case INT_DOUBLE_FAULT:
		/*
		 * For double fault, "reason" is actually passed as
		 * SYSTEM_SAVE_K_2, the hypervisor's double-fault info, so
		 * we can provide the original fault number rather than
		 * the uninteresting "INT_DOUBLE_FAULT" so the user can
		 * learn what actually struck while PL0 ICS was set.
		 */
		fault_num = reason;
		signo = SIGILL;
		code = ILL_DBLFLT;
		address = regs->pc;
		break;
#ifdef __tilegx__
	case INT_ILL_TRANS: {
		/* Avoid a hardware erratum with the return address stack. */
		fill_ra_stack();

		signo = SIGSEGV;
		address = reason;
		code = SEGV_MAPERR;
		break;
	}
#endif
	default:
		panic("Unexpected do_trap interrupt number %d", fault_num);
	}

	info.si_signo = signo;
	info.si_code = code;
	info.si_addr = (void __user *)address;
	if (signo == SIGILL)
		info.si_trapno = fault_num;
	if (signo != SIGTRAP)
		trace_unhandled_signal("trap", regs, address, signo);
	force_sig_info(signo, &info, current);
}

void do_nmi(struct pt_regs *regs, int fault_num, unsigned long reason)
{
	nmi_enter();
	switch (reason) {
#ifdef arch_trigger_cpumask_backtrace
	case TILE_NMI_DUMP_STACK:
		nmi_cpu_backtrace(regs);
		break;
#endif
	default:
		panic("Unexpected do_nmi type %ld", reason);
	}
	nmi_exit();
}

/* Deprecated function currently only used here. */
extern void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52);

void kernel_double_fault(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
{
	_dump_stack(dummy, pc, lr, sp, r52);
	pr_emerg("Double fault: exiting\n");
	machine_halt();
}
Commit	Line	Data
867e359b CM	1	/*
	2	* Copyright 2010 Tilera Corporation. All Rights Reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation, version 2.
	7	*
	8	* This program is distributed in the hope that it will be useful, but
	9	* WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
	11	* NON INFRINGEMENT. See the GNU General Public License for
	12	* more details.
	13	*/
	14
	15	#include <linux/sched.h>
b17b0153	16	#include <linux/sched/debug.h>
867e359b CM	17	#include <linux/kernel.h>
867e359b CM	18	#include <linux/kprobes.h>
3fa17c39	19	#include <linux/kdebug.h>
867e359b CM	20	#include <linux/module.h>
	21	#include <linux/reboot.h>
	22	#include <linux/uaccess.h>
	23	#include <linux/ptrace.h>
511f8389 CM	24	#include <linux/hardirq.h>
511f8389 CM	25	#include <linux/nmi.h>
0707ad30 CM	26	#include <asm/stack.h>
0707ad30 CM	27	#include <asm/traps.h>
bd119c69	28	#include <asm/setup.h>
867e359b CM	29
	30	#include <arch/interrupts.h>
	31	#include <arch/spr_def.h>
eb7c792d	32	#include <arch/opcode.h>
867e359b CM	33
	34	void __init trap_init(void)
	35	{
acbde1db	36	/* Nothing needed here since we link code at .intrpt */
867e359b CM	37	}
	38
	39	int unaligned_fixup = 1;
	40
	41	static int __init setup_unaligned_fixup(char *str)
	42	{
	43	/*
	44	* Say "=-1" to completely disable it. If you just do "=0", we
	45	* will still parse the instruction, then fire a SIGBUS with
	46	* the correct address from inside the single_step code.
	47	*/
b2dfa048	48	if (kstrtoint(str, 0, &unaligned_fixup) != 0)
867e359b	49	return 0;
b2dfa048	50
0707ad30	51	pr_info("Fixups for unaligned data accesses are %s\n",
f4743673 JP	52	unaligned_fixup >= 0 ?
	53	(unaligned_fixup ? "enabled" : "disabled") :
	54	"completely disabled");
867e359b CM	55	return 1;
	56	}
	57	__setup("unaligned_fixup=", setup_unaligned_fixup);
	58
	59	#if CHIP_HAS_TILE_DMA()
	60
	61	static int dma_disabled;
	62
	63	static int __init nodma(char *str)
	64	{
0707ad30	65	pr_info("User-space DMA is disabled\n");
867e359b CM	66	dma_disabled = 1;
	67	return 1;
	68	}
	69	__setup("nodma", nodma);
	70
	71	/* How to decode SPR_GPV_REASON */
	72	#define IRET_ERROR (1U << 31)
	73	#define MT_ERROR (1U << 30)
	74	#define MF_ERROR (1U << 29)
	75	#define SPR_INDEX ((1U << 15) - 1)
	76	#define SPR_MPL_SHIFT 9 /* starting bit position for MPL encoded in SPR */
	77
	78	/*
	79	* See if this GPV is just to notify the kernel of SPR use and we can
	80	* retry the user instruction after adjusting some MPLs suitably.
	81	*/
	82	static int retry_gpv(unsigned int gpv_reason)
	83	{
	84	int mpl;
	85
	86	if (gpv_reason & IRET_ERROR)
	87	return 0;
	88
	89	BUG_ON((gpv_reason & (MT_ERROR\|MF_ERROR)) == 0);
	90	mpl = (gpv_reason & SPR_INDEX) >> SPR_MPL_SHIFT;
	91	if (mpl == INT_DMA_NOTIFY && !dma_disabled) {
	92	/* User is turning on DMA. Allow it and retry. */
	93	printk(KERN_DEBUG "Process %d/%s is now enabled for DMA\n",
	94	current->pid, current->comm);
	95	BUG_ON(current->thread.tile_dma_state.enabled);
	96	current->thread.tile_dma_state.enabled = 1;
	97	grant_dma_mpls();
	98	return 1;
	99	}
	100
	101	return 0;
	102	}
	103
	104	#endif /* CHIP_HAS_TILE_DMA() */
	105
a0099303	106	extern tile_bundle_bits bpt_code;
0707ad30 CM	107
	108	asm(".pushsection .rodata.bpt_code,\"a\";"
	109	".align 8;"
	110	"bpt_code: bpt;"
	111	".size bpt_code,.-bpt_code;"
	112	".popsection");
	113
a0099303	114	static int special_ill(tile_bundle_bits bundle, int sigp, int codep)
0707ad30 CM	115	{
	116	int sig, code, maxcode;
	117
	118	if (bundle == bpt_code) {
	119	*sigp = SIGTRAP;
	120	*codep = TRAP_BRKPT;
	121	return 1;
	122	}
	123
	124	/* If it's a "raise" bundle, then "ill" must be in pipe X1. */
	125	#ifdef __tilegx__
	126	if ((bundle & TILEGX_BUNDLE_MODE_MASK) != 0)
	127	return 0;
1fcbe027 CM	128	if (get_Opcode_X1(bundle) != RRR_0_OPCODE_X1)
	129	return 0;
	130	if (get_RRROpcodeExtension_X1(bundle) != UNARY_RRR_0_OPCODE_X1)
0707ad30 CM	131	return 0;
	132	if (get_UnaryOpcodeExtension_X1(bundle) != ILL_UNARY_OPCODE_X1)
	133	return 0;
	134	#else
eb7c792d	135	if (bundle & TILEPRO_BUNDLE_Y_ENCODING_MASK)
0707ad30 CM	136	return 0;
	137	if (get_Opcode_X1(bundle) != SHUN_0_OPCODE_X1)
	138	return 0;
	139	if (get_UnShOpcodeExtension_X1(bundle) != UN_0_SHUN_0_OPCODE_X1)
	140	return 0;
	141	if (get_UnOpcodeExtension_X1(bundle) != ILL_UN_0_SHUN_0_OPCODE_X1)
	142	return 0;
	143	#endif
	144
	145	/* Check that the magic distinguishers are set to mean "raise". */
	146	if (get_Dest_X1(bundle) != 29 \|\| get_SrcA_X1(bundle) != 37)
	147	return 0;
	148
	149	/* There must be an "addli zero, zero, VAL" in X0. */
	150	if (get_Opcode_X0(bundle) != ADDLI_OPCODE_X0)
	151	return 0;
	152	if (get_Dest_X0(bundle) != TREG_ZERO)
	153	return 0;
	154	if (get_SrcA_X0(bundle) != TREG_ZERO)
	155	return 0;
	156
	157	/*
	158	* Validate the proposed signal number and si_code value.
	159	* Note that we embed these in the static instruction itself
	160	* so that we perturb the register state as little as possible
	161	* at the time of the actual fault; it's unlikely you'd ever
	162	* need to dynamically choose which kind of fault to raise
	163	* from user space.
	164	*/
	165	sig = get_Imm16_X0(bundle) & 0x3f;
	166	switch (sig) {
	167	case SIGILL:
	168	maxcode = NSIGILL;
	169	break;
	170	case SIGFPE:
	171	maxcode = NSIGFPE;
	172	break;
	173	case SIGSEGV:
	174	maxcode = NSIGSEGV;
	175	break;
	176	case SIGBUS:
	177	maxcode = NSIGBUS;
	178	break;
	179	case SIGTRAP:
	180	maxcode = NSIGTRAP;
	181	break;
	182	default:
	183	return 0;
	184	}
	185	code = (get_Imm16_X0(bundle) >> 6) & 0xf;
	186	if (code <= 0 \|\| code > maxcode)
	187	return 0;
	188
	189	/* Make it the requested signal. */
	190	*sigp = sig;
	191	*codep = code \| __SI_FAULT;
	192	return 1;
	193	}
	194
c6f696f6 CM	195	static const char *const int_name[] = {
	196	[INT_MEM_ERROR] = "Memory error",
	197	[INT_ILL] = "Illegal instruction",
	198	[INT_GPV] = "General protection violation",
	199	[INT_UDN_ACCESS] = "UDN access",
	200	[INT_IDN_ACCESS] = "IDN access",
	201	#if CHIP_HAS_SN()
	202	[INT_SN_ACCESS] = "SN access",
	203	#endif
	204	[INT_SWINT_3] = "Software interrupt 3",
	205	[INT_SWINT_2] = "Software interrupt 2",
	206	[INT_SWINT_0] = "Software interrupt 0",
	207	[INT_UNALIGN_DATA] = "Unaligned data",
	208	[INT_DOUBLE_FAULT] = "Double fault",
	209	#ifdef __tilegx__
	210	[INT_ILL_TRANS] = "Illegal virtual address",
	211	#endif
	212	};
	213
3fa17c39 TL	214	static int do_bpt(struct pt_regs *regs)
	215	{
	216	unsigned long bundle, bcode, bpt;
	217
	218	bundle = (unsigned long )instruction_pointer(regs);
	219
	220	/*
	221	* bpt shoule be { bpt; nop }, which is 0x286a44ae51485000ULL.
	222	* we encode the unused least significant bits for other purpose.
	223	*/
	224	bpt = bundle & ~((1ULL << 12) - 1);
	225	if (bpt != TILE_BPT_BUNDLE)
	226	return 0;
	227
	228	bcode = bundle & ((1ULL << 12) - 1);
	229	/*
	230	* notify the kprobe handlers, if instruction is likely to
	231	* pertain to them.
	232	*/
	233	switch (bcode) {
	234	/* breakpoint_insn */
	235	case 0:
	236	notify_die(DIE_BREAK, "debug", regs, bundle,
	237	INT_ILL, SIGTRAP);
	238	break;
8157107b CM	239	/* compiled_bpt */
	240	case DIE_COMPILED_BPT:
	241	notify_die(DIE_COMPILED_BPT, "debug", regs, bundle,
	242	INT_ILL, SIGTRAP);
	243	break;
3fa17c39 TL	244	/* breakpoint2_insn */
	245	case DIE_SSTEPBP:
	246	notify_die(DIE_SSTEPBP, "single_step", regs, bundle,
	247	INT_ILL, SIGTRAP);
	248	break;
	249	default:
	250	return 0;
	251	}
	252
	253	return 1;
	254	}
	255
867e359b CM	256	void __kprobes do_trap(struct pt_regs *regs, int fault_num,
	257	unsigned long reason)
	258	{
	259	siginfo_t info = { 0 };
	260	int signo, code;
a714ffff	261	unsigned long address = 0;
a0099303	262	tile_bundle_bits instr;
3fa17c39 TL	263	int is_kernel = !user_mode(regs);
	264
	265	/* Handle breakpoints, etc. */
	266	if (is_kernel && fault_num == INT_ILL && do_bpt(regs))
1bb50cad	267	return;
867e359b	268
70d2b595 CM	269	/* Re-enable interrupts, if they were previously enabled. */
	270	if (!(regs->flags & PT_FLAGS_DISABLE_IRQ))
	271	local_irq_enable();
867e359b CM	272
	273	/*
	274	* If it hits in kernel mode and we can't fix it up, just exit the
	275	* current process and hope for the best.
	276	*/
3fa17c39	277	if (is_kernel) {
c6f696f6	278	const char *name;
70d2b595 CM	279	char buf[100];
70d2b595 CM	280	if (fixup_exception(regs)) /* ILL_TRANS or UNALIGN_DATA */
1bb50cad	281	return;
c6f696f6	282	if (fault_num >= 0 &&
367b9380	283	fault_num < ARRAY_SIZE(int_name) &&
c6f696f6 CM	284	int_name[fault_num] != NULL)
	285	name = int_name[fault_num];
	286	else
	287	name = "Unknown interrupt";
867e359b	288	if (fault_num == INT_GPV)
70d2b595 CM	289	snprintf(buf, sizeof(buf), "; GPV_REASON %#lx", reason);
	290	#ifdef __tilegx__
	291	else if (fault_num == INT_ILL_TRANS)
	292	snprintf(buf, sizeof(buf), "; address %#lx", reason);
	293	#endif
	294	else
	295	buf[0] = '\0';
	296	pr_alert("Kernel took bad trap %d (%s) at PC %#lx%s\n",
	297	fault_num, name, regs->pc, buf);
867e359b CM	298	show_regs(regs);
867e359b CM	299	do_exit(SIGKILL); /* FIXME: implement i386 die() */
867e359b CM	300	}
	301
	302	switch (fault_num) {
a714ffff CM	303	case INT_MEM_ERROR:
	304	signo = SIGBUS;
	305	code = BUS_OBJERR;
	306	break;
867e359b	307	case INT_ILL:
0707ad30 CM	308	if (copy_from_user(&instr, (void __user *)regs->pc,
0707ad30 CM	309	sizeof(instr))) {
f4743673 JP	310	pr_err("Unreadable instruction for INT_ILL: %#lx\n",
f4743673 JP	311	regs->pc);
867e359b	312	do_exit(SIGKILL);
867e359b	313	}
0707ad30	314	if (!special_ill(instr, &signo, &code)) {
867e359b CM	315	signo = SIGILL;
	316	code = ILL_ILLOPC;
	317	}
	318	address = regs->pc;
	319	break;
	320	case INT_GPV:
	321	#if CHIP_HAS_TILE_DMA()
	322	if (retry_gpv(reason))
1bb50cad	323	return;
867e359b CM	324	#endif
	325	/FALLTHROUGH/
	326	case INT_UDN_ACCESS:
	327	case INT_IDN_ACCESS:
	328	#if CHIP_HAS_SN()
	329	case INT_SN_ACCESS:
	330	#endif
	331	signo = SIGILL;
	332	code = ILL_PRVREG;
	333	address = regs->pc;
	334	break;
	335	case INT_SWINT_3:
	336	case INT_SWINT_2:
	337	case INT_SWINT_0:
	338	signo = SIGILL;
	339	code = ILL_ILLTRP;
	340	address = regs->pc;
	341	break;
	342	case INT_UNALIGN_DATA:
233325b9	343	#ifndef __tilegx__ /* Emulated support for single step debugging */
867e359b CM	344	if (unaligned_fixup >= 0) {
	345	struct single_step_state *state =
	346	current_thread_info()->step_state;
0707ad30 CM	347	if (!state \|\|
0707ad30 CM	348	(void __user *)(regs->pc) != state->buffer) {
867e359b	349	single_step_once(regs);
1bb50cad	350	return;
867e359b CM	351	}
	352	}
	353	#endif
	354	signo = SIGBUS;
	355	code = BUS_ADRALN;
	356	address = 0;
	357	break;
	358	case INT_DOUBLE_FAULT:
	359	/*
	360	* For double fault, "reason" is actually passed as
a78c942d	361	* SYSTEM_SAVE_K_2, the hypervisor's double-fault info, so
867e359b CM	362	* we can provide the original fault number rather than
	363	* the uninteresting "INT_DOUBLE_FAULT" so the user can
	364	* learn what actually struck while PL0 ICS was set.
	365	*/
	366	fault_num = reason;
	367	signo = SIGILL;
	368	code = ILL_DBLFLT;
	369	address = regs->pc;
	370	break;
	371	#ifdef __tilegx__
e1723538 CM	372	case INT_ILL_TRANS: {
	373	/* Avoid a hardware erratum with the return address stack. */
	374	fill_ra_stack();
	375
867e359b	376	signo = SIGSEGV;
70d2b595	377	address = reason;
867e359b	378	code = SEGV_MAPERR;
867e359b	379	break;
e1723538	380	}
867e359b CM	381	#endif
	382	default:
	383	panic("Unexpected do_trap interrupt number %d", fault_num);
867e359b CM	384	}
	385
	386	info.si_signo = signo;
	387	info.si_code = code;
0707ad30	388	info.si_addr = (void __user *)address;
867e359b CM	389	if (signo == SIGILL)
867e359b CM	390	info.si_trapno = fault_num;
a714ffff CM	391	if (signo != SIGTRAP)
a714ffff CM	392	trace_unhandled_signal("trap", regs, address, signo);
867e359b CM	393	force_sig_info(signo, &info, current);
	394	}
	395
e5701b74 CM	396	void do_nmi(struct pt_regs *regs, int fault_num, unsigned long reason)
e5701b74 CM	397	{
511f8389	398	nmi_enter();
e5701b74	399	switch (reason) {
511f8389	400	#ifdef arch_trigger_cpumask_backtrace
e5701b74	401	case TILE_NMI_DUMP_STACK:
511f8389	402	nmi_cpu_backtrace(regs);
e5701b74	403	break;
511f8389	404	#endif
e5701b74 CM	405	default:
e5701b74 CM	406	panic("Unexpected do_nmi type %ld", reason);
e5701b74	407	}
511f8389	408	nmi_exit();
e5701b74 CM	409	}
e5701b74 CM	410
47ad7b9b CM	411	/* Deprecated function currently only used here. */
	412	extern void _dump_stack(int dummy, ulong pc, ulong lr, ulong sp, ulong r52);
	413
867e359b CM	414	void kernel_double_fault(int dummy, ulong pc, ulong lr, ulong sp, ulong r52)
	415	{
	416	_dump_stack(dummy, pc, lr, sp, r52);
0707ad30	417	pr_emerg("Double fault: exiting\n");
867e359b CM	418	machine_halt();
867e359b CM	419	}