1 // SPDX-License-Identifier: GPL-2.0
3 * Architecture-specific trap handling.
5 * Copyright (C) 1998-2003 Hewlett-Packard Co
6 * David Mosberger-Tang <davidm@hpl.hp.com>
8 * 05/12/00 grao <goutham.rao@intel.com> : added isr in siginfo for SIGFPE
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/sched/signal.h>
14 #include <linux/sched/debug.h>
15 #include <linux/tty.h>
16 #include <linux/vt_kern.h> /* For unblank_screen() */
17 #include <linux/export.h>
18 #include <linux/extable.h>
19 #include <linux/hardirq.h>
20 #include <linux/kprobes.h>
21 #include <linux/delay.h> /* for ssleep() */
22 #include <linux/kdebug.h>
23 #include <linux/uaccess.h>
25 #include <asm/fpswa.h>
26 #include <asm/intrinsics.h>
27 #include <asm/processor.h>
28 #include <asm/exception.h>
29 #include <asm/setup.h>
31 fpswa_interface_t *fpswa_interface;
32 EXPORT_SYMBOL(fpswa_interface);
37 if (ia64_boot_param->fpswa)
38 /* FPSWA fixup: make the interface pointer a kernel virtual address: */
39 fpswa_interface = __va(ia64_boot_param->fpswa);
43 die (const char *str, struct pt_regs *regs, long err)
50 .lock = __SPIN_LOCK_UNLOCKED(die.lock),
54 static int die_counter;
57 if (die.lock_owner != cpu) {
59 spin_lock_irq(&die.lock);
61 die.lock_owner_depth = 0;
66 if (++die.lock_owner_depth < 3) {
67 printk("%s[%d]: %s %ld [%d]\n",
68 current->comm, task_pid_nr(current), str, err, ++die_counter);
69 if (notify_die(DIE_OOPS, str, regs, err, 255, SIGSEGV)
75 printk(KERN_ERR "Recursive die() failure, output suppressed\n");
79 add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
80 spin_unlock_irq(&die.lock);
86 panic("Fatal exception");
93 die_if_kernel (char *str, struct pt_regs *regs, long err)
96 return die(str, regs, err);
101 __kprobes ia64_bad_break (unsigned long break_num, struct pt_regs *regs)
106 /* SIGILL, SIGFPE, SIGSEGV, and SIGBUS want these field initialized: */
107 clear_siginfo(&siginfo);
108 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
109 siginfo.si_imm = break_num;
110 siginfo.si_flags = 0; /* clear __ISR_VALID */
114 case 0: /* unknown error (used by GCC for __builtin_abort()) */
115 if (notify_die(DIE_BREAK, "break 0", regs, break_num, TRAP_BRKPT, SIGTRAP)
118 if (die_if_kernel("bugcheck!", regs, break_num))
120 sig = SIGILL; code = ILL_ILLOPC;
123 case 1: /* integer divide by zero */
124 sig = SIGFPE; code = FPE_INTDIV;
127 case 2: /* integer overflow */
128 sig = SIGFPE; code = FPE_INTOVF;
131 case 3: /* range check/bounds check */
132 sig = SIGFPE; code = FPE_FLTSUB;
135 case 4: /* null pointer dereference */
136 sig = SIGSEGV; code = SEGV_MAPERR;
139 case 5: /* misaligned data */
140 sig = SIGSEGV; code = BUS_ADRALN;
143 case 6: /* decimal overflow */
144 sig = SIGFPE; code = __FPE_DECOVF;
147 case 7: /* decimal divide by zero */
148 sig = SIGFPE; code = __FPE_DECDIV;
151 case 8: /* packed decimal error */
152 sig = SIGFPE; code = __FPE_DECERR;
155 case 9: /* invalid ASCII digit */
156 sig = SIGFPE; code = __FPE_INVASC;
159 case 10: /* invalid decimal digit */
160 sig = SIGFPE; code = __FPE_INVDEC;
163 case 11: /* paragraph stack overflow */
164 sig = SIGSEGV; code = __SEGV_PSTKOVF;
167 case 0x3f000 ... 0x3ffff: /* bundle-update in progress */
168 sig = SIGILL; code = __ILL_BNDMOD;
172 if ((break_num < 0x40000 || break_num > 0x100000)
173 && die_if_kernel("Bad break", regs, break_num))
176 if (break_num < 0x80000) {
177 sig = SIGILL; code = __ILL_BREAK;
179 if (notify_die(DIE_BREAK, "bad break", regs, break_num, TRAP_BRKPT, SIGTRAP)
182 sig = SIGTRAP; code = TRAP_BRKPT;
185 siginfo.si_signo = sig;
186 siginfo.si_errno = 0;
187 siginfo.si_code = code;
188 force_sig_info(sig, &siginfo, current);
192 * disabled_fph_fault() is called when a user-level process attempts to access f32..f127
193 * and it doesn't own the fp-high register partition. When this happens, we save the
194 * current fph partition in the task_struct of the fpu-owner (if necessary) and then load
195 * the fp-high partition of the current task (if necessary). Note that the kernel has
196 * access to fph by the time we get here, as the IVT's "Disabled FP-Register" handler takes
197 * care of clearing psr.dfh.
200 disabled_fph_fault (struct pt_regs *regs)
202 struct ia64_psr *psr = ia64_psr(regs);
204 /* first, grant user-level access to fph partition: */
208 * Make sure that no other task gets in on this processor
209 * while we're claiming the FPU
214 struct task_struct *fpu_owner
215 = (struct task_struct *)ia64_get_kr(IA64_KR_FPU_OWNER);
217 if (ia64_is_local_fpu_owner(current)) {
218 preempt_enable_no_resched();
223 ia64_flush_fph(fpu_owner);
225 #endif /* !CONFIG_SMP */
226 ia64_set_local_fpu_owner(current);
227 if ((current->thread.flags & IA64_THREAD_FPH_VALID) != 0) {
228 __ia64_load_fpu(current->thread.fph);
233 * Set mfh because the state in thread.fph does not match the state in
238 preempt_enable_no_resched();
242 fp_emulate (int fp_fault, void *bundle, long *ipsr, long *fpsr, long *isr, long *pr, long *ifs,
243 struct pt_regs *regs)
248 if (!fpswa_interface)
251 memset(&fp_state, 0, sizeof(fp_state_t));
254 * compute fp_state. only FP registers f6 - f11 are used by the
255 * kernel, so set those bits in the mask and set the low volatile
256 * pointer to point to these registers.
258 fp_state.bitmask_low64 = 0xfc0; /* bit6..bit11 */
260 fp_state.fp_state_low_volatile = (fp_state_low_volatile_t *) ®s->f6;
262 * unsigned long (*EFI_FPSWA) (
263 * unsigned long trap_type,
265 * unsigned long *pipsr,
266 * unsigned long *pfsr,
267 * unsigned long *pisr,
268 * unsigned long *ppreds,
269 * unsigned long *pifs,
272 ret = (*fpswa_interface->fpswa)((unsigned long) fp_fault, bundle,
273 (unsigned long *) ipsr, (unsigned long *) fpsr,
274 (unsigned long *) isr, (unsigned long *) pr,
275 (unsigned long *) ifs, &fp_state);
284 static DEFINE_PER_CPU(struct fpu_swa_msg, cpulast);
285 DECLARE_PER_CPU(struct fpu_swa_msg, cpulast);
286 static struct fpu_swa_msg last __cacheline_aligned;
290 * Handle floating-point assist faults and traps.
293 handle_fpu_swa (int fp_fault, struct pt_regs *regs, unsigned long isr)
295 long exception, bundle[2];
296 unsigned long fault_ip;
298 fault_ip = regs->cr_iip;
299 if (!fp_fault && (ia64_psr(regs)->ri == 0))
301 if (copy_from_user(bundle, (void __user *) fault_ip, sizeof(bundle)))
304 if (!(current->thread.flags & IA64_THREAD_FPEMU_NOPRINT)) {
305 unsigned long count, current_jiffies = jiffies;
306 struct fpu_swa_msg *cp = this_cpu_ptr(&cpulast);
308 if (unlikely(current_jiffies > cp->time))
310 if (unlikely(cp->count < 5)) {
312 cp->time = current_jiffies + 5 * HZ;
314 /* minimize races by grabbing a copy of count BEFORE checking last.time. */
319 * Lower 4 bits are used as a count. Upper bits are a sequence
320 * number that is updated when count is reset. The cmpxchg will
321 * fail is seqno has changed. This minimizes mutiple cpus
322 * resetting the count.
324 if (current_jiffies > last.time)
325 (void) cmpxchg_acq(&last.count, count, 16 + (count & ~15));
327 /* used fetchadd to atomically update the count */
328 if ((last.count & 15) < 5 && (ia64_fetchadd(1, &last.count, acq) & 15) < 5) {
329 last.time = current_jiffies + 5 * HZ;
331 "%s(%d): floating-point assist fault at ip %016lx, isr %016lx\n",
332 current->comm, task_pid_nr(current), regs->cr_iip + ia64_psr(regs)->ri, isr);
337 exception = fp_emulate(fp_fault, bundle, ®s->cr_ipsr, ®s->ar_fpsr, &isr, ®s->pr,
338 ®s->cr_ifs, regs);
340 if (exception == 0) {
341 /* emulation was successful */
342 ia64_increment_ip(regs);
343 } else if (exception == -1) {
344 printk(KERN_ERR "handle_fpu_swa: fp_emulate() returned -1\n");
347 struct siginfo siginfo;
349 /* is next instruction a trap? */
351 ia64_increment_ip(regs);
353 clear_siginfo(&siginfo);
354 siginfo.si_signo = SIGFPE;
355 siginfo.si_errno = 0;
356 siginfo.si_code = FPE_FLTUNK; /* default code */
357 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
359 siginfo.si_code = FPE_FLTINV;
360 } else if (isr & 0x22) {
361 /* denormal operand gets the same si_code as underflow
362 * see arch/i386/kernel/traps.c:math_error() */
363 siginfo.si_code = FPE_FLTUND;
364 } else if (isr & 0x44) {
365 siginfo.si_code = FPE_FLTDIV;
367 siginfo.si_isr = isr;
368 siginfo.si_flags = __ISR_VALID;
370 force_sig_info(SIGFPE, &siginfo, current);
373 if (exception == -1) {
374 printk(KERN_ERR "handle_fpu_swa: fp_emulate() returned -1\n");
376 } else if (exception != 0) {
377 /* raise exception */
378 struct siginfo siginfo;
380 clear_siginfo(&siginfo);
381 siginfo.si_signo = SIGFPE;
382 siginfo.si_errno = 0;
383 siginfo.si_code = FPE_FLTUNK; /* default code */
384 siginfo.si_addr = (void __user *) (regs->cr_iip + ia64_psr(regs)->ri);
386 siginfo.si_code = FPE_FLTOVF;
387 } else if (isr & 0x1100) {
388 siginfo.si_code = FPE_FLTUND;
389 } else if (isr & 0x2200) {
390 siginfo.si_code = FPE_FLTRES;
392 siginfo.si_isr = isr;
393 siginfo.si_flags = __ISR_VALID;
395 force_sig_info(SIGFPE, &siginfo, current);
401 struct illegal_op_return {
402 unsigned long fkt, arg1, arg2, arg3;
405 struct illegal_op_return
406 ia64_illegal_op_fault (unsigned long ec, long arg1, long arg2, long arg3,
407 long arg4, long arg5, long arg6, long arg7,
410 struct illegal_op_return rv;
414 #ifdef CONFIG_IA64_BRL_EMU
416 extern struct illegal_op_return ia64_emulate_brl (struct pt_regs *, unsigned long);
418 rv = ia64_emulate_brl(®s, ec);
419 if (rv.fkt != (unsigned long) -1)
424 sprintf(buf, "IA-64 Illegal operation fault");
426 if (die_if_kernel(buf, ®s, 0))
430 si.si_signo = SIGILL;
431 si.si_code = ILL_ILLOPC;
432 si.si_addr = (void __user *) (regs.cr_iip + ia64_psr(®s)->ri);
433 force_sig_info(SIGILL, &si, current);
438 ia64_fault (unsigned long vector, unsigned long isr, unsigned long ifa,
439 unsigned long iim, unsigned long itir, long arg5, long arg6,
440 long arg7, struct pt_regs regs)
442 unsigned long code, error = isr, iip;
445 static const char *reason[] = {
446 "IA-64 Illegal Operation fault",
447 "IA-64 Privileged Operation fault",
448 "IA-64 Privileged Register fault",
449 "IA-64 Reserved Register/Field fault",
450 "Disabled Instruction Set Transition fault",
451 "Unknown fault 5", "Unknown fault 6", "Unknown fault 7", "Illegal Hazard fault",
452 "Unknown fault 9", "Unknown fault 10", "Unknown fault 11", "Unknown fault 12",
453 "Unknown fault 13", "Unknown fault 14", "Unknown fault 15"
456 if ((isr & IA64_ISR_NA) && ((isr & IA64_ISR_CODE_MASK) == IA64_ISR_CODE_LFETCH)) {
458 * This fault was due to lfetch.fault, set "ed" bit in the psr to cancel
461 ia64_psr(®s)->ed = 1;
465 iip = regs.cr_iip + ia64_psr(®s)->ri;
468 case 24: /* General Exception */
469 code = (isr >> 4) & 0xf;
470 sprintf(buf, "General Exception: %s%s", reason[code],
471 (code == 3) ? ((isr & (1UL << 37))
472 ? " (RSE access)" : " (data access)") : "");
474 # ifdef CONFIG_IA64_PRINT_HAZARDS
475 printk("%s[%d]: possible hazard @ ip=%016lx (pr = %016lx)\n",
476 current->comm, task_pid_nr(current),
477 regs.cr_iip + ia64_psr(®s)->ri, regs.pr);
483 case 25: /* Disabled FP-Register */
485 disabled_fph_fault(®s);
488 sprintf(buf, "Disabled FPL fault---not supposed to happen!");
491 case 26: /* NaT Consumption */
492 if (user_mode(®s)) {
493 struct siginfo siginfo;
496 if (((isr >> 4) & 0xf) == 2) {
497 /* NaT page consumption */
500 addr = (void __user *) ifa;
502 /* register NaT consumption */
505 addr = (void __user *) (regs.cr_iip
506 + ia64_psr(®s)->ri);
508 clear_siginfo(&siginfo);
509 siginfo.si_signo = sig;
510 siginfo.si_code = code;
511 siginfo.si_errno = 0;
512 siginfo.si_addr = addr;
513 siginfo.si_imm = vector;
514 siginfo.si_flags = __ISR_VALID;
515 siginfo.si_isr = isr;
516 force_sig_info(sig, &siginfo, current);
518 } else if (ia64_done_with_exception(®s))
520 sprintf(buf, "NaT consumption");
523 case 31: /* Unsupported Data Reference */
524 if (user_mode(®s)) {
525 struct siginfo siginfo;
527 clear_siginfo(&siginfo);
528 siginfo.si_signo = SIGILL;
529 siginfo.si_code = ILL_ILLOPN;
530 siginfo.si_errno = 0;
531 siginfo.si_addr = (void __user *) iip;
532 siginfo.si_imm = vector;
533 siginfo.si_flags = __ISR_VALID;
534 siginfo.si_isr = isr;
535 force_sig_info(SIGILL, &siginfo, current);
538 sprintf(buf, "Unsupported data reference");
542 case 35: /* Taken Branch Trap */
543 case 36: /* Single Step Trap */
545 struct siginfo siginfo;
547 clear_siginfo(&siginfo);
548 if (fsys_mode(current, ®s)) {
549 extern char __kernel_syscall_via_break[];
551 * Got a trap in fsys-mode: Taken Branch Trap
552 * and Single Step trap need special handling;
553 * Debug trap is ignored (we disable it here
554 * and re-enable it in the lower-privilege trap).
556 if (unlikely(vector == 29)) {
557 set_thread_flag(TIF_DB_DISABLED);
558 ia64_psr(®s)->db = 0;
559 ia64_psr(®s)->lp = 1;
562 /* re-do the system call via break 0x100000: */
563 regs.cr_iip = (unsigned long) __kernel_syscall_via_break;
564 ia64_psr(®s)->ri = 0;
565 ia64_psr(®s)->cpl = 3;
571 siginfo.si_code = TRAP_HWBKPT;
572 #ifdef CONFIG_ITANIUM
574 * Erratum 10 (IFA may contain incorrect address) now has
575 * "NoFix" status. There are no plans for fixing this.
577 if (ia64_psr(®s)->is == 0)
581 case 35: siginfo.si_code = TRAP_BRANCH; ifa = 0; break;
582 case 36: siginfo.si_code = TRAP_TRACE; ifa = 0; break;
584 if (notify_die(DIE_FAULT, "ia64_fault", ®s, vector, siginfo.si_code, SIGTRAP)
587 siginfo.si_signo = SIGTRAP;
588 siginfo.si_errno = 0;
589 siginfo.si_addr = (void __user *) ifa;
591 siginfo.si_flags = __ISR_VALID;
592 siginfo.si_isr = isr;
593 force_sig_info(SIGTRAP, &siginfo, current);
597 case 32: /* fp fault */
598 case 33: /* fp trap */
599 result = handle_fpu_swa((vector == 32) ? 1 : 0, ®s, isr);
600 if ((result < 0) || (current->thread.flags & IA64_THREAD_FPEMU_SIGFPE)) {
601 struct siginfo siginfo;
603 clear_siginfo(&siginfo);
604 siginfo.si_signo = SIGFPE;
605 siginfo.si_errno = 0;
606 siginfo.si_code = FPE_FLTINV;
607 siginfo.si_addr = (void __user *) iip;
608 siginfo.si_flags = __ISR_VALID;
609 siginfo.si_isr = isr;
611 force_sig_info(SIGFPE, &siginfo, current);
617 /* Lower-Privilege Transfer Trap */
619 /* If we disabled debug traps during an fsyscall,
620 * re-enable them here.
622 if (test_thread_flag(TIF_DB_DISABLED)) {
623 clear_thread_flag(TIF_DB_DISABLED);
624 ia64_psr(®s)->db = 1;
628 * Just clear PSR.lp and then return immediately:
629 * all the interesting work (e.g., signal delivery)
630 * is done in the kernel exit path.
632 ia64_psr(®s)->lp = 0;
635 /* Unimplemented Instr. Address Trap */
636 if (user_mode(®s)) {
637 struct siginfo siginfo;
639 clear_siginfo(&siginfo);
640 siginfo.si_signo = SIGILL;
641 siginfo.si_code = ILL_BADIADDR;
642 siginfo.si_errno = 0;
643 siginfo.si_flags = 0;
646 siginfo.si_addr = (void __user *) iip;
647 force_sig_info(SIGILL, &siginfo, current);
650 sprintf(buf, "Unimplemented Instruction Address fault");
655 printk(KERN_ERR "Unexpected IA-32 exception (Trap 45)\n");
656 printk(KERN_ERR " iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx\n",
658 force_sig(SIGSEGV, current);
662 printk(KERN_ERR "Unexpected IA-32 intercept trap (Trap 46)\n");
663 printk(KERN_ERR " iip - 0x%lx, ifa - 0x%lx, isr - 0x%lx, iim - 0x%lx\n",
665 force_sig(SIGSEGV, current);
669 sprintf(buf, "IA-32 Interruption Fault (int 0x%lx)", isr >> 16);
673 sprintf(buf, "Fault %lu", vector);
676 if (!die_if_kernel(buf, ®s, error))
677 force_sig(SIGILL, current);