Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-for-linus-2.6
[linux-2.6] / 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 #ifdef CONFIG_CHECKING
432        { 
433                unsigned long gs; 
434                struct x8664_pda *pda = cpu_pda + safe_smp_processor_id(); 
435                rdmsrl(MSR_GS_BASE, gs); 
436                if (gs != (unsigned long)pda) { 
437                        wrmsrl(MSR_GS_BASE, pda); 
438                        printk("%s: wrong gs %lx expected %p rip %lx\n", str, gs, pda,
439                               regs->rip);
440                }
441        }
442 #endif
443
444         if (user_mode(regs)) {
445                 struct task_struct *tsk = current;
446
447                 if (exception_trace && unhandled_signal(tsk, signr))
448                         printk(KERN_INFO
449                                "%s[%d] trap %s rip:%lx rsp:%lx error:%lx\n",
450                                tsk->comm, tsk->pid, str,
451                                regs->rip,regs->rsp,error_code); 
452
453                 tsk->thread.error_code = error_code;
454                 tsk->thread.trap_no = trapnr;
455                 if (info)
456                         force_sig_info(signr, info, tsk);
457                 else
458                         force_sig(signr, tsk);
459                 return;
460         }
461
462
463         /* kernel trap */ 
464         {            
465                 const struct exception_table_entry *fixup;
466                 fixup = search_exception_tables(regs->rip);
467                 if (fixup) {
468                         regs->rip = fixup->fixup;
469                 } else  
470                         die(str, regs, error_code);
471                 return;
472         }
473 }
474
475 #define DO_ERROR(trapnr, signr, str, name) \
476 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
477 { \
478         if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
479                                                         == NOTIFY_STOP) \
480                 return; \
481         do_trap(trapnr, signr, str, regs, error_code, NULL); \
482 }
483
484 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
485 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
486 { \
487         siginfo_t info; \
488         info.si_signo = signr; \
489         info.si_errno = 0; \
490         info.si_code = sicode; \
491         info.si_addr = (void __user *)siaddr; \
492         if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
493                                                         == NOTIFY_STOP) \
494                 return; \
495         do_trap(trapnr, signr, str, regs, error_code, &info); \
496 }
497
498 DO_ERROR_INFO( 0, SIGFPE,  "divide error", divide_error, FPE_INTDIV, regs->rip)
499 DO_ERROR( 4, SIGSEGV, "overflow", overflow)
500 DO_ERROR( 5, SIGSEGV, "bounds", bounds)
501 DO_ERROR_INFO( 6, SIGILL,  "invalid operand", invalid_op, ILL_ILLOPN, regs->rip)
502 DO_ERROR( 7, SIGSEGV, "device not available", device_not_available)
503 DO_ERROR( 9, SIGFPE,  "coprocessor segment overrun", coprocessor_segment_overrun)
504 DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS)
505 DO_ERROR(11, SIGBUS,  "segment not present", segment_not_present)
506 DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0)
507 DO_ERROR(18, SIGSEGV, "reserved", reserved)
508 DO_ERROR(12, SIGBUS,  "stack segment", stack_segment)
509 DO_ERROR( 8, SIGSEGV, "double fault", double_fault)
510
511 asmlinkage void __kprobes do_general_protection(struct pt_regs * regs,
512                                                 long error_code)
513 {
514         conditional_sti(regs);
515
516 #ifdef CONFIG_CHECKING
517        { 
518                unsigned long gs; 
519                struct x8664_pda *pda = cpu_pda + safe_smp_processor_id(); 
520                rdmsrl(MSR_GS_BASE, gs); 
521                if (gs != (unsigned long)pda) { 
522                        wrmsrl(MSR_GS_BASE, pda); 
523                        oops_in_progress++;
524                        printk("general protection handler: wrong gs %lx expected %p\n", gs, pda);
525                        oops_in_progress--;
526                }
527        }
528 #endif
529
530         if (user_mode(regs)) {
531                 struct task_struct *tsk = current;
532
533                 if (exception_trace && unhandled_signal(tsk, SIGSEGV))
534                         printk(KERN_INFO
535                        "%s[%d] general protection rip:%lx rsp:%lx error:%lx\n",
536                                tsk->comm, tsk->pid,
537                                regs->rip,regs->rsp,error_code); 
538
539                 tsk->thread.error_code = error_code;
540                 tsk->thread.trap_no = 13;
541                 force_sig(SIGSEGV, tsk);
542                 return;
543         } 
544
545         /* kernel gp */
546         {
547                 const struct exception_table_entry *fixup;
548                 fixup = search_exception_tables(regs->rip);
549                 if (fixup) {
550                         regs->rip = fixup->fixup;
551                         return;
552                 }
553                 if (notify_die(DIE_GPF, "general protection fault", regs,
554                                         error_code, 13, SIGSEGV) == NOTIFY_STOP)
555                         return;
556                 die("general protection fault", regs, error_code);
557         }
558 }
559
560 static void mem_parity_error(unsigned char reason, struct pt_regs * regs)
561 {
562         printk("Uhhuh. NMI received. Dazed and confused, but trying to continue\n");
563         printk("You probably have a hardware problem with your RAM chips\n");
564
565         /* Clear and disable the memory parity error line. */
566         reason = (reason & 0xf) | 4;
567         outb(reason, 0x61);
568 }
569
570 static void io_check_error(unsigned char reason, struct pt_regs * regs)
571 {
572         printk("NMI: IOCK error (debug interrupt?)\n");
573         show_registers(regs);
574
575         /* Re-enable the IOCK line, wait for a few seconds */
576         reason = (reason & 0xf) | 8;
577         outb(reason, 0x61);
578         mdelay(2000);
579         reason &= ~8;
580         outb(reason, 0x61);
581 }
582
583 static void unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
584 {       printk("Uhhuh. NMI received for unknown reason %02x.\n", reason);
585         printk("Dazed and confused, but trying to continue\n");
586         printk("Do you have a strange power saving mode enabled?\n");
587 }
588
589 /* Runs on IST stack. This code must keep interrupts off all the time.
590    Nested NMIs are prevented by the CPU. */
591 asmlinkage void default_do_nmi(struct pt_regs *regs)
592 {
593         unsigned char reason = 0;
594         int cpu;
595
596         cpu = smp_processor_id();
597
598         /* Only the BSP gets external NMIs from the system.  */
599         if (!cpu)
600                 reason = get_nmi_reason();
601
602         if (!(reason & 0xc0)) {
603                 if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 0, SIGINT)
604                                                                 == NOTIFY_STOP)
605                         return;
606 #ifdef CONFIG_X86_LOCAL_APIC
607                 /*
608                  * Ok, so this is none of the documented NMI sources,
609                  * so it must be the NMI watchdog.
610                  */
611                 if (nmi_watchdog > 0) {
612                         nmi_watchdog_tick(regs,reason);
613                         return;
614                 }
615 #endif
616                 unknown_nmi_error(reason, regs);
617                 return;
618         }
619         if (notify_die(DIE_NMI, "nmi", regs, reason, 0, SIGINT) == NOTIFY_STOP)
620                 return; 
621
622         /* AK: following checks seem to be broken on modern chipsets. FIXME */
623
624         if (reason & 0x80)
625                 mem_parity_error(reason, regs);
626         if (reason & 0x40)
627                 io_check_error(reason, regs);
628 }
629
630 asmlinkage void __kprobes do_int3(struct pt_regs * regs, long error_code)
631 {
632         if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) == NOTIFY_STOP) {
633                 return;
634         }
635         do_trap(3, SIGTRAP, "int3", regs, error_code, NULL);
636         return;
637 }
638
639 /* Help handler running on IST stack to switch back to user stack
640    for scheduling or signal handling. The actual stack switch is done in
641    entry.S */
642 asmlinkage struct pt_regs *sync_regs(struct pt_regs *eregs)
643 {
644         struct pt_regs *regs = eregs;
645         /* Did already sync */
646         if (eregs == (struct pt_regs *)eregs->rsp)
647                 ;
648         /* Exception from user space */
649         else if (user_mode(eregs))
650                 regs = ((struct pt_regs *)current->thread.rsp0) - 1;
651         /* Exception from kernel and interrupts are enabled. Move to
652            kernel process stack. */
653         else if (eregs->eflags & X86_EFLAGS_IF)
654                 regs = (struct pt_regs *)(eregs->rsp -= sizeof(struct pt_regs));
655         if (eregs != regs)
656                 *regs = *eregs;
657         return regs;
658 }
659
660 /* runs on IST stack. */
661 asmlinkage void __kprobes do_debug(struct pt_regs * regs,
662                                    unsigned long error_code)
663 {
664         unsigned long condition;
665         struct task_struct *tsk = current;
666         siginfo_t info;
667
668 #ifdef CONFIG_CHECKING
669        { 
670                /* RED-PEN interaction with debugger - could destroy gs */
671                unsigned long gs; 
672                struct x8664_pda *pda = cpu_pda + safe_smp_processor_id(); 
673                rdmsrl(MSR_GS_BASE, gs); 
674                if (gs != (unsigned long)pda) { 
675                        wrmsrl(MSR_GS_BASE, pda); 
676                        printk("debug handler: wrong gs %lx expected %p\n", gs, pda);
677                }
678        }
679 #endif
680
681         get_debugreg(condition, 6);
682
683         if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
684                                                 SIGTRAP) == NOTIFY_STOP)
685                 return;
686
687         conditional_sti(regs);
688
689         /* Mask out spurious debug traps due to lazy DR7 setting */
690         if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
691                 if (!tsk->thread.debugreg7) { 
692                         goto clear_dr7;
693                 }
694         }
695
696         tsk->thread.debugreg6 = condition;
697
698         /* Mask out spurious TF errors due to lazy TF clearing */
699         if (condition & DR_STEP) {
700                 /*
701                  * The TF error should be masked out only if the current
702                  * process is not traced and if the TRAP flag has been set
703                  * previously by a tracing process (condition detected by
704                  * the PT_DTRACE flag); remember that the i386 TRAP flag
705                  * can be modified by the process itself in user mode,
706                  * allowing programs to debug themselves without the ptrace()
707                  * interface.
708                  */
709                 if (!user_mode(regs))
710                        goto clear_TF_reenable;
711                 /*
712                  * Was the TF flag set by a debugger? If so, clear it now,
713                  * so that register information is correct.
714                  */
715                 if (tsk->ptrace & PT_DTRACE) {
716                         regs->eflags &= ~TF_MASK;
717                         tsk->ptrace &= ~PT_DTRACE;
718                 }
719         }
720
721         /* Ok, finally something we can handle */
722         tsk->thread.trap_no = 1;
723         tsk->thread.error_code = error_code;
724         info.si_signo = SIGTRAP;
725         info.si_errno = 0;
726         info.si_code = TRAP_BRKPT;
727         if (!user_mode(regs))
728                 goto clear_dr7; 
729
730         info.si_addr = (void __user *)regs->rip;
731         force_sig_info(SIGTRAP, &info, tsk);    
732 clear_dr7:
733         set_debugreg(0UL, 7);
734         return;
735
736 clear_TF_reenable:
737         set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
738         regs->eflags &= ~TF_MASK;
739 }
740
741 static int kernel_math_error(struct pt_regs *regs, char *str)
742 {
743         const struct exception_table_entry *fixup;
744         fixup = search_exception_tables(regs->rip);
745         if (fixup) {
746                 regs->rip = fixup->fixup;
747                 return 1;
748         }
749         notify_die(DIE_GPF, str, regs, 0, 16, SIGFPE);
750         /* Illegal floating point operation in the kernel */
751         die(str, regs, 0);
752         return 0;
753 }
754
755 /*
756  * Note that we play around with the 'TS' bit in an attempt to get
757  * the correct behaviour even in the presence of the asynchronous
758  * IRQ13 behaviour
759  */
760 asmlinkage void do_coprocessor_error(struct pt_regs *regs)
761 {
762         void __user *rip = (void __user *)(regs->rip);
763         struct task_struct * task;
764         siginfo_t info;
765         unsigned short cwd, swd;
766
767         conditional_sti(regs);
768         if (!user_mode(regs) &&
769             kernel_math_error(regs, "kernel x87 math error"))
770                 return;
771
772         /*
773          * Save the info for the exception handler and clear the error.
774          */
775         task = current;
776         save_init_fpu(task);
777         task->thread.trap_no = 16;
778         task->thread.error_code = 0;
779         info.si_signo = SIGFPE;
780         info.si_errno = 0;
781         info.si_code = __SI_FAULT;
782         info.si_addr = rip;
783         /*
784          * (~cwd & swd) will mask out exceptions that are not set to unmasked
785          * status.  0x3f is the exception bits in these regs, 0x200 is the
786          * C1 reg you need in case of a stack fault, 0x040 is the stack
787          * fault bit.  We should only be taking one exception at a time,
788          * so if this combination doesn't produce any single exception,
789          * then we have a bad program that isn't synchronizing its FPU usage
790          * and it will suffer the consequences since we won't be able to
791          * fully reproduce the context of the exception
792          */
793         cwd = get_fpu_cwd(task);
794         swd = get_fpu_swd(task);
795         switch (swd & ~cwd & 0x3f) {
796                 case 0x000:
797                 default:
798                         break;
799                 case 0x001: /* Invalid Op */
800                         /*
801                          * swd & 0x240 == 0x040: Stack Underflow
802                          * swd & 0x240 == 0x240: Stack Overflow
803                          * User must clear the SF bit (0x40) if set
804                          */
805                         info.si_code = FPE_FLTINV;
806                         break;
807                 case 0x002: /* Denormalize */
808                 case 0x010: /* Underflow */
809                         info.si_code = FPE_FLTUND;
810                         break;
811                 case 0x004: /* Zero Divide */
812                         info.si_code = FPE_FLTDIV;
813                         break;
814                 case 0x008: /* Overflow */
815                         info.si_code = FPE_FLTOVF;
816                         break;
817                 case 0x020: /* Precision */
818                         info.si_code = FPE_FLTRES;
819                         break;
820         }
821         force_sig_info(SIGFPE, &info, task);
822 }
823
824 asmlinkage void bad_intr(void)
825 {
826         printk("bad interrupt"); 
827 }
828
829 asmlinkage void do_simd_coprocessor_error(struct pt_regs *regs)
830 {
831         void __user *rip = (void __user *)(regs->rip);
832         struct task_struct * task;
833         siginfo_t info;
834         unsigned short mxcsr;
835
836         conditional_sti(regs);
837         if (!user_mode(regs) &&
838                 kernel_math_error(regs, "kernel simd math error"))
839                 return;
840
841         /*
842          * Save the info for the exception handler and clear the error.
843          */
844         task = current;
845         save_init_fpu(task);
846         task->thread.trap_no = 19;
847         task->thread.error_code = 0;
848         info.si_signo = SIGFPE;
849         info.si_errno = 0;
850         info.si_code = __SI_FAULT;
851         info.si_addr = rip;
852         /*
853          * The SIMD FPU exceptions are handled a little differently, as there
854          * is only a single status/control register.  Thus, to determine which
855          * unmasked exception was caught we must mask the exception mask bits
856          * at 0x1f80, and then use these to mask the exception bits at 0x3f.
857          */
858         mxcsr = get_fpu_mxcsr(task);
859         switch (~((mxcsr & 0x1f80) >> 7) & (mxcsr & 0x3f)) {
860                 case 0x000:
861                 default:
862                         break;
863                 case 0x001: /* Invalid Op */
864                         info.si_code = FPE_FLTINV;
865                         break;
866                 case 0x002: /* Denormalize */
867                 case 0x010: /* Underflow */
868                         info.si_code = FPE_FLTUND;
869                         break;
870                 case 0x004: /* Zero Divide */
871                         info.si_code = FPE_FLTDIV;
872                         break;
873                 case 0x008: /* Overflow */
874                         info.si_code = FPE_FLTOVF;
875                         break;
876                 case 0x020: /* Precision */
877                         info.si_code = FPE_FLTRES;
878                         break;
879         }
880         force_sig_info(SIGFPE, &info, task);
881 }
882
883 asmlinkage void do_spurious_interrupt_bug(struct pt_regs * regs)
884 {
885 }
886
887 asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void)
888 {
889 }
890
891 /*
892  *  'math_state_restore()' saves the current math information in the
893  * old math state array, and gets the new ones from the current task
894  *
895  * Careful.. There are problems with IBM-designed IRQ13 behaviour.
896  * Don't touch unless you *really* know how it works.
897  */
898 asmlinkage void math_state_restore(void)
899 {
900         struct task_struct *me = current;
901         clts();                 /* Allow maths ops (or we recurse) */
902
903         if (!used_math())
904                 init_fpu(me);
905         restore_fpu_checking(&me->thread.i387.fxsave);
906         me->thread_info->status |= TS_USEDFPU;
907 }
908
909 void do_call_debug(struct pt_regs *regs) 
910
911         notify_die(DIE_CALL, "debug call", regs, 0, 255, SIGINT); 
912 }
913
914 void __init trap_init(void)
915 {
916         set_intr_gate(0,&divide_error);
917         set_intr_gate_ist(1,&debug,DEBUG_STACK);
918         set_intr_gate_ist(2,&nmi,NMI_STACK);
919         set_system_gate(3,&int3);
920         set_system_gate(4,&overflow);   /* int4-5 can be called from all */
921         set_system_gate(5,&bounds);
922         set_intr_gate(6,&invalid_op);
923         set_intr_gate(7,&device_not_available);
924         set_intr_gate_ist(8,&double_fault, DOUBLEFAULT_STACK);
925         set_intr_gate(9,&coprocessor_segment_overrun);
926         set_intr_gate(10,&invalid_TSS);
927         set_intr_gate(11,&segment_not_present);
928         set_intr_gate_ist(12,&stack_segment,STACKFAULT_STACK);
929         set_intr_gate(13,&general_protection);
930         set_intr_gate(14,&page_fault);
931         set_intr_gate(15,&spurious_interrupt_bug);
932         set_intr_gate(16,&coprocessor_error);
933         set_intr_gate(17,&alignment_check);
934 #ifdef CONFIG_X86_MCE
935         set_intr_gate_ist(18,&machine_check, MCE_STACK); 
936 #endif
937         set_intr_gate(19,&simd_coprocessor_error);
938
939 #ifdef CONFIG_IA32_EMULATION
940         set_system_gate(IA32_SYSCALL_VECTOR, ia32_syscall);
941 #endif
942        
943         set_intr_gate(KDB_VECTOR, call_debug);
944        
945         /*
946          * Should be a barrier for any external CPU state.
947          */
948         cpu_init();
949 }
950
951
952 /* Actual parsing is done early in setup.c. */
953 static int __init oops_dummy(char *s)
954
955         panic_on_oops = 1;
956         return -1; 
957
958 __setup("oops=", oops_dummy); 
959
960 static int __init kstack_setup(char *s)
961 {
962         kstack_depth_to_print = simple_strtoul(s,NULL,0);
963         return 0;
964 }
965 __setup("kstack=", kstack_setup);
966