xref: /openbmc/linux/arch/xtensa/kernel/traps.c (revision 0e25498f8cd43c1b5aa327f373dd094e9a006da7)
15a0015d6SChris Zankel /*
25a0015d6SChris Zankel  * arch/xtensa/kernel/traps.c
35a0015d6SChris Zankel  *
45a0015d6SChris Zankel  * Exception handling.
55a0015d6SChris Zankel  *
65a0015d6SChris Zankel  * Derived from code with the following copyrights:
75a0015d6SChris Zankel  * Copyright (C) 1994 - 1999 by Ralf Baechle
85a0015d6SChris Zankel  * Modified for R3000 by Paul M. Antoine, 1995, 1996
95a0015d6SChris Zankel  * Complete output from die() by Ulf Carlsson, 1998
105a0015d6SChris Zankel  * Copyright (C) 1999 Silicon Graphics, Inc.
115a0015d6SChris Zankel  *
125a0015d6SChris Zankel  * Essentially rewritten for the Xtensa architecture port.
135a0015d6SChris Zankel  *
143e4196a5SMax Filippov  * Copyright (C) 2001 - 2013 Tensilica Inc.
155a0015d6SChris Zankel  *
165a0015d6SChris Zankel  * Joe Taylor	<joe@tensilica.com, joetylr@yahoo.com>
175a0015d6SChris Zankel  * Chris Zankel	<chris@zankel.net>
185a0015d6SChris Zankel  * Marc Gauthier<marc@tensilica.com, marc@alumni.uwaterloo.ca>
195a0015d6SChris Zankel  * Kevin Chea
205a0015d6SChris Zankel  *
215a0015d6SChris Zankel  * This file is subject to the terms and conditions of the GNU General Public
225a0015d6SChris Zankel  * License.  See the file "COPYING" in the main directory of this archive
235a0015d6SChris Zankel  * for more details.
245a0015d6SChris Zankel  */
255a0015d6SChris Zankel 
265a0015d6SChris Zankel #include <linux/kernel.h>
273f07c014SIngo Molnar #include <linux/sched/signal.h>
28b17b0153SIngo Molnar #include <linux/sched/debug.h>
293f8c2452SIngo Molnar #include <linux/sched/task_stack.h>
305a0015d6SChris Zankel #include <linux/init.h>
315a0015d6SChris Zankel #include <linux/module.h>
325a0015d6SChris Zankel #include <linux/stringify.h>
335a0015d6SChris Zankel #include <linux/kallsyms.h>
345c888d53SNishanth Aravamudan #include <linux/delay.h>
355a891ed5SAlexey Dobriyan #include <linux/hardirq.h>
36c130d3beSMax Filippov #include <linux/ratelimit.h>
3765fddcfcSMike Rapoport #include <linux/pgtable.h>
385a0015d6SChris Zankel 
393e4196a5SMax Filippov #include <asm/stacktrace.h>
405a0015d6SChris Zankel #include <asm/ptrace.h>
415a0015d6SChris Zankel #include <asm/timex.h>
427c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
435a0015d6SChris Zankel #include <asm/processor.h>
442d6f82feSMax Filippov #include <asm/traps.h>
45c91e02bdSMax Filippov #include <asm/hw_breakpoint.h>
465a0015d6SChris Zankel 
475a0015d6SChris Zankel /*
485a0015d6SChris Zankel  * Machine specific interrupt handlers
495a0015d6SChris Zankel  */
505a0015d6SChris Zankel 
515a0015d6SChris Zankel extern void kernel_exception(void);
525a0015d6SChris Zankel extern void user_exception(void);
535a0015d6SChris Zankel 
5409f8a6dbSMax Filippov extern void fast_illegal_instruction_user(void);
555a0015d6SChris Zankel extern void fast_syscall_user(void);
565a0015d6SChris Zankel extern void fast_alloca(void);
575a0015d6SChris Zankel extern void fast_unaligned(void);
585a0015d6SChris Zankel extern void fast_second_level_miss(void);
595a0015d6SChris Zankel extern void fast_store_prohibited(void);
605a0015d6SChris Zankel extern void fast_coprocessor(void);
615a0015d6SChris Zankel 
625a0015d6SChris Zankel extern void do_illegal_instruction (struct pt_regs*);
635a0015d6SChris Zankel extern void do_interrupt (struct pt_regs*);
6438fef73cSMax Filippov extern void do_nmi(struct pt_regs *);
655a0015d6SChris Zankel extern void do_unaligned_user (struct pt_regs*);
665a0015d6SChris Zankel extern void do_multihit (struct pt_regs*, unsigned long);
675a0015d6SChris Zankel extern void do_page_fault (struct pt_regs*, unsigned long);
685a0015d6SChris Zankel extern void do_debug (struct pt_regs*);
695a0015d6SChris Zankel extern void system_call (struct pt_regs*);
705a0015d6SChris Zankel 
715a0015d6SChris Zankel /*
725a0015d6SChris Zankel  * The vector table must be preceded by a save area (which
735a0015d6SChris Zankel  * implies it must be in RAM, unless one places RAM immediately
745a0015d6SChris Zankel  * before a ROM and puts the vector at the start of the ROM (!))
755a0015d6SChris Zankel  */
765a0015d6SChris Zankel 
775a0015d6SChris Zankel #define KRNL		0x01
785a0015d6SChris Zankel #define USER		0x02
795a0015d6SChris Zankel 
805a0015d6SChris Zankel #define COPROCESSOR(x)							\
81173d6681SChris Zankel { EXCCAUSE_COPROCESSOR ## x ## _DISABLED, USER, fast_coprocessor }
825a0015d6SChris Zankel 
835a0015d6SChris Zankel typedef struct {
845a0015d6SChris Zankel 	int cause;
855a0015d6SChris Zankel 	int fast;
865a0015d6SChris Zankel 	void* handler;
875a0015d6SChris Zankel } dispatch_init_table_t;
885a0015d6SChris Zankel 
89b91dc336SChris Zankel static dispatch_init_table_t __initdata dispatch_init_table[] = {
905a0015d6SChris Zankel 
9109f8a6dbSMax Filippov #ifdef CONFIG_USER_ABI_CALL0_PROBE
9209f8a6dbSMax Filippov { EXCCAUSE_ILLEGAL_INSTRUCTION,	USER,	   fast_illegal_instruction_user },
9309f8a6dbSMax Filippov #endif
94173d6681SChris Zankel { EXCCAUSE_ILLEGAL_INSTRUCTION,	0,	   do_illegal_instruction},
95173d6681SChris Zankel { EXCCAUSE_SYSTEM_CALL,		USER,	   fast_syscall_user },
96173d6681SChris Zankel { EXCCAUSE_SYSTEM_CALL,		0,	   system_call },
97173d6681SChris Zankel /* EXCCAUSE_INSTRUCTION_FETCH unhandled */
98173d6681SChris Zankel /* EXCCAUSE_LOAD_STORE_ERROR unhandled*/
99173d6681SChris Zankel { EXCCAUSE_LEVEL1_INTERRUPT,	0,	   do_interrupt },
100da0a4e5cSMax Filippov #ifdef SUPPORT_WINDOWED
101173d6681SChris Zankel { EXCCAUSE_ALLOCA,		USER|KRNL, fast_alloca },
102da0a4e5cSMax Filippov #endif
103173d6681SChris Zankel /* EXCCAUSE_INTEGER_DIVIDE_BY_ZERO unhandled */
104173d6681SChris Zankel /* EXCCAUSE_PRIVILEGED unhandled */
1055a0015d6SChris Zankel #if XCHAL_UNALIGNED_LOAD_EXCEPTION || XCHAL_UNALIGNED_STORE_EXCEPTION
1064ded6282SMax Filippov #ifdef CONFIG_XTENSA_UNALIGNED_USER
107173d6681SChris Zankel { EXCCAUSE_UNALIGNED,		USER,	   fast_unaligned },
1085a0015d6SChris Zankel #endif
1093cfc096eSMax Filippov { EXCCAUSE_UNALIGNED,		0,	   do_unaligned_user },
110173d6681SChris Zankel { EXCCAUSE_UNALIGNED,		KRNL,	   fast_unaligned },
1115a0015d6SChris Zankel #endif
112e5083a63SJohannes Weiner #ifdef CONFIG_MMU
113173d6681SChris Zankel { EXCCAUSE_ITLB_MISS,		0,	   do_page_fault },
114173d6681SChris Zankel { EXCCAUSE_ITLB_MISS,		USER|KRNL, fast_second_level_miss},
115173d6681SChris Zankel { EXCCAUSE_ITLB_MULTIHIT,		0,	   do_multihit },
116173d6681SChris Zankel { EXCCAUSE_ITLB_PRIVILEGE,	0,	   do_page_fault },
117173d6681SChris Zankel /* EXCCAUSE_SIZE_RESTRICTION unhandled */
118173d6681SChris Zankel { EXCCAUSE_FETCH_CACHE_ATTRIBUTE,	0,	   do_page_fault },
119173d6681SChris Zankel { EXCCAUSE_DTLB_MISS,		USER|KRNL, fast_second_level_miss},
120173d6681SChris Zankel { EXCCAUSE_DTLB_MISS,		0,	   do_page_fault },
121173d6681SChris Zankel { EXCCAUSE_DTLB_MULTIHIT,		0,	   do_multihit },
122173d6681SChris Zankel { EXCCAUSE_DTLB_PRIVILEGE,	0,	   do_page_fault },
123173d6681SChris Zankel /* EXCCAUSE_DTLB_SIZE_RESTRICTION unhandled */
124173d6681SChris Zankel { EXCCAUSE_STORE_CACHE_ATTRIBUTE,	USER|KRNL, fast_store_prohibited },
125173d6681SChris Zankel { EXCCAUSE_STORE_CACHE_ATTRIBUTE,	0,	   do_page_fault },
126173d6681SChris Zankel { EXCCAUSE_LOAD_CACHE_ATTRIBUTE,	0,	   do_page_fault },
127e5083a63SJohannes Weiner #endif /* CONFIG_MMU */
1285a0015d6SChris Zankel /* XCCHAL_EXCCAUSE_FLOATING_POINT unhandled */
129c658eac6SChris Zankel #if XTENSA_HAVE_COPROCESSOR(0)
1305a0015d6SChris Zankel COPROCESSOR(0),
1315a0015d6SChris Zankel #endif
132c658eac6SChris Zankel #if XTENSA_HAVE_COPROCESSOR(1)
1335a0015d6SChris Zankel COPROCESSOR(1),
1345a0015d6SChris Zankel #endif
135c658eac6SChris Zankel #if XTENSA_HAVE_COPROCESSOR(2)
1365a0015d6SChris Zankel COPROCESSOR(2),
1375a0015d6SChris Zankel #endif
138c658eac6SChris Zankel #if XTENSA_HAVE_COPROCESSOR(3)
1395a0015d6SChris Zankel COPROCESSOR(3),
1405a0015d6SChris Zankel #endif
141c658eac6SChris Zankel #if XTENSA_HAVE_COPROCESSOR(4)
1425a0015d6SChris Zankel COPROCESSOR(4),
1435a0015d6SChris Zankel #endif
144c658eac6SChris Zankel #if XTENSA_HAVE_COPROCESSOR(5)
1455a0015d6SChris Zankel COPROCESSOR(5),
1465a0015d6SChris Zankel #endif
147c658eac6SChris Zankel #if XTENSA_HAVE_COPROCESSOR(6)
1485a0015d6SChris Zankel COPROCESSOR(6),
1495a0015d6SChris Zankel #endif
150c658eac6SChris Zankel #if XTENSA_HAVE_COPROCESSOR(7)
1515a0015d6SChris Zankel COPROCESSOR(7),
1525a0015d6SChris Zankel #endif
15338fef73cSMax Filippov #if XTENSA_FAKE_NMI
15438fef73cSMax Filippov { EXCCAUSE_MAPPED_NMI,			0,		do_nmi },
15538fef73cSMax Filippov #endif
1565a0015d6SChris Zankel { EXCCAUSE_MAPPED_DEBUG,		0,		do_debug },
1575a0015d6SChris Zankel { -1, -1, 0 }
1585a0015d6SChris Zankel 
1595a0015d6SChris Zankel };
1605a0015d6SChris Zankel 
1615a0015d6SChris Zankel /* The exception table <exc_table> serves two functions:
1625a0015d6SChris Zankel  * 1. it contains three dispatch tables (fast_user, fast_kernel, default-c)
1635a0015d6SChris Zankel  * 2. it is a temporary memory buffer for the exception handlers.
1645a0015d6SChris Zankel  */
1655a0015d6SChris Zankel 
166f21a79caSMax Filippov DEFINE_PER_CPU(struct exc_table, exc_table);
1676ec7026aSMax Filippov DEFINE_PER_CPU(struct debug_table, debug_table);
1686ec7026aSMax Filippov 
1695a0015d6SChris Zankel void die(const char*, struct pt_regs*, long);
1705a0015d6SChris Zankel 
1715a0015d6SChris Zankel static inline void
1725a0015d6SChris Zankel __die_if_kernel(const char *str, struct pt_regs *regs, long err)
1735a0015d6SChris Zankel {
1745a0015d6SChris Zankel 	if (!user_mode(regs))
1755a0015d6SChris Zankel 		die(str, regs, err);
1765a0015d6SChris Zankel }
1775a0015d6SChris Zankel 
1785a0015d6SChris Zankel /*
1795a0015d6SChris Zankel  * Unhandled Exceptions. Kill user task or panic if in kernel space.
1805a0015d6SChris Zankel  */
1815a0015d6SChris Zankel 
1825a0015d6SChris Zankel void do_unhandled(struct pt_regs *regs, unsigned long exccause)
1835a0015d6SChris Zankel {
1845a0015d6SChris Zankel 	__die_if_kernel("Caught unhandled exception - should not happen",
1855a0015d6SChris Zankel 			regs, SIGKILL);
1865a0015d6SChris Zankel 
1875a0015d6SChris Zankel 	/* If in user mode, send SIGILL signal to current process */
188c130d3beSMax Filippov 	pr_info_ratelimited("Caught unhandled exception in '%s' "
1895a0015d6SChris Zankel 			    "(pid = %d, pc = %#010lx) - should not happen\n"
1905a0015d6SChris Zankel 			    "\tEXCCAUSE is %ld\n",
191c130d3beSMax Filippov 			    current->comm, task_pid_nr(current), regs->pc,
192c130d3beSMax Filippov 			    exccause);
1933cf5d076SEric W. Biederman 	force_sig(SIGILL);
1945a0015d6SChris Zankel }
1955a0015d6SChris Zankel 
1965a0015d6SChris Zankel /*
1975a0015d6SChris Zankel  * Multi-hit exception. This if fatal!
1985a0015d6SChris Zankel  */
1995a0015d6SChris Zankel 
2005a0015d6SChris Zankel void do_multihit(struct pt_regs *regs, unsigned long exccause)
2015a0015d6SChris Zankel {
2025a0015d6SChris Zankel 	die("Caught multihit exception", regs, SIGKILL);
2035a0015d6SChris Zankel }
2045a0015d6SChris Zankel 
2055a0015d6SChris Zankel /*
2062d1c645cSMarc Gauthier  * IRQ handler.
2075a0015d6SChris Zankel  */
2085a0015d6SChris Zankel 
2095a0015d6SChris Zankel extern void do_IRQ(int, struct pt_regs *);
2105a0015d6SChris Zankel 
21138fef73cSMax Filippov #if XTENSA_FAKE_NMI
21238fef73cSMax Filippov 
213e4629194SMax Filippov #define IS_POW2(v) (((v) & ((v) - 1)) == 0)
214e4629194SMax Filippov 
215e4629194SMax Filippov #if !(PROFILING_INTLEVEL == XCHAL_EXCM_LEVEL && \
216e4629194SMax Filippov       IS_POW2(XTENSA_INTLEVEL_MASK(PROFILING_INTLEVEL)))
217e4629194SMax Filippov #warning "Fake NMI is requested for PMM, but there are other IRQs at or above its level."
218e4629194SMax Filippov #warning "Fake NMI will be used, but there will be a bugcheck if one of those IRQs fire."
219e4629194SMax Filippov 
220e4629194SMax Filippov static inline void check_valid_nmi(void)
221e4629194SMax Filippov {
222cad6fadeSMax Filippov 	unsigned intread = xtensa_get_sr(interrupt);
223cad6fadeSMax Filippov 	unsigned intenable = xtensa_get_sr(intenable);
224e4629194SMax Filippov 
225e4629194SMax Filippov 	BUG_ON(intread & intenable &
226e4629194SMax Filippov 	       ~(XTENSA_INTLEVEL_ANDBELOW_MASK(PROFILING_INTLEVEL) ^
227e4629194SMax Filippov 		 XTENSA_INTLEVEL_MASK(PROFILING_INTLEVEL) ^
228e4629194SMax Filippov 		 BIT(XCHAL_PROFILING_INTERRUPT)));
229e4629194SMax Filippov }
230e4629194SMax Filippov 
231e4629194SMax Filippov #else
232e4629194SMax Filippov 
233e4629194SMax Filippov static inline void check_valid_nmi(void)
234e4629194SMax Filippov {
235e4629194SMax Filippov }
236e4629194SMax Filippov 
237e4629194SMax Filippov #endif
238e4629194SMax Filippov 
23938fef73cSMax Filippov irqreturn_t xtensa_pmu_irq_handler(int irq, void *dev_id);
24038fef73cSMax Filippov 
24138fef73cSMax Filippov DEFINE_PER_CPU(unsigned long, nmi_count);
24238fef73cSMax Filippov 
24338fef73cSMax Filippov void do_nmi(struct pt_regs *regs)
24438fef73cSMax Filippov {
24538fef73cSMax Filippov 	struct pt_regs *old_regs;
24638fef73cSMax Filippov 
24738fef73cSMax Filippov 	if ((regs->ps & PS_INTLEVEL_MASK) < LOCKLEVEL)
24838fef73cSMax Filippov 		trace_hardirqs_off();
24938fef73cSMax Filippov 
25038fef73cSMax Filippov 	old_regs = set_irq_regs(regs);
25138fef73cSMax Filippov 	nmi_enter();
25238fef73cSMax Filippov 	++*this_cpu_ptr(&nmi_count);
253e4629194SMax Filippov 	check_valid_nmi();
25438fef73cSMax Filippov 	xtensa_pmu_irq_handler(0, NULL);
25538fef73cSMax Filippov 	nmi_exit();
25638fef73cSMax Filippov 	set_irq_regs(old_regs);
25738fef73cSMax Filippov }
25838fef73cSMax Filippov #endif
25938fef73cSMax Filippov 
2605a0015d6SChris Zankel void do_interrupt(struct pt_regs *regs)
2615a0015d6SChris Zankel {
2622d1c645cSMarc Gauthier 	static const unsigned int_level_mask[] = {
2632d1c645cSMarc Gauthier 		0,
2642d1c645cSMarc Gauthier 		XCHAL_INTLEVEL1_MASK,
2652d1c645cSMarc Gauthier 		XCHAL_INTLEVEL2_MASK,
2662d1c645cSMarc Gauthier 		XCHAL_INTLEVEL3_MASK,
2672d1c645cSMarc Gauthier 		XCHAL_INTLEVEL4_MASK,
2682d1c645cSMarc Gauthier 		XCHAL_INTLEVEL5_MASK,
2692d1c645cSMarc Gauthier 		XCHAL_INTLEVEL6_MASK,
2702d1c645cSMarc Gauthier 		XCHAL_INTLEVEL7_MASK,
2712d1c645cSMarc Gauthier 	};
2727d5f6a9aSMax Filippov 	struct pt_regs *old_regs;
27343ba2237SMax Filippov 	unsigned unhandled = ~0u;
27499623239SMax Filippov 
2757d5f6a9aSMax Filippov 	trace_hardirqs_off();
2767d5f6a9aSMax Filippov 
2777d5f6a9aSMax Filippov 	old_regs = set_irq_regs(regs);
27899623239SMax Filippov 	irq_enter();
2792d1c645cSMarc Gauthier 
2802d1c645cSMarc Gauthier 	for (;;) {
281cad6fadeSMax Filippov 		unsigned intread = xtensa_get_sr(interrupt);
282cad6fadeSMax Filippov 		unsigned intenable = xtensa_get_sr(intenable);
283895666a9SMax Filippov 		unsigned int_at_level = intread & intenable;
284895666a9SMax Filippov 		unsigned level;
2852d1c645cSMarc Gauthier 
286895666a9SMax Filippov 		for (level = LOCKLEVEL; level > 0; --level) {
287895666a9SMax Filippov 			if (int_at_level & int_level_mask[level]) {
288895666a9SMax Filippov 				int_at_level &= int_level_mask[level];
28943ba2237SMax Filippov 				if (int_at_level & unhandled)
29043ba2237SMax Filippov 					int_at_level &= unhandled;
29143ba2237SMax Filippov 				else
29243ba2237SMax Filippov 					unhandled |= int_level_mask[level];
293895666a9SMax Filippov 				break;
294895666a9SMax Filippov 			}
295895666a9SMax Filippov 		}
296895666a9SMax Filippov 
297895666a9SMax Filippov 		if (level == 0)
29899623239SMax Filippov 			break;
2992d1c645cSMarc Gauthier 
30043ba2237SMax Filippov 		/* clear lowest pending irq in the unhandled mask */
30143ba2237SMax Filippov 		unhandled ^= (int_at_level & -int_at_level);
30299623239SMax Filippov 		do_IRQ(__ffs(int_at_level), regs);
30399623239SMax Filippov 	}
3045a0015d6SChris Zankel 
30599623239SMax Filippov 	irq_exit();
30699623239SMax Filippov 	set_irq_regs(old_regs);
3075a0015d6SChris Zankel }
3085a0015d6SChris Zankel 
3095a0015d6SChris Zankel /*
3105a0015d6SChris Zankel  * Illegal instruction. Fatal if in kernel space.
3115a0015d6SChris Zankel  */
3125a0015d6SChris Zankel 
3135a0015d6SChris Zankel void
3145a0015d6SChris Zankel do_illegal_instruction(struct pt_regs *regs)
3155a0015d6SChris Zankel {
3165a0015d6SChris Zankel 	__die_if_kernel("Illegal instruction in kernel", regs, SIGKILL);
3175a0015d6SChris Zankel 
3185a0015d6SChris Zankel 	/* If in user mode, send SIGILL signal to current process. */
3195a0015d6SChris Zankel 
320c130d3beSMax Filippov 	pr_info_ratelimited("Illegal Instruction in '%s' (pid = %d, pc = %#010lx)\n",
32119c5870cSAlexey Dobriyan 			    current->comm, task_pid_nr(current), regs->pc);
3223cf5d076SEric W. Biederman 	force_sig(SIGILL);
3235a0015d6SChris Zankel }
3245a0015d6SChris Zankel 
3255a0015d6SChris Zankel 
3265a0015d6SChris Zankel /*
3275a0015d6SChris Zankel  * Handle unaligned memory accesses from user space. Kill task.
3285a0015d6SChris Zankel  *
3295a0015d6SChris Zankel  * If CONFIG_UNALIGNED_USER is not set, we don't allow unaligned memory
3305a0015d6SChris Zankel  * accesses causes from user space.
3315a0015d6SChris Zankel  */
3325a0015d6SChris Zankel 
3335a0015d6SChris Zankel #if XCHAL_UNALIGNED_LOAD_EXCEPTION || XCHAL_UNALIGNED_STORE_EXCEPTION
3345a0015d6SChris Zankel void
3355a0015d6SChris Zankel do_unaligned_user (struct pt_regs *regs)
3365a0015d6SChris Zankel {
3375a0015d6SChris Zankel 	__die_if_kernel("Unhandled unaligned exception in kernel",
3385a0015d6SChris Zankel 			regs, SIGKILL);
3395a0015d6SChris Zankel 
3405a0015d6SChris Zankel 	current->thread.bad_vaddr = regs->excvaddr;
3415a0015d6SChris Zankel 	current->thread.error_code = -3;
342c130d3beSMax Filippov 	pr_info_ratelimited("Unaligned memory access to %08lx in '%s' "
3435a0015d6SChris Zankel 			    "(pid = %d, pc = %#010lx)\n",
344c130d3beSMax Filippov 			    regs->excvaddr, current->comm,
345c130d3beSMax Filippov 			    task_pid_nr(current), regs->pc);
3462e1661d2SEric W. Biederman 	force_sig_fault(SIGBUS, BUS_ADRALN, (void *) regs->excvaddr);
3475a0015d6SChris Zankel }
3485a0015d6SChris Zankel #endif
3495a0015d6SChris Zankel 
350c91e02bdSMax Filippov /* Handle debug events.
351c91e02bdSMax Filippov  * When CONFIG_HAVE_HW_BREAKPOINT is on this handler is called with
352c91e02bdSMax Filippov  * preemption disabled to avoid rescheduling and keep mapping of hardware
353c91e02bdSMax Filippov  * breakpoint structures to debug registers intact, so that
354c91e02bdSMax Filippov  * DEBUGCAUSE.DBNUM could be used in case of data breakpoint hit.
355c91e02bdSMax Filippov  */
3565a0015d6SChris Zankel void
3575a0015d6SChris Zankel do_debug(struct pt_regs *regs)
3585a0015d6SChris Zankel {
359c91e02bdSMax Filippov #ifdef CONFIG_HAVE_HW_BREAKPOINT
360c91e02bdSMax Filippov 	int ret = check_hw_breakpoint(regs);
361c91e02bdSMax Filippov 
362c91e02bdSMax Filippov 	preempt_enable();
363c91e02bdSMax Filippov 	if (ret == 0)
364c91e02bdSMax Filippov 		return;
365c91e02bdSMax Filippov #endif
3665a0015d6SChris Zankel 	__die_if_kernel("Breakpoint in kernel", regs, SIGKILL);
3675a0015d6SChris Zankel 
3685a0015d6SChris Zankel 	/* If in user mode, send SIGTRAP signal to current process */
3695a0015d6SChris Zankel 
3703cf5d076SEric W. Biederman 	force_sig(SIGTRAP);
3715a0015d6SChris Zankel }
3725a0015d6SChris Zankel 
3735a0015d6SChris Zankel 
374f21a79caSMax Filippov #define set_handler(type, cause, handler)				\
375f21a79caSMax Filippov 	do {								\
376f21a79caSMax Filippov 		unsigned int cpu;					\
377f21a79caSMax Filippov 									\
378f21a79caSMax Filippov 		for_each_possible_cpu(cpu)				\
379f21a79caSMax Filippov 			per_cpu(exc_table, cpu).type[cause] = (handler);\
380f21a79caSMax Filippov 	} while (0)
381f615136cSMax Filippov 
38228570e8dSMax Filippov /* Set exception C handler - for temporary use when probing exceptions */
38328570e8dSMax Filippov 
38428570e8dSMax Filippov void * __init trap_set_handler(int cause, void *handler)
38528570e8dSMax Filippov {
386f21a79caSMax Filippov 	void *previous = per_cpu(exc_table, 0).default_handler[cause];
387f21a79caSMax Filippov 
388f21a79caSMax Filippov 	set_handler(default_handler, cause, handler);
38928570e8dSMax Filippov 	return previous;
39028570e8dSMax Filippov }
39128570e8dSMax Filippov 
39228570e8dSMax Filippov 
39349b424feSMax Filippov static void trap_init_excsave(void)
394f615136cSMax Filippov {
395f21a79caSMax Filippov 	unsigned long excsave1 = (unsigned long)this_cpu_ptr(&exc_table);
396f615136cSMax Filippov 	__asm__ __volatile__("wsr  %0, excsave1\n" : : "a" (excsave1));
397f615136cSMax Filippov }
398f615136cSMax Filippov 
3996ec7026aSMax Filippov static void trap_init_debug(void)
4006ec7026aSMax Filippov {
4016ec7026aSMax Filippov 	unsigned long debugsave = (unsigned long)this_cpu_ptr(&debug_table);
4026ec7026aSMax Filippov 
4036ec7026aSMax Filippov 	this_cpu_ptr(&debug_table)->debug_exception = debug_exception;
4046ec7026aSMax Filippov 	__asm__ __volatile__("wsr %0, excsave" __stringify(XCHAL_DEBUGLEVEL)
4056ec7026aSMax Filippov 			     :: "a"(debugsave));
4066ec7026aSMax Filippov }
4076ec7026aSMax Filippov 
4085a0015d6SChris Zankel /*
4095a0015d6SChris Zankel  * Initialize dispatch tables.
4105a0015d6SChris Zankel  *
4115a0015d6SChris Zankel  * The exception vectors are stored compressed the __init section in the
4125a0015d6SChris Zankel  * dispatch_init_table. This function initializes the following three tables
4135a0015d6SChris Zankel  * from that compressed table:
4145a0015d6SChris Zankel  * - fast user		first dispatch table for user exceptions
4155a0015d6SChris Zankel  * - fast kernel	first dispatch table for kernel exceptions
4165a0015d6SChris Zankel  * - default C-handler	C-handler called by the default fast handler.
4175a0015d6SChris Zankel  *
4185a0015d6SChris Zankel  * See vectors.S for more details.
4195a0015d6SChris Zankel  */
4205a0015d6SChris Zankel 
421b91dc336SChris Zankel void __init trap_init(void)
4225a0015d6SChris Zankel {
4235a0015d6SChris Zankel 	int i;
4245a0015d6SChris Zankel 
4255a0015d6SChris Zankel 	/* Setup default vectors. */
4265a0015d6SChris Zankel 
427f21a79caSMax Filippov 	for (i = 0; i < EXCCAUSE_N; i++) {
428f21a79caSMax Filippov 		set_handler(fast_user_handler, i, user_exception);
429f21a79caSMax Filippov 		set_handler(fast_kernel_handler, i, kernel_exception);
430f21a79caSMax Filippov 		set_handler(default_handler, i, do_unhandled);
4315a0015d6SChris Zankel 	}
4325a0015d6SChris Zankel 
4335a0015d6SChris Zankel 	/* Setup specific handlers. */
4345a0015d6SChris Zankel 
4355a0015d6SChris Zankel 	for(i = 0; dispatch_init_table[i].cause >= 0; i++) {
4365a0015d6SChris Zankel 		int fast = dispatch_init_table[i].fast;
4375a0015d6SChris Zankel 		int cause = dispatch_init_table[i].cause;
4385a0015d6SChris Zankel 		void *handler = dispatch_init_table[i].handler;
4395a0015d6SChris Zankel 
4405a0015d6SChris Zankel 		if (fast == 0)
441f21a79caSMax Filippov 			set_handler(default_handler, cause, handler);
44260deebe6SMax Filippov 		if ((fast & USER) != 0)
443f21a79caSMax Filippov 			set_handler(fast_user_handler, cause, handler);
44460deebe6SMax Filippov 		if ((fast & KRNL) != 0)
445f21a79caSMax Filippov 			set_handler(fast_kernel_handler, cause, handler);
4465a0015d6SChris Zankel 	}
4475a0015d6SChris Zankel 
4485a0015d6SChris Zankel 	/* Initialize EXCSAVE_1 to hold the address of the exception table. */
449f615136cSMax Filippov 	trap_init_excsave();
4506ec7026aSMax Filippov 	trap_init_debug();
4515a0015d6SChris Zankel }
4525a0015d6SChris Zankel 
453f615136cSMax Filippov #ifdef CONFIG_SMP
45449b424feSMax Filippov void secondary_trap_init(void)
455f615136cSMax Filippov {
456f615136cSMax Filippov 	trap_init_excsave();
4576ec7026aSMax Filippov 	trap_init_debug();
458f615136cSMax Filippov }
459f615136cSMax Filippov #endif
460f615136cSMax Filippov 
4615a0015d6SChris Zankel /*
4625a0015d6SChris Zankel  * This function dumps the current valid window frame and other base registers.
4635a0015d6SChris Zankel  */
4645a0015d6SChris Zankel 
4655a0015d6SChris Zankel void show_regs(struct pt_regs * regs)
4665a0015d6SChris Zankel {
467431d1a34SMax Filippov 	int i;
4685a0015d6SChris Zankel 
469a43cb95dSTejun Heo 	show_regs_print_info(KERN_DEFAULT);
470a43cb95dSTejun Heo 
4718d7e8240SChris Zankel 	for (i = 0; i < 16; i++) {
4725a0015d6SChris Zankel 		if ((i % 8) == 0)
473d4eccafcSMax Filippov 			pr_info("a%02d:", i);
474d4eccafcSMax Filippov 		pr_cont(" %08lx", regs->areg[i]);
4755a0015d6SChris Zankel 	}
476d4eccafcSMax Filippov 	pr_cont("\n");
477d4eccafcSMax Filippov 	pr_info("pc: %08lx, ps: %08lx, depc: %08lx, excvaddr: %08lx\n",
4785a0015d6SChris Zankel 		regs->pc, regs->ps, regs->depc, regs->excvaddr);
479d4eccafcSMax Filippov 	pr_info("lbeg: %08lx, lend: %08lx lcount: %08lx, sar: %08lx\n",
4805a0015d6SChris Zankel 		regs->lbeg, regs->lend, regs->lcount, regs->sar);
4815a0015d6SChris Zankel 	if (user_mode(regs))
482d4eccafcSMax Filippov 		pr_cont("wb: %08lx, ws: %08lx, wmask: %08lx, syscall: %ld\n",
4835a0015d6SChris Zankel 			regs->windowbase, regs->windowstart, regs->wmask,
4845a0015d6SChris Zankel 			regs->syscall);
4855a0015d6SChris Zankel }
4865a0015d6SChris Zankel 
4873e4196a5SMax Filippov static int show_trace_cb(struct stackframe *frame, void *data)
488586411dcSJohannes Weiner {
48947fb7029SDmitry Safonov 	const char *loglvl = data;
49047fb7029SDmitry Safonov 
491e640cc30SMax Filippov 	if (kernel_text_address(frame->pc))
49247fb7029SDmitry Safonov 		printk("%s [<%08lx>] %pB\n",
49347fb7029SDmitry Safonov 			loglvl, frame->pc, (void *)frame->pc);
4943e4196a5SMax Filippov 	return 0;
495586411dcSJohannes Weiner }
496586411dcSJohannes Weiner 
49747fb7029SDmitry Safonov static void show_trace(struct task_struct *task, unsigned long *sp,
49847fb7029SDmitry Safonov 		       const char *loglvl)
4995a0015d6SChris Zankel {
5003e4196a5SMax Filippov 	if (!sp)
5013e4196a5SMax Filippov 		sp = stack_pointer(task);
5025a0015d6SChris Zankel 
50347fb7029SDmitry Safonov 	printk("%sCall Trace:\n", loglvl);
50447fb7029SDmitry Safonov 	walk_stackframe(sp, show_trace_cb, (void *)loglvl);
5055a0015d6SChris Zankel }
5065a0015d6SChris Zankel 
507c5fccebcSMax Filippov #define STACK_DUMP_ENTRY_SIZE 4
508c5fccebcSMax Filippov #define STACK_DUMP_LINE_SIZE 32
5098951eb15SMax Filippov static size_t kstack_depth_to_print = CONFIG_PRINT_STACK_DEPTH;
5105a0015d6SChris Zankel 
5119cb8f069SDmitry Safonov void show_stack(struct task_struct *task, unsigned long *sp, const char *loglvl)
5125a0015d6SChris Zankel {
513c5fccebcSMax Filippov 	size_t len;
5145a0015d6SChris Zankel 
51528a0ce7fSJohannes Weiner 	if (!sp)
516586411dcSJohannes Weiner 		sp = stack_pointer(task);
517c5fccebcSMax Filippov 
518c5fccebcSMax Filippov 	len = min((-(size_t)sp) & (THREAD_SIZE - STACK_DUMP_ENTRY_SIZE),
519c5fccebcSMax Filippov 		  kstack_depth_to_print * STACK_DUMP_ENTRY_SIZE);
5205a0015d6SChris Zankel 
52120da1e8bSDmitry Safonov 	printk("%sStack:\n", loglvl);
52220da1e8bSDmitry Safonov 	print_hex_dump(loglvl, " ", DUMP_PREFIX_NONE,
523c5fccebcSMax Filippov 		       STACK_DUMP_LINE_SIZE, STACK_DUMP_ENTRY_SIZE,
524c5fccebcSMax Filippov 		       sp, len, false);
52520da1e8bSDmitry Safonov 	show_trace(task, sp, loglvl);
52620da1e8bSDmitry Safonov }
52720da1e8bSDmitry Safonov 
52834af946aSIngo Molnar DEFINE_SPINLOCK(die_lock);
5295a0015d6SChris Zankel 
5309fd5a04dSEric W. Biederman void __noreturn die(const char * str, struct pt_regs * regs, long err)
5315a0015d6SChris Zankel {
5325a0015d6SChris Zankel 	static int die_counter;
5336c5260d7SThomas Gleixner 	const char *pr = "";
5346c5260d7SThomas Gleixner 
5356c5260d7SThomas Gleixner 	if (IS_ENABLED(CONFIG_PREEMPTION))
5366c5260d7SThomas Gleixner 		pr = IS_ENABLED(CONFIG_PREEMPT_RT) ? " PREEMPT_RT" : " PREEMPT";
5375a0015d6SChris Zankel 
5385a0015d6SChris Zankel 	console_verbose();
5395a0015d6SChris Zankel 	spin_lock_irq(&die_lock);
5405a0015d6SChris Zankel 
5416c5260d7SThomas Gleixner 	pr_info("%s: sig: %ld [#%d]%s\n", str, err, ++die_counter, pr);
5425a0015d6SChris Zankel 	show_regs(regs);
5435a0015d6SChris Zankel 	if (!user_mode(regs))
5449cb8f069SDmitry Safonov 		show_stack(NULL, (unsigned long *)regs->areg[1], KERN_INFO);
5455a0015d6SChris Zankel 
546373d4d09SRusty Russell 	add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
5475a0015d6SChris Zankel 	spin_unlock_irq(&die_lock);
5485a0015d6SChris Zankel 
5495a0015d6SChris Zankel 	if (in_interrupt())
5505a0015d6SChris Zankel 		panic("Fatal exception in interrupt");
5515a0015d6SChris Zankel 
552cea6a4baSHorms 	if (panic_on_oops)
553012c437dSHorms 		panic("Fatal exception");
554cea6a4baSHorms 
555*0e25498fSEric W. Biederman 	make_task_dead(err);
5565a0015d6SChris Zankel }
557