]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - arch/xtensa/kernel/traps.c
Merge remote-tracking branches 'asoc/topic/inntel', 'asoc/topic/input', 'asoc/topic...
[mirror_ubuntu-bionic-kernel.git] / arch / xtensa / kernel / traps.c
CommitLineData
5a0015d6
CZ
1/*
2 * arch/xtensa/kernel/traps.c
3 *
4 * Exception handling.
5 *
6 * Derived from code with the following copyrights:
7 * Copyright (C) 1994 - 1999 by Ralf Baechle
8 * Modified for R3000 by Paul M. Antoine, 1995, 1996
9 * Complete output from die() by Ulf Carlsson, 1998
10 * Copyright (C) 1999 Silicon Graphics, Inc.
11 *
12 * Essentially rewritten for the Xtensa architecture port.
13 *
3e4196a5 14 * Copyright (C) 2001 - 2013 Tensilica Inc.
5a0015d6
CZ
15 *
16 * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
17 * Chris Zankel <chris@zankel.net>
18 * Marc Gauthier<marc@tensilica.com, marc@alumni.uwaterloo.ca>
19 * Kevin Chea
20 *
21 * This file is subject to the terms and conditions of the GNU General Public
22 * License. See the file "COPYING" in the main directory of this archive
23 * for more details.
24 */
25
26#include <linux/kernel.h>
27#include <linux/sched.h>
28#include <linux/init.h>
29#include <linux/module.h>
30#include <linux/stringify.h>
31#include <linux/kallsyms.h>
5c888d53 32#include <linux/delay.h>
5a891ed5 33#include <linux/hardirq.h>
5a0015d6 34
3e4196a5 35#include <asm/stacktrace.h>
5a0015d6
CZ
36#include <asm/ptrace.h>
37#include <asm/timex.h>
38#include <asm/uaccess.h>
39#include <asm/pgtable.h>
40#include <asm/processor.h>
2d6f82fe 41#include <asm/traps.h>
c91e02bd 42#include <asm/hw_breakpoint.h>
5a0015d6 43
5a0015d6
CZ
44/*
45 * Machine specific interrupt handlers
46 */
47
48extern void kernel_exception(void);
49extern void user_exception(void);
50
51extern void fast_syscall_kernel(void);
52extern void fast_syscall_user(void);
53extern void fast_alloca(void);
54extern void fast_unaligned(void);
55extern void fast_second_level_miss(void);
56extern void fast_store_prohibited(void);
57extern void fast_coprocessor(void);
58
59extern void do_illegal_instruction (struct pt_regs*);
60extern void do_interrupt (struct pt_regs*);
38fef73c 61extern void do_nmi(struct pt_regs *);
5a0015d6
CZ
62extern void do_unaligned_user (struct pt_regs*);
63extern void do_multihit (struct pt_regs*, unsigned long);
64extern void do_page_fault (struct pt_regs*, unsigned long);
65extern void do_debug (struct pt_regs*);
66extern void system_call (struct pt_regs*);
67
68/*
69 * The vector table must be preceded by a save area (which
70 * implies it must be in RAM, unless one places RAM immediately
71 * before a ROM and puts the vector at the start of the ROM (!))
72 */
73
74#define KRNL 0x01
75#define USER 0x02
76
77#define COPROCESSOR(x) \
173d6681 78{ EXCCAUSE_COPROCESSOR ## x ## _DISABLED, USER, fast_coprocessor }
5a0015d6
CZ
79
80typedef struct {
81 int cause;
82 int fast;
83 void* handler;
84} dispatch_init_table_t;
85
b91dc336 86static dispatch_init_table_t __initdata dispatch_init_table[] = {
5a0015d6 87
173d6681
CZ
88{ EXCCAUSE_ILLEGAL_INSTRUCTION, 0, do_illegal_instruction},
89{ EXCCAUSE_SYSTEM_CALL, KRNL, fast_syscall_kernel },
90{ EXCCAUSE_SYSTEM_CALL, USER, fast_syscall_user },
91{ EXCCAUSE_SYSTEM_CALL, 0, system_call },
92/* EXCCAUSE_INSTRUCTION_FETCH unhandled */
93/* EXCCAUSE_LOAD_STORE_ERROR unhandled*/
94{ EXCCAUSE_LEVEL1_INTERRUPT, 0, do_interrupt },
95{ EXCCAUSE_ALLOCA, USER|KRNL, fast_alloca },
96/* EXCCAUSE_INTEGER_DIVIDE_BY_ZERO unhandled */
97/* EXCCAUSE_PRIVILEGED unhandled */
5a0015d6 98#if XCHAL_UNALIGNED_LOAD_EXCEPTION || XCHAL_UNALIGNED_STORE_EXCEPTION
4ded6282 99#ifdef CONFIG_XTENSA_UNALIGNED_USER
173d6681 100{ EXCCAUSE_UNALIGNED, USER, fast_unaligned },
5a0015d6 101#endif
3cfc096e 102{ EXCCAUSE_UNALIGNED, 0, do_unaligned_user },
173d6681 103{ EXCCAUSE_UNALIGNED, KRNL, fast_unaligned },
5a0015d6 104#endif
e5083a63 105#ifdef CONFIG_MMU
173d6681
CZ
106{ EXCCAUSE_ITLB_MISS, 0, do_page_fault },
107{ EXCCAUSE_ITLB_MISS, USER|KRNL, fast_second_level_miss},
108{ EXCCAUSE_ITLB_MULTIHIT, 0, do_multihit },
109{ EXCCAUSE_ITLB_PRIVILEGE, 0, do_page_fault },
110/* EXCCAUSE_SIZE_RESTRICTION unhandled */
111{ EXCCAUSE_FETCH_CACHE_ATTRIBUTE, 0, do_page_fault },
112{ EXCCAUSE_DTLB_MISS, USER|KRNL, fast_second_level_miss},
113{ EXCCAUSE_DTLB_MISS, 0, do_page_fault },
114{ EXCCAUSE_DTLB_MULTIHIT, 0, do_multihit },
115{ EXCCAUSE_DTLB_PRIVILEGE, 0, do_page_fault },
116/* EXCCAUSE_DTLB_SIZE_RESTRICTION unhandled */
117{ EXCCAUSE_STORE_CACHE_ATTRIBUTE, USER|KRNL, fast_store_prohibited },
118{ EXCCAUSE_STORE_CACHE_ATTRIBUTE, 0, do_page_fault },
119{ EXCCAUSE_LOAD_CACHE_ATTRIBUTE, 0, do_page_fault },
e5083a63 120#endif /* CONFIG_MMU */
5a0015d6 121/* XCCHAL_EXCCAUSE_FLOATING_POINT unhandled */
c658eac6 122#if XTENSA_HAVE_COPROCESSOR(0)
5a0015d6
CZ
123COPROCESSOR(0),
124#endif
c658eac6 125#if XTENSA_HAVE_COPROCESSOR(1)
5a0015d6
CZ
126COPROCESSOR(1),
127#endif
c658eac6 128#if XTENSA_HAVE_COPROCESSOR(2)
5a0015d6
CZ
129COPROCESSOR(2),
130#endif
c658eac6 131#if XTENSA_HAVE_COPROCESSOR(3)
5a0015d6
CZ
132COPROCESSOR(3),
133#endif
c658eac6 134#if XTENSA_HAVE_COPROCESSOR(4)
5a0015d6
CZ
135COPROCESSOR(4),
136#endif
c658eac6 137#if XTENSA_HAVE_COPROCESSOR(5)
5a0015d6
CZ
138COPROCESSOR(5),
139#endif
c658eac6 140#if XTENSA_HAVE_COPROCESSOR(6)
5a0015d6
CZ
141COPROCESSOR(6),
142#endif
c658eac6 143#if XTENSA_HAVE_COPROCESSOR(7)
5a0015d6
CZ
144COPROCESSOR(7),
145#endif
38fef73c
MF
146#if XTENSA_FAKE_NMI
147{ EXCCAUSE_MAPPED_NMI, 0, do_nmi },
148#endif
5a0015d6
CZ
149{ EXCCAUSE_MAPPED_DEBUG, 0, do_debug },
150{ -1, -1, 0 }
151
152};
153
154/* The exception table <exc_table> serves two functions:
155 * 1. it contains three dispatch tables (fast_user, fast_kernel, default-c)
156 * 2. it is a temporary memory buffer for the exception handlers.
157 */
158
f615136c 159DEFINE_PER_CPU(unsigned long, exc_table[EXC_TABLE_SIZE/4]);
5a0015d6 160
6ec7026a
MF
161DEFINE_PER_CPU(struct debug_table, debug_table);
162
5a0015d6
CZ
163void die(const char*, struct pt_regs*, long);
164
165static inline void
166__die_if_kernel(const char *str, struct pt_regs *regs, long err)
167{
168 if (!user_mode(regs))
169 die(str, regs, err);
170}
171
172/*
173 * Unhandled Exceptions. Kill user task or panic if in kernel space.
174 */
175
176void do_unhandled(struct pt_regs *regs, unsigned long exccause)
177{
178 __die_if_kernel("Caught unhandled exception - should not happen",
179 regs, SIGKILL);
180
181 /* If in user mode, send SIGILL signal to current process */
182 printk("Caught unhandled exception in '%s' "
183 "(pid = %d, pc = %#010lx) - should not happen\n"
184 "\tEXCCAUSE is %ld\n",
19c5870c 185 current->comm, task_pid_nr(current), regs->pc, exccause);
5a0015d6
CZ
186 force_sig(SIGILL, current);
187}
188
189/*
190 * Multi-hit exception. This if fatal!
191 */
192
193void do_multihit(struct pt_regs *regs, unsigned long exccause)
194{
195 die("Caught multihit exception", regs, SIGKILL);
196}
197
198/*
2d1c645c 199 * IRQ handler.
5a0015d6
CZ
200 */
201
5a0015d6
CZ
202extern void do_IRQ(int, struct pt_regs *);
203
38fef73c
MF
204#if XTENSA_FAKE_NMI
205
e4629194
MF
206#define IS_POW2(v) (((v) & ((v) - 1)) == 0)
207
208#if !(PROFILING_INTLEVEL == XCHAL_EXCM_LEVEL && \
209 IS_POW2(XTENSA_INTLEVEL_MASK(PROFILING_INTLEVEL)))
210#warning "Fake NMI is requested for PMM, but there are other IRQs at or above its level."
211#warning "Fake NMI will be used, but there will be a bugcheck if one of those IRQs fire."
212
213static inline void check_valid_nmi(void)
214{
215 unsigned intread = get_sr(interrupt);
216 unsigned intenable = get_sr(intenable);
217
218 BUG_ON(intread & intenable &
219 ~(XTENSA_INTLEVEL_ANDBELOW_MASK(PROFILING_INTLEVEL) ^
220 XTENSA_INTLEVEL_MASK(PROFILING_INTLEVEL) ^
221 BIT(XCHAL_PROFILING_INTERRUPT)));
222}
223
224#else
225
226static inline void check_valid_nmi(void)
227{
228}
229
230#endif
231
38fef73c
MF
232irqreturn_t xtensa_pmu_irq_handler(int irq, void *dev_id);
233
234DEFINE_PER_CPU(unsigned long, nmi_count);
235
236void do_nmi(struct pt_regs *regs)
237{
238 struct pt_regs *old_regs;
239
240 if ((regs->ps & PS_INTLEVEL_MASK) < LOCKLEVEL)
241 trace_hardirqs_off();
242
243 old_regs = set_irq_regs(regs);
244 nmi_enter();
245 ++*this_cpu_ptr(&nmi_count);
e4629194 246 check_valid_nmi();
38fef73c
MF
247 xtensa_pmu_irq_handler(0, NULL);
248 nmi_exit();
249 set_irq_regs(old_regs);
250}
251#endif
252
2d1c645c 253void do_interrupt(struct pt_regs *regs)
5a0015d6 254{
2d1c645c
MG
255 static const unsigned int_level_mask[] = {
256 0,
257 XCHAL_INTLEVEL1_MASK,
258 XCHAL_INTLEVEL2_MASK,
259 XCHAL_INTLEVEL3_MASK,
260 XCHAL_INTLEVEL4_MASK,
261 XCHAL_INTLEVEL5_MASK,
262 XCHAL_INTLEVEL6_MASK,
263 XCHAL_INTLEVEL7_MASK,
264 };
7d5f6a9a 265 struct pt_regs *old_regs;
99623239 266
7d5f6a9a
MF
267 trace_hardirqs_off();
268
269 old_regs = set_irq_regs(regs);
99623239 270 irq_enter();
5a0015d6 271
2d1c645c
MG
272 for (;;) {
273 unsigned intread = get_sr(interrupt);
274 unsigned intenable = get_sr(intenable);
895666a9
MF
275 unsigned int_at_level = intread & intenable;
276 unsigned level;
277
278 for (level = LOCKLEVEL; level > 0; --level) {
279 if (int_at_level & int_level_mask[level]) {
280 int_at_level &= int_level_mask[level];
281 break;
282 }
283 }
2d1c645c 284
895666a9 285 if (level == 0)
99623239
MF
286 break;
287
288 do_IRQ(__ffs(int_at_level), regs);
5a0015d6 289 }
99623239
MF
290
291 irq_exit();
292 set_irq_regs(old_regs);
5a0015d6
CZ
293}
294
295/*
296 * Illegal instruction. Fatal if in kernel space.
297 */
298
299void
300do_illegal_instruction(struct pt_regs *regs)
301{
302 __die_if_kernel("Illegal instruction in kernel", regs, SIGKILL);
303
304 /* If in user mode, send SIGILL signal to current process. */
305
306 printk("Illegal Instruction in '%s' (pid = %d, pc = %#010lx)\n",
19c5870c 307 current->comm, task_pid_nr(current), regs->pc);
5a0015d6
CZ
308 force_sig(SIGILL, current);
309}
310
311
312/*
313 * Handle unaligned memory accesses from user space. Kill task.
314 *
315 * If CONFIG_UNALIGNED_USER is not set, we don't allow unaligned memory
316 * accesses causes from user space.
317 */
318
319#if XCHAL_UNALIGNED_LOAD_EXCEPTION || XCHAL_UNALIGNED_STORE_EXCEPTION
5a0015d6
CZ
320void
321do_unaligned_user (struct pt_regs *regs)
322{
323 siginfo_t info;
324
325 __die_if_kernel("Unhandled unaligned exception in kernel",
326 regs, SIGKILL);
327
328 current->thread.bad_vaddr = regs->excvaddr;
329 current->thread.error_code = -3;
330 printk("Unaligned memory access to %08lx in '%s' "
331 "(pid = %d, pc = %#010lx)\n",
19c5870c 332 regs->excvaddr, current->comm, task_pid_nr(current), regs->pc);
5a0015d6
CZ
333 info.si_signo = SIGBUS;
334 info.si_errno = 0;
335 info.si_code = BUS_ADRALN;
336 info.si_addr = (void *) regs->excvaddr;
337 force_sig_info(SIGSEGV, &info, current);
338
339}
340#endif
5a0015d6 341
c91e02bd
MF
342/* Handle debug events.
343 * When CONFIG_HAVE_HW_BREAKPOINT is on this handler is called with
344 * preemption disabled to avoid rescheduling and keep mapping of hardware
345 * breakpoint structures to debug registers intact, so that
346 * DEBUGCAUSE.DBNUM could be used in case of data breakpoint hit.
347 */
5a0015d6
CZ
348void
349do_debug(struct pt_regs *regs)
350{
c91e02bd
MF
351#ifdef CONFIG_HAVE_HW_BREAKPOINT
352 int ret = check_hw_breakpoint(regs);
353
354 preempt_enable();
355 if (ret == 0)
356 return;
357#endif
5a0015d6
CZ
358 __die_if_kernel("Breakpoint in kernel", regs, SIGKILL);
359
360 /* If in user mode, send SIGTRAP signal to current process */
361
362 force_sig(SIGTRAP, current);
363}
364
365
f615136c
MF
366static void set_handler(int idx, void *handler)
367{
368 unsigned int cpu;
369
370 for_each_possible_cpu(cpu)
371 per_cpu(exc_table, cpu)[idx] = (unsigned long)handler;
372}
373
28570e8d
MF
374/* Set exception C handler - for temporary use when probing exceptions */
375
376void * __init trap_set_handler(int cause, void *handler)
377{
f615136c
MF
378 void *previous = (void *)per_cpu(exc_table, 0)[
379 EXC_TABLE_DEFAULT / 4 + cause];
380 set_handler(EXC_TABLE_DEFAULT / 4 + cause, handler);
28570e8d
MF
381 return previous;
382}
383
384
49b424fe 385static void trap_init_excsave(void)
f615136c
MF
386{
387 unsigned long excsave1 = (unsigned long)this_cpu_ptr(exc_table);
388 __asm__ __volatile__("wsr %0, excsave1\n" : : "a" (excsave1));
389}
390
6ec7026a
MF
391static void trap_init_debug(void)
392{
393 unsigned long debugsave = (unsigned long)this_cpu_ptr(&debug_table);
394
395 this_cpu_ptr(&debug_table)->debug_exception = debug_exception;
396 __asm__ __volatile__("wsr %0, excsave" __stringify(XCHAL_DEBUGLEVEL)
397 :: "a"(debugsave));
398}
399
5a0015d6
CZ
400/*
401 * Initialize dispatch tables.
402 *
403 * The exception vectors are stored compressed the __init section in the
404 * dispatch_init_table. This function initializes the following three tables
405 * from that compressed table:
406 * - fast user first dispatch table for user exceptions
407 * - fast kernel first dispatch table for kernel exceptions
408 * - default C-handler C-handler called by the default fast handler.
409 *
410 * See vectors.S for more details.
411 */
412
b91dc336 413void __init trap_init(void)
5a0015d6
CZ
414{
415 int i;
416
417 /* Setup default vectors. */
418
419 for(i = 0; i < 64; i++) {
420 set_handler(EXC_TABLE_FAST_USER/4 + i, user_exception);
421 set_handler(EXC_TABLE_FAST_KERNEL/4 + i, kernel_exception);
422 set_handler(EXC_TABLE_DEFAULT/4 + i, do_unhandled);
423 }
424
425 /* Setup specific handlers. */
426
427 for(i = 0; dispatch_init_table[i].cause >= 0; i++) {
428
429 int fast = dispatch_init_table[i].fast;
430 int cause = dispatch_init_table[i].cause;
431 void *handler = dispatch_init_table[i].handler;
432
433 if (fast == 0)
434 set_handler (EXC_TABLE_DEFAULT/4 + cause, handler);
435 if (fast && fast & USER)
436 set_handler (EXC_TABLE_FAST_USER/4 + cause, handler);
437 if (fast && fast & KRNL)
438 set_handler (EXC_TABLE_FAST_KERNEL/4 + cause, handler);
439 }
440
441 /* Initialize EXCSAVE_1 to hold the address of the exception table. */
f615136c 442 trap_init_excsave();
6ec7026a 443 trap_init_debug();
f615136c 444}
5a0015d6 445
f615136c 446#ifdef CONFIG_SMP
49b424fe 447void secondary_trap_init(void)
f615136c
MF
448{
449 trap_init_excsave();
6ec7026a 450 trap_init_debug();
5a0015d6 451}
f615136c 452#endif
5a0015d6
CZ
453
454/*
455 * This function dumps the current valid window frame and other base registers.
456 */
457
458void show_regs(struct pt_regs * regs)
459{
460 int i, wmask;
461
a43cb95d
TH
462 show_regs_print_info(KERN_DEFAULT);
463
5a0015d6
CZ
464 wmask = regs->wmask & ~1;
465
8d7e8240 466 for (i = 0; i < 16; i++) {
5a0015d6 467 if ((i % 8) == 0)
d4eccafc
MF
468 pr_info("a%02d:", i);
469 pr_cont(" %08lx", regs->areg[i]);
5a0015d6 470 }
d4eccafc
MF
471 pr_cont("\n");
472 pr_info("pc: %08lx, ps: %08lx, depc: %08lx, excvaddr: %08lx\n",
473 regs->pc, regs->ps, regs->depc, regs->excvaddr);
474 pr_info("lbeg: %08lx, lend: %08lx lcount: %08lx, sar: %08lx\n",
475 regs->lbeg, regs->lend, regs->lcount, regs->sar);
5a0015d6 476 if (user_mode(regs))
d4eccafc
MF
477 pr_cont("wb: %08lx, ws: %08lx, wmask: %08lx, syscall: %ld\n",
478 regs->windowbase, regs->windowstart, regs->wmask,
479 regs->syscall);
5a0015d6
CZ
480}
481
3e4196a5 482static int show_trace_cb(struct stackframe *frame, void *data)
586411dc 483{
3e4196a5 484 if (kernel_text_address(frame->pc)) {
d4eccafc
MF
485 pr_cont(" [<%08lx>]", frame->pc);
486 print_symbol(" %s\n", frame->pc);
3e4196a5
MF
487 }
488 return 0;
586411dc
JW
489}
490
5a0015d6
CZ
491void show_trace(struct task_struct *task, unsigned long *sp)
492{
3e4196a5
MF
493 if (!sp)
494 sp = stack_pointer(task);
5a0015d6 495
d4eccafc 496 pr_info("Call Trace:\n");
3e4196a5 497 walk_stackframe(sp, show_trace_cb, NULL);
d4eccafc
MF
498#ifndef CONFIG_KALLSYMS
499 pr_cont("\n");
500#endif
5a0015d6
CZ
501}
502
5a0015d6
CZ
503static int kstack_depth_to_print = 24;
504
505void show_stack(struct task_struct *task, unsigned long *sp)
506{
507 int i = 0;
508 unsigned long *stack;
509
28a0ce7f 510 if (!sp)
586411dc 511 sp = stack_pointer(task);
c4c4594b 512 stack = sp;
5a0015d6 513
d4eccafc 514 pr_info("Stack:\n");
5a0015d6
CZ
515
516 for (i = 0; i < kstack_depth_to_print; i++) {
517 if (kstack_end(sp))
518 break;
d4eccafc
MF
519 pr_cont(" %08lx", *sp++);
520 if (i % 8 == 7)
521 pr_cont("\n");
5a0015d6 522 }
5a0015d6
CZ
523 show_trace(task, stack);
524}
525
34af946a 526DEFINE_SPINLOCK(die_lock);
5a0015d6
CZ
527
528void die(const char * str, struct pt_regs * regs, long err)
529{
530 static int die_counter;
5a0015d6
CZ
531
532 console_verbose();
533 spin_lock_irq(&die_lock);
534
d4eccafc
MF
535 pr_info("%s: sig: %ld [#%d]%s\n", str, err, ++die_counter,
536 IS_ENABLED(CONFIG_PREEMPT) ? " PREEMPT" : "");
5a0015d6
CZ
537 show_regs(regs);
538 if (!user_mode(regs))
539 show_stack(NULL, (unsigned long*)regs->areg[1]);
540
373d4d09 541 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
5a0015d6
CZ
542 spin_unlock_irq(&die_lock);
543
544 if (in_interrupt())
545 panic("Fatal exception in interrupt");
546
cea6a4ba 547 if (panic_on_oops)
012c437d 548 panic("Fatal exception");
cea6a4ba 549
5a0015d6
CZ
550 do_exit(err);
551}