2 * linux/arch/parisc/traps.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1999, 2000 Philipp Rumpf <prumpf@tux.org>
9 * 'Traps.c' handles hardware traps and faults after we have saved some
13 #include <linux/sched.h>
14 #include <linux/kernel.h>
15 #include <linux/string.h>
16 #include <linux/errno.h>
17 #include <linux/ptrace.h>
18 #include <linux/timer.h>
19 #include <linux/delay.h>
21 #include <linux/module.h>
22 #include <linux/smp.h>
23 #include <linux/smp_lock.h>
24 #include <linux/spinlock.h>
25 #include <linux/init.h>
26 #include <linux/interrupt.h>
27 #include <linux/console.h>
28 #include <linux/kallsyms.h>
29 #include <linux/bug.h>
31 #include <asm/assembly.h>
32 #include <asm/system.h>
33 #include <asm/uaccess.h>
36 #include <asm/traps.h>
37 #include <asm/unaligned.h>
38 #include <asm/atomic.h>
41 #include <asm/pdc_chassis.h>
42 #include <asm/unwind.h>
43 #include <asm/tlbflush.h>
44 #include <asm/cacheflush.h>
46 #include "../math-emu/math-emu.h" /* for handle_fpe() */
48 #define PRINT_USER_FAULTS /* (turn this on if you want user faults to be */
49 /* dumped to the console via printk) */
51 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
52 DEFINE_SPINLOCK(pa_dbit_lock);
55 static int printbinary(char *buf, unsigned long x, int nbits)
57 unsigned long mask = 1UL << (nbits - 1);
59 *buf++ = (mask & x ? '1' : '0');
72 #define FFMT "%016llx" /* fpregs are 64-bit always */
74 #define PRINTREGS(lvl,r,f,fmt,x) \
75 printk("%s%s%02d-%02d " fmt " " fmt " " fmt " " fmt "\n", \
76 lvl, f, (x), (x+3), (r)[(x)+0], (r)[(x)+1], \
77 (r)[(x)+2], (r)[(x)+3])
79 static void print_gr(char *level, struct pt_regs *regs)
84 printk("%s\n", level);
85 printk("%s YZrvWESTHLNXBCVMcbcbcbcbOGFRQPDI\n", level);
86 printbinary(buf, regs->gr[0], 32);
87 printk("%sPSW: %s %s\n", level, buf, print_tainted());
89 for (i = 0; i < 32; i += 4)
90 PRINTREGS(level, regs->gr, "r", RFMT, i);
93 static void print_fr(char *level, struct pt_regs *regs)
97 struct { u32 sw[2]; } s;
99 /* FR are 64bit everywhere. Need to use asm to get the content
100 * of fpsr/fper1, and we assume that we won't have a FP Identify
101 * in our way, otherwise we're screwed.
102 * The fldd is used to restore the T-bit if there was one, as the
103 * store clears it anyway.
104 * PA2.0 book says "thou shall not use fstw on FPSR/FPERs" - T-Bone */
105 asm volatile ("fstd %%fr0,0(%1) \n\t"
106 "fldd 0(%1),%%fr0 \n\t"
107 : "=m" (s) : "r" (&s) : "r0");
109 printk("%s\n", level);
110 printk("%s VZOUICununcqcqcqcqcqcrmunTDVZOUI\n", level);
111 printbinary(buf, s.sw[0], 32);
112 printk("%sFPSR: %s\n", level, buf);
113 printk("%sFPER1: %08x\n", level, s.sw[1]);
115 /* here we'll print fr0 again, tho it'll be meaningless */
116 for (i = 0; i < 32; i += 4)
117 PRINTREGS(level, regs->fr, "fr", FFMT, i);
120 void show_regs(struct pt_regs *regs)
124 unsigned long cr30, cr31;
126 level = user_mode(regs) ? KERN_DEBUG : KERN_CRIT;
128 print_gr(level, regs);
130 for (i = 0; i < 8; i += 4)
131 PRINTREGS(level, regs->sr, "sr", RFMT, i);
134 print_fr(level, regs);
138 printk("%s\n", level);
139 printk("%sIASQ: " RFMT " " RFMT " IAOQ: " RFMT " " RFMT "\n",
140 level, regs->iasq[0], regs->iasq[1], regs->iaoq[0], regs->iaoq[1]);
141 printk("%s IIR: %08lx ISR: " RFMT " IOR: " RFMT "\n",
142 level, regs->iir, regs->isr, regs->ior);
143 printk("%s CPU: %8d CR30: " RFMT " CR31: " RFMT "\n",
144 level, current_thread_info()->cpu, cr30, cr31);
145 printk("%s ORIG_R28: " RFMT "\n", level, regs->orig_r28);
147 print_symbol(" IAOQ[0]: %s\n", regs->iaoq[0]);
149 print_symbol(" IAOQ[1]: %s\n", regs->iaoq[1]);
151 print_symbol(" RP(r2): %s\n", regs->gr[2]);
155 void dump_stack(void)
157 show_stack(NULL, NULL);
160 EXPORT_SYMBOL(dump_stack);
162 static void do_show_stack(struct unwind_frame_info *info)
166 printk("Backtrace:\n");
168 if (unwind_once(info) < 0 || info->ip == 0)
171 if (__kernel_text_address(info->ip)) {
172 printk(" [<" RFMT ">] ", info->ip);
173 #ifdef CONFIG_KALLSYMS
174 print_symbol("%s\n", info->ip);
185 void show_stack(struct task_struct *task, unsigned long *s)
187 struct unwind_frame_info info;
193 asm volatile ("copy %%r30, %0" : "=r"(sp));
197 memset(&r, 0, sizeof(struct pt_regs));
198 r.iaoq[0] = (unsigned long)&&HERE;
199 r.gr[2] = (unsigned long)__builtin_return_address(0);
202 unwind_frame_init(&info, current, &r);
205 unwind_frame_init_from_blocked_task(&info, task);
208 do_show_stack(&info);
211 int is_valid_bugaddr(unsigned long iaoq)
216 void die_if_kernel(char *str, struct pt_regs *regs, long err)
218 if (user_mode(regs)) {
222 printk(KERN_CRIT "%s (pid %d): %s (code %ld) at " RFMT "\n",
223 current->comm, current->pid, str, err, regs->iaoq[0]);
224 #ifdef PRINT_USER_FAULTS
225 /* XXX for debugging only */
231 oops_in_progress = 1;
233 /* Amuse the user in a SPARC fashion */
235 " _______________________________ \n"
236 " < Your System ate a SPARC! Gah! >\n"
237 " ------------------------------- \n"
239 " \\ (xx)\\_______\n"
244 /* unlock the pdc lock if necessary */
245 pdc_emergency_unlock();
247 /* maybe the kernel hasn't booted very far yet and hasn't been able
248 * to initialize the serial or STI console. In that case we should
249 * re-enable the pdc console, so that the user will be able to
250 * identify the problem. */
251 if (!console_drivers)
252 pdc_console_restart();
255 printk(KERN_CRIT "%s (pid %d): %s (code %ld)\n",
256 current->comm, current->pid, str, err);
260 panic("Fatal exception in interrupt");
263 printk(KERN_EMERG "Fatal exception: panic in 5 seconds\n");
265 panic("Fatal exception");
268 /* Wot's wrong wif bein' racy? */
269 if (current->thread.flags & PARISC_KERNEL_DEATH) {
270 printk(KERN_CRIT "%s() recursion detected.\n", __FUNCTION__);
275 current->thread.flags |= PARISC_KERNEL_DEATH;
279 int syscall_ipi(int (*syscall) (struct pt_regs *), struct pt_regs *regs)
281 return syscall(regs);
284 /* gdb uses break 4,8 */
285 #define GDB_BREAK_INSN 0x10004
286 static void handle_gdb_break(struct pt_regs *regs, int wot)
290 si.si_signo = SIGTRAP;
293 si.si_addr = (void __user *) (regs->iaoq[0] & ~3);
294 force_sig_info(SIGTRAP, &si, current);
297 static void handle_break(struct pt_regs *regs)
299 unsigned iir = regs->iir;
301 if (unlikely(iir == PARISC_BUG_BREAK_INSN && !user_mode(regs))) {
302 /* check if a BUG() or WARN() trapped here. */
303 enum bug_trap_type tt;
304 tt = report_bug(regs->iaoq[0] & ~3);
305 if (tt == BUG_TRAP_TYPE_WARN) {
308 return; /* return to next instruction when WARN_ON(). */
310 die_if_kernel("Unknown kernel breakpoint", regs,
311 (tt == BUG_TRAP_TYPE_NONE) ? 9 : 0);
314 #ifdef PRINT_USER_FAULTS
315 if (unlikely(iir != GDB_BREAK_INSN)) {
316 printk(KERN_DEBUG "break %d,%d: pid=%d command='%s'\n",
317 (iir>>13) & ((1<<13)-1), iir & 31,
318 current->pid, current->comm);
323 /* send standard GDB signal */
324 handle_gdb_break(regs, TRAP_BRKPT);
327 static void default_trap(int code, struct pt_regs *regs)
329 printk(KERN_ERR "Trap %d on CPU %d\n", code, smp_processor_id());
333 void (*cpu_lpmc) (int code, struct pt_regs *regs) __read_mostly = default_trap;
336 void transfer_pim_to_trap_frame(struct pt_regs *regs)
339 extern unsigned int hpmc_pim_data[];
340 struct pdc_hpmc_pim_11 *pim_narrow;
341 struct pdc_hpmc_pim_20 *pim_wide;
343 if (boot_cpu_data.cpu_type >= pcxu) {
345 pim_wide = (struct pdc_hpmc_pim_20 *)hpmc_pim_data;
348 * Note: The following code will probably generate a
349 * bunch of truncation error warnings from the compiler.
350 * Could be handled with an ifdef, but perhaps there
354 regs->gr[0] = pim_wide->cr[22];
356 for (i = 1; i < 32; i++)
357 regs->gr[i] = pim_wide->gr[i];
359 for (i = 0; i < 32; i++)
360 regs->fr[i] = pim_wide->fr[i];
362 for (i = 0; i < 8; i++)
363 regs->sr[i] = pim_wide->sr[i];
365 regs->iasq[0] = pim_wide->cr[17];
366 regs->iasq[1] = pim_wide->iasq_back;
367 regs->iaoq[0] = pim_wide->cr[18];
368 regs->iaoq[1] = pim_wide->iaoq_back;
370 regs->sar = pim_wide->cr[11];
371 regs->iir = pim_wide->cr[19];
372 regs->isr = pim_wide->cr[20];
373 regs->ior = pim_wide->cr[21];
376 pim_narrow = (struct pdc_hpmc_pim_11 *)hpmc_pim_data;
378 regs->gr[0] = pim_narrow->cr[22];
380 for (i = 1; i < 32; i++)
381 regs->gr[i] = pim_narrow->gr[i];
383 for (i = 0; i < 32; i++)
384 regs->fr[i] = pim_narrow->fr[i];
386 for (i = 0; i < 8; i++)
387 regs->sr[i] = pim_narrow->sr[i];
389 regs->iasq[0] = pim_narrow->cr[17];
390 regs->iasq[1] = pim_narrow->iasq_back;
391 regs->iaoq[0] = pim_narrow->cr[18];
392 regs->iaoq[1] = pim_narrow->iaoq_back;
394 regs->sar = pim_narrow->cr[11];
395 regs->iir = pim_narrow->cr[19];
396 regs->isr = pim_narrow->cr[20];
397 regs->ior = pim_narrow->cr[21];
401 * The following fields only have meaning if we came through
402 * another path. So just zero them here.
412 * This routine is called as a last resort when everything else
413 * has gone clearly wrong. We get called for faults in kernel space,
416 void parisc_terminate(char *msg, struct pt_regs *regs, int code, unsigned long offset)
418 static DEFINE_SPINLOCK(terminate_lock);
420 oops_in_progress = 1;
424 spin_lock(&terminate_lock);
426 /* unlock the pdc lock if necessary */
427 pdc_emergency_unlock();
429 /* restart pdc console if necessary */
430 if (!console_drivers)
431 pdc_console_restart();
433 /* Not all paths will gutter the processor... */
437 transfer_pim_to_trap_frame(regs);
447 /* show_stack(NULL, (unsigned long *)regs->gr[30]); */
448 struct unwind_frame_info info;
449 unwind_frame_init(&info, current, regs);
450 do_show_stack(&info);
454 printk(KERN_CRIT "%s: Code=%d regs=%p (Addr=" RFMT ")\n",
455 msg, code, regs, offset);
458 spin_unlock(&terminate_lock);
460 /* put soft power button back under hardware control;
461 * if the user had pressed it once at any time, the
462 * system will shut down immediately right here. */
463 pdc_soft_power_button(0);
465 /* Call kernel panic() so reboot timeouts work properly
466 * FIXME: This function should be on the list of
467 * panic notifiers, and we should call panic
468 * directly from the location that we wish.
469 * e.g. We should not call panic from
470 * parisc_terminate, but rather the oter way around.
471 * This hack works, prints the panic message twice,
472 * and it enables reboot timers!
477 void handle_interruption(int code, struct pt_regs *regs)
479 unsigned long fault_address = 0;
480 unsigned long fault_space = 0;
484 pdc_console_restart(); /* switch back to pdc if HPMC */
489 * If the priority level is still user, and the
490 * faulting space is not equal to the active space
491 * then the user is attempting something in a space
492 * that does not belong to them. Kill the process.
494 * This is normally the situation when the user
495 * attempts to jump into the kernel space at the
496 * wrong offset, be it at the gateway page or a
499 * We cannot normally signal the process because it
500 * could *be* on the gateway page, and processes
501 * executing on the gateway page can't have signals
504 * We merely readjust the address into the users
505 * space, at a destination address of zero, and
506 * allow processing to continue.
508 if (((unsigned long)regs->iaoq[0] & 3) &&
509 ((unsigned long)regs->iasq[0] != (unsigned long)regs->sr[7])) {
510 /* Kill the user process later */
511 regs->iaoq[0] = 0 | 3;
512 regs->iaoq[1] = regs->iaoq[0] + 4;
513 regs->iasq[0] = regs->iasq[0] = regs->sr[7];
514 regs->gr[0] &= ~PSW_B;
519 printk(KERN_CRIT "Interruption # %d\n", code);
525 /* High-priority machine check (HPMC) */
527 /* set up a new led state on systems shipped with a LED State panel */
528 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_HPMC);
530 parisc_terminate("High Priority Machine Check (HPMC)",
535 /* Power failure interrupt */
536 printk(KERN_CRIT "Power failure interrupt !\n");
540 /* Recovery counter trap */
541 regs->gr[0] &= ~PSW_R;
542 if (user_space(regs))
543 handle_gdb_break(regs, TRAP_TRACE);
544 /* else this must be the start of a syscall - just let it run */
548 /* Low-priority machine check */
549 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_LPMC);
557 /* Instruction TLB miss fault/Instruction page fault */
558 fault_address = regs->iaoq[0];
559 fault_space = regs->iasq[0];
563 /* Illegal instruction trap */
564 die_if_kernel("Illegal instruction", regs, code);
565 si.si_code = ILL_ILLOPC;
569 /* Break instruction trap */
574 /* Privileged operation trap */
575 die_if_kernel("Privileged operation", regs, code);
576 si.si_code = ILL_PRVOPC;
580 /* Privileged register trap */
581 if ((regs->iir & 0xffdfffe0) == 0x034008a0) {
583 /* This is a MFCTL cr26/cr27 to gr instruction.
584 * PCXS traps on this, so we need to emulate it.
587 if (regs->iir & 0x00200000)
588 regs->gr[regs->iir & 0x1f] = mfctl(27);
590 regs->gr[regs->iir & 0x1f] = mfctl(26);
592 regs->iaoq[0] = regs->iaoq[1];
594 regs->iasq[0] = regs->iasq[1];
598 die_if_kernel("Privileged register usage", regs, code);
599 si.si_code = ILL_PRVREG;
601 si.si_signo = SIGILL;
603 si.si_addr = (void __user *) regs->iaoq[0];
604 force_sig_info(SIGILL, &si, current);
608 /* Overflow Trap, let the userland signal handler do the cleanup */
609 si.si_signo = SIGFPE;
610 si.si_code = FPE_INTOVF;
611 si.si_addr = (void __user *) regs->iaoq[0];
612 force_sig_info(SIGFPE, &si, current);
617 The condition succees in an instruction which traps
620 si.si_signo = SIGFPE;
621 /* Set to zero, and let the userspace app figure it out from
622 the insn pointed to by si_addr */
624 si.si_addr = (void __user *) regs->iaoq[0];
625 force_sig_info(SIGFPE, &si, current);
628 /* The kernel doesn't want to handle condition codes */
632 /* Assist Exception Trap, i.e. floating point exception. */
633 die_if_kernel("Floating point exception", regs, 0); /* quiet */
638 /* Data TLB miss fault/Data page fault */
641 /* Non-access instruction TLB miss fault */
642 /* The instruction TLB entry needed for the target address of the FIC
643 is absent, and hardware can't find it, so we get to cleanup */
646 /* Non-access data TLB miss fault/Non-access data page fault */
648 Still need to add slow path emulation code here!
649 If the insn used a non-shadow register, then the tlb
650 handlers could not have their side-effect (e.g. probe
651 writing to a target register) emulated since rfir would
652 erase the changes to said register. Instead we have to
653 setup everything, call this function we are in, and emulate
654 by hand. Technically we need to emulate:
655 fdc,fdce,pdc,"fic,4f",prober,probeir,probew, probeiw
657 fault_address = regs->ior;
658 fault_space = regs->isr;
662 /* PCXS only -- later cpu's split this into types 26,27 & 28 */
663 /* Check for unaligned access */
664 if (check_unaligned(regs)) {
665 handle_unaligned(regs);
670 /* PCXL: Data memory access rights trap */
671 fault_address = regs->ior;
672 fault_space = regs->isr;
676 /* Data memory break trap */
677 regs->gr[0] |= PSW_X; /* So we can single-step over the trap */
680 /* Page reference trap */
681 handle_gdb_break(regs, TRAP_HWBKPT);
685 /* Taken branch trap */
686 regs->gr[0] &= ~PSW_T;
687 if (user_space(regs))
688 handle_gdb_break(regs, TRAP_BRANCH);
689 /* else this must be the start of a syscall - just let it
695 /* Instruction access rights */
696 /* PCXL: Instruction memory protection trap */
699 * This could be caused by either: 1) a process attempting
700 * to execute within a vma that does not have execute
701 * permission, or 2) an access rights violation caused by a
702 * flush only translation set up by ptep_get_and_clear().
703 * So we check the vma permissions to differentiate the two.
704 * If the vma indicates we have execute permission, then
705 * the cause is the latter one. In this case, we need to
706 * call do_page_fault() to fix the problem.
709 if (user_mode(regs)) {
710 struct vm_area_struct *vma;
712 down_read(¤t->mm->mmap_sem);
713 vma = find_vma(current->mm,regs->iaoq[0]);
714 if (vma && (regs->iaoq[0] >= vma->vm_start)
715 && (vma->vm_flags & VM_EXEC)) {
717 fault_address = regs->iaoq[0];
718 fault_space = regs->iasq[0];
720 up_read(¤t->mm->mmap_sem);
721 break; /* call do_page_fault() */
723 up_read(¤t->mm->mmap_sem);
727 /* Data memory protection ID trap */
728 die_if_kernel("Protection id trap", regs, code);
729 si.si_code = SEGV_MAPERR;
730 si.si_signo = SIGSEGV;
733 si.si_addr = (void __user *) regs->iaoq[0];
735 si.si_addr = (void __user *) regs->ior;
736 force_sig_info(SIGSEGV, &si, current);
740 /* Unaligned data reference trap */
741 handle_unaligned(regs);
745 if (user_mode(regs)) {
746 #ifdef PRINT_USER_FAULTS
747 printk(KERN_DEBUG "\nhandle_interruption() pid=%d command='%s'\n",
748 current->pid, current->comm);
751 /* SIGBUS, for lack of a better one. */
752 si.si_signo = SIGBUS;
753 si.si_code = BUS_OBJERR;
755 si.si_addr = (void __user *) regs->ior;
756 force_sig_info(SIGBUS, &si, current);
759 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC);
761 parisc_terminate("Unexpected interruption", regs, code, 0);
765 if (user_mode(regs)) {
766 if ((fault_space >> SPACEID_SHIFT) != (regs->sr[7] >> SPACEID_SHIFT)) {
767 #ifdef PRINT_USER_FAULTS
768 if (fault_space == 0)
769 printk(KERN_DEBUG "User Fault on Kernel Space ");
771 printk(KERN_DEBUG "User Fault (long pointer) (fault %d) ",
773 printk("pid=%d command='%s'\n", current->pid, current->comm);
776 si.si_signo = SIGSEGV;
778 si.si_code = SEGV_MAPERR;
779 si.si_addr = (void __user *) regs->ior;
780 force_sig_info(SIGSEGV, &si, current);
787 * The kernel should never fault on its own address space.
790 if (fault_space == 0)
792 pdc_chassis_send_status(PDC_CHASSIS_DIRECT_PANIC);
793 parisc_terminate("Kernel Fault", regs, code, fault_address);
798 do_page_fault(regs, code, fault_address);
802 int __init check_ivt(void *iva)
809 extern void os_hpmc(void);
810 extern void os_hpmc_end(void);
812 if (strcmp((char *)iva, "cows can fly"))
817 for (i = 0; i < 8; i++)
820 /* Compute Checksum for HPMC handler */
822 length = (u32)((unsigned long)os_hpmc_end - (unsigned long)os_hpmc);
825 hpmcp = (u32 *)os_hpmc;
827 for (i=0; i<length/4; i++)
839 extern const void fault_vector_11;
841 extern const void fault_vector_20;
843 void __init trap_init(void)
847 if (boot_cpu_data.cpu_type >= pcxu)
848 iva = (void *) &fault_vector_20;
851 panic("Can't boot 64-bit OS on PA1.1 processor!");
853 iva = (void *) &fault_vector_11;
857 panic("IVT invalid");