2 * Copyright (C) 1991, 1992 Linus Torvalds
3 * Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
5 * Pentium III FXSR, SSE support
6 * Gareth Hughes <gareth@valinux.com>, May 2000
10 * 'Traps.c' handles hardware traps and faults after we have saved some
13 #include <linux/moduleparam.h>
14 #include <linux/interrupt.h>
15 #include <linux/kallsyms.h>
16 #include <linux/spinlock.h>
17 #include <linux/kprobes.h>
18 #include <linux/uaccess.h>
19 #include <linux/utsname.h>
20 #include <linux/kdebug.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/ptrace.h>
24 #include <linux/string.h>
25 #include <linux/unwind.h>
26 #include <linux/delay.h>
27 #include <linux/errno.h>
28 #include <linux/kexec.h>
29 #include <linux/sched.h>
30 #include <linux/timer.h>
31 #include <linux/init.h>
32 #include <linux/bug.h>
33 #include <linux/nmi.h>
35 #include <linux/smp.h>
38 #if defined(CONFIG_EDAC)
39 #include <linux/edac.h>
42 #include <asm/stacktrace.h>
43 #include <asm/processor.h>
44 #include <asm/debugreg.h>
45 #include <asm/atomic.h>
46 #include <asm/system.h>
47 #include <asm/unwind.h>
50 #include <asm/pgalloc.h>
51 #include <asm/proto.h>
53 #include <asm/traps.h>
55 #include <mach_traps.h>
57 int panic_on_unrecovered_nmi;
58 int kstack_depth_to_print = 12;
59 static unsigned int code_bytes = 64;
60 static int ignore_nmis;
61 static int die_counter;
63 static inline void conditional_sti(struct pt_regs *regs)
65 if (regs->flags & X86_EFLAGS_IF)
69 static inline void preempt_conditional_sti(struct pt_regs *regs)
72 if (regs->flags & X86_EFLAGS_IF)
76 static inline void preempt_conditional_cli(struct pt_regs *regs)
78 if (regs->flags & X86_EFLAGS_IF)
80 /* Make sure to not schedule here because we could be running
81 on an exception stack. */
85 void printk_address(unsigned long address, int reliable)
87 printk(" [<%016lx>] %s%pS\n",
88 address, reliable ? "" : "? ", (void *) address);
91 static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack,
92 unsigned *usedp, char **idp)
94 static char ids[][8] = {
95 [DEBUG_STACK - 1] = "#DB",
96 [NMI_STACK - 1] = "NMI",
97 [DOUBLEFAULT_STACK - 1] = "#DF",
98 [STACKFAULT_STACK - 1] = "#SS",
99 [MCE_STACK - 1] = "#MC",
100 #if DEBUG_STKSZ > EXCEPTION_STKSZ
101 [N_EXCEPTION_STACKS ...
102 N_EXCEPTION_STACKS + DEBUG_STKSZ / EXCEPTION_STKSZ - 2] = "#DB[?]"
108 * Iterate over all exception stacks, and figure out whether
109 * 'stack' is in one of them:
111 for (k = 0; k < N_EXCEPTION_STACKS; k++) {
112 unsigned long end = per_cpu(orig_ist, cpu).ist[k];
114 * Is 'stack' above this exception frame's end?
115 * If yes then skip to the next frame.
120 * Is 'stack' above this exception frame's start address?
121 * If yes then we found the right frame.
123 if (stack >= end - EXCEPTION_STKSZ) {
125 * Make sure we only iterate through an exception
126 * stack once. If it comes up for the second time
127 * then there's something wrong going on - just
128 * break out and return NULL:
130 if (*usedp & (1U << k))
134 return (unsigned long *)end;
137 * If this is a debug stack, and if it has a larger size than
138 * the usual exception stacks, then 'stack' might still
139 * be within the lower portion of the debug stack:
141 #if DEBUG_STKSZ > EXCEPTION_STKSZ
142 if (k == DEBUG_STACK - 1 && stack >= end - DEBUG_STKSZ) {
143 unsigned j = N_EXCEPTION_STACKS - 1;
146 * Black magic. A large debug stack is composed of
147 * multiple exception stack entries, which we
148 * iterate through now. Dont look:
152 end -= EXCEPTION_STKSZ;
153 ids[j][4] = '1' + (j - N_EXCEPTION_STACKS);
154 } while (stack < end - EXCEPTION_STKSZ);
155 if (*usedp & (1U << j))
159 return (unsigned long *)end;
167 * x86-64 can have up to three kernel stacks:
170 * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
173 static inline int valid_stack_ptr(struct thread_info *tinfo,
174 void *p, unsigned int size, void *end)
178 if (p < end && p >= (end-THREAD_SIZE))
183 return p > t && p < t + THREAD_SIZE - size;
186 /* The form of the top of the frame on the stack */
188 struct stack_frame *next_frame;
189 unsigned long return_address;
192 static inline unsigned long
193 print_context_stack(struct thread_info *tinfo,
194 unsigned long *stack, unsigned long bp,
195 const struct stacktrace_ops *ops, void *data,
198 struct stack_frame *frame = (struct stack_frame *)bp;
200 while (valid_stack_ptr(tinfo, stack, sizeof(*stack), end)) {
204 if (__kernel_text_address(addr)) {
205 if ((unsigned long) stack == bp + 8) {
206 ops->address(data, addr, 1);
207 frame = frame->next_frame;
208 bp = (unsigned long) frame;
210 ops->address(data, addr, bp == 0);
218 void dump_trace(struct task_struct *task, struct pt_regs *regs,
219 unsigned long *stack, unsigned long bp,
220 const struct stacktrace_ops *ops, void *data)
222 const unsigned cpu = get_cpu();
223 unsigned long *irqstack_end = (unsigned long *)cpu_pda(cpu)->irqstackptr;
225 struct thread_info *tinfo;
233 if (task && task != current)
234 stack = (unsigned long *)task->thread.sp;
237 #ifdef CONFIG_FRAME_POINTER
239 if (task == current) {
240 /* Grab bp right from our regs */
241 asm("movq %%rbp, %0" : "=r" (bp) : );
243 /* bp is the last reg pushed by switch_to */
244 bp = *(unsigned long *) task->thread.sp;
250 * Print function call entries in all stacks, starting at the
251 * current stack address. If the stacks consist of nested
254 tinfo = task_thread_info(task);
257 unsigned long *estack_end;
258 estack_end = in_exception_stack(cpu, (unsigned long)stack,
262 if (ops->stack(data, id) < 0)
265 bp = print_context_stack(tinfo, stack, bp, ops,
267 ops->stack(data, "<EOE>");
269 * We link to the next stack via the
270 * second-to-last pointer (index -2 to end) in the
273 stack = (unsigned long *) estack_end[-2];
277 unsigned long *irqstack;
278 irqstack = irqstack_end -
279 (IRQSTACKSIZE - 64) / sizeof(*irqstack);
281 if (stack >= irqstack && stack < irqstack_end) {
282 if (ops->stack(data, "IRQ") < 0)
284 bp = print_context_stack(tinfo, stack, bp,
285 ops, data, irqstack_end);
287 * We link to the next stack (which would be
288 * the process stack normally) the last
289 * pointer (index -1 to end) in the IRQ stack:
291 stack = (unsigned long *) (irqstack_end[-1]);
293 ops->stack(data, "EOI");
301 * This handles the process stack:
303 bp = print_context_stack(tinfo, stack, bp, ops, data, NULL);
306 EXPORT_SYMBOL(dump_trace);
309 print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
311 print_symbol(msg, symbol);
315 static void print_trace_warning(void *data, char *msg)
320 static int print_trace_stack(void *data, char *name)
322 printk(" <%s> ", name);
326 static void print_trace_address(void *data, unsigned long addr, int reliable)
328 touch_nmi_watchdog();
329 printk_address(addr, reliable);
332 static const struct stacktrace_ops print_trace_ops = {
333 .warning = print_trace_warning,
334 .warning_symbol = print_trace_warning_symbol,
335 .stack = print_trace_stack,
336 .address = print_trace_address,
340 show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
341 unsigned long *stack, unsigned long bp, char *log_lvl)
343 printk("\nCall Trace:\n");
344 dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl);
348 void show_trace(struct task_struct *task, struct pt_regs *regs,
349 unsigned long *stack, unsigned long bp)
351 show_trace_log_lvl(task, regs, stack, bp, "");
355 show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs,
356 unsigned long *sp, unsigned long bp, char *log_lvl)
358 unsigned long *stack;
360 const int cpu = smp_processor_id();
361 unsigned long *irqstack_end =
362 (unsigned long *) (cpu_pda(cpu)->irqstackptr);
363 unsigned long *irqstack =
364 (unsigned long *) (cpu_pda(cpu)->irqstackptr - IRQSTACKSIZE);
367 * debugging aid: "show_stack(NULL, NULL);" prints the
368 * back trace for this cpu.
373 sp = (unsigned long *)task->thread.sp;
375 sp = (unsigned long *)&sp;
379 for (i = 0; i < kstack_depth_to_print; i++) {
380 if (stack >= irqstack && stack <= irqstack_end) {
381 if (stack == irqstack_end) {
382 stack = (unsigned long *) (irqstack_end[-1]);
386 if (((long) stack & (THREAD_SIZE-1)) == 0)
389 if (i && ((i % 4) == 0))
391 printk(" %016lx", *stack++);
392 touch_nmi_watchdog();
394 show_trace_log_lvl(task, regs, sp, bp, log_lvl);
397 void show_stack(struct task_struct *task, unsigned long *sp)
399 show_stack_log_lvl(task, NULL, sp, 0, "");
403 * The architecture-independent dump_stack generator
405 void dump_stack(void)
407 unsigned long bp = 0;
410 #ifdef CONFIG_FRAME_POINTER
412 asm("movq %%rbp, %0" : "=r" (bp) : );
415 printk("Pid: %d, comm: %.20s %s %s %.*s\n",
416 current->pid, current->comm, print_tainted(),
417 init_utsname()->release,
418 (int)strcspn(init_utsname()->version, " "),
419 init_utsname()->version);
420 show_trace(NULL, NULL, &stack, bp);
422 EXPORT_SYMBOL(dump_stack);
424 void show_registers(struct pt_regs *regs)
428 const int cpu = smp_processor_id();
429 struct task_struct *cur = cpu_pda(cpu)->pcurrent;
432 printk("CPU %d ", cpu);
434 printk("Process %s (pid: %d, threadinfo %p, task %p)\n",
435 cur->comm, cur->pid, task_thread_info(cur), cur);
438 * When in-kernel, we also print out the stack and code at the
439 * time of the fault..
441 if (!user_mode(regs)) {
442 unsigned int code_prologue = code_bytes * 43 / 64;
443 unsigned int code_len = code_bytes;
448 show_stack_log_lvl(NULL, regs, (unsigned long *)sp,
452 printk(KERN_EMERG "Code: ");
454 ip = (u8 *)regs->ip - code_prologue;
455 if (ip < (u8 *)PAGE_OFFSET || probe_kernel_address(ip, c)) {
456 /* try starting at RIP */
458 code_len = code_len - code_prologue + 1;
460 for (i = 0; i < code_len; i++, ip++) {
461 if (ip < (u8 *)PAGE_OFFSET ||
462 probe_kernel_address(ip, c)) {
463 printk(" Bad RIP value.");
466 if (ip == (u8 *)regs->ip)
467 printk("<%02x> ", c);
475 int is_valid_bugaddr(unsigned long ip)
479 if (__copy_from_user(&ud2, (const void __user *) ip, sizeof(ud2)))
482 return ud2 == 0x0b0f;
485 static raw_spinlock_t die_lock = __RAW_SPIN_LOCK_UNLOCKED;
486 static int die_owner = -1;
487 static unsigned int die_nest_count;
489 unsigned __kprobes long oops_begin(void)
496 /* racy, but better than risking deadlock. */
497 raw_local_irq_save(flags);
498 cpu = smp_processor_id();
499 if (!__raw_spin_trylock(&die_lock)) {
500 if (cpu == die_owner)
501 /* nested oops. should stop eventually */;
503 __raw_spin_lock(&die_lock);
512 void __kprobes oops_end(unsigned long flags, struct pt_regs *regs, int signr)
518 /* Nest count reaches zero, release the lock. */
519 __raw_spin_unlock(&die_lock);
520 raw_local_irq_restore(flags);
526 panic("Fatal exception");
531 int __kprobes __die(const char *str, struct pt_regs *regs, long err)
533 printk(KERN_EMERG "%s: %04lx [%u] ", str, err & 0xffff, ++die_counter);
534 #ifdef CONFIG_PREEMPT
540 #ifdef CONFIG_DEBUG_PAGEALLOC
541 printk("DEBUG_PAGEALLOC");
544 if (notify_die(DIE_OOPS, str, regs, err,
545 current->thread.trap_no, SIGSEGV) == NOTIFY_STOP)
548 show_registers(regs);
549 add_taint(TAINT_DIE);
550 /* Executive summary in case the oops scrolled away */
551 printk(KERN_ALERT "RIP ");
552 printk_address(regs->ip, 1);
553 printk(" RSP <%016lx>\n", regs->sp);
554 if (kexec_should_crash(current))
559 void die(const char *str, struct pt_regs *regs, long err)
561 unsigned long flags = oops_begin();
563 if (!user_mode(regs))
564 report_bug(regs->ip, regs);
566 if (__die(str, regs, err))
568 oops_end(flags, regs, SIGSEGV);
571 notrace __kprobes void
572 die_nmi(char *str, struct pt_regs *regs, int do_panic)
576 if (notify_die(DIE_NMIWATCHDOG, str, regs, 0, 2, SIGINT) == NOTIFY_STOP)
579 flags = oops_begin();
581 * We are in trouble anyway, lets at least try
582 * to get a message out.
584 printk(KERN_EMERG "%s", str);
585 printk(" on CPU%d, ip %08lx, registers:\n",
586 smp_processor_id(), regs->ip);
587 show_registers(regs);
588 if (kexec_should_crash(current))
590 if (do_panic || panic_on_oops)
591 panic("Non maskable interrupt");
592 oops_end(flags, NULL, SIGBUS);
598 static void __kprobes
599 do_trap(int trapnr, int signr, char *str, struct pt_regs *regs,
600 long error_code, siginfo_t *info)
602 struct task_struct *tsk = current;
604 if (!user_mode(regs))
608 * We want error_code and trap_no set for userspace faults and
609 * kernelspace faults which result in die(), but not
610 * kernelspace faults which are fixed up. die() gives the
611 * process no chance to handle the signal and notice the
612 * kernel fault information, so that won't result in polluting
613 * the information about previously queued, but not yet
614 * delivered, faults. See also do_general_protection below.
616 tsk->thread.error_code = error_code;
617 tsk->thread.trap_no = trapnr;
619 if (show_unhandled_signals && unhandled_signal(tsk, signr) &&
620 printk_ratelimit()) {
622 "%s[%d] trap %s ip:%lx sp:%lx error:%lx",
623 tsk->comm, tsk->pid, str,
624 regs->ip, regs->sp, error_code);
625 print_vma_addr(" in ", regs->ip);
630 force_sig_info(signr, info, tsk);
632 force_sig(signr, tsk);
636 if (!fixup_exception(regs)) {
637 tsk->thread.error_code = error_code;
638 tsk->thread.trap_no = trapnr;
639 die(str, regs, error_code);
644 #define DO_ERROR(trapnr, signr, str, name) \
645 asmlinkage void do_##name(struct pt_regs *regs, long error_code) \
647 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
650 conditional_sti(regs); \
651 do_trap(trapnr, signr, str, regs, error_code, NULL); \
654 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
655 asmlinkage void do_##name(struct pt_regs *regs, long error_code) \
658 info.si_signo = signr; \
660 info.si_code = sicode; \
661 info.si_addr = (void __user *)siaddr; \
662 trace_hardirqs_fixup(); \
663 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
666 conditional_sti(regs); \
667 do_trap(trapnr, signr, str, regs, error_code, &info); \
670 DO_ERROR_INFO(0, SIGFPE, "divide error", divide_error, FPE_INTDIV, regs->ip)
671 DO_ERROR(4, SIGSEGV, "overflow", overflow)
672 DO_ERROR(5, SIGSEGV, "bounds", bounds)
673 DO_ERROR_INFO(6, SIGILL, "invalid opcode", invalid_op, ILL_ILLOPN, regs->ip)
674 DO_ERROR(9, SIGFPE, "coprocessor segment overrun", coprocessor_segment_overrun)
675 DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS)
676 DO_ERROR(11, SIGBUS, "segment not present", segment_not_present)
677 DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0)
679 /* Runs on IST stack */
680 asmlinkage void do_stack_segment(struct pt_regs *regs, long error_code)
682 if (notify_die(DIE_TRAP, "stack segment", regs, error_code,
683 12, SIGBUS) == NOTIFY_STOP)
685 preempt_conditional_sti(regs);
686 do_trap(12, SIGBUS, "stack segment", regs, error_code, NULL);
687 preempt_conditional_cli(regs);
690 asmlinkage void do_double_fault(struct pt_regs *regs, long error_code)
692 static const char str[] = "double fault";
693 struct task_struct *tsk = current;
695 /* Return not checked because double check cannot be ignored */
696 notify_die(DIE_TRAP, str, regs, error_code, 8, SIGSEGV);
698 tsk->thread.error_code = error_code;
699 tsk->thread.trap_no = 8;
701 /* This is always a kernel trap and never fixable (and thus must
704 die(str, regs, error_code);
707 asmlinkage void __kprobes
708 do_general_protection(struct pt_regs *regs, long error_code)
710 struct task_struct *tsk;
712 conditional_sti(regs);
715 if (!user_mode(regs))
718 tsk->thread.error_code = error_code;
719 tsk->thread.trap_no = 13;
721 if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) &&
722 printk_ratelimit()) {
724 "%s[%d] general protection ip:%lx sp:%lx error:%lx",
726 regs->ip, regs->sp, error_code);
727 print_vma_addr(" in ", regs->ip);
731 force_sig(SIGSEGV, tsk);
735 if (fixup_exception(regs))
738 tsk->thread.error_code = error_code;
739 tsk->thread.trap_no = 13;
740 if (notify_die(DIE_GPF, "general protection fault", regs,
741 error_code, 13, SIGSEGV) == NOTIFY_STOP)
743 die("general protection fault", regs, error_code);
746 static notrace __kprobes void
747 mem_parity_error(unsigned char reason, struct pt_regs *regs)
749 printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
751 printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n");
753 #if defined(CONFIG_EDAC)
754 if (edac_handler_set()) {
755 edac_atomic_assert_error();
760 if (panic_on_unrecovered_nmi)
761 panic("NMI: Not continuing");
763 printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
765 /* Clear and disable the memory parity error line. */
766 reason = (reason & 0xf) | 4;
770 static notrace __kprobes void
771 io_check_error(unsigned char reason, struct pt_regs *regs)
773 printk("NMI: IOCK error (debug interrupt?)\n");
774 show_registers(regs);
776 /* Re-enable the IOCK line, wait for a few seconds */
777 reason = (reason & 0xf) | 8;
784 static notrace __kprobes void
785 unknown_nmi_error(unsigned char reason, struct pt_regs *regs)
787 if (notify_die(DIE_NMIUNKNOWN, "nmi", regs, reason, 2, SIGINT) ==
790 printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
792 printk(KERN_EMERG "Do you have a strange power saving mode enabled?\n");
794 if (panic_on_unrecovered_nmi)
795 panic("NMI: Not continuing");
797 printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
800 /* Runs on IST stack. This code must keep interrupts off all the time.
801 Nested NMIs are prevented by the CPU. */
802 asmlinkage notrace __kprobes void default_do_nmi(struct pt_regs *regs)
804 unsigned char reason = 0;
807 cpu = smp_processor_id();
809 /* Only the BSP gets external NMIs from the system. */
811 reason = get_nmi_reason();
813 if (!(reason & 0xc0)) {
814 if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 2, SIGINT)
818 * Ok, so this is none of the documented NMI sources,
819 * so it must be the NMI watchdog.
821 if (nmi_watchdog_tick(regs, reason))
823 if (!do_nmi_callback(regs, cpu))
824 unknown_nmi_error(reason, regs);
828 if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP)
831 /* AK: following checks seem to be broken on modern chipsets. FIXME */
833 mem_parity_error(reason, regs);
835 io_check_error(reason, regs);
838 asmlinkage notrace __kprobes void
839 do_nmi(struct pt_regs *regs, long error_code)
843 add_pda(__nmi_count, 1);
846 default_do_nmi(regs);
857 void restart_nmi(void)
863 /* runs on IST stack. */
864 asmlinkage void __kprobes do_int3(struct pt_regs *regs, long error_code)
866 trace_hardirqs_fixup();
868 if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP)
872 preempt_conditional_sti(regs);
873 do_trap(3, SIGTRAP, "int3", regs, error_code, NULL);
874 preempt_conditional_cli(regs);
877 /* Help handler running on IST stack to switch back to user stack
878 for scheduling or signal handling. The actual stack switch is done in
880 asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs)
882 struct pt_regs *regs = eregs;
883 /* Did already sync */
884 if (eregs == (struct pt_regs *)eregs->sp)
886 /* Exception from user space */
887 else if (user_mode(eregs))
888 regs = task_pt_regs(current);
889 /* Exception from kernel and interrupts are enabled. Move to
890 kernel process stack. */
891 else if (eregs->flags & X86_EFLAGS_IF)
892 regs = (struct pt_regs *)(eregs->sp -= sizeof(struct pt_regs));
898 /* runs on IST stack. */
899 asmlinkage void __kprobes do_debug(struct pt_regs *regs,
900 unsigned long error_code)
902 struct task_struct *tsk = current;
903 unsigned long condition;
906 trace_hardirqs_fixup();
908 get_debugreg(condition, 6);
911 * The processor cleared BTF, so don't mark that we need it set.
913 clear_tsk_thread_flag(tsk, TIF_DEBUGCTLMSR);
914 tsk->thread.debugctlmsr = 0;
916 if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
917 SIGTRAP) == NOTIFY_STOP)
920 preempt_conditional_sti(regs);
922 /* Mask out spurious debug traps due to lazy DR7 setting */
923 if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
924 if (!tsk->thread.debugreg7)
928 tsk->thread.debugreg6 = condition;
931 * Single-stepping through TF: make sure we ignore any events in
932 * kernel space (but re-enable TF when returning to user mode).
934 if (condition & DR_STEP) {
935 if (!user_mode(regs))
936 goto clear_TF_reenable;
939 /* Ok, finally something we can handle */
940 tsk->thread.trap_no = 1;
941 tsk->thread.error_code = error_code;
942 info.si_signo = SIGTRAP;
944 info.si_code = TRAP_BRKPT;
945 info.si_addr = user_mode(regs) ? (void __user *)regs->ip : NULL;
946 force_sig_info(SIGTRAP, &info, tsk);
950 preempt_conditional_cli(regs);
954 set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
955 regs->flags &= ~X86_EFLAGS_TF;
956 preempt_conditional_cli(regs);
960 static int kernel_math_error(struct pt_regs *regs, const char *str, int trapnr)
962 if (fixup_exception(regs))
965 notify_die(DIE_GPF, str, regs, 0, trapnr, SIGFPE);
966 /* Illegal floating point operation in the kernel */
967 current->thread.trap_no = trapnr;
973 * Note that we play around with the 'TS' bit in an attempt to get
974 * the correct behaviour even in the presence of the asynchronous
977 asmlinkage void do_coprocessor_error(struct pt_regs *regs)
979 void __user *ip = (void __user *)(regs->ip);
980 struct task_struct *task;
982 unsigned short cwd, swd;
984 conditional_sti(regs);
985 if (!user_mode(regs) &&
986 kernel_math_error(regs, "kernel x87 math error", 16))
990 * Save the info for the exception handler and clear the error.
994 task->thread.trap_no = 16;
995 task->thread.error_code = 0;
996 info.si_signo = SIGFPE;
998 info.si_code = __SI_FAULT;
1001 * (~cwd & swd) will mask out exceptions that are not set to unmasked
1002 * status. 0x3f is the exception bits in these regs, 0x200 is the
1003 * C1 reg you need in case of a stack fault, 0x040 is the stack
1004 * fault bit. We should only be taking one exception at a time,
1005 * so if this combination doesn't produce any single exception,
1006 * then we have a bad program that isn't synchronizing its FPU usage
1007 * and it will suffer the consequences since we won't be able to
1008 * fully reproduce the context of the exception
1010 cwd = get_fpu_cwd(task);
1011 swd = get_fpu_swd(task);
1012 switch (swd & ~cwd & 0x3f) {
1013 case 0x000: /* No unmasked exception */
1014 default: /* Multiple exceptions */
1016 case 0x001: /* Invalid Op */
1018 * swd & 0x240 == 0x040: Stack Underflow
1019 * swd & 0x240 == 0x240: Stack Overflow
1020 * User must clear the SF bit (0x40) if set
1022 info.si_code = FPE_FLTINV;
1024 case 0x002: /* Denormalize */
1025 case 0x010: /* Underflow */
1026 info.si_code = FPE_FLTUND;
1028 case 0x004: /* Zero Divide */
1029 info.si_code = FPE_FLTDIV;
1031 case 0x008: /* Overflow */
1032 info.si_code = FPE_FLTOVF;
1034 case 0x020: /* Precision */
1035 info.si_code = FPE_FLTRES;
1038 force_sig_info(SIGFPE, &info, task);
1041 asmlinkage void bad_intr(void)
1043 printk("bad interrupt");
1046 asmlinkage void do_simd_coprocessor_error(struct pt_regs *regs)
1048 void __user *ip = (void __user *)(regs->ip);
1049 struct task_struct *task;
1051 unsigned short mxcsr;
1053 conditional_sti(regs);
1054 if (!user_mode(regs) &&
1055 kernel_math_error(regs, "kernel simd math error", 19))
1059 * Save the info for the exception handler and clear the error.
1062 save_init_fpu(task);
1063 task->thread.trap_no = 19;
1064 task->thread.error_code = 0;
1065 info.si_signo = SIGFPE;
1067 info.si_code = __SI_FAULT;
1070 * The SIMD FPU exceptions are handled a little differently, as there
1071 * is only a single status/control register. Thus, to determine which
1072 * unmasked exception was caught we must mask the exception mask bits
1073 * at 0x1f80, and then use these to mask the exception bits at 0x3f.
1075 mxcsr = get_fpu_mxcsr(task);
1076 switch (~((mxcsr & 0x1f80) >> 7) & (mxcsr & 0x3f)) {
1080 case 0x001: /* Invalid Op */
1081 info.si_code = FPE_FLTINV;
1083 case 0x002: /* Denormalize */
1084 case 0x010: /* Underflow */
1085 info.si_code = FPE_FLTUND;
1087 case 0x004: /* Zero Divide */
1088 info.si_code = FPE_FLTDIV;
1090 case 0x008: /* Overflow */
1091 info.si_code = FPE_FLTOVF;
1093 case 0x020: /* Precision */
1094 info.si_code = FPE_FLTRES;
1097 force_sig_info(SIGFPE, &info, task);
1100 asmlinkage void do_spurious_interrupt_bug(struct pt_regs *regs)
1104 asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void)
1108 asmlinkage void __attribute__((weak)) mce_threshold_interrupt(void)
1113 * 'math_state_restore()' saves the current math information in the
1114 * old math state array, and gets the new ones from the current task
1116 * Careful.. There are problems with IBM-designed IRQ13 behaviour.
1117 * Don't touch unless you *really* know how it works.
1119 asmlinkage void math_state_restore(void)
1121 struct task_struct *me = current;
1126 * does a slab alloc which can sleep
1130 * ran out of memory!
1132 do_group_exit(SIGKILL);
1135 local_irq_disable();
1138 clts(); /* Allow maths ops (or we recurse) */
1140 * Paranoid restore. send a SIGSEGV if we fail to restore the state.
1142 if (unlikely(restore_fpu_checking(&me->thread.xstate->fxsave))) {
1144 force_sig(SIGSEGV, me);
1147 task_thread_info(me)->status |= TS_USEDFPU;
1150 EXPORT_SYMBOL_GPL(math_state_restore);
1152 void __init trap_init(void)
1154 set_intr_gate(0, ÷_error);
1155 set_intr_gate_ist(1, &debug, DEBUG_STACK);
1156 set_intr_gate_ist(2, &nmi, NMI_STACK);
1157 /* int3 can be called from all */
1158 set_system_gate_ist(3, &int3, DEBUG_STACK);
1159 /* int4 can be called from all */
1160 set_system_gate(4, &overflow);
1161 set_intr_gate(5, &bounds);
1162 set_intr_gate(6, &invalid_op);
1163 set_intr_gate(7, &device_not_available);
1164 set_intr_gate_ist(8, &double_fault, DOUBLEFAULT_STACK);
1165 set_intr_gate(9, &coprocessor_segment_overrun);
1166 set_intr_gate(10, &invalid_TSS);
1167 set_intr_gate(11, &segment_not_present);
1168 set_intr_gate_ist(12, &stack_segment, STACKFAULT_STACK);
1169 set_intr_gate(13, &general_protection);
1170 set_intr_gate(14, &page_fault);
1171 set_intr_gate(15, &spurious_interrupt_bug);
1172 set_intr_gate(16, &coprocessor_error);
1173 set_intr_gate(17, &alignment_check);
1174 #ifdef CONFIG_X86_MCE
1175 set_intr_gate_ist(18, &machine_check, MCE_STACK);
1177 set_intr_gate(19, &simd_coprocessor_error);
1179 #ifdef CONFIG_IA32_EMULATION
1180 set_system_gate(IA32_SYSCALL_VECTOR, ia32_syscall);
1183 * initialize the per thread extended state:
1185 init_thread_xstate();
1187 * Should be a barrier for any external CPU state:
1192 static int __init oops_setup(char *s)
1196 if (!strcmp(s, "panic"))
1200 early_param("oops", oops_setup);
1202 static int __init kstack_setup(char *s)
1206 kstack_depth_to_print = simple_strtoul(s, NULL, 0);
1209 early_param("kstack", kstack_setup);
1211 static int __init code_bytes_setup(char *s)
1213 code_bytes = simple_strtoul(s, NULL, 0);
1214 if (code_bytes > 8192)
1219 __setup("code_bytes=", code_bytes_setup);