[PATCH] x86_64: Remove CONFIG_CHECKING and add command line option for pagefault...
[linux-2.6.git] / arch / x86_64 / kernel / traps.c
1 /*
2  *  linux/arch/x86-64/traps.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *  Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
6  *
7  *  Pentium III FXSR, SSE support
8  *      Gareth Hughes <gareth@valinux.com>, May 2000
9  *
10  *  $Id: traps.c,v 1.36 2002/03/24 11:09:10 ak Exp $
11  */
12
13 /*
14  * 'Traps.c' handles hardware traps and faults after we have saved some
15  * state in 'entry.S'.
16  */
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>
24 #include <linux/mm.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
34 #include <asm/system.h>
35 #include <asm/uaccess.h>
36 #include <asm/io.h>
37 #include <asm/atomic.h>
38 #include <asm/debugreg.h>
39 #include <asm/desc.h>
40 #include <asm/i387.h>
41 #include <asm/kdebug.h>
42 #include <asm/processor.h>
43
44 #include <asm/smp.h>
45 #include <asm/pgalloc.h>
46 #include <asm/pda.h>
47 #include <asm/proto.h>
48 #include <asm/nmi.h>
49
50 extern struct gate_struct idt_table[256]; 
51
52 asmlinkage void divide_error(void);
53 asmlinkage void debug(void);
54 asmlinkage void nmi(void);
55 asmlinkage void int3(void);
56 asmlinkage void overflow(void);
57 asmlinkage void bounds(void);
58 asmlinkage void invalid_op(void);
59 asmlinkage void device_not_available(void);
60 asmlinkage void double_fault(void);
61 asmlinkage void coprocessor_segment_overrun(void);
62 asmlinkage void invalid_TSS(void);
63 asmlinkage void segment_not_present(void);
64 asmlinkage void stack_segment(void);
65 asmlinkage void general_protection(void);
66 asmlinkage void page_fault(void);
67 asmlinkage void coprocessor_error(void);
68 asmlinkage void simd_coprocessor_error(void);
69 asmlinkage void reserved(void);
70 asmlinkage void alignment_check(void);
71 asmlinkage void machine_check(void);
72 asmlinkage void spurious_interrupt_bug(void);
73 asmlinkage void call_debug(void);
74
75 struct notifier_block *die_chain;
76 static DEFINE_SPINLOCK(die_notifier_lock);
77
78 int register_die_notifier(struct notifier_block *nb)
79 {
80         int err = 0;
81         unsigned long flags;
82         spin_lock_irqsave(&die_notifier_lock, flags);
83         err = notifier_chain_register(&die_chain, nb);
84         spin_unlock_irqrestore(&die_notifier_lock, flags);
85         return err;
86 }
87
88 static inline void conditional_sti(struct pt_regs *regs)
89 {
90         if (regs->eflags & X86_EFLAGS_IF)
91                 local_irq_enable();
92 }
93
94 static int kstack_depth_to_print = 10;
95
96 #ifdef CONFIG_KALLSYMS
97 #include <linux/kallsyms.h> 
98 int printk_address(unsigned long address)
99
100         unsigned long offset = 0, symsize;
101         const char *symname;
102         char *modname;
103         char *delim = ":"; 
104         char namebuf[128];
105
106         symname = kallsyms_lookup(address, &symsize, &offset, &modname, namebuf); 
107         if (!symname) 
108                 return printk("[<%016lx>]", address);
109         if (!modname) 
110                 modname = delim = "";           
111         return printk("<%016lx>{%s%s%s%s%+ld}",
112                       address,delim,modname,delim,symname,offset); 
113
114 #else
115 int printk_address(unsigned long address)
116
117         return printk("[<%016lx>]", address);
118
119 #endif
120
121 static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack,
122                                         unsigned *usedp, const char **idp)
123 {
124         static const char ids[N_EXCEPTION_STACKS][8] = {
125                 [DEBUG_STACK - 1] = "#DB",
126                 [NMI_STACK - 1] = "NMI",
127                 [DOUBLEFAULT_STACK - 1] = "#DF",
128                 [STACKFAULT_STACK - 1] = "#SS",
129                 [MCE_STACK - 1] = "#MC",
130         };
131         unsigned k;
132
133         for (k = 0; k < N_EXCEPTION_STACKS; k++) {
134                 unsigned long end;
135
136                 end = per_cpu(init_tss, cpu).ist[k];
137                 if (stack >= end)
138                         continue;
139                 if (stack >= end - EXCEPTION_STKSZ) {
140                         if (*usedp & (1U << k))
141                                 break;
142                         *usedp |= 1U << k;
143                         *idp = ids[k];
144                         return (unsigned long *)end;
145                 }
146         }
147         return NULL;
148 }
149
150 /*
151  * x86-64 can have upto three kernel stacks: 
152  * process stack
153  * interrupt stack
154  * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
155  */
156
157 void show_trace(unsigned long *stack)
158 {
159         unsigned long addr;
160         const unsigned cpu = safe_smp_processor_id();
161         unsigned long *irqstack_end = (unsigned long *)cpu_pda[cpu].irqstackptr;
162         int i;
163         unsigned used = 0;
164
165         printk("\nCall Trace:");
166
167 #define HANDLE_STACK(cond) \
168         do while (cond) { \
169                 addr = *stack++; \
170                 if (kernel_text_address(addr)) { \
171                         /* \
172                          * If the address is either in the text segment of the \
173                          * kernel, or in the region which contains vmalloc'ed \
174                          * memory, it *may* be the address of a calling \
175                          * routine; if so, print it so that someone tracing \
176                          * down the cause of the crash will be able to figure \
177                          * out the call path that was taken. \
178                          */ \
179                         i += printk_address(addr); \
180                         if (i > 50) { \
181                                 printk("\n       "); \
182                                 i = 0; \
183                         } \
184                         else \
185                                 i += printk(" "); \
186                 } \
187         } while (0)
188
189         for(i = 0; ; ) {
190                 const char *id;
191                 unsigned long *estack_end;
192                 estack_end = in_exception_stack(cpu, (unsigned long)stack,
193                                                 &used, &id);
194
195                 if (estack_end) {
196                         i += printk(" <%s> ", id);
197                         HANDLE_STACK (stack < estack_end);
198                         i += printk(" <EOE> ");
199                         stack = (unsigned long *) estack_end[-2];
200                         continue;
201                 }
202                 if (irqstack_end) {
203                         unsigned long *irqstack;
204                         irqstack = irqstack_end -
205                                 (IRQSTACKSIZE - 64) / sizeof(*irqstack);
206
207                         if (stack >= irqstack && stack < irqstack_end) {
208                                 i += printk(" <IRQ> ");
209                                 HANDLE_STACK (stack < irqstack_end);
210                                 stack = (unsigned long *) (irqstack_end[-1]);
211                                 irqstack_end = NULL;
212                                 i += printk(" <EOI> ");
213                                 continue;
214                         }
215                 }
216                 break;
217         }
218
219         HANDLE_STACK (((long) stack & (THREAD_SIZE-1)) != 0);
220 #undef HANDLE_STACK
221         printk("\n");
222 }
223
224 void show_stack(struct task_struct *tsk, unsigned long * rsp)
225 {
226         unsigned long *stack;
227         int i;
228         const int cpu = safe_smp_processor_id();
229         unsigned long *irqstack_end = (unsigned long *) (cpu_pda[cpu].irqstackptr);
230         unsigned long *irqstack = (unsigned long *) (cpu_pda[cpu].irqstackptr - IRQSTACKSIZE);    
231
232         // debugging aid: "show_stack(NULL, NULL);" prints the
233         // back trace for this cpu.
234
235         if (rsp == NULL) {
236                 if (tsk)
237                         rsp = (unsigned long *)tsk->thread.rsp;
238                 else
239                         rsp = (unsigned long *)&rsp;
240         }
241
242         stack = rsp;
243         for(i=0; i < kstack_depth_to_print; i++) {
244                 if (stack >= irqstack && stack <= irqstack_end) {
245                         if (stack == irqstack_end) {
246                                 stack = (unsigned long *) (irqstack_end[-1]);
247                                 printk(" <EOI> ");
248                         }
249                 } else {
250                 if (((long) stack & (THREAD_SIZE-1)) == 0)
251                         break;
252                 }
253                 if (i && ((i % 4) == 0))
254                         printk("\n       ");
255                 printk("%016lx ", *stack++);
256                 touch_nmi_watchdog();
257         }
258         show_trace((unsigned long *)rsp);
259 }
260
261 /*
262  * The architecture-independent dump_stack generator
263  */
264 void dump_stack(void)
265 {
266         unsigned long dummy;
267         show_trace(&dummy);
268 }
269
270 EXPORT_SYMBOL(dump_stack);
271
272 void show_registers(struct pt_regs *regs)
273 {
274         int i;
275         int in_kernel = !user_mode(regs);
276         unsigned long rsp;
277         const int cpu = safe_smp_processor_id(); 
278         struct task_struct *cur = cpu_pda[cpu].pcurrent; 
279
280                 rsp = regs->rsp;
281
282         printk("CPU %d ", cpu);
283         __show_regs(regs);
284         printk("Process %s (pid: %d, threadinfo %p, task %p)\n",
285                 cur->comm, cur->pid, cur->thread_info, cur);
286
287         /*
288          * When in-kernel, we also print out the stack and code at the
289          * time of the fault..
290          */
291         if (in_kernel) {
292
293                 printk("Stack: ");
294                 show_stack(NULL, (unsigned long*)rsp);
295
296                 printk("\nCode: ");
297                 if(regs->rip < PAGE_OFFSET)
298                         goto bad;
299
300                 for(i=0;i<20;i++)
301                 {
302                         unsigned char c;
303                         if(__get_user(c, &((unsigned char*)regs->rip)[i])) {
304 bad:
305                                 printk(" Bad RIP value.");
306                                 break;
307                         }
308                         printk("%02x ", c);
309                 }
310         }
311         printk("\n");
312 }       
313
314 void handle_BUG(struct pt_regs *regs)
315
316         struct bug_frame f;
317         char tmp;
318
319         if (user_mode(regs))
320                 return; 
321         if (__copy_from_user(&f, (struct bug_frame *) regs->rip, 
322                              sizeof(struct bug_frame)))
323                 return; 
324         if (f.filename >= 0 ||
325             f.ud2[0] != 0x0f || f.ud2[1] != 0x0b) 
326                 return;
327         if (__get_user(tmp, (char *)(long)f.filename))
328                 f.filename = (int)(long)"unmapped filename";
329         printk("----------- [cut here ] --------- [please bite here ] ---------\n");
330         printk(KERN_ALERT "Kernel BUG at %.50s:%d\n", (char *)(long)f.filename, f.line);
331
332
333 #ifdef CONFIG_BUG
334 void out_of_line_bug(void)
335
336         BUG(); 
337
338 #endif
339
340 static DEFINE_SPINLOCK(die_lock);
341 static int die_owner = -1;
342
343 unsigned long oops_begin(void)
344 {
345         int cpu = safe_smp_processor_id();
346         unsigned long flags;
347
348         /* racy, but better than risking deadlock. */
349         local_irq_save(flags);
350         if (!spin_trylock(&die_lock)) { 
351                 if (cpu == die_owner) 
352                         /* nested oops. should stop eventually */;
353                 else
354                         spin_lock(&die_lock);
355         }
356         die_owner = cpu;
357         console_verbose();
358         bust_spinlocks(1);
359         return flags;
360 }
361
362 void oops_end(unsigned long flags)
363
364         die_owner = -1;
365         bust_spinlocks(0);
366         spin_unlock_irqrestore(&die_lock, flags);
367         if (panic_on_oops)
368                 panic("Oops");
369 }
370
371 void __die(const char * str, struct pt_regs * regs, long err)
372 {
373         static int die_counter;
374         printk(KERN_EMERG "%s: %04lx [%u] ", str, err & 0xffff,++die_counter);
375 #ifdef CONFIG_PREEMPT
376         printk("PREEMPT ");
377 #endif
378 #ifdef CONFIG_SMP
379         printk("SMP ");
380 #endif
381 #ifdef CONFIG_DEBUG_PAGEALLOC
382         printk("DEBUG_PAGEALLOC");
383 #endif
384         printk("\n");
385         notify_die(DIE_OOPS, (char *)str, regs, err, 255, SIGSEGV);
386         show_registers(regs);
387         /* Executive summary in case the oops scrolled away */
388         printk(KERN_ALERT "RIP ");
389         printk_address(regs->rip); 
390         printk(" RSP <%016lx>\n", regs->rsp); 
391 }
392
393 void die(const char * str, struct pt_regs * regs, long err)
394 {
395         unsigned long flags = oops_begin();
396
397         handle_BUG(regs);
398         __die(str, regs, err);
399         oops_end(flags);
400         do_exit(SIGSEGV); 
401 }
402 static inline void die_if_kernel(const char * str, struct pt_regs * regs, long err)
403 {
404         if (!(regs->eflags & VM_MASK) && (regs->cs == __KERNEL_CS))
405                 die(str, regs, err);
406 }
407
408 void die_nmi(char *str, struct pt_regs *regs)
409 {
410         unsigned long flags = oops_begin();
411
412         /*
413          * We are in trouble anyway, lets at least try
414          * to get a message out.
415          */
416         printk(str, safe_smp_processor_id());
417         show_registers(regs);
418         if (panic_on_timeout || panic_on_oops)
419                 panic("nmi watchdog");
420         printk("console shuts up ...\n");
421         oops_end(flags);
422         do_exit(SIGSEGV);
423 }
424
425 static void __kprobes do_trap(int trapnr, int signr, char *str,
426                               struct pt_regs * regs, long error_code,
427                               siginfo_t *info)
428 {
429         conditional_sti(regs);
430
431         if (user_mode(regs)) {
432                 struct task_struct *tsk = current;
433
434                 if (exception_trace && unhandled_signal(tsk, signr))
435                         printk(KERN_INFO
436                                "%s[%d] trap %s rip:%lx rsp:%lx error:%lx\n",
437                                tsk->comm, tsk->pid, str,
438                                regs->rip,regs->rsp,error_code); 
439
440                 tsk->thread.error_code = error_code;
441                 tsk->thread.trap_no = trapnr;
442                 if (info)
443                         force_sig_info(signr, info, tsk);
444                 else
445                         force_sig(signr, tsk);
446                 return;
447         }
448
449
450         /* kernel trap */ 
451         {            
452                 const struct exception_table_entry *fixup;
453                 fixup = search_exception_tables(regs->rip);
454                 if (fixup) {
455                         regs->rip = fixup->fixup;
456                 } else  
457                         die(str, regs, error_code);
458                 return;
459         }
460 }
461
462 #define DO_ERROR(trapnr, signr, str, name) \
463 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
464 { \
465         if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
466                                                         == NOTIFY_STOP) \
467                 return; \
468         do_trap(trapnr, signr, str, regs, error_code, NULL); \
469 }
470
471 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
472 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
473 { \
474         siginfo_t info; \
475         info.si_signo = signr; \
476         info.si_errno = 0; \
477         info.si_code = sicode; \
478         info.si_addr = (void __user *)siaddr; \
479         if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
480                                                         == NOTIFY_STOP) \
481                 return; \
482         do_trap(trapnr, signr, str, regs, error_code, &info); \
483 }
484
485 DO_ERROR_INFO( 0, SIGFPE,  "divide error", divide_error, FPE_INTDIV, regs->rip)
486 DO_ERROR( 4, SIGSEGV, "overflow", overflow)
487 DO_ERROR( 5, SIGSEGV, "bounds", bounds)
488 DO_ERROR_INFO( 6, SIGILL,  "invalid operand", invalid_op, ILL_ILLOPN, regs->rip)
489 DO_ERROR( 7, SIGSEGV, "device not available", device_not_available)
490 DO_ERROR( 9, SIGFPE,  "coprocessor segment overrun", coprocessor_segment_overrun)
491 DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS)
492 DO_ERROR(11, SIGBUS,  "segment not present", segment_not_present)
493 DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0)
494 DO_ERROR(18, SIGSEGV, "reserved", reserved)
495 DO_ERROR(12, SIGBUS,  "stack segment", stack_segment)
496 DO_ERROR( 8, SIGSEGV, "double fault", double_fault)
497
498 asmlinkage void __kprobes do_general_protection(struct pt_regs * regs,
499                                                 long error_code)
500 {
501         conditional_sti(regs);
502
503         if (user_mode(regs)) {
504                 struct task_struct *tsk = current;
505
506                 if (exception_trace && unhandled_signal(tsk, SIGSEGV))
507                         printk(KERN_INFO
508                        "%s[%d] general protection rip:%lx rsp:%lx error:%lx\n",
509                                tsk->comm, tsk->pid,
510                                regs->rip,regs->rsp,error_code); 
511
512                 tsk->thread.error_code = error_code;
513                 tsk->thread.trap_no = 13;
514                 force_sig(SIGSEGV, tsk);
515                 return;
516         } 
517
518         /* kernel gp */
519         {
520                 const struct exception_table_entry *fixup;
521                 fixup = search_exception_tables(regs->rip);
522                 if (fixup) {
523                         regs->rip = fixup->fixup;
524                         return;
525                 }
526                 if (notify_die(DIE_GPF, "general protection fault", regs,
527                                         error_code, 13, SIGSEGV) == NOTIFY_STOP)
528                         return;
529                 die("general protection fault", regs, error_code);
530         }
531 }
532
533 static void mem_parity_error(unsigned char reason, struct pt_regs * regs)
534 {
535         printk("Uhhuh. NMI received. Dazed and confused, but trying to continue\n");
536         printk("You probably have a hardware problem with your RAM chips\n");
537
538         /* Clear and disable the memory parity error line. */
539         reason = (reason & 0xf) | 4;
540         outb(reason, 0x61);
541 }
542
543 static void io_check_error(unsigned char reason, struct pt_regs * regs)
544 {
545         printk("NMI: IOCK error (debug interrupt?)\n");
546         show_registers(regs);
547
548         /* Re-enable the IOCK line, wait for a few seconds */
549         reason = (reason & 0xf) | 8;
550         outb(reason, 0x61);
551         mdelay(2000);
552         reason &= ~8;
553         outb(reason, 0x61);
554 }
555
556 static void unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
557 {       printk("Uhhuh. NMI received for unknown reason %02x.\n", reason);
558         printk("Dazed and confused, but trying to continue\n");
559         printk("Do you have a strange power saving mode enabled?\n");
560 }
561
562 /* Runs on IST stack. This code must keep interrupts off all the time.
563    Nested NMIs are prevented by the CPU. */
564 asmlinkage void default_do_nmi(struct pt_regs *regs)
565 {
566         unsigned char reason = 0;
567         int cpu;
568
569         cpu = smp_processor_id();
570
571         /* Only the BSP gets external NMIs from the system.  */
572         if (!cpu)
573                 reason = get_nmi_reason();
574
575         if (!(reason & 0xc0)) {
576                 if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 0, SIGINT)
577                                                                 == NOTIFY_STOP)
578                         return;
579 #ifdef CONFIG_X86_LOCAL_APIC
580                 /*
581                  * Ok, so this is none of the documented NMI sources,
582                  * so it must be the NMI watchdog.
583                  */
584                 if (nmi_watchdog > 0) {
585                         nmi_watchdog_tick(regs,reason);
586                         return;
587                 }
588 #endif
589                 unknown_nmi_error(reason, regs);
590                 return;
591         }
592         if (notify_die(DIE_NMI, "nmi", regs, reason, 0, SIGINT) == NOTIFY_STOP)
593                 return; 
594
595         /* AK: following checks seem to be broken on modern chipsets. FIXME */
596
597         if (reason & 0x80)
598                 mem_parity_error(reason, regs);
599         if (reason & 0x40)
600                 io_check_error(reason, regs);
601 }
602
603 asmlinkage void __kprobes do_int3(struct pt_regs * regs, long error_code)
604 {
605         if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) == NOTIFY_STOP) {
606                 return;
607         }
608         do_trap(3, SIGTRAP, "int3", regs, error_code, NULL);
609         return;
610 }
611
612 /* Help handler running on IST stack to switch back to user stack
613    for scheduling or signal handling. The actual stack switch is done in
614    entry.S */
615 asmlinkage struct pt_regs *sync_regs(struct pt_regs *eregs)
616 {
617         struct pt_regs *regs = eregs;
618         /* Did already sync */
619         if (eregs == (struct pt_regs *)eregs->rsp)
620                 ;
621         /* Exception from user space */
622         else if (user_mode(eregs))
623                 regs = ((struct pt_regs *)current->thread.rsp0) - 1;
624         /* Exception from kernel and interrupts are enabled. Move to
625            kernel process stack. */
626         else if (eregs->eflags & X86_EFLAGS_IF)
627                 regs = (struct pt_regs *)(eregs->rsp -= sizeof(struct pt_regs));
628         if (eregs != regs)
629                 *regs = *eregs;
630         return regs;
631 }
632
633 /* runs on IST stack. */
634 asmlinkage void __kprobes do_debug(struct pt_regs * regs,
635                                    unsigned long error_code)
636 {
637         unsigned long condition;
638         struct task_struct *tsk = current;
639         siginfo_t info;
640
641         get_debugreg(condition, 6);
642
643         if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
644                                                 SIGTRAP) == NOTIFY_STOP)
645                 return;
646
647         conditional_sti(regs);
648
649         /* Mask out spurious debug traps due to lazy DR7 setting */
650         if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
651                 if (!tsk->thread.debugreg7) { 
652                         goto clear_dr7;
653                 }
654         }
655
656         tsk->thread.debugreg6 = condition;
657
658         /* Mask out spurious TF errors due to lazy TF clearing */
659         if (condition & DR_STEP) {
660                 /*
661                  * The TF error should be masked out only if the current
662                  * process is not traced and if the TRAP flag has been set
663                  * previously by a tracing process (condition detected by
664                  * the PT_DTRACE flag); remember that the i386 TRAP flag
665                  * can be modified by the process itself in user mode,
666                  * allowing programs to debug themselves without the ptrace()
667                  * interface.
668                  */
669                 if (!user_mode(regs))
670                        goto clear_TF_reenable;
671                 /*
672                  * Was the TF flag set by a debugger? If so, clear it now,
673                  * so that register information is correct.
674                  */
675                 if (tsk->ptrace & PT_DTRACE) {
676                         regs->eflags &= ~TF_MASK;
677                         tsk->ptrace &= ~PT_DTRACE;
678                 }
679         }
680
681         /* Ok, finally something we can handle */
682         tsk->thread.trap_no = 1;
683         tsk->thread.error_code = error_code;
684         info.si_signo = SIGTRAP;
685         info.si_errno = 0;
686         info.si_code = TRAP_BRKPT;
687         if (!user_mode(regs))
688                 goto clear_dr7; 
689
690         info.si_addr = (void __user *)regs->rip;
691         force_sig_info(SIGTRAP, &info, tsk);    
692 clear_dr7:
693         set_debugreg(0UL, 7);
694         return;
695
696 clear_TF_reenable:
697         set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
698         regs->eflags &= ~TF_MASK;
699 }
700
701 static int kernel_math_error(struct pt_regs *regs, char *str)
702 {
703         const struct exception_table_entry *fixup;
704         fixup = search_exception_tables(regs->rip);
705         if (fixup) {
706                 regs->rip = fixup->fixup;
707                 return 1;
708         }
709         notify_die(DIE_GPF, str, regs, 0, 16, SIGFPE);
710         /* Illegal floating point operation in the kernel */
711         die(str, regs, 0);
712         return 0;
713 }
714
715 /*
716  * Note that we play around with the 'TS' bit in an attempt to get
717  * the correct behaviour even in the presence of the asynchronous
718  * IRQ13 behaviour
719  */
720 asmlinkage void do_coprocessor_error(struct pt_regs *regs)
721 {
722         void __user *rip = (void __user *)(regs->rip);
723         struct task_struct * task;
724         siginfo_t info;
725         unsigned short cwd, swd;
726
727         conditional_sti(regs);
728         if (!user_mode(regs) &&
729             kernel_math_error(regs, "kernel x87 math error"))
730                 return;
731
732         /*
733          * Save the info for the exception handler and clear the error.
734          */
735         task = current;
736         save_init_fpu(task);
737         task->thread.trap_no = 16;
738         task->thread.error_code = 0;
739         info.si_signo = SIGFPE;
740         info.si_errno = 0;
741         info.si_code = __SI_FAULT;
742         info.si_addr = rip;
743         /*
744          * (~cwd & swd) will mask out exceptions that are not set to unmasked
745          * status.  0x3f is the exception bits in these regs, 0x200 is the
746          * C1 reg you need in case of a stack fault, 0x040 is the stack
747          * fault bit.  We should only be taking one exception at a time,
748          * so if this combination doesn't produce any single exception,
749          * then we have a bad program that isn't synchronizing its FPU usage
750          * and it will suffer the consequences since we won't be able to
751          * fully reproduce the context of the exception
752          */
753         cwd = get_fpu_cwd(task);
754         swd = get_fpu_swd(task);
755         switch (swd & ~cwd & 0x3f) {
756                 case 0x000:
757                 default:
758                         break;
759                 case 0x001: /* Invalid Op */
760                         /*
761                          * swd & 0x240 == 0x040: Stack Underflow
762                          * swd & 0x240 == 0x240: Stack Overflow
763                          * User must clear the SF bit (0x40) if set
764                          */
765                         info.si_code = FPE_FLTINV;
766                         break;
767                 case 0x002: /* Denormalize */
768                 case 0x010: /* Underflow */
769                         info.si_code = FPE_FLTUND;
770                         break;
771                 case 0x004: /* Zero Divide */
772                         info.si_code = FPE_FLTDIV;
773                         break;
774                 case 0x008: /* Overflow */
775                         info.si_code = FPE_FLTOVF;
776                         break;
777                 case 0x020: /* Precision */
778                         info.si_code = FPE_FLTRES;
779                         break;
780         }
781         force_sig_info(SIGFPE, &info, task);
782 }
783
784 asmlinkage void bad_intr(void)
785 {
786         printk("bad interrupt"); 
787 }
788
789 asmlinkage void do_simd_coprocessor_error(struct pt_regs *regs)
790 {
791         void __user *rip = (void __user *)(regs->rip);
792         struct task_struct * task;
793         siginfo_t info;
794         unsigned short mxcsr;
795
796         conditional_sti(regs);
797         if (!user_mode(regs) &&
798                 kernel_math_error(regs, "kernel simd math error"))
799                 return;
800
801         /*
802          * Save the info for the exception handler and clear the error.
803          */
804         task = current;
805         save_init_fpu(task);
806         task->thread.trap_no = 19;
807         task->thread.error_code = 0;
808         info.si_signo = SIGFPE;
809         info.si_errno = 0;
810         info.si_code = __SI_FAULT;
811         info.si_addr = rip;
812         /*
813          * The SIMD FPU exceptions are handled a little differently, as there
814          * is only a single status/control register.  Thus, to determine which
815          * unmasked exception was caught we must mask the exception mask bits
816          * at 0x1f80, and then use these to mask the exception bits at 0x3f.
817          */
818         mxcsr = get_fpu_mxcsr(task);
819         switch (~((mxcsr & 0x1f80) >> 7) & (mxcsr & 0x3f)) {
820                 case 0x000:
821                 default:
822                         break;
823                 case 0x001: /* Invalid Op */
824                         info.si_code = FPE_FLTINV;
825                         break;
826                 case 0x002: /* Denormalize */
827                 case 0x010: /* Underflow */
828                         info.si_code = FPE_FLTUND;
829                         break;
830                 case 0x004: /* Zero Divide */
831                         info.si_code = FPE_FLTDIV;
832                         break;
833                 case 0x008: /* Overflow */
834                         info.si_code = FPE_FLTOVF;
835                         break;
836                 case 0x020: /* Precision */
837                         info.si_code = FPE_FLTRES;
838                         break;
839         }
840         force_sig_info(SIGFPE, &info, task);
841 }
842
843 asmlinkage void do_spurious_interrupt_bug(struct pt_regs * regs)
844 {
845 }
846
847 asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void)
848 {
849 }
850
851 asmlinkage void __attribute__((weak)) mce_threshold_interrupt(void)
852 {
853 }
854
855 /*
856  *  'math_state_restore()' saves the current math information in the
857  * old math state array, and gets the new ones from the current task
858  *
859  * Careful.. There are problems with IBM-designed IRQ13 behaviour.
860  * Don't touch unless you *really* know how it works.
861  */
862 asmlinkage void math_state_restore(void)
863 {
864         struct task_struct *me = current;
865         clts();                 /* Allow maths ops (or we recurse) */
866
867         if (!used_math())
868                 init_fpu(me);
869         restore_fpu_checking(&me->thread.i387.fxsave);
870         me->thread_info->status |= TS_USEDFPU;
871 }
872
873 void do_call_debug(struct pt_regs *regs) 
874
875         notify_die(DIE_CALL, "debug call", regs, 0, 255, SIGINT); 
876 }
877
878 void __init trap_init(void)
879 {
880         set_intr_gate(0,&divide_error);
881         set_intr_gate_ist(1,&debug,DEBUG_STACK);
882         set_intr_gate_ist(2,&nmi,NMI_STACK);
883         set_system_gate(3,&int3);
884         set_system_gate(4,&overflow);   /* int4-5 can be called from all */
885         set_system_gate(5,&bounds);
886         set_intr_gate(6,&invalid_op);
887         set_intr_gate(7,&device_not_available);
888         set_intr_gate_ist(8,&double_fault, DOUBLEFAULT_STACK);
889         set_intr_gate(9,&coprocessor_segment_overrun);
890         set_intr_gate(10,&invalid_TSS);
891         set_intr_gate(11,&segment_not_present);
892         set_intr_gate_ist(12,&stack_segment,STACKFAULT_STACK);
893         set_intr_gate(13,&general_protection);
894         set_intr_gate(14,&page_fault);
895         set_intr_gate(15,&spurious_interrupt_bug);
896         set_intr_gate(16,&coprocessor_error);
897         set_intr_gate(17,&alignment_check);
898 #ifdef CONFIG_X86_MCE
899         set_intr_gate_ist(18,&machine_check, MCE_STACK); 
900 #endif
901         set_intr_gate(19,&simd_coprocessor_error);
902
903 #ifdef CONFIG_IA32_EMULATION
904         set_system_gate(IA32_SYSCALL_VECTOR, ia32_syscall);
905 #endif
906        
907         set_intr_gate(KDB_VECTOR, call_debug);
908        
909         /*
910          * Should be a barrier for any external CPU state.
911          */
912         cpu_init();
913 }
914
915
916 /* Actual parsing is done early in setup.c. */
917 static int __init oops_dummy(char *s)
918
919         panic_on_oops = 1;
920         return -1; 
921
922 __setup("oops=", oops_dummy); 
923
924 static int __init kstack_setup(char *s)
925 {
926         kstack_depth_to_print = simple_strtoul(s,NULL,0);
927         return 0;
928 }
929 __setup("kstack=", kstack_setup);
930