2 * linux/arch/x86-64/traps.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
7 * Pentium III FXSR, SSE support
8 * Gareth Hughes <gareth@valinux.com>, May 2000
10 * $Id: traps.c,v 1.36 2002/03/24 11:09:10 ak Exp $
14 * 'Traps.c' handles hardware traps and faults after we have saved some
17 #include <linux/config.h>
18 #include <linux/sched.h>
19 #include <linux/kernel.h>
20 #include <linux/string.h>
21 #include <linux/errno.h>
22 #include <linux/ptrace.h>
23 #include <linux/timer.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/spinlock.h>
28 #include <linux/interrupt.h>
29 #include <linux/module.h>
30 #include <linux/moduleparam.h>
31 #include <linux/nmi.h>
32 #include <linux/kprobes.h>
33 #include <linux/kexec.h>
35 #include <asm/system.h>
36 #include <asm/uaccess.h>
38 #include <asm/atomic.h>
39 #include <asm/debugreg.h>
42 #include <asm/kdebug.h>
43 #include <asm/processor.h>
46 #include <asm/pgalloc.h>
48 #include <asm/proto.h>
51 asmlinkage
void divide_error(void);
52 asmlinkage
void debug(void);
53 asmlinkage
void nmi(void);
54 asmlinkage
void int3(void);
55 asmlinkage
void overflow(void);
56 asmlinkage
void bounds(void);
57 asmlinkage
void invalid_op(void);
58 asmlinkage
void device_not_available(void);
59 asmlinkage
void double_fault(void);
60 asmlinkage
void coprocessor_segment_overrun(void);
61 asmlinkage
void invalid_TSS(void);
62 asmlinkage
void segment_not_present(void);
63 asmlinkage
void stack_segment(void);
64 asmlinkage
void general_protection(void);
65 asmlinkage
void page_fault(void);
66 asmlinkage
void coprocessor_error(void);
67 asmlinkage
void simd_coprocessor_error(void);
68 asmlinkage
void reserved(void);
69 asmlinkage
void alignment_check(void);
70 asmlinkage
void machine_check(void);
71 asmlinkage
void spurious_interrupt_bug(void);
73 ATOMIC_NOTIFIER_HEAD(die_chain
);
75 int register_die_notifier(struct notifier_block
*nb
)
78 return atomic_notifier_chain_register(&die_chain
, nb
);
80 EXPORT_SYMBOL(register_die_notifier
);
82 int unregister_die_notifier(struct notifier_block
*nb
)
84 return atomic_notifier_chain_unregister(&die_chain
, nb
);
86 EXPORT_SYMBOL(unregister_die_notifier
);
88 static inline void conditional_sti(struct pt_regs
*regs
)
90 if (regs
->eflags
& X86_EFLAGS_IF
)
94 static inline void preempt_conditional_sti(struct pt_regs
*regs
)
97 if (regs
->eflags
& X86_EFLAGS_IF
)
101 static inline void preempt_conditional_cli(struct pt_regs
*regs
)
103 if (regs
->eflags
& X86_EFLAGS_IF
)
105 /* Make sure to not schedule here because we could be running
106 on an exception stack. */
107 preempt_enable_no_resched();
110 static int kstack_depth_to_print
= 10;
112 #ifdef CONFIG_KALLSYMS
113 #include <linux/kallsyms.h>
114 int printk_address(unsigned long address
)
116 unsigned long offset
= 0, symsize
;
122 symname
= kallsyms_lookup(address
, &symsize
, &offset
, &modname
, namebuf
);
124 return printk("[<%016lx>]", address
);
126 modname
= delim
= "";
127 return printk("<%016lx>{%s%s%s%s%+ld}",
128 address
, delim
, modname
, delim
, symname
, offset
);
131 int printk_address(unsigned long address
)
133 return printk("[<%016lx>]", address
);
137 static unsigned long *in_exception_stack(unsigned cpu
, unsigned long stack
,
138 unsigned *usedp
, const char **idp
)
140 static char ids
[][8] = {
141 [DEBUG_STACK
- 1] = "#DB",
142 [NMI_STACK
- 1] = "NMI",
143 [DOUBLEFAULT_STACK
- 1] = "#DF",
144 [STACKFAULT_STACK
- 1] = "#SS",
145 [MCE_STACK
- 1] = "#MC",
146 #if DEBUG_STKSZ > EXCEPTION_STKSZ
147 [N_EXCEPTION_STACKS
... N_EXCEPTION_STACKS
+ DEBUG_STKSZ
/ EXCEPTION_STKSZ
- 2] = "#DB[?]"
152 for (k
= 0; k
< N_EXCEPTION_STACKS
; k
++) {
156 #if DEBUG_STKSZ > EXCEPTION_STKSZ
158 end
= cpu_pda(cpu
)->debugstack
+ DEBUG_STKSZ
;
162 end
= per_cpu(init_tss
, cpu
).ist
[k
];
167 if (stack
>= end
- EXCEPTION_STKSZ
) {
168 if (*usedp
& (1U << k
))
172 return (unsigned long *)end
;
174 #if DEBUG_STKSZ > EXCEPTION_STKSZ
175 if (k
== DEBUG_STACK
- 1 && stack
>= end
- DEBUG_STKSZ
) {
176 unsigned j
= N_EXCEPTION_STACKS
- 1;
180 end
-= EXCEPTION_STKSZ
;
181 ids
[j
][4] = '1' + (j
- N_EXCEPTION_STACKS
);
182 } while (stack
< end
- EXCEPTION_STKSZ
);
183 if (*usedp
& (1U << j
))
187 return (unsigned long *)end
;
195 * x86-64 can have upto three kernel stacks:
198 * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
201 void show_trace(unsigned long *stack
)
203 const unsigned cpu
= safe_smp_processor_id();
204 unsigned long *irqstack_end
= (unsigned long *)cpu_pda(cpu
)->irqstackptr
;
208 printk("\nCall Trace:");
210 #define HANDLE_STACK(cond) \
212 unsigned long addr = *stack++; \
213 if (kernel_text_address(addr)) { \
221 * If the address is either in the text segment of the \
222 * kernel, or in the region which contains vmalloc'ed \
223 * memory, it *may* be the address of a calling \
224 * routine; if so, print it so that someone tracing \
225 * down the cause of the crash will be able to figure \
226 * out the call path that was taken. \
228 i += printk_address(addr); \
234 unsigned long *estack_end
;
235 estack_end
= in_exception_stack(cpu
, (unsigned long)stack
,
239 i
+= printk(" <%s>", id
);
240 HANDLE_STACK (stack
< estack_end
);
241 i
+= printk(" <EOE>");
242 stack
= (unsigned long *) estack_end
[-2];
246 unsigned long *irqstack
;
247 irqstack
= irqstack_end
-
248 (IRQSTACKSIZE
- 64) / sizeof(*irqstack
);
250 if (stack
>= irqstack
&& stack
< irqstack_end
) {
251 i
+= printk(" <IRQ>");
252 HANDLE_STACK (stack
< irqstack_end
);
253 stack
= (unsigned long *) (irqstack_end
[-1]);
255 i
+= printk(" <EOI>");
262 HANDLE_STACK (((long) stack
& (THREAD_SIZE
-1)) != 0);
267 void show_stack(struct task_struct
*tsk
, unsigned long * rsp
)
269 unsigned long *stack
;
271 const int cpu
= safe_smp_processor_id();
272 unsigned long *irqstack_end
= (unsigned long *) (cpu_pda(cpu
)->irqstackptr
);
273 unsigned long *irqstack
= (unsigned long *) (cpu_pda(cpu
)->irqstackptr
- IRQSTACKSIZE
);
275 // debugging aid: "show_stack(NULL, NULL);" prints the
276 // back trace for this cpu.
280 rsp
= (unsigned long *)tsk
->thread
.rsp
;
282 rsp
= (unsigned long *)&rsp
;
286 for(i
=0; i
< kstack_depth_to_print
; i
++) {
287 if (stack
>= irqstack
&& stack
<= irqstack_end
) {
288 if (stack
== irqstack_end
) {
289 stack
= (unsigned long *) (irqstack_end
[-1]);
293 if (((long) stack
& (THREAD_SIZE
-1)) == 0)
296 if (i
&& ((i
% 4) == 0))
298 printk("%016lx ", *stack
++);
299 touch_nmi_watchdog();
301 show_trace((unsigned long *)rsp
);
305 * The architecture-independent dump_stack generator
307 void dump_stack(void)
313 EXPORT_SYMBOL(dump_stack
);
315 void show_registers(struct pt_regs
*regs
)
318 int in_kernel
= !user_mode(regs
);
320 const int cpu
= safe_smp_processor_id();
321 struct task_struct
*cur
= cpu_pda(cpu
)->pcurrent
;
325 printk("CPU %d ", cpu
);
327 printk("Process %s (pid: %d, threadinfo %p, task %p)\n",
328 cur
->comm
, cur
->pid
, task_thread_info(cur
), cur
);
331 * When in-kernel, we also print out the stack and code at the
332 * time of the fault..
337 show_stack(NULL
, (unsigned long*)rsp
);
340 if (regs
->rip
< PAGE_OFFSET
)
343 for (i
=0; i
<20; i
++) {
345 if (__get_user(c
, &((unsigned char*)regs
->rip
)[i
])) {
347 printk(" Bad RIP value.");
356 void handle_BUG(struct pt_regs
*regs
)
360 const char *prefix
= "";
364 if (__copy_from_user(&f
, (const void __user
*) regs
->rip
,
365 sizeof(struct bug_frame
)))
367 if (f
.filename
>= 0 ||
368 f
.ud2
[0] != 0x0f || f
.ud2
[1] != 0x0b)
370 len
= __strnlen_user((char *)(long)f
.filename
, PATH_MAX
) - 1;
371 if (len
< 0 || len
>= PATH_MAX
)
372 f
.filename
= (int)(long)"unmapped filename";
374 f
.filename
+= len
- 50;
377 printk("----------- [cut here ] --------- [please bite here ] ---------\n");
378 printk(KERN_ALERT
"Kernel BUG at %s%.50s:%d\n", prefix
, (char *)(long)f
.filename
, f
.line
);
382 void out_of_line_bug(void)
388 static DEFINE_SPINLOCK(die_lock
);
389 static int die_owner
= -1;
390 static unsigned int die_nest_count
;
392 unsigned __kprobes
long oops_begin(void)
394 int cpu
= safe_smp_processor_id();
397 /* racy, but better than risking deadlock. */
398 local_irq_save(flags
);
399 if (!spin_trylock(&die_lock
)) {
400 if (cpu
== die_owner
)
401 /* nested oops. should stop eventually */;
403 spin_lock(&die_lock
);
412 void __kprobes
oops_end(unsigned long flags
)
418 /* We still own the lock */
419 local_irq_restore(flags
);
421 /* Nest count reaches zero, release the lock. */
422 spin_unlock_irqrestore(&die_lock
, flags
);
427 void __kprobes
__die(const char * str
, struct pt_regs
* regs
, long err
)
429 static int die_counter
;
430 printk(KERN_EMERG
"%s: %04lx [%u] ", str
, err
& 0xffff,++die_counter
);
431 #ifdef CONFIG_PREEMPT
437 #ifdef CONFIG_DEBUG_PAGEALLOC
438 printk("DEBUG_PAGEALLOC");
441 notify_die(DIE_OOPS
, str
, regs
, err
, current
->thread
.trap_no
, SIGSEGV
);
442 show_registers(regs
);
443 /* Executive summary in case the oops scrolled away */
444 printk(KERN_ALERT
"RIP ");
445 printk_address(regs
->rip
);
446 printk(" RSP <%016lx>\n", regs
->rsp
);
447 if (kexec_should_crash(current
))
451 void die(const char * str
, struct pt_regs
* regs
, long err
)
453 unsigned long flags
= oops_begin();
456 __die(str
, regs
, err
);
461 void __kprobes
die_nmi(char *str
, struct pt_regs
*regs
)
463 unsigned long flags
= oops_begin();
466 * We are in trouble anyway, lets at least try
467 * to get a message out.
469 printk(str
, safe_smp_processor_id());
470 show_registers(regs
);
471 if (kexec_should_crash(current
))
473 if (panic_on_timeout
|| panic_on_oops
)
474 panic("nmi watchdog");
475 printk("console shuts up ...\n");
482 static void __kprobes
do_trap(int trapnr
, int signr
, char *str
,
483 struct pt_regs
* regs
, long error_code
,
486 struct task_struct
*tsk
= current
;
488 tsk
->thread
.error_code
= error_code
;
489 tsk
->thread
.trap_no
= trapnr
;
491 if (user_mode(regs
)) {
492 if (exception_trace
&& unhandled_signal(tsk
, signr
))
494 "%s[%d] trap %s rip:%lx rsp:%lx error:%lx\n",
495 tsk
->comm
, tsk
->pid
, str
,
496 regs
->rip
, regs
->rsp
, error_code
);
499 force_sig_info(signr
, info
, tsk
);
501 force_sig(signr
, tsk
);
508 const struct exception_table_entry
*fixup
;
509 fixup
= search_exception_tables(regs
->rip
);
511 regs
->rip
= fixup
->fixup
;
513 die(str
, regs
, error_code
);
518 #define DO_ERROR(trapnr, signr, str, name) \
519 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
521 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
524 conditional_sti(regs); \
525 do_trap(trapnr, signr, str, regs, error_code, NULL); \
528 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
529 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
532 info.si_signo = signr; \
534 info.si_code = sicode; \
535 info.si_addr = (void __user *)siaddr; \
536 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
539 conditional_sti(regs); \
540 do_trap(trapnr, signr, str, regs, error_code, &info); \
543 DO_ERROR_INFO( 0, SIGFPE
, "divide error", divide_error
, FPE_INTDIV
, regs
->rip
)
544 DO_ERROR( 4, SIGSEGV
, "overflow", overflow
)
545 DO_ERROR( 5, SIGSEGV
, "bounds", bounds
)
546 DO_ERROR_INFO( 6, SIGILL
, "invalid opcode", invalid_op
, ILL_ILLOPN
, regs
->rip
)
547 DO_ERROR( 7, SIGSEGV
, "device not available", device_not_available
)
548 DO_ERROR( 9, SIGFPE
, "coprocessor segment overrun", coprocessor_segment_overrun
)
549 DO_ERROR(10, SIGSEGV
, "invalid TSS", invalid_TSS
)
550 DO_ERROR(11, SIGBUS
, "segment not present", segment_not_present
)
551 DO_ERROR_INFO(17, SIGBUS
, "alignment check", alignment_check
, BUS_ADRALN
, 0)
552 DO_ERROR(18, SIGSEGV
, "reserved", reserved
)
554 /* Runs on IST stack */
555 asmlinkage
void do_stack_segment(struct pt_regs
*regs
, long error_code
)
557 if (notify_die(DIE_TRAP
, "stack segment", regs
, error_code
,
558 12, SIGBUS
) == NOTIFY_STOP
)
560 preempt_conditional_sti(regs
);
561 do_trap(12, SIGBUS
, "stack segment", regs
, error_code
, NULL
);
562 preempt_conditional_cli(regs
);
565 asmlinkage
void do_double_fault(struct pt_regs
* regs
, long error_code
)
567 static const char str
[] = "double fault";
568 struct task_struct
*tsk
= current
;
570 /* Return not checked because double check cannot be ignored */
571 notify_die(DIE_TRAP
, str
, regs
, error_code
, 8, SIGSEGV
);
573 tsk
->thread
.error_code
= error_code
;
574 tsk
->thread
.trap_no
= 8;
576 /* This is always a kernel trap and never fixable (and thus must
579 die(str
, regs
, error_code
);
582 asmlinkage
void __kprobes
do_general_protection(struct pt_regs
* regs
,
585 struct task_struct
*tsk
= current
;
587 conditional_sti(regs
);
589 tsk
->thread
.error_code
= error_code
;
590 tsk
->thread
.trap_no
= 13;
592 if (user_mode(regs
)) {
593 if (exception_trace
&& unhandled_signal(tsk
, SIGSEGV
))
595 "%s[%d] general protection rip:%lx rsp:%lx error:%lx\n",
597 regs
->rip
, regs
->rsp
, error_code
);
599 force_sig(SIGSEGV
, tsk
);
605 const struct exception_table_entry
*fixup
;
606 fixup
= search_exception_tables(regs
->rip
);
608 regs
->rip
= fixup
->fixup
;
611 if (notify_die(DIE_GPF
, "general protection fault", regs
,
612 error_code
, 13, SIGSEGV
) == NOTIFY_STOP
)
614 die("general protection fault", regs
, error_code
);
618 static __kprobes
void
619 mem_parity_error(unsigned char reason
, struct pt_regs
* regs
)
621 printk("Uhhuh. NMI received. Dazed and confused, but trying to continue\n");
622 printk("You probably have a hardware problem with your RAM chips\n");
624 /* Clear and disable the memory parity error line. */
625 reason
= (reason
& 0xf) | 4;
629 static __kprobes
void
630 io_check_error(unsigned char reason
, struct pt_regs
* regs
)
632 printk("NMI: IOCK error (debug interrupt?)\n");
633 show_registers(regs
);
635 /* Re-enable the IOCK line, wait for a few seconds */
636 reason
= (reason
& 0xf) | 8;
643 static __kprobes
void
644 unknown_nmi_error(unsigned char reason
, struct pt_regs
* regs
)
645 { printk("Uhhuh. NMI received for unknown reason %02x.\n", reason
);
646 printk("Dazed and confused, but trying to continue\n");
647 printk("Do you have a strange power saving mode enabled?\n");
650 /* Runs on IST stack. This code must keep interrupts off all the time.
651 Nested NMIs are prevented by the CPU. */
652 asmlinkage __kprobes
void default_do_nmi(struct pt_regs
*regs
)
654 unsigned char reason
= 0;
657 cpu
= smp_processor_id();
659 /* Only the BSP gets external NMIs from the system. */
661 reason
= get_nmi_reason();
663 if (!(reason
& 0xc0)) {
664 if (notify_die(DIE_NMI_IPI
, "nmi_ipi", regs
, reason
, 2, SIGINT
)
667 #ifdef CONFIG_X86_LOCAL_APIC
669 * Ok, so this is none of the documented NMI sources,
670 * so it must be the NMI watchdog.
672 if (nmi_watchdog
> 0) {
673 nmi_watchdog_tick(regs
,reason
);
677 unknown_nmi_error(reason
, regs
);
680 if (notify_die(DIE_NMI
, "nmi", regs
, reason
, 2, SIGINT
) == NOTIFY_STOP
)
683 /* AK: following checks seem to be broken on modern chipsets. FIXME */
686 mem_parity_error(reason
, regs
);
688 io_check_error(reason
, regs
);
691 /* runs on IST stack. */
692 asmlinkage
void __kprobes
do_int3(struct pt_regs
* regs
, long error_code
)
694 if (notify_die(DIE_INT3
, "int3", regs
, error_code
, 3, SIGTRAP
) == NOTIFY_STOP
) {
697 preempt_conditional_sti(regs
);
698 do_trap(3, SIGTRAP
, "int3", regs
, error_code
, NULL
);
699 preempt_conditional_cli(regs
);
702 /* Help handler running on IST stack to switch back to user stack
703 for scheduling or signal handling. The actual stack switch is done in
705 asmlinkage __kprobes
struct pt_regs
*sync_regs(struct pt_regs
*eregs
)
707 struct pt_regs
*regs
= eregs
;
708 /* Did already sync */
709 if (eregs
== (struct pt_regs
*)eregs
->rsp
)
711 /* Exception from user space */
712 else if (user_mode(eregs
))
713 regs
= task_pt_regs(current
);
714 /* Exception from kernel and interrupts are enabled. Move to
715 kernel process stack. */
716 else if (eregs
->eflags
& X86_EFLAGS_IF
)
717 regs
= (struct pt_regs
*)(eregs
->rsp
-= sizeof(struct pt_regs
));
723 /* runs on IST stack. */
724 asmlinkage
void __kprobes
do_debug(struct pt_regs
* regs
,
725 unsigned long error_code
)
727 unsigned long condition
;
728 struct task_struct
*tsk
= current
;
731 get_debugreg(condition
, 6);
733 if (notify_die(DIE_DEBUG
, "debug", regs
, condition
, error_code
,
734 SIGTRAP
) == NOTIFY_STOP
)
737 preempt_conditional_sti(regs
);
739 /* Mask out spurious debug traps due to lazy DR7 setting */
740 if (condition
& (DR_TRAP0
|DR_TRAP1
|DR_TRAP2
|DR_TRAP3
)) {
741 if (!tsk
->thread
.debugreg7
) {
746 tsk
->thread
.debugreg6
= condition
;
748 /* Mask out spurious TF errors due to lazy TF clearing */
749 if (condition
& DR_STEP
) {
751 * The TF error should be masked out only if the current
752 * process is not traced and if the TRAP flag has been set
753 * previously by a tracing process (condition detected by
754 * the PT_DTRACE flag); remember that the i386 TRAP flag
755 * can be modified by the process itself in user mode,
756 * allowing programs to debug themselves without the ptrace()
759 if (!user_mode(regs
))
760 goto clear_TF_reenable
;
762 * Was the TF flag set by a debugger? If so, clear it now,
763 * so that register information is correct.
765 if (tsk
->ptrace
& PT_DTRACE
) {
766 regs
->eflags
&= ~TF_MASK
;
767 tsk
->ptrace
&= ~PT_DTRACE
;
771 /* Ok, finally something we can handle */
772 tsk
->thread
.trap_no
= 1;
773 tsk
->thread
.error_code
= error_code
;
774 info
.si_signo
= SIGTRAP
;
776 info
.si_code
= TRAP_BRKPT
;
777 info
.si_addr
= user_mode(regs
) ? (void __user
*)regs
->rip
: NULL
;
778 force_sig_info(SIGTRAP
, &info
, tsk
);
781 set_debugreg(0UL, 7);
782 preempt_conditional_cli(regs
);
786 set_tsk_thread_flag(tsk
, TIF_SINGLESTEP
);
787 regs
->eflags
&= ~TF_MASK
;
788 preempt_conditional_cli(regs
);
791 static int kernel_math_error(struct pt_regs
*regs
, const char *str
, int trapnr
)
793 const struct exception_table_entry
*fixup
;
794 fixup
= search_exception_tables(regs
->rip
);
796 regs
->rip
= fixup
->fixup
;
799 notify_die(DIE_GPF
, str
, regs
, 0, trapnr
, SIGFPE
);
800 /* Illegal floating point operation in the kernel */
801 current
->thread
.trap_no
= trapnr
;
807 * Note that we play around with the 'TS' bit in an attempt to get
808 * the correct behaviour even in the presence of the asynchronous
811 asmlinkage
void do_coprocessor_error(struct pt_regs
*regs
)
813 void __user
*rip
= (void __user
*)(regs
->rip
);
814 struct task_struct
* task
;
816 unsigned short cwd
, swd
;
818 conditional_sti(regs
);
819 if (!user_mode(regs
) &&
820 kernel_math_error(regs
, "kernel x87 math error", 16))
824 * Save the info for the exception handler and clear the error.
828 task
->thread
.trap_no
= 16;
829 task
->thread
.error_code
= 0;
830 info
.si_signo
= SIGFPE
;
832 info
.si_code
= __SI_FAULT
;
835 * (~cwd & swd) will mask out exceptions that are not set to unmasked
836 * status. 0x3f is the exception bits in these regs, 0x200 is the
837 * C1 reg you need in case of a stack fault, 0x040 is the stack
838 * fault bit. We should only be taking one exception at a time,
839 * so if this combination doesn't produce any single exception,
840 * then we have a bad program that isn't synchronizing its FPU usage
841 * and it will suffer the consequences since we won't be able to
842 * fully reproduce the context of the exception
844 cwd
= get_fpu_cwd(task
);
845 swd
= get_fpu_swd(task
);
846 switch (swd
& ~cwd
& 0x3f) {
850 case 0x001: /* Invalid Op */
852 * swd & 0x240 == 0x040: Stack Underflow
853 * swd & 0x240 == 0x240: Stack Overflow
854 * User must clear the SF bit (0x40) if set
856 info
.si_code
= FPE_FLTINV
;
858 case 0x002: /* Denormalize */
859 case 0x010: /* Underflow */
860 info
.si_code
= FPE_FLTUND
;
862 case 0x004: /* Zero Divide */
863 info
.si_code
= FPE_FLTDIV
;
865 case 0x008: /* Overflow */
866 info
.si_code
= FPE_FLTOVF
;
868 case 0x020: /* Precision */
869 info
.si_code
= FPE_FLTRES
;
872 force_sig_info(SIGFPE
, &info
, task
);
875 asmlinkage
void bad_intr(void)
877 printk("bad interrupt");
880 asmlinkage
void do_simd_coprocessor_error(struct pt_regs
*regs
)
882 void __user
*rip
= (void __user
*)(regs
->rip
);
883 struct task_struct
* task
;
885 unsigned short mxcsr
;
887 conditional_sti(regs
);
888 if (!user_mode(regs
) &&
889 kernel_math_error(regs
, "kernel simd math error", 19))
893 * Save the info for the exception handler and clear the error.
897 task
->thread
.trap_no
= 19;
898 task
->thread
.error_code
= 0;
899 info
.si_signo
= SIGFPE
;
901 info
.si_code
= __SI_FAULT
;
904 * The SIMD FPU exceptions are handled a little differently, as there
905 * is only a single status/control register. Thus, to determine which
906 * unmasked exception was caught we must mask the exception mask bits
907 * at 0x1f80, and then use these to mask the exception bits at 0x3f.
909 mxcsr
= get_fpu_mxcsr(task
);
910 switch (~((mxcsr
& 0x1f80) >> 7) & (mxcsr
& 0x3f)) {
914 case 0x001: /* Invalid Op */
915 info
.si_code
= FPE_FLTINV
;
917 case 0x002: /* Denormalize */
918 case 0x010: /* Underflow */
919 info
.si_code
= FPE_FLTUND
;
921 case 0x004: /* Zero Divide */
922 info
.si_code
= FPE_FLTDIV
;
924 case 0x008: /* Overflow */
925 info
.si_code
= FPE_FLTOVF
;
927 case 0x020: /* Precision */
928 info
.si_code
= FPE_FLTRES
;
931 force_sig_info(SIGFPE
, &info
, task
);
934 asmlinkage
void do_spurious_interrupt_bug(struct pt_regs
* regs
)
938 asmlinkage
void __attribute__((weak
)) smp_thermal_interrupt(void)
942 asmlinkage
void __attribute__((weak
)) mce_threshold_interrupt(void)
947 * 'math_state_restore()' saves the current math information in the
948 * old math state array, and gets the new ones from the current task
950 * Careful.. There are problems with IBM-designed IRQ13 behaviour.
951 * Don't touch unless you *really* know how it works.
953 asmlinkage
void math_state_restore(void)
955 struct task_struct
*me
= current
;
956 clts(); /* Allow maths ops (or we recurse) */
960 restore_fpu_checking(&me
->thread
.i387
.fxsave
);
961 task_thread_info(me
)->status
|= TS_USEDFPU
;
964 void __init
trap_init(void)
966 set_intr_gate(0,÷_error
);
967 set_intr_gate_ist(1,&debug
,DEBUG_STACK
);
968 set_intr_gate_ist(2,&nmi
,NMI_STACK
);
969 set_system_gate_ist(3,&int3
,DEBUG_STACK
); /* int3 can be called from all */
970 set_system_gate(4,&overflow
); /* int4 can be called from all */
971 set_intr_gate(5,&bounds
);
972 set_intr_gate(6,&invalid_op
);
973 set_intr_gate(7,&device_not_available
);
974 set_intr_gate_ist(8,&double_fault
, DOUBLEFAULT_STACK
);
975 set_intr_gate(9,&coprocessor_segment_overrun
);
976 set_intr_gate(10,&invalid_TSS
);
977 set_intr_gate(11,&segment_not_present
);
978 set_intr_gate_ist(12,&stack_segment
,STACKFAULT_STACK
);
979 set_intr_gate(13,&general_protection
);
980 set_intr_gate(14,&page_fault
);
981 set_intr_gate(15,&spurious_interrupt_bug
);
982 set_intr_gate(16,&coprocessor_error
);
983 set_intr_gate(17,&alignment_check
);
984 #ifdef CONFIG_X86_MCE
985 set_intr_gate_ist(18,&machine_check
, MCE_STACK
);
987 set_intr_gate(19,&simd_coprocessor_error
);
989 #ifdef CONFIG_IA32_EMULATION
990 set_system_gate(IA32_SYSCALL_VECTOR
, ia32_syscall
);
994 * Should be a barrier for any external CPU state.
1000 /* Actual parsing is done early in setup.c. */
1001 static int __init
oops_dummy(char *s
)
1006 __setup("oops=", oops_dummy
);
1008 static int __init
kstack_setup(char *s
)
1010 kstack_depth_to_print
= simple_strtoul(s
,NULL
,0);
1013 __setup("kstack=", kstack_setup
);