/* * arch/xtensa/kernel/traps.c * * Exception handling. * * Derived from code with the following copyrights: * Copyright (C) 1994 - 1999 by Ralf Baechle * Modified for R3000 by Paul M. Antoine, 1995, 1996 * Complete output from die() by Ulf Carlsson, 1998 * Copyright (C) 1999 Silicon Graphics, Inc. * * Essentially rewritten for the Xtensa architecture port. * * Copyright (C) 2001 - 2013 Tensilica Inc. * * Joe Taylor	<joe@tensilica.com, joetylr@yahoo.com> * Chris Zankel	<chris@zankel.net> * Marc Gauthier<marc@tensilica.com, marc@alumni.uwaterloo.ca> * Kevin Chea * * This file is subject to the terms and conditions of the GNU General Public * License.  See the file "COPYING" in the main directory of this archive * for more details. */ #include <linux/cpu.h>#include <linux/kernel.h>#include <linux/sched/signal.h>#include <linux/sched/debug.h>#include <linux/sched/task_stack.h>#include <linux/init.h>#include <linux/module.h>#include <linux/stringify.h>#include <linux/kallsyms.h>#include <linux/delay.h>#include <linux/hardirq.h>#include <linux/ratelimit.h>#include <linux/pgtable.h> #include <asm/stacktrace.h>#include <asm/ptrace.h>#include <asm/timex.h>#include <linux/uaccess.h>#include <asm/processor.h>#include <asm/traps.h>#include <asm/hw_breakpoint.h> /* * Machine specific interrupt handlers */ static void do_illegal_instruction(struct pt_regs *regs);static void do_div0(struct pt_regs *regs);static void do_interrupt(struct pt_regs *regs);#if XTENSA_FAKE_NMIstatic void do_nmi(struct pt_regs *regs);#endif#ifdef CONFIG_XTENSA_LOAD_STOREstatic void do_load_store(struct pt_regs *regs);#endifstatic void do_unaligned_user(struct pt_regs *regs);static void do_multihit(struct pt_regs *regs);#if XTENSA_HAVE_COPROCESSORSstatic void do_coprocessor(struct pt_regs *regs);#endifstatic void do_debug(struct pt_regs *regs); /* * The vector table must be preceded by a save area (which * implies it must be in RAM, unless one places RAM immediately * before a ROM and puts the vector at the start of the ROM (!)) */ #define KRNL		0x01#define USER		0x02 #define COPROCESSOR(x)							\{ EXCCAUSE_COPROCESSOR ## x ## _DISABLED, USER|KRNL, fast_coprocessor },\{ EXCCAUSE_COPROCESSOR ## x ## _DISABLED, 0, do_coprocessor } typedef struct {	int cause;	int fast;	void* handler;} dispatch_init_table_t; static dispatch_init_table_t __initdata dispatch_init_table[] = { #ifdef CONFIG_USER_ABI_CALL0_PROBE{ EXCCAUSE_ILLEGAL_INSTRUCTION,	USER,	   fast_illegal_instruction_user },#endif{ EXCCAUSE_ILLEGAL_INSTRUCTION,	0,	   do_illegal_instruction},{ EXCCAUSE_SYSTEM_CALL,		USER,	   fast_syscall_user },{ EXCCAUSE_SYSTEM_CALL,		0,	   system_call },/* EXCCAUSE_INSTRUCTION_FETCH unhandled */#ifdef CONFIG_XTENSA_LOAD_STORE{ EXCCAUSE_LOAD_STORE_ERROR,	USER|KRNL, fast_load_store },{ EXCCAUSE_LOAD_STORE_ERROR,	0,	   do_load_store },#endif{ EXCCAUSE_LEVEL1_INTERRUPT,	0,	   do_interrupt },#ifdef SUPPORT_WINDOWED{ EXCCAUSE_ALLOCA,		USER|KRNL, fast_alloca },#endif{ EXCCAUSE_INTEGER_DIVIDE_BY_ZERO, 0,	   do_div0 },/* EXCCAUSE_PRIVILEGED unhandled */#if XCHAL_UNALIGNED_LOAD_EXCEPTION || XCHAL_UNALIGNED_STORE_EXCEPTION || \		IS_ENABLED(CONFIG_XTENSA_LOAD_STORE)#ifdef CONFIG_XTENSA_UNALIGNED_USER{ EXCCAUSE_UNALIGNED,		USER,	   fast_unaligned },#endif{ EXCCAUSE_UNALIGNED,		KRNL,	   fast_unaligned },#endif{ EXCCAUSE_UNALIGNED,		0,	   do_unaligned_user },#ifdef CONFIG_MMU{ EXCCAUSE_ITLB_MISS,			0,	   do_page_fault },{ EXCCAUSE_ITLB_MISS,			USER|KRNL, fast_second_level_miss},{ EXCCAUSE_DTLB_MISS,			USER|KRNL, fast_second_level_miss},{ EXCCAUSE_DTLB_MISS,			0,	   do_page_fault },{ EXCCAUSE_STORE_CACHE_ATTRIBUTE,	USER|KRNL, fast_store_prohibited },#endif /* CONFIG_MMU */#ifdef CONFIG_PFAULT{ EXCCAUSE_ITLB_MULTIHIT,		0,	   do_multihit },{ EXCCAUSE_ITLB_PRIVILEGE,		0,	   do_page_fault },{ EXCCAUSE_FETCH_CACHE_ATTRIBUTE,	0,	   do_page_fault },{ EXCCAUSE_DTLB_MULTIHIT,		0,	   do_multihit },{ EXCCAUSE_DTLB_PRIVILEGE,		0,	   do_page_fault },{ EXCCAUSE_STORE_CACHE_ATTRIBUTE,	0,	   do_page_fault },{ EXCCAUSE_LOAD_CACHE_ATTRIBUTE,	0,	   do_page_fault },#endif/* XCCHAL_EXCCAUSE_FLOATING_POINT unhandled */#if XTENSA_HAVE_COPROCESSOR(0)COPROCESSOR(0),#endif#if XTENSA_HAVE_COPROCESSOR(1)COPROCESSOR(1),#endif#if XTENSA_HAVE_COPROCESSOR(2)COPROCESSOR(2),#endif#if XTENSA_HAVE_COPROCESSOR(3)COPROCESSOR(3),#endif#if XTENSA_HAVE_COPROCESSOR(4)COPROCESSOR(4),#endif#if XTENSA_HAVE_COPROCESSOR(5)COPROCESSOR(5),#endif#if XTENSA_HAVE_COPROCESSOR(6)COPROCESSOR(6),#endif#if XTENSA_HAVE_COPROCESSOR(7)COPROCESSOR(7),#endif#if XTENSA_FAKE_NMI{ EXCCAUSE_MAPPED_NMI,			0,		do_nmi },#endif{ EXCCAUSE_MAPPED_DEBUG,		0,		do_debug },{ -1, -1, 0 } }; /* The exception table <exc_table> serves two functions: * 1. it contains three dispatch tables (fast_user, fast_kernel, default-c) * 2. it is a temporary memory buffer for the exception handlers. */ DEFINE_PER_CPU(struct exc_table, exc_table);DEFINE_PER_CPU(struct debug_table, debug_table); void die(const char*, struct pt_regs*, long); static inline void__die_if_kernel(const char *str, struct pt_regs *regs, long err){	if (!user_mode(regs))		die(str, regs, err);} #ifdef CONFIG_PRINT_USER_CODE_ON_UNHANDLED_EXCEPTIONstatic inline void dump_user_code(struct pt_regs *regs){	char buf[32]; 	if (copy_from_user(buf, (void __user *)(regs->pc & -16), sizeof(buf)) == 0) {		print_hex_dump(KERN_INFO, " ", DUMP_PREFIX_NONE,			       32, 1, buf, sizeof(buf), false); 	}}#elsestatic inline void dump_user_code(struct pt_regs *regs){}#endif /* * Unhandled Exceptions. Kill user task or panic if in kernel space. */ void do_unhandled(struct pt_regs *regs){	__die_if_kernel("Caught unhandled exception - should not happen",			regs, SIGKILL); 	/* If in user mode, send SIGILL signal to current process */	pr_info_ratelimited("Caught unhandled exception in '%s' "			    "(pid = %d, pc = %#010lx) - should not happen\n"			    "\tEXCCAUSE is %ld\n",			    current->comm, task_pid_nr(current), regs->pc,			    regs->exccause);	dump_user_code(regs);	force_sig(SIGILL);} /* * Multi-hit exception. This if fatal! */ static void do_multihit(struct pt_regs *regs){	die("Caught multihit exception", regs, SIGKILL);} /* * IRQ handler. */ #if XTENSA_FAKE_NMI #define IS_POW2(v) (((v) & ((v) - 1)) == 0) #if !(PROFILING_INTLEVEL == XCHAL_EXCM_LEVEL && \      IS_POW2(XTENSA_INTLEVEL_MASK(PROFILING_INTLEVEL)))#warning "Fake NMI is requested for PMM, but there are other IRQs at or above its level."#warning "Fake NMI will be used, but there will be a bugcheck if one of those IRQs fire." static inline void check_valid_nmi(void){	unsigned intread = xtensa_get_sr(interrupt);	unsigned intenable = xtensa_get_sr(intenable); 	BUG_ON(intread & intenable &	       ~(XTENSA_INTLEVEL_ANDBELOW_MASK(PROFILING_INTLEVEL) ^		 XTENSA_INTLEVEL_MASK(PROFILING_INTLEVEL) ^		 BIT(XCHAL_PROFILING_INTERRUPT)));} #else static inline void check_valid_nmi(void){} #endif irqreturn_t xtensa_pmu_irq_handler(int irq, void *dev_id); DEFINE_PER_CPU(unsigned long, nmi_count); static void do_nmi(struct pt_regs *regs){	struct pt_regs *old_regs = set_irq_regs(regs); 	nmi_enter();	++*this_cpu_ptr(&nmi_count);	check_valid_nmi();	xtensa_pmu_irq_handler(0, NULL);	nmi_exit();	set_irq_regs(old_regs);}#endif static void do_interrupt(struct pt_regs *regs){	static const unsigned int_level_mask[] = {		0,		XCHAL_INTLEVEL1_MASK,		XCHAL_INTLEVEL2_MASK,		XCHAL_INTLEVEL3_MASK,		XCHAL_INTLEVEL4_MASK,		XCHAL_INTLEVEL5_MASK,		XCHAL_INTLEVEL6_MASK,		XCHAL_INTLEVEL7_MASK,	};	struct pt_regs *old_regs = set_irq_regs(regs);	unsigned unhandled = ~0u; 	irq_enter(); 	for (;;) {		unsigned intread = xtensa_get_sr(interrupt);		unsigned intenable = xtensa_get_sr(intenable);		unsigned int_at_level = intread & intenable;		unsigned level; 		for (level = LOCKLEVEL; level > 0; --level) {			if (int_at_level & int_level_mask[level]) {				int_at_level &= int_level_mask[level];				if (int_at_level & unhandled)					int_at_level &= unhandled;				else					unhandled |= int_level_mask[level];				break;			}		} 		if (level == 0)			break; 		/* clear lowest pending irq in the unhandled mask */		unhandled ^= (int_at_level & -int_at_level);		do_IRQ(__ffs(int_at_level), regs);	} 	irq_exit();	set_irq_regs(old_regs);} static bool check_div0(struct pt_regs *regs){	static const u8 pattern[] = {'D', 'I', 'V', '0'};	const u8 *p;	u8 buf[5]; 	if (user_mode(regs)) {		if (copy_from_user(buf, (void __user *)regs->pc + 2, 5))			return false;		p = buf;	} else {		p = (const u8 *)regs->pc + 2;	} 	return memcmp(p, pattern, sizeof(pattern)) == 0 ||		memcmp(p + 1, pattern, sizeof(pattern)) == 0;} /* * Illegal instruction. Fatal if in kernel space. */ static void do_illegal_instruction(struct pt_regs *regs){#ifdef CONFIG_USER_ABI_CALL0_PROBE	/*	 * When call0 application encounters an illegal instruction fast	 * exception handler will attempt to set PS.WOE and retry failing	 * instruction.	 * If we get here we know that that instruction is also illegal	 * with PS.WOE set, so it's not related to the windowed option	 * hence PS.WOE may be cleared.	 */	if (regs->pc == current_thread_info()->ps_woe_fix_addr)		regs->ps &= ~PS_WOE_MASK;#endif	if (check_div0(regs)) {		do_div0(regs);		return;	} 	__die_if_kernel("Illegal instruction in kernel", regs, SIGKILL); 	/* If in user mode, send SIGILL signal to current process. */ 	pr_info_ratelimited("Illegal Instruction in '%s' (pid = %d, pc = %#010lx)\n",			    current->comm, task_pid_nr(current), regs->pc);	force_sig(SIGILL);} static void do_div0(struct pt_regs *regs){	__die_if_kernel("Unhandled division by 0 in kernel", regs, SIGKILL);	force_sig_fault(SIGFPE, FPE_INTDIV, (void __user *)regs->pc);} #ifdef CONFIG_XTENSA_LOAD_STOREstatic void do_load_store(struct pt_regs *regs){	__die_if_kernel("Unhandled load/store exception in kernel",			regs, SIGKILL); 	pr_info_ratelimited("Load/store error to %08lx in '%s' (pid = %d, pc = %#010lx)\n",			    regs->excvaddr, current->comm,			    task_pid_nr(current), regs->pc);	force_sig_fault(SIGBUS, BUS_ADRERR, (void *)regs->excvaddr);}#endif /* * Handle unaligned memory accesses from user space. Kill task. * * If CONFIG_UNALIGNED_USER is not set, we don't allow unaligned memory * accesses causes from user space. */ static void do_unaligned_user(struct pt_regs *regs){	__die_if_kernel("Unhandled unaligned exception in kernel",			regs, SIGKILL); 	pr_info_ratelimited("Unaligned memory access to %08lx in '%s' "			    "(pid = %d, pc = %#010lx)\n",			    regs->excvaddr, current->comm,			    task_pid_nr(current), regs->pc);	force_sig_fault(SIGBUS, BUS_ADRALN, (void *) regs->excvaddr);} #if XTENSA_HAVE_COPROCESSORSstatic void do_coprocessor(struct pt_regs *regs){	coprocessor_flush_release_all(current_thread_info());}#endif /* Handle debug events. * When CONFIG_HAVE_HW_BREAKPOINT is on this handler is called with * preemption disabled to avoid rescheduling and keep mapping of hardware * breakpoint structures to debug registers intact, so that * DEBUGCAUSE.DBNUM could be used in case of data breakpoint hit. */static void do_debug(struct pt_regs *regs){#ifdef CONFIG_HAVE_HW_BREAKPOINT	int ret = check_hw_breakpoint(regs); 	preempt_enable();	if (ret == 0)		return;#endif	__die_if_kernel("Breakpoint in kernel", regs, SIGKILL); 	/* If in user mode, send SIGTRAP signal to current process */ 	force_sig(SIGTRAP);}  #define set_handler(type, cause, handler)				\	do {								\		unsigned int cpu;					\									\		for_each_possible_cpu(cpu)				\			per_cpu(exc_table, cpu).type[cause] = (handler);\	} while (0) /* Set exception C handler - for temporary use when probing exceptions */ xtensa_exception_handler *__init trap_set_handler(int cause, xtensa_exception_handler *handler){	void *previous = per_cpu(exc_table, 0).default_handler[cause]; 	set_handler(default_handler, cause, handler);	return previous;}  static void trap_init_excsave(void){	xtensa_set_sr(this_cpu_ptr(&exc_table), excsave1);} static void trap_init_debug(void){	unsigned long debugsave = (unsigned long)this_cpu_ptr(&debug_table); 	this_cpu_ptr(&debug_table)->debug_exception = debug_exception;	__asm__ __volatile__("wsr %0, excsave" __stringify(XCHAL_DEBUGLEVEL)			     :: "a"(debugsave));} /* * Initialize dispatch tables. * * The exception vectors are stored compressed the __init section in the * dispatch_init_table. This function initializes the following three tables * from that compressed table: * - fast user		first dispatch table for user exceptions * - fast kernel	first dispatch table for kernel exceptions * - default C-handler	C-handler called by the default fast handler. * * See vectors.S for more details. */ void __init trap_init(void){	int i; 	/* Setup default vectors. */ 	for (i = 0; i < EXCCAUSE_N; i++) {		set_handler(fast_user_handler, i, user_exception);		set_handler(fast_kernel_handler, i, kernel_exception);		set_handler(default_handler, i, do_unhandled);	} 	/* Setup specific handlers. */ 	for(i = 0; dispatch_init_table[i].cause >= 0; i++) {		int fast = dispatch_init_table[i].fast;

Lines 1–500 of 651. Load more