x86: constify stacktrace_ops
[linux-2.6.git] / arch / x86 / kernel / traps_64.c
1 /*
2  *  Copyright (C) 1991, 1992  Linus Torvalds
3  *  Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
4  *
5  *  Pentium III FXSR, SSE support
6  *      Gareth Hughes <gareth@valinux.com>, May 2000
7  */
8
9 /*
10  * 'Traps.c' handles hardware traps and faults after we have saved some
11  * state in 'entry.S'.
12  */
13 #include <linux/sched.h>
14 #include <linux/kernel.h>
15 #include <linux/string.h>
16 #include <linux/errno.h>
17 #include <linux/ptrace.h>
18 #include <linux/timer.h>
19 #include <linux/mm.h>
20 #include <linux/init.h>
21 #include <linux/delay.h>
22 #include <linux/spinlock.h>
23 #include <linux/interrupt.h>
24 #include <linux/kallsyms.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/nmi.h>
28 #include <linux/kprobes.h>
29 #include <linux/kexec.h>
30 #include <linux/unwind.h>
31 #include <linux/uaccess.h>
32 #include <linux/bug.h>
33 #include <linux/kdebug.h>
34
35 #if defined(CONFIG_EDAC)
36 #include <linux/edac.h>
37 #endif
38
39 #include <asm/system.h>
40 #include <asm/io.h>
41 #include <asm/atomic.h>
42 #include <asm/debugreg.h>
43 #include <asm/desc.h>
44 #include <asm/i387.h>
45 #include <asm/processor.h>
46 #include <asm/unwind.h>
47 #include <asm/smp.h>
48 #include <asm/pgalloc.h>
49 #include <asm/pda.h>
50 #include <asm/proto.h>
51 #include <asm/nmi.h>
52 #include <asm/stacktrace.h>
53
54 asmlinkage void divide_error(void);
55 asmlinkage void debug(void);
56 asmlinkage void nmi(void);
57 asmlinkage void int3(void);
58 asmlinkage void overflow(void);
59 asmlinkage void bounds(void);
60 asmlinkage void invalid_op(void);
61 asmlinkage void device_not_available(void);
62 asmlinkage void double_fault(void);
63 asmlinkage void coprocessor_segment_overrun(void);
64 asmlinkage void invalid_TSS(void);
65 asmlinkage void segment_not_present(void);
66 asmlinkage void stack_segment(void);
67 asmlinkage void general_protection(void);
68 asmlinkage void page_fault(void);
69 asmlinkage void coprocessor_error(void);
70 asmlinkage void simd_coprocessor_error(void);
71 asmlinkage void reserved(void);
72 asmlinkage void alignment_check(void);
73 asmlinkage void machine_check(void);
74 asmlinkage void spurious_interrupt_bug(void);
75
76 static inline void conditional_sti(struct pt_regs *regs)
77 {
78         if (regs->eflags & X86_EFLAGS_IF)
79                 local_irq_enable();
80 }
81
82 static inline void preempt_conditional_sti(struct pt_regs *regs)
83 {
84         preempt_disable();
85         if (regs->eflags & X86_EFLAGS_IF)
86                 local_irq_enable();
87 }
88
89 static inline void preempt_conditional_cli(struct pt_regs *regs)
90 {
91         if (regs->eflags & X86_EFLAGS_IF)
92                 local_irq_disable();
93         /* Make sure to not schedule here because we could be running
94            on an exception stack. */
95         preempt_enable_no_resched();
96 }
97
98 int kstack_depth_to_print = 12;
99
100 #ifdef CONFIG_KALLSYMS
101 void printk_address(unsigned long address)
102 {
103         unsigned long offset = 0, symsize;
104         const char *symname;
105         char *modname;
106         char *delim = ":";
107         char namebuf[128];
108
109         symname = kallsyms_lookup(address, &symsize, &offset,
110                                         &modname, namebuf);
111         if (!symname) {
112                 printk(" [<%016lx>]\n", address);
113                 return;
114         }
115         if (!modname)
116                 modname = delim = "";           
117         printk(" [<%016lx>] %s%s%s%s+0x%lx/0x%lx\n",
118                 address, delim, modname, delim, symname, offset, symsize);
119 }
120 #else
121 void printk_address(unsigned long address)
122 {
123         printk(" [<%016lx>]\n", address);
124 }
125 #endif
126
127 static unsigned long *in_exception_stack(unsigned cpu, unsigned long stack,
128                                         unsigned *usedp, char **idp)
129 {
130         static char ids[][8] = {
131                 [DEBUG_STACK - 1] = "#DB",
132                 [NMI_STACK - 1] = "NMI",
133                 [DOUBLEFAULT_STACK - 1] = "#DF",
134                 [STACKFAULT_STACK - 1] = "#SS",
135                 [MCE_STACK - 1] = "#MC",
136 #if DEBUG_STKSZ > EXCEPTION_STKSZ
137                 [N_EXCEPTION_STACKS ... N_EXCEPTION_STACKS + DEBUG_STKSZ / EXCEPTION_STKSZ - 2] = "#DB[?]"
138 #endif
139         };
140         unsigned k;
141
142         /*
143          * Iterate over all exception stacks, and figure out whether
144          * 'stack' is in one of them:
145          */
146         for (k = 0; k < N_EXCEPTION_STACKS; k++) {
147                 unsigned long end = per_cpu(orig_ist, cpu).ist[k];
148                 /*
149                  * Is 'stack' above this exception frame's end?
150                  * If yes then skip to the next frame.
151                  */
152                 if (stack >= end)
153                         continue;
154                 /*
155                  * Is 'stack' above this exception frame's start address?
156                  * If yes then we found the right frame.
157                  */
158                 if (stack >= end - EXCEPTION_STKSZ) {
159                         /*
160                          * Make sure we only iterate through an exception
161                          * stack once. If it comes up for the second time
162                          * then there's something wrong going on - just
163                          * break out and return NULL:
164                          */
165                         if (*usedp & (1U << k))
166                                 break;
167                         *usedp |= 1U << k;
168                         *idp = ids[k];
169                         return (unsigned long *)end;
170                 }
171                 /*
172                  * If this is a debug stack, and if it has a larger size than
173                  * the usual exception stacks, then 'stack' might still
174                  * be within the lower portion of the debug stack:
175                  */
176 #if DEBUG_STKSZ > EXCEPTION_STKSZ
177                 if (k == DEBUG_STACK - 1 && stack >= end - DEBUG_STKSZ) {
178                         unsigned j = N_EXCEPTION_STACKS - 1;
179
180                         /*
181                          * Black magic. A large debug stack is composed of
182                          * multiple exception stack entries, which we
183                          * iterate through now. Dont look:
184                          */
185                         do {
186                                 ++j;
187                                 end -= EXCEPTION_STKSZ;
188                                 ids[j][4] = '1' + (j - N_EXCEPTION_STACKS);
189                         } while (stack < end - EXCEPTION_STKSZ);
190                         if (*usedp & (1U << j))
191                                 break;
192                         *usedp |= 1U << j;
193                         *idp = ids[j];
194                         return (unsigned long *)end;
195                 }
196 #endif
197         }
198         return NULL;
199 }
200
201 #define MSG(txt) ops->warning(data, txt)
202
203 /*
204  * x86-64 can have upto three kernel stacks: 
205  * process stack
206  * interrupt stack
207  * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack
208  */
209
210 static inline int valid_stack_ptr(struct thread_info *tinfo, void *p)
211 {
212         void *t = (void *)tinfo;
213         return p > t && p < t + THREAD_SIZE - 3;
214 }
215
216 void dump_trace(struct task_struct *tsk, struct pt_regs *regs,
217                 unsigned long *stack,
218                 const struct stacktrace_ops *ops, void *data)
219 {
220         const unsigned cpu = get_cpu();
221         unsigned long *irqstack_end = (unsigned long*)cpu_pda(cpu)->irqstackptr;
222         unsigned used = 0;
223         struct thread_info *tinfo;
224
225         if (!tsk)
226                 tsk = current;
227
228         if (!stack) {
229                 unsigned long dummy;
230                 stack = &dummy;
231                 if (tsk && tsk != current)
232                         stack = (unsigned long *)tsk->thread.rsp;
233         }
234
235         /*
236          * Print function call entries within a stack. 'cond' is the
237          * "end of stackframe" condition, that the 'stack++'
238          * iteration will eventually trigger.
239          */
240 #define HANDLE_STACK(cond) \
241         do while (cond) { \
242                 unsigned long addr = *stack++; \
243                 /* Use unlocked access here because except for NMIs     \
244                    we should be already protected against module unloads */ \
245                 if (__kernel_text_address(addr)) { \
246                         /* \
247                          * If the address is either in the text segment of the \
248                          * kernel, or in the region which contains vmalloc'ed \
249                          * memory, it *may* be the address of a calling \
250                          * routine; if so, print it so that someone tracing \
251                          * down the cause of the crash will be able to figure \
252                          * out the call path that was taken. \
253                          */ \
254                         ops->address(data, addr);   \
255                 } \
256         } while (0)
257
258         /*
259          * Print function call entries in all stacks, starting at the
260          * current stack address. If the stacks consist of nested
261          * exceptions
262          */
263         for (;;) {
264                 char *id;
265                 unsigned long *estack_end;
266                 estack_end = in_exception_stack(cpu, (unsigned long)stack,
267                                                 &used, &id);
268
269                 if (estack_end) {
270                         if (ops->stack(data, id) < 0)
271                                 break;
272                         HANDLE_STACK (stack < estack_end);
273                         ops->stack(data, "<EOE>");
274                         /*
275                          * We link to the next stack via the
276                          * second-to-last pointer (index -2 to end) in the
277                          * exception stack:
278                          */
279                         stack = (unsigned long *) estack_end[-2];
280                         continue;
281                 }
282                 if (irqstack_end) {
283                         unsigned long *irqstack;
284                         irqstack = irqstack_end -
285                                 (IRQSTACKSIZE - 64) / sizeof(*irqstack);
286
287                         if (stack >= irqstack && stack < irqstack_end) {
288                                 if (ops->stack(data, "IRQ") < 0)
289                                         break;
290                                 HANDLE_STACK (stack < irqstack_end);
291                                 /*
292                                  * We link to the next stack (which would be
293                                  * the process stack normally) the last
294                                  * pointer (index -1 to end) in the IRQ stack:
295                                  */
296                                 stack = (unsigned long *) (irqstack_end[-1]);
297                                 irqstack_end = NULL;
298                                 ops->stack(data, "EOI");
299                                 continue;
300                         }
301                 }
302                 break;
303         }
304
305         /*
306          * This handles the process stack:
307          */
308         tinfo = task_thread_info(tsk);
309         HANDLE_STACK (valid_stack_ptr(tinfo, stack));
310 #undef HANDLE_STACK
311         put_cpu();
312 }
313 EXPORT_SYMBOL(dump_trace);
314
315 static void
316 print_trace_warning_symbol(void *data, char *msg, unsigned long symbol)
317 {
318         print_symbol(msg, symbol);
319         printk("\n");
320 }
321
322 static void print_trace_warning(void *data, char *msg)
323 {
324         printk("%s\n", msg);
325 }
326
327 static int print_trace_stack(void *data, char *name)
328 {
329         printk(" <%s> ", name);
330         return 0;
331 }
332
333 static void print_trace_address(void *data, unsigned long addr)
334 {
335         touch_nmi_watchdog();
336         printk_address(addr);
337 }
338
339 static const struct stacktrace_ops print_trace_ops = {
340         .warning = print_trace_warning,
341         .warning_symbol = print_trace_warning_symbol,
342         .stack = print_trace_stack,
343         .address = print_trace_address,
344 };
345
346 void
347 show_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long *stack)
348 {
349         printk("\nCall Trace:\n");
350         dump_trace(tsk, regs, stack, &print_trace_ops, NULL);
351         printk("\n");
352 }
353
354 static void
355 _show_stack(struct task_struct *tsk, struct pt_regs *regs, unsigned long *rsp)
356 {
357         unsigned long *stack;
358         int i;
359         const int cpu = smp_processor_id();
360         unsigned long *irqstack_end = (unsigned long *) (cpu_pda(cpu)->irqstackptr);
361         unsigned long *irqstack = (unsigned long *) (cpu_pda(cpu)->irqstackptr - IRQSTACKSIZE);
362
363         // debugging aid: "show_stack(NULL, NULL);" prints the
364         // back trace for this cpu.
365
366         if (rsp == NULL) {
367                 if (tsk)
368                         rsp = (unsigned long *)tsk->thread.rsp;
369                 else
370                         rsp = (unsigned long *)&rsp;
371         }
372
373         stack = rsp;
374         for(i=0; i < kstack_depth_to_print; i++) {
375                 if (stack >= irqstack && stack <= irqstack_end) {
376                         if (stack == irqstack_end) {
377                                 stack = (unsigned long *) (irqstack_end[-1]);
378                                 printk(" <EOI> ");
379                         }
380                 } else {
381                 if (((long) stack & (THREAD_SIZE-1)) == 0)
382                         break;
383                 }
384                 if (i && ((i % 4) == 0))
385                         printk("\n");
386                 printk(" %016lx", *stack++);
387                 touch_nmi_watchdog();
388         }
389         show_trace(tsk, regs, rsp);
390 }
391
392 void show_stack(struct task_struct *tsk, unsigned long * rsp)
393 {
394         _show_stack(tsk, NULL, rsp);
395 }
396
397 /*
398  * The architecture-independent dump_stack generator
399  */
400 void dump_stack(void)
401 {
402         unsigned long dummy;
403         show_trace(NULL, NULL, &dummy);
404 }
405
406 EXPORT_SYMBOL(dump_stack);
407
408 void show_registers(struct pt_regs *regs)
409 {
410         int i;
411         int in_kernel = !user_mode(regs);
412         unsigned long rsp;
413         const int cpu = smp_processor_id();
414         struct task_struct *cur = cpu_pda(cpu)->pcurrent;
415
416         rsp = regs->rsp;
417         printk("CPU %d ", cpu);
418         __show_regs(regs);
419         printk("Process %s (pid: %d, threadinfo %p, task %p)\n",
420                 cur->comm, cur->pid, task_thread_info(cur), cur);
421
422         /*
423          * When in-kernel, we also print out the stack and code at the
424          * time of the fault..
425          */
426         if (in_kernel) {
427                 printk("Stack: ");
428                 _show_stack(NULL, regs, (unsigned long*)rsp);
429
430                 printk("\nCode: ");
431                 if (regs->rip < PAGE_OFFSET)
432                         goto bad;
433
434                 for (i=0; i<20; i++) {
435                         unsigned char c;
436                         if (__get_user(c, &((unsigned char*)regs->rip)[i])) {
437 bad:
438                                 printk(" Bad RIP value.");
439                                 break;
440                         }
441                         printk("%02x ", c);
442                 }
443         }
444         printk("\n");
445 }       
446
447 int is_valid_bugaddr(unsigned long rip)
448 {
449         unsigned short ud2;
450
451         if (__copy_from_user(&ud2, (const void __user *) rip, sizeof(ud2)))
452                 return 0;
453
454         return ud2 == 0x0b0f;
455 }
456
457 #ifdef CONFIG_BUG
458 void out_of_line_bug(void)
459
460         BUG(); 
461
462 EXPORT_SYMBOL(out_of_line_bug);
463 #endif
464
465 static DEFINE_SPINLOCK(die_lock);
466 static int die_owner = -1;
467 static unsigned int die_nest_count;
468
469 unsigned __kprobes long oops_begin(void)
470 {
471         int cpu;
472         unsigned long flags;
473
474         oops_enter();
475
476         /* racy, but better than risking deadlock. */
477         local_irq_save(flags);
478         cpu = smp_processor_id();
479         if (!spin_trylock(&die_lock)) { 
480                 if (cpu == die_owner) 
481                         /* nested oops. should stop eventually */;
482                 else
483                         spin_lock(&die_lock);
484         }
485         die_nest_count++;
486         die_owner = cpu;
487         console_verbose();
488         bust_spinlocks(1);
489         return flags;
490 }
491
492 void __kprobes oops_end(unsigned long flags)
493
494         die_owner = -1;
495         bust_spinlocks(0);
496         die_nest_count--;
497         if (die_nest_count)
498                 /* We still own the lock */
499                 local_irq_restore(flags);
500         else
501                 /* Nest count reaches zero, release the lock. */
502                 spin_unlock_irqrestore(&die_lock, flags);
503         if (panic_on_oops)
504                 panic("Fatal exception");
505         oops_exit();
506 }
507
508 void __kprobes __die(const char * str, struct pt_regs * regs, long err)
509 {
510         static int die_counter;
511         printk(KERN_EMERG "%s: %04lx [%u] ", str, err & 0xffff,++die_counter);
512 #ifdef CONFIG_PREEMPT
513         printk("PREEMPT ");
514 #endif
515 #ifdef CONFIG_SMP
516         printk("SMP ");
517 #endif
518 #ifdef CONFIG_DEBUG_PAGEALLOC
519         printk("DEBUG_PAGEALLOC");
520 #endif
521         printk("\n");
522         notify_die(DIE_OOPS, str, regs, err, current->thread.trap_no, SIGSEGV);
523         show_registers(regs);
524         add_taint(TAINT_DIE);
525         /* Executive summary in case the oops scrolled away */
526         printk(KERN_ALERT "RIP ");
527         printk_address(regs->rip); 
528         printk(" RSP <%016lx>\n", regs->rsp); 
529         if (kexec_should_crash(current))
530                 crash_kexec(regs);
531 }
532
533 void die(const char * str, struct pt_regs * regs, long err)
534 {
535         unsigned long flags = oops_begin();
536
537         if (!user_mode(regs))
538                 report_bug(regs->rip, regs);
539
540         __die(str, regs, err);
541         oops_end(flags);
542         do_exit(SIGSEGV); 
543 }
544
545 void __kprobes die_nmi(char *str, struct pt_regs *regs, int do_panic)
546 {
547         unsigned long flags = oops_begin();
548
549         /*
550          * We are in trouble anyway, lets at least try
551          * to get a message out.
552          */
553         printk(str, smp_processor_id());
554         show_registers(regs);
555         if (kexec_should_crash(current))
556                 crash_kexec(regs);
557         if (do_panic || panic_on_oops)
558                 panic("Non maskable interrupt");
559         oops_end(flags);
560         nmi_exit();
561         local_irq_enable();
562         do_exit(SIGSEGV);
563 }
564
565 static void __kprobes do_trap(int trapnr, int signr, char *str,
566                               struct pt_regs * regs, long error_code,
567                               siginfo_t *info)
568 {
569         struct task_struct *tsk = current;
570
571         if (user_mode(regs)) {
572                 /*
573                  * We want error_code and trap_no set for userspace
574                  * faults and kernelspace faults which result in
575                  * die(), but not kernelspace faults which are fixed
576                  * up.  die() gives the process no chance to handle
577                  * the signal and notice the kernel fault information,
578                  * so that won't result in polluting the information
579                  * about previously queued, but not yet delivered,
580                  * faults.  See also do_general_protection below.
581                  */
582                 tsk->thread.error_code = error_code;
583                 tsk->thread.trap_no = trapnr;
584
585                 if (show_unhandled_signals && unhandled_signal(tsk, signr) &&
586                     printk_ratelimit())
587                         printk(KERN_INFO
588                                "%s[%d] trap %s rip:%lx rsp:%lx error:%lx\n",
589                                tsk->comm, tsk->pid, str,
590                                regs->rip, regs->rsp, error_code); 
591
592                 if (info)
593                         force_sig_info(signr, info, tsk);
594                 else
595                         force_sig(signr, tsk);
596                 return;
597         }
598
599
600         /* kernel trap */ 
601         {            
602                 const struct exception_table_entry *fixup;
603                 fixup = search_exception_tables(regs->rip);
604                 if (fixup)
605                         regs->rip = fixup->fixup;
606                 else {
607                         tsk->thread.error_code = error_code;
608                         tsk->thread.trap_no = trapnr;
609                         die(str, regs, error_code);
610                 }
611                 return;
612         }
613 }
614
615 #define DO_ERROR(trapnr, signr, str, name) \
616 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
617 { \
618         if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
619                                                         == NOTIFY_STOP) \
620                 return; \
621         conditional_sti(regs);                                          \
622         do_trap(trapnr, signr, str, regs, error_code, NULL); \
623 }
624
625 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \
626 asmlinkage void do_##name(struct pt_regs * regs, long error_code) \
627 { \
628         siginfo_t info; \
629         info.si_signo = signr; \
630         info.si_errno = 0; \
631         info.si_code = sicode; \
632         info.si_addr = (void __user *)siaddr; \
633         if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \
634                                                         == NOTIFY_STOP) \
635                 return; \
636         conditional_sti(regs);                                          \
637         do_trap(trapnr, signr, str, regs, error_code, &info); \
638 }
639
640 DO_ERROR_INFO( 0, SIGFPE,  "divide error", divide_error, FPE_INTDIV, regs->rip)
641 DO_ERROR( 4, SIGSEGV, "overflow", overflow)
642 DO_ERROR( 5, SIGSEGV, "bounds", bounds)
643 DO_ERROR_INFO( 6, SIGILL,  "invalid opcode", invalid_op, ILL_ILLOPN, regs->rip)
644 DO_ERROR( 7, SIGSEGV, "device not available", device_not_available)
645 DO_ERROR( 9, SIGFPE,  "coprocessor segment overrun", coprocessor_segment_overrun)
646 DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS)
647 DO_ERROR(11, SIGBUS,  "segment not present", segment_not_present)
648 DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0)
649 DO_ERROR(18, SIGSEGV, "reserved", reserved)
650
651 /* Runs on IST stack */
652 asmlinkage void do_stack_segment(struct pt_regs *regs, long error_code)
653 {
654         if (notify_die(DIE_TRAP, "stack segment", regs, error_code,
655                         12, SIGBUS) == NOTIFY_STOP)
656                 return;
657         preempt_conditional_sti(regs);
658         do_trap(12, SIGBUS, "stack segment", regs, error_code, NULL);
659         preempt_conditional_cli(regs);
660 }
661
662 asmlinkage void do_double_fault(struct pt_regs * regs, long error_code)
663 {
664         static const char str[] = "double fault";
665         struct task_struct *tsk = current;
666
667         /* Return not checked because double check cannot be ignored */
668         notify_die(DIE_TRAP, str, regs, error_code, 8, SIGSEGV);
669
670         tsk->thread.error_code = error_code;
671         tsk->thread.trap_no = 8;
672
673         /* This is always a kernel trap and never fixable (and thus must
674            never return). */
675         for (;;)
676                 die(str, regs, error_code);
677 }
678
679 asmlinkage void __kprobes do_general_protection(struct pt_regs * regs,
680                                                 long error_code)
681 {
682         struct task_struct *tsk = current;
683
684         conditional_sti(regs);
685
686         if (user_mode(regs)) {
687                 tsk->thread.error_code = error_code;
688                 tsk->thread.trap_no = 13;
689
690                 if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) &&
691                     printk_ratelimit())
692                         printk(KERN_INFO
693                        "%s[%d] general protection rip:%lx rsp:%lx error:%lx\n",
694                                tsk->comm, tsk->pid,
695                                regs->rip, regs->rsp, error_code); 
696
697                 force_sig(SIGSEGV, tsk);
698                 return;
699         } 
700
701         /* kernel gp */
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;
708                 }
709
710                 tsk->thread.error_code = error_code;
711                 tsk->thread.trap_no = 13;
712                 if (notify_die(DIE_GPF, "general protection fault", regs,
713                                         error_code, 13, SIGSEGV) == NOTIFY_STOP)
714                         return;
715                 die("general protection fault", regs, error_code);
716         }
717 }
718
719 static __kprobes void
720 mem_parity_error(unsigned char reason, struct pt_regs * regs)
721 {
722         printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
723                 reason);
724         printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n");
725
726 #if defined(CONFIG_EDAC)
727         if(edac_handler_set()) {
728                 edac_atomic_assert_error();
729                 return;
730         }
731 #endif
732
733         if (panic_on_unrecovered_nmi)
734                 panic("NMI: Not continuing");
735
736         printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
737
738         /* Clear and disable the memory parity error line. */
739         reason = (reason & 0xf) | 4;
740         outb(reason, 0x61);
741 }
742
743 static __kprobes void
744 io_check_error(unsigned char reason, struct pt_regs * regs)
745 {
746         printk("NMI: IOCK error (debug interrupt?)\n");
747         show_registers(regs);
748
749         /* Re-enable the IOCK line, wait for a few seconds */
750         reason = (reason & 0xf) | 8;
751         outb(reason, 0x61);
752         mdelay(2000);
753         reason &= ~8;
754         outb(reason, 0x61);
755 }
756
757 static __kprobes void
758 unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
759 {
760         printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x.\n",
761                 reason);
762         printk(KERN_EMERG "Do you have a strange power saving mode enabled?\n");
763
764         if (panic_on_unrecovered_nmi)
765                 panic("NMI: Not continuing");
766
767         printk(KERN_EMERG "Dazed and confused, but trying to continue\n");
768 }
769
770 /* Runs on IST stack. This code must keep interrupts off all the time.
771    Nested NMIs are prevented by the CPU. */
772 asmlinkage __kprobes void default_do_nmi(struct pt_regs *regs)
773 {
774         unsigned char reason = 0;
775         int cpu;
776
777         cpu = smp_processor_id();
778
779         /* Only the BSP gets external NMIs from the system.  */
780         if (!cpu)
781                 reason = get_nmi_reason();
782
783         if (!(reason & 0xc0)) {
784                 if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 2, SIGINT)
785                                                                 == NOTIFY_STOP)
786                         return;
787                 /*
788                  * Ok, so this is none of the documented NMI sources,
789                  * so it must be the NMI watchdog.
790                  */
791                 if (nmi_watchdog_tick(regs,reason))
792                         return;
793                 if (!do_nmi_callback(regs,cpu))
794                         unknown_nmi_error(reason, regs);
795
796                 return;
797         }
798         if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP)
799                 return; 
800
801         /* AK: following checks seem to be broken on modern chipsets. FIXME */
802
803         if (reason & 0x80)
804                 mem_parity_error(reason, regs);
805         if (reason & 0x40)
806                 io_check_error(reason, regs);
807 }
808
809 /* runs on IST stack. */
810 asmlinkage void __kprobes do_int3(struct pt_regs * regs, long error_code)
811 {
812         if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) == NOTIFY_STOP) {
813                 return;
814         }
815         preempt_conditional_sti(regs);
816         do_trap(3, SIGTRAP, "int3", regs, error_code, NULL);
817         preempt_conditional_cli(regs);
818 }
819
820 /* Help handler running on IST stack to switch back to user stack
821    for scheduling or signal handling. The actual stack switch is done in
822    entry.S */
823 asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs)
824 {
825         struct pt_regs *regs = eregs;
826         /* Did already sync */
827         if (eregs == (struct pt_regs *)eregs->rsp)
828                 ;
829         /* Exception from user space */
830         else if (user_mode(eregs))
831                 regs = task_pt_regs(current);
832         /* Exception from kernel and interrupts are enabled. Move to
833            kernel process stack. */
834         else if (eregs->eflags & X86_EFLAGS_IF)
835                 regs = (struct pt_regs *)(eregs->rsp -= sizeof(struct pt_regs));
836         if (eregs != regs)
837                 *regs = *eregs;
838         return regs;
839 }
840
841 /* runs on IST stack. */
842 asmlinkage void __kprobes do_debug(struct pt_regs * regs,
843                                    unsigned long error_code)
844 {
845         unsigned long condition;
846         struct task_struct *tsk = current;
847         siginfo_t info;
848
849         get_debugreg(condition, 6);
850
851         if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
852                                                 SIGTRAP) == NOTIFY_STOP)
853                 return;
854
855         preempt_conditional_sti(regs);
856
857         /* Mask out spurious debug traps due to lazy DR7 setting */
858         if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
859                 if (!tsk->thread.debugreg7) { 
860                         goto clear_dr7;
861                 }
862         }
863
864         tsk->thread.debugreg6 = condition;
865
866         /* Mask out spurious TF errors due to lazy TF clearing */
867         if (condition & DR_STEP) {
868                 /*
869                  * The TF error should be masked out only if the current
870                  * process is not traced and if the TRAP flag has been set
871                  * previously by a tracing process (condition detected by
872                  * the PT_DTRACE flag); remember that the i386 TRAP flag
873                  * can be modified by the process itself in user mode,
874                  * allowing programs to debug themselves without the ptrace()
875                  * interface.
876                  */
877                 if (!user_mode(regs))
878                        goto clear_TF_reenable;
879                 /*
880                  * Was the TF flag set by a debugger? If so, clear it now,
881                  * so that register information is correct.
882                  */
883                 if (tsk->ptrace & PT_DTRACE) {
884                         regs->eflags &= ~TF_MASK;
885                         tsk->ptrace &= ~PT_DTRACE;
886                 }
887         }
888
889         /* Ok, finally something we can handle */
890         tsk->thread.trap_no = 1;
891         tsk->thread.error_code = error_code;
892         info.si_signo = SIGTRAP;
893         info.si_errno = 0;
894         info.si_code = TRAP_BRKPT;
895         info.si_addr = user_mode(regs) ? (void __user *)regs->rip : NULL;
896         force_sig_info(SIGTRAP, &info, tsk);
897
898 clear_dr7:
899         set_debugreg(0UL, 7);
900         preempt_conditional_cli(regs);
901         return;
902
903 clear_TF_reenable:
904         set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
905         regs->eflags &= ~TF_MASK;
906         preempt_conditional_cli(regs);
907 }
908
909 static int kernel_math_error(struct pt_regs *regs, const char *str, int trapnr)
910 {
911         const struct exception_table_entry *fixup;
912         fixup = search_exception_tables(regs->rip);
913         if (fixup) {
914                 regs->rip = fixup->fixup;
915                 return 1;
916         }
917         notify_die(DIE_GPF, str, regs, 0, trapnr, SIGFPE);
918         /* Illegal floating point operation in the kernel */
919         current->thread.trap_no = trapnr;
920         die(str, regs, 0);
921         return 0;
922 }
923
924 /*
925  * Note that we play around with the 'TS' bit in an attempt to get
926  * the correct behaviour even in the presence of the asynchronous
927  * IRQ13 behaviour
928  */
929 asmlinkage void do_coprocessor_error(struct pt_regs *regs)
930 {
931         void __user *rip = (void __user *)(regs->rip);
932         struct task_struct * task;
933         siginfo_t info;
934         unsigned short cwd, swd;
935
936         conditional_sti(regs);
937         if (!user_mode(regs) &&
938             kernel_math_error(regs, "kernel x87 math error", 16))
939                 return;
940
941         /*
942          * Save the info for the exception handler and clear the error.
943          */
944         task = current;
945         save_init_fpu(task);
946         task->thread.trap_no = 16;
947         task->thread.error_code = 0;
948         info.si_signo = SIGFPE;
949         info.si_errno = 0;
950         info.si_code = __SI_FAULT;
951         info.si_addr = rip;
952         /*
953          * (~cwd & swd) will mask out exceptions that are not set to unmasked
954          * status.  0x3f is the exception bits in these regs, 0x200 is the
955          * C1 reg you need in case of a stack fault, 0x040 is the stack
956          * fault bit.  We should only be taking one exception at a time,
957          * so if this combination doesn't produce any single exception,
958          * then we have a bad program that isn't synchronizing its FPU usage
959          * and it will suffer the consequences since we won't be able to
960          * fully reproduce the context of the exception
961          */
962         cwd = get_fpu_cwd(task);
963         swd = get_fpu_swd(task);
964         switch (swd & ~cwd & 0x3f) {
965                 case 0x000:
966                 default:
967                         break;
968                 case 0x001: /* Invalid Op */
969                         /*
970                          * swd & 0x240 == 0x040: Stack Underflow
971                          * swd & 0x240 == 0x240: Stack Overflow
972                          * User must clear the SF bit (0x40) if set
973                          */
974                         info.si_code = FPE_FLTINV;
975                         break;
976                 case 0x002: /* Denormalize */
977                 case 0x010: /* Underflow */
978                         info.si_code = FPE_FLTUND;
979                         break;
980                 case 0x004: /* Zero Divide */
981                         info.si_code = FPE_FLTDIV;
982                         break;
983                 case 0x008: /* Overflow */
984                         info.si_code = FPE_FLTOVF;
985                         break;
986                 case 0x020: /* Precision */
987                         info.si_code = FPE_FLTRES;
988                         break;
989         }
990         force_sig_info(SIGFPE, &info, task);
991 }
992
993 asmlinkage void bad_intr(void)
994 {
995         printk("bad interrupt"); 
996 }
997
998 asmlinkage void do_simd_coprocessor_error(struct pt_regs *regs)
999 {
1000         void __user *rip = (void __user *)(regs->rip);
1001         struct task_struct * task;
1002         siginfo_t info;
1003         unsigned short mxcsr;
1004
1005         conditional_sti(regs);
1006         if (!user_mode(regs) &&
1007                 kernel_math_error(regs, "kernel simd math error", 19))
1008                 return;
1009
1010         /*
1011          * Save the info for the exception handler and clear the error.
1012          */
1013         task = current;
1014         save_init_fpu(task);
1015         task->thread.trap_no = 19;
1016         task->thread.error_code = 0;
1017         info.si_signo = SIGFPE;
1018         info.si_errno = 0;
1019         info.si_code = __SI_FAULT;
1020         info.si_addr = rip;
1021         /*
1022          * The SIMD FPU exceptions are handled a little differently, as there
1023          * is only a single status/control register.  Thus, to determine which
1024          * unmasked exception was caught we must mask the exception mask bits
1025          * at 0x1f80, and then use these to mask the exception bits at 0x3f.
1026          */
1027         mxcsr = get_fpu_mxcsr(task);
1028         switch (~((mxcsr & 0x1f80) >> 7) & (mxcsr & 0x3f)) {
1029                 case 0x000:
1030                 default:
1031                         break;
1032                 case 0x001: /* Invalid Op */
1033                         info.si_code = FPE_FLTINV;
1034                         break;
1035                 case 0x002: /* Denormalize */
1036                 case 0x010: /* Underflow */
1037                         info.si_code = FPE_FLTUND;
1038                         break;
1039                 case 0x004: /* Zero Divide */
1040                         info.si_code = FPE_FLTDIV;
1041                         break;
1042                 case 0x008: /* Overflow */
1043                         info.si_code = FPE_FLTOVF;
1044                         break;
1045                 case 0x020: /* Precision */
1046                         info.si_code = FPE_FLTRES;
1047                         break;
1048         }
1049         force_sig_info(SIGFPE, &info, task);
1050 }
1051
1052 asmlinkage void do_spurious_interrupt_bug(struct pt_regs * regs)
1053 {
1054 }
1055
1056 asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void)
1057 {
1058 }
1059
1060 asmlinkage void __attribute__((weak)) mce_threshold_interrupt(void)
1061 {
1062 }
1063
1064 /*
1065  *  'math_state_restore()' saves the current math information in the
1066  * old math state array, and gets the new ones from the current task
1067  *
1068  * Careful.. There are problems with IBM-designed IRQ13 behaviour.
1069  * Don't touch unless you *really* know how it works.
1070  */
1071 asmlinkage void math_state_restore(void)
1072 {
1073         struct task_struct *me = current;
1074         clts();                 /* Allow maths ops (or we recurse) */
1075
1076         if (!used_math())
1077                 init_fpu(me);
1078         restore_fpu_checking(&me->thread.i387.fxsave);
1079         task_thread_info(me)->status |= TS_USEDFPU;
1080         me->fpu_counter++;
1081 }
1082
1083 void __init trap_init(void)
1084 {
1085         set_intr_gate(0,&divide_error);
1086         set_intr_gate_ist(1,&debug,DEBUG_STACK);
1087         set_intr_gate_ist(2,&nmi,NMI_STACK);
1088         set_system_gate_ist(3,&int3,DEBUG_STACK); /* int3 can be called from all */
1089         set_system_gate(4,&overflow);   /* int4 can be called from all */
1090         set_intr_gate(5,&bounds);
1091         set_intr_gate(6,&invalid_op);
1092         set_intr_gate(7,&device_not_available);
1093         set_intr_gate_ist(8,&double_fault, DOUBLEFAULT_STACK);
1094         set_intr_gate(9,&coprocessor_segment_overrun);
1095         set_intr_gate(10,&invalid_TSS);
1096         set_intr_gate(11,&segment_not_present);
1097         set_intr_gate_ist(12,&stack_segment,STACKFAULT_STACK);
1098         set_intr_gate(13,&general_protection);
1099         set_intr_gate(14,&page_fault);
1100         set_intr_gate(15,&spurious_interrupt_bug);
1101         set_intr_gate(16,&coprocessor_error);
1102         set_intr_gate(17,&alignment_check);
1103 #ifdef CONFIG_X86_MCE
1104         set_intr_gate_ist(18,&machine_check, MCE_STACK); 
1105 #endif
1106         set_intr_gate(19,&simd_coprocessor_error);
1107
1108 #ifdef CONFIG_IA32_EMULATION
1109         set_system_gate(IA32_SYSCALL_VECTOR, ia32_syscall);
1110 #endif
1111        
1112         /*
1113          * Should be a barrier for any external CPU state.
1114          */
1115         cpu_init();
1116 }
1117
1118
1119 static int __init oops_setup(char *s)
1120
1121         if (!s)
1122                 return -EINVAL;
1123         if (!strcmp(s, "panic"))
1124                 panic_on_oops = 1;
1125         return 0;
1126
1127 early_param("oops", oops_setup);
1128
1129 static int __init kstack_setup(char *s)
1130 {
1131         if (!s)
1132                 return -EINVAL;
1133         kstack_depth_to_print = simple_strtoul(s,NULL,0);
1134         return 0;
1135 }
1136 early_param("kstack", kstack_setup);