2 * Architecture-specific trap handling.
4 * Copyright (C) 1998-2003 Hewlett-Packard Co
5 * David Mosberger-Tang <davidm@hpl.hp.com>
7 * 05/12/00 grao <goutham.rao@intel.com> : added isr in siginfo for SIGFPE
10 #include <linux/kernel.h>
11 #include <linux/init.h>
12 #include <linux/sched.h>
13 #include <linux/tty.h>
14 #include <linux/vt_kern.h> /* For unblank_screen() */
15 #include <linux/module.h> /* for EXPORT_SYMBOL */
16 #include <linux/hardirq.h>
17 #include <linux/kprobes.h>
18 #include <linux/delay.h> /* for ssleep() */
20 #include <asm/fpswa.h>
22 #include <asm/intrinsics.h>
23 #include <asm/processor.h>
24 #include <asm/uaccess.h>
25 #include <asm/kdebug.h>
27 extern spinlock_t timerlist_lock;
29 fpswa_interface_t *fpswa_interface;
30 EXPORT_SYMBOL(fpswa_interface);
32 ATOMIC_NOTIFIER_HEAD(ia64die_chain);
35 register_die_notifier(struct notifier_block *nb)
37 return atomic_notifier_chain_register(&ia64die_chain, nb);
39 EXPORT_SYMBOL_GPL(register_die_notifier);
42 unregister_die_notifier(struct notifier_block *nb)
44 return atomic_notifier_chain_unregister(&ia64die_chain, nb);
46 EXPORT_SYMBOL_GPL(unregister_die_notifier);
51 if (ia64_boot_param->fpswa)
52 /* FPSWA fixup: make the interface pointer a kernel virtual address: */
53 fpswa_interface = __va(ia64_boot_param->fpswa);
57 * Unlock any spinlocks which will prevent us from getting the message out (timerlist_lock
58 * is acquired through the console unblank code)
61 bust_spinlocks (int yes)
63 int loglevel_save = console_loglevel;
75 * OK, the message is on the console. Now we call printk() without
76 * oops_in_progress set so that printk will give klogd a poke. Hold onto
79 console_loglevel = 15; /* NMI oopser may have shut the console up */
81 console_loglevel = loglevel_save;
85 die (const char *str, struct pt_regs *regs, long err)
92 .lock = SPIN_LOCK_UNLOCKED,
96 static int die_counter;
99 if (die.lock_owner != cpu) {
101 spin_lock_irq(&die.lock);
102 die.lock_owner = cpu;
103 die.lock_owner_depth = 0;
108 if (++die.lock_owner_depth < 3) {
109 printk("%s[%d[#%u]]: %s %ld [%d]\n",
110 current->comm, current->pid, current->xid,
111 str, err, ++die_counter);
112 (void) notify_die(DIE_OOPS, (char *)str, regs, err, 255, SIGSEGV);
115 printk(KERN_ERR "Recursive die() failure, output suppressed\n");
119 spin_unlock_irq(&die.lock);
122 panic("Fatal exception");
128 die_if_kernel (char *str, struct pt_regs *regs, long err)
130 if (!user_mode(regs))
135 __kprobes ia64_bad_break (unsigned long break_num, struct pt_regs *regs)
140 /* SIGILL, SIGFPE, SIGSEGV, and SIGBUS want these field initialized: */
141 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
142 siginfo.si_imm = break_num;
143 siginfo.si_flags = 0; /* clear __ISR_VALID */
147 case 0: /* unknown error (used by GCC for __builtin_abort()) */
148 if (notify_die(DIE_BREAK, "break 0", regs, break_num, TRAP_BRKPT, SIGTRAP)
151 die_if_kernel("bugcheck!", regs, break_num);
152 sig = SIGILL; code = ILL_ILLOPC;
155 case 1: /* integer divide by zero */
156 sig = SIGFPE; code = FPE_INTDIV;
159 case 2: /* integer overflow */
160 sig = SIGFPE; code = FPE_INTOVF;
163 case 3: /* range check/bounds check */
164 sig = SIGFPE; code = FPE_FLTSUB;
167 case 4: /* null pointer dereference */
168 sig = SIGSEGV; code = SEGV_MAPERR;
171 case 5: /* misaligned data */
172 sig = SIGSEGV; code = BUS_ADRALN;
175 case 6: /* decimal overflow */
176 sig = SIGFPE; code = __FPE_DECOVF;
179 case 7: /* decimal divide by zero */
180 sig = SIGFPE; code = __FPE_DECDIV;
183 case 8: /* packed decimal error */
184 sig = SIGFPE; code = __FPE_DECERR;
187 case 9: /* invalid ASCII digit */
188 sig = SIGFPE; code = __FPE_INVASC;
191 case 10: /* invalid decimal digit */
192 sig = SIGFPE; code = __FPE_INVDEC;
195 case 11: /* paragraph stack overflow */
196 sig = SIGSEGV; code = __SEGV_PSTKOVF;
199 case 0x3f000 ... 0x3ffff: /* bundle-update in progress */
200 sig = SIGILL; code = __ILL_BNDMOD;
204 if (break_num < 0x40000 || break_num > 0x100000)
205 die_if_kernel("Bad break", regs, break_num);
207 if (break_num < 0x80000) {
208 sig = SIGILL; code = __ILL_BREAK;
210 if (notify_die(DIE_BREAK, "bad break", regs, break_num, TRAP_BRKPT, SIGTRAP)
213 sig = SIGTRAP; code = TRAP_BRKPT;
216 siginfo.si_signo = sig;
217 siginfo.si_errno = 0;
218 siginfo.si_code = code;
219 force_sig_info(sig, &siginfo, current);
223 * disabled_fph_fault() is called when a user-level process attempts to access f32..f127
224 * and it doesn't own the fp-high register partition. When this happens, we save the
225 * current fph partition in the task_struct of the fpu-owner (if necessary) and then load
226 * the fp-high partition of the current task (if necessary). Note that the kernel has
227 * access to fph by the time we get here, as the IVT's "Disabled FP-Register" handler takes
228 * care of clearing psr.dfh.
231 disabled_fph_fault (struct pt_regs *regs)
233 struct ia64_psr *psr = ia64_psr(regs);
235 /* first, grant user-level access to fph partition: */
239 * Make sure that no other task gets in on this processor
240 * while we're claiming the FPU
245 struct task_struct *fpu_owner
246 = (struct task_struct *)ia64_get_kr(IA64_KR_FPU_OWNER);
248 if (ia64_is_local_fpu_owner(current)) {
249 preempt_enable_no_resched();
254 ia64_flush_fph(fpu_owner);
256 #endif /* !CONFIG_SMP */
257 ia64_set_local_fpu_owner(current);
258 if ((current->thread.flags & IA64_THREAD_FPH_VALID) != 0) {
259 __ia64_load_fpu(current->thread.fph);
264 * Set mfh because the state in thread.fph does not match the state in
269 preempt_enable_no_resched();
273 fp_emulate (int fp_fault, void *bundle, long *ipsr, long *fpsr, long *isr, long *pr, long *ifs,
274 struct pt_regs *regs)
279 if (!fpswa_interface)
282 memset(&fp_state, 0, sizeof(fp_state_t));
285 * compute fp_state. only FP registers f6 - f11 are used by the
286 * kernel, so set those bits in the mask and set the low volatile
287 * pointer to point to these registers.
289 fp_state.bitmask_low64 = 0xfc0; /* bit6..bit11 */
291 fp_state.fp_state_low_volatile = (fp_state_low_volatile_t *) ®s->f6;
293 * unsigned long (*EFI_FPSWA) (
294 * unsigned long trap_type,
296 * unsigned long *pipsr,
297 * unsigned long *pfsr,
298 * unsigned long *pisr,
299 * unsigned long *ppreds,
300 * unsigned long *pifs,
303 ret = (*fpswa_interface->fpswa)((unsigned long) fp_fault, bundle,
304 (unsigned long *) ipsr, (unsigned long *) fpsr,
305 (unsigned long *) isr, (unsigned long *) pr,
306 (unsigned long *) ifs, &fp_state);
315 static DEFINE_PER_CPU(struct fpu_swa_msg, cpulast);
316 DECLARE_PER_CPU(struct fpu_swa_msg, cpulast);
317 static struct fpu_swa_msg last __cacheline_aligned;
321 * Handle floating-point assist faults and traps.
324 handle_fpu_swa (int fp_fault, struct pt_regs *regs, unsigned long isr)
326 long exception, bundle[2];
327 unsigned long fault_ip;
328 struct siginfo siginfo;
330 fault_ip = regs->cr_iip;
331 if (!fp_fault && (ia64_psr(regs)->ri == 0))
333 if (copy_from_user(bundle, (void __user *) fault_ip, sizeof(bundle)))
336 if (!(current->thread.flags & IA64_THREAD_FPEMU_NOPRINT)) {
337 unsigned long count, current_jiffies = jiffies;
338 struct fpu_swa_msg *cp = &__get_cpu_var(cpulast);
340 if (unlikely(current_jiffies > cp->time))
342 if (unlikely(cp->count < 5)) {
344 cp->time = current_jiffies + 5 * HZ;
346 /* minimize races by grabbing a copy of count BEFORE checking last.time. */
351 * Lower 4 bits are used as a count. Upper bits are a sequence
352 * number that is updated when count is reset. The cmpxchg will
353 * fail is seqno has changed. This minimizes mutiple cpus
354 * reseting the count.
356 if (current_jiffies > last.time)
357 (void) cmpxchg_acq(&last.count, count, 16 + (count & ~15));
359 /* used fetchadd to atomically update the count */
360 if ((last.count & 15) < 5 && (ia64_fetchadd(1, &last.count, acq) & 15) < 5) {
361 last.time = current_jiffies + 5 * HZ;
363 "%s(%d[#%u]): floating-point assist fault at ip %016lx, isr %016lx\n",
364 current->comm, current->pid, current->xid,
365 regs->cr_iip + ia64_psr(regs)->ri, isr);
370 exception = fp_emulate(fp_fault, bundle, ®s->cr_ipsr, ®s->ar_fpsr, &isr, ®s->pr,
371 ®s->cr_ifs, regs);
373 if (exception == 0) {
374 /* emulation was successful */
375 ia64_increment_ip(regs);
376 } else if (exception == -1) {
377 printk(KERN_ERR "handle_fpu_swa: fp_emulate() returned -1\n");
380 /* is next instruction a trap? */
382 ia64_increment_ip(regs);
384 siginfo.si_signo = SIGFPE;
385 siginfo.si_errno = 0;
386 siginfo.si_code = __SI_FAULT; /* default code */
387 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
389 siginfo.si_code = FPE_FLTINV;
390 } else if (isr & 0x22) {
391 /* denormal operand gets the same si_code as underflow
392 * see arch/i386/kernel/traps.c:math_error() */
393 siginfo.si_code = FPE_FLTUND;
394 } else if (isr & 0x44) {
395 siginfo.si_code = FPE_FLTDIV;
397 siginfo.si_isr = isr;
398 siginfo.si_flags = __ISR_VALID;
400 force_sig_info(SIGFPE, &siginfo, current);
403 if (exception == -1) {
404 printk(KERN_ERR "handle_fpu_swa: fp_emulate() returned -1\n");
406 } else if (exception != 0) {
407 /* raise exception */
408 siginfo.si_signo = SIGFPE;
409 siginfo.si_errno = 0;
410 siginfo.si_code = __SI_FAULT; /* default code */
411 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
413 siginfo.si_code = FPE_FLTOVF;
414 } else if (isr & 0x1100) {
415 siginfo.si_code = FPE_FLTUND;
416 } else if (isr & 0x2200) {
417 siginfo.si_code = FPE_FLTRES;
419 siginfo.si_isr = isr;
420 siginfo.si_flags = __ISR_VALID;
422 force_sig_info(SIGFPE, &siginfo, current);
428 struct illegal_op_return {
429 unsigned long fkt, arg1, arg2, arg3;
432 struct illegal_op_return
433 ia64_illegal_op_fault (unsigned long ec, long arg1, long arg2, long arg3,
434 long arg4, long arg5, long arg6, long arg7,
437 struct illegal_op_return rv;
441 #ifdef CONFIG_IA64_BRL_EMU
443 extern struct illegal_op_return ia64_emulate_brl (struct pt_regs *, unsigned long);
445 rv = ia64_emulate_brl(®s, ec);
446 if (rv.fkt != (unsigned long) -1)
451 sprintf(buf, "IA-64 Illegal operation fault");
452 die_if_kernel(buf, ®s, 0);
454 memset(&si, 0, sizeof(si));
455 si.si_signo = SIGILL;
456 si.si_code = ILL_ILLOPC;
457 si.si_addr = (void __user *) (regs.cr_iip + ia64_psr(®s)->ri);
458 force_sig_info(SIGILL, &si, current);
464 ia64_fault (unsigned long vector, unsigned long isr, unsigned long ifa,
465 unsigned long iim, unsigned long itir, long arg5, long arg6,
466 long arg7, struct pt_regs regs)
468 unsigned long code, error = isr, iip;
469 struct siginfo siginfo;
472 static const char *reason[] = {
473 "IA-64 Illegal Operation fault",
474 "IA-64 Privileged Operation fault",
475 "IA-64 Privileged Register fault",
476 "IA-64 Reserved Register/Field fault",
477 "Disabled Instruction Set Transition fault",
478 "Unknown fault 5", "Unknown fault 6", "Unknown fault 7", "Illegal Hazard fault",
479 "Unknown fault 9", "Unknown fault 10", "Unknown fault 11", "Unknown fault 12",
480 "Unknown fault 13", "Unknown fault 14", "Unknown fault 15"
483 if ((isr & IA64_ISR_NA) && ((isr & IA64_ISR_CODE_MASK) == IA64_ISR_CODE_LFETCH)) {
485 * This fault was due to lfetch.fault, set "ed" bit in the psr to cancel
488 ia64_psr(®s)->ed = 1;
492 iip = regs.cr_iip + ia64_psr(®s)->ri;
495 case 24: /* General Exception */
496 code = (isr >> 4) & 0xf;
497 sprintf(buf, "General Exception: %s%s", reason[code],
498 (code == 3) ? ((isr & (1UL << 37))
499 ? " (RSE access)" : " (data access)") : "");
501 # ifdef CONFIG_IA64_PRINT_HAZARDS
502 printk("%s[%d]: possible hazard @ ip=%016lx (pr = %016lx)\n",
503 current->comm, current->pid,
504 regs.cr_iip + ia64_psr(®s)->ri, regs.pr);
510 case 25: /* Disabled FP-Register */
512 disabled_fph_fault(®s);
515 sprintf(buf, "Disabled FPL fault---not supposed to happen!");
518 case 26: /* NaT Consumption */
519 if (user_mode(®s)) {
522 if (((isr >> 4) & 0xf) == 2) {
523 /* NaT page consumption */
526 addr = (void __user *) ifa;
528 /* register NaT consumption */
531 addr = (void __user *) (regs.cr_iip
532 + ia64_psr(®s)->ri);
534 siginfo.si_signo = sig;
535 siginfo.si_code = code;
536 siginfo.si_errno = 0;
537 siginfo.si_addr = addr;
538 siginfo.si_imm = vector;
539 siginfo.si_flags = __ISR_VALID;
540 siginfo.si_isr = isr;
541 force_sig_info(sig, &siginfo, current);
543 } else if (ia64_done_with_exception(®s))
545 sprintf(buf, "NaT consumption");
548 case 31: /* Unsupported Data Reference */
549 if (user_mode(®s)) {
550 siginfo.si_signo = SIGILL;
551 siginfo.si_code = ILL_ILLOPN;
552 siginfo.si_errno = 0;
553 siginfo.si_addr = (void __user *) iip;
554 siginfo.si_imm = vector;
555 siginfo.si_flags = __ISR_VALID;
556 siginfo.si_isr = isr;
557 force_sig_info(SIGILL, &siginfo, current);
560 sprintf(buf, "Unsupported data reference");
564 case 35: /* Taken Branch Trap */
565 case 36: /* Single Step Trap */
566 if (fsys_mode(current, ®s)) {
567 extern char __kernel_syscall_via_break[];
569 * Got a trap in fsys-mode: Taken Branch Trap
570 * and Single Step trap need special handling;
571 * Debug trap is ignored (we disable it here
572 * and re-enable it in the lower-privilege trap).
574 if (unlikely(vector == 29)) {
575 set_thread_flag(TIF_DB_DISABLED);
576 ia64_psr(®s)->db = 0;
577 ia64_psr(®s)->lp = 1;
580 /* re-do the system call via break 0x100000: */
581 regs.cr_iip = (unsigned long) __kernel_syscall_via_break;
582 ia64_psr(®s)->ri = 0;
583 ia64_psr(®s)->cpl = 3;
588 siginfo.si_code = TRAP_HWBKPT;
589 #ifdef CONFIG_ITANIUM
591 * Erratum 10 (IFA may contain incorrect address) now has
592 * "NoFix" status. There are no plans for fixing this.
594 if (ia64_psr(®s)->is == 0)
598 case 35: siginfo.si_code = TRAP_BRANCH; ifa = 0; break;
599 case 36: siginfo.si_code = TRAP_TRACE; ifa = 0; break;
601 if (notify_die(DIE_FAULT, "ia64_fault", ®s, vector, siginfo.si_code, SIGTRAP)
604 siginfo.si_signo = SIGTRAP;
605 siginfo.si_errno = 0;
606 siginfo.si_addr = (void __user *) ifa;
608 siginfo.si_flags = __ISR_VALID;
609 siginfo.si_isr = isr;
610 force_sig_info(SIGTRAP, &siginfo, current);
613 case 32: /* fp fault */
614 case 33: /* fp trap */
615 result = handle_fpu_swa((vector == 32) ? 1 : 0, ®s, isr);
616 if ((result < 0) || (current->thread.flags & IA64_THREAD_FPEMU_SIGFPE)) {
617 siginfo.si_signo = SIGFPE;
618 siginfo.si_errno = 0;
619 siginfo.si_code = FPE_FLTINV;
620 siginfo.si_addr = (void __user *) iip;
621 siginfo.si_flags = __ISR_VALID;
622 siginfo.si_isr = isr;
624 force_sig_info(SIGFPE, &siginfo, current);
630 /* Lower-Privilege Transfer Trap */
632 /* If we disabled debug traps during an fsyscall,
633 * re-enable them here.
635 if (test_thread_flag(TIF_DB_DISABLED)) {
636 clear_thread_flag(TIF_DB_DISABLED);
637 ia64_psr(®s)->db = 1;
641 * Just clear PSR.lp and then return immediately:
642 * all the interesting work (e.g., signal delivery)
643 * is done in the kernel exit path.
645 ia64_psr(®s)->lp = 0;
648 /* Unimplemented Instr. Address Trap */
649 if (user_mode(®s)) {
650 siginfo.si_signo = SIGILL;
651 siginfo.si_code = ILL_BADIADDR;
652 siginfo.si_errno = 0;
653 siginfo.si_flags = 0;
656 siginfo.si_addr = (void __user *) iip;
657 force_sig_info(SIGILL, &siginfo, current);
660 sprintf(buf, "Unimplemented Instruction Address fault");
665 #ifdef CONFIG_IA32_SUPPORT
666 if (ia32_exception(®s, isr) == 0)
669 printk(KERN_ERR "Unexpected IA-32 exception (Trap 45)\n");
670 printk(KERN_ERR " iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx\n",
672 force_sig(SIGSEGV, current);
676 #ifdef CONFIG_IA32_SUPPORT
677 if (ia32_intercept(®s, isr) == 0)
680 printk(KERN_ERR "Unexpected IA-32 intercept trap (Trap 46)\n");
681 printk(KERN_ERR " iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx, iim - 0x%lx\n",
683 force_sig(SIGSEGV, current);
687 sprintf(buf, "IA-32 Interruption Fault (int 0x%lx)", isr >> 16);
691 sprintf(buf, "Fault %lu", vector);
694 die_if_kernel(buf, ®s, error);
695 force_sig(SIGILL, current);