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