Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/arch/i386/kernel/traps.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* 2 * linux/arch/i386/traps.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * 6 * Pentium III FXSR, SSE support 7 * Gareth Hughes <gareth@valinux.com>, May 2000 8 */ 9 10 /* 11 * 'Traps.c' handles hardware traps and faults after we have saved some 12 * state in 'asm.s'. 13 */ 14 #include <linux/sched.h> 15 #include <linux/kernel.h> 16 #include <linux/string.h> 17 #include <linux/errno.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/highmem.h> 25 #include <linux/kallsyms.h> 26 #include <linux/ptrace.h> 27 #include <linux/utsname.h> 28 #include <linux/kprobes.h> 29 #include <linux/kexec.h> 30 #include <linux/unwind.h> 31 #include <linux/uaccess.h> 32 #include <linux/nmi.h> 33 #include <linux/bug.h> 34 35 #ifdef CONFIG_EISA 36 #include <linux/ioport.h> 37 #include <linux/eisa.h> 38 #endif 39 40 #ifdef CONFIG_MCA 41 #include <linux/mca.h> 42 #endif 43 44 #include <asm/processor.h> 45 #include <asm/system.h> 46 #include <asm/io.h> 47 #include <asm/atomic.h> 48 #include <asm/debugreg.h> 49 #include <asm/desc.h> 50 #include <asm/i387.h> 51 #include <asm/nmi.h> 52 #include <asm/unwind.h> 53 #include <asm/smp.h> 54 #include <asm/arch_hooks.h> 55 #include <linux/kdebug.h> 56 #include <asm/stacktrace.h> 57 58 #include <linux/module.h> 59 60 #include "mach_traps.h" 61 62 int panic_on_unrecovered_nmi; 63 64 asmlinkage int system_call(void); 65 66 /* Do we ignore FPU interrupts ? */ 67 char ignore_fpu_irq = 0; 68 69 /* 70 * The IDT has to be page-aligned to simplify the Pentium 71 * F0 0F bug workaround.. We have a special link segment 72 * for this. 73 */ 74 struct desc_struct idt_table[256] __attribute__((__section__(".data.idt"))) = { {0, 0}, }; 75 76 asmlinkage void divide_error(void); 77 asmlinkage void debug(void); 78 asmlinkage void nmi(void); 79 asmlinkage void int3(void); 80 asmlinkage void overflow(void); 81 asmlinkage void bounds(void); 82 asmlinkage void invalid_op(void); 83 asmlinkage void device_not_available(void); 84 asmlinkage void coprocessor_segment_overrun(void); 85 asmlinkage void invalid_TSS(void); 86 asmlinkage void segment_not_present(void); 87 asmlinkage void stack_segment(void); 88 asmlinkage void general_protection(void); 89 asmlinkage void page_fault(void); 90 asmlinkage void coprocessor_error(void); 91 asmlinkage void simd_coprocessor_error(void); 92 asmlinkage void alignment_check(void); 93 asmlinkage void spurious_interrupt_bug(void); 94 asmlinkage void machine_check(void); 95 96 int kstack_depth_to_print = 24; 97 static unsigned int code_bytes = 64; 98 99 static inline int valid_stack_ptr(struct thread_info *tinfo, void *p) 100 { 101 return p > (void *)tinfo && 102 p < (void *)tinfo + THREAD_SIZE - 3; 103 } 104 105 static inline unsigned long print_context_stack(struct thread_info *tinfo, 106 unsigned long *stack, unsigned long ebp, 107 struct stacktrace_ops *ops, void *data) 108 { 109 unsigned long addr; 110 111 #ifdef CONFIG_FRAME_POINTER 112 while (valid_stack_ptr(tinfo, (void *)ebp)) { 113 unsigned long new_ebp; 114 addr = *(unsigned long *)(ebp + 4); 115 ops->address(data, addr); 116 /* 117 * break out of recursive entries (such as 118 * end_of_stack_stop_unwind_function). Also, 119 * we can never allow a frame pointer to 120 * move downwards! 121 */ 122 new_ebp = *(unsigned long *)ebp; 123 if (new_ebp <= ebp) 124 break; 125 ebp = new_ebp; 126 } 127 #else 128 while (valid_stack_ptr(tinfo, stack)) { 129 addr = *stack++; 130 if (__kernel_text_address(addr)) 131 ops->address(data, addr); 132 } 133 #endif 134 return ebp; 135 } 136 137 #define MSG(msg) ops->warning(data, msg) 138 139 void dump_trace(struct task_struct *task, struct pt_regs *regs, 140 unsigned long *stack, 141 struct stacktrace_ops *ops, void *data) 142 { 143 unsigned long ebp = 0; 144 145 if (!task) 146 task = current; 147 148 if (!stack) { 149 unsigned long dummy; 150 stack = &dummy; 151 if (task && task != current) 152 stack = (unsigned long *)task->thread.esp; 153 } 154 155 #ifdef CONFIG_FRAME_POINTER 156 if (!ebp) { 157 if (task == current) { 158 /* Grab ebp right from our regs */ 159 asm ("movl %%ebp, %0" : "=r" (ebp) : ); 160 } else { 161 /* ebp is the last reg pushed by switch_to */ 162 ebp = *(unsigned long *) task->thread.esp; 163 } 164 } 165 #endif 166 167 while (1) { 168 struct thread_info *context; 169 context = (struct thread_info *) 170 ((unsigned long)stack & (~(THREAD_SIZE - 1))); 171 ebp = print_context_stack(context, stack, ebp, ops, data); 172 /* Should be after the line below, but somewhere 173 in early boot context comes out corrupted and we 174 can't reference it -AK */ 175 if (ops->stack(data, "IRQ") < 0) 176 break; 177 stack = (unsigned long*)context->previous_esp; 178 if (!stack) 179 break; 180 touch_nmi_watchdog(); 181 } 182 } 183 EXPORT_SYMBOL(dump_trace); 184 185 static void 186 print_trace_warning_symbol(void *data, char *msg, unsigned long symbol) 187 { 188 printk(data); 189 print_symbol(msg, symbol); 190 printk("\n"); 191 } 192 193 static void print_trace_warning(void *data, char *msg) 194 { 195 printk("%s%s\n", (char *)data, msg); 196 } 197 198 static int print_trace_stack(void *data, char *name) 199 { 200 return 0; 201 } 202 203 /* 204 * Print one address/symbol entries per line. 205 */ 206 static void print_trace_address(void *data, unsigned long addr) 207 { 208 printk("%s [<%08lx>] ", (char *)data, addr); 209 print_symbol("%s\n", addr); 210 } 211 212 static struct stacktrace_ops print_trace_ops = { 213 .warning = print_trace_warning, 214 .warning_symbol = print_trace_warning_symbol, 215 .stack = print_trace_stack, 216 .address = print_trace_address, 217 }; 218 219 static void 220 show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs, 221 unsigned long * stack, char *log_lvl) 222 { 223 dump_trace(task, regs, stack, &print_trace_ops, log_lvl); 224 printk("%s =======================\n", log_lvl); 225 } 226 227 void show_trace(struct task_struct *task, struct pt_regs *regs, 228 unsigned long * stack) 229 { 230 show_trace_log_lvl(task, regs, stack, ""); 231 } 232 233 static void show_stack_log_lvl(struct task_struct *task, struct pt_regs *regs, 234 unsigned long *esp, char *log_lvl) 235 { 236 unsigned long *stack; 237 int i; 238 239 if (esp == NULL) { 240 if (task) 241 esp = (unsigned long*)task->thread.esp; 242 else 243 esp = (unsigned long *)&esp; 244 } 245 246 stack = esp; 247 for(i = 0; i < kstack_depth_to_print; i++) { 248 if (kstack_end(stack)) 249 break; 250 if (i && ((i % 8) == 0)) 251 printk("\n%s ", log_lvl); 252 printk("%08lx ", *stack++); 253 } 254 printk("\n%sCall Trace:\n", log_lvl); 255 show_trace_log_lvl(task, regs, esp, log_lvl); 256 } 257 258 void show_stack(struct task_struct *task, unsigned long *esp) 259 { 260 printk(" "); 261 show_stack_log_lvl(task, NULL, esp, ""); 262 } 263 264 /* 265 * The architecture-independent dump_stack generator 266 */ 267 void dump_stack(void) 268 { 269 unsigned long stack; 270 271 show_trace(current, NULL, &stack); 272 } 273 274 EXPORT_SYMBOL(dump_stack); 275 276 void show_registers(struct pt_regs *regs) 277 { 278 int i; 279 int in_kernel = 1; 280 unsigned long esp; 281 unsigned short ss, gs; 282 283 esp = (unsigned long) (®s->esp); 284 savesegment(ss, ss); 285 savesegment(gs, gs); 286 if (user_mode_vm(regs)) { 287 in_kernel = 0; 288 esp = regs->esp; 289 ss = regs->xss & 0xffff; 290 } 291 print_modules(); 292 printk(KERN_EMERG "CPU: %d\n" 293 KERN_EMERG "EIP: %04x:[<%08lx>] %s VLI\n" 294 KERN_EMERG "EFLAGS: %08lx (%s %.*s)\n", 295 smp_processor_id(), 0xffff & regs->xcs, regs->eip, 296 print_tainted(), regs->eflags, init_utsname()->release, 297 (int)strcspn(init_utsname()->version, " "), 298 init_utsname()->version); 299 print_symbol(KERN_EMERG "EIP is at %s\n", regs->eip); 300 printk(KERN_EMERG "eax: %08lx ebx: %08lx ecx: %08lx edx: %08lx\n", 301 regs->eax, regs->ebx, regs->ecx, regs->edx); 302 printk(KERN_EMERG "esi: %08lx edi: %08lx ebp: %08lx esp: %08lx\n", 303 regs->esi, regs->edi, regs->ebp, esp); 304 printk(KERN_EMERG "ds: %04x es: %04x fs: %04x gs: %04x ss: %04x\n", 305 regs->xds & 0xffff, regs->xes & 0xffff, regs->xfs & 0xffff, gs, ss); 306 printk(KERN_EMERG "Process %.*s (pid: %d, ti=%p task=%p task.ti=%p)", 307 TASK_COMM_LEN, current->comm, current->pid, 308 current_thread_info(), current, task_thread_info(current)); 309 /* 310 * When in-kernel, we also print out the stack and code at the 311 * time of the fault.. 312 */ 313 if (in_kernel) { 314 u8 *eip; 315 unsigned int code_prologue = code_bytes * 43 / 64; 316 unsigned int code_len = code_bytes; 317 unsigned char c; 318 319 printk("\n" KERN_EMERG "Stack: "); 320 show_stack_log_lvl(NULL, regs, (unsigned long *)esp, KERN_EMERG); 321 322 printk(KERN_EMERG "Code: "); 323 324 eip = (u8 *)regs->eip - code_prologue; 325 if (eip < (u8 *)PAGE_OFFSET || 326 probe_kernel_address(eip, c)) { 327 /* try starting at EIP */ 328 eip = (u8 *)regs->eip; 329 code_len = code_len - code_prologue + 1; 330 } 331 for (i = 0; i < code_len; i++, eip++) { 332 if (eip < (u8 *)PAGE_OFFSET || 333 probe_kernel_address(eip, c)) { 334 printk(" Bad EIP value."); 335 break; 336 } 337 if (eip == (u8 *)regs->eip) 338 printk("<%02x> ", c); 339 else 340 printk("%02x ", c); 341 } 342 } 343 printk("\n"); 344 } 345 346 int is_valid_bugaddr(unsigned long eip) 347 { 348 unsigned short ud2; 349 350 if (eip < PAGE_OFFSET) 351 return 0; 352 if (probe_kernel_address((unsigned short *)eip, ud2)) 353 return 0; 354 355 return ud2 == 0x0b0f; 356 } 357 358 /* 359 * This is gone through when something in the kernel has done something bad and 360 * is about to be terminated. 361 */ 362 void die(const char * str, struct pt_regs * regs, long err) 363 { 364 static struct { 365 spinlock_t lock; 366 u32 lock_owner; 367 int lock_owner_depth; 368 } die = { 369 .lock = __SPIN_LOCK_UNLOCKED(die.lock), 370 .lock_owner = -1, 371 .lock_owner_depth = 0 372 }; 373 static int die_counter; 374 unsigned long flags; 375 376 oops_enter(); 377 378 if (die.lock_owner != raw_smp_processor_id()) { 379 console_verbose(); 380 spin_lock_irqsave(&die.lock, flags); 381 die.lock_owner = smp_processor_id(); 382 die.lock_owner_depth = 0; 383 bust_spinlocks(1); 384 } 385 else 386 local_save_flags(flags); 387 388 if (++die.lock_owner_depth < 3) { 389 int nl = 0; 390 unsigned long esp; 391 unsigned short ss; 392 393 report_bug(regs->eip); 394 395 printk(KERN_EMERG "%s: %04lx [#%d]\n", str, err & 0xffff, ++die_counter); 396 #ifdef CONFIG_PREEMPT 397 printk(KERN_EMERG "PREEMPT "); 398 nl = 1; 399 #endif 400 #ifdef CONFIG_SMP 401 if (!nl) 402 printk(KERN_EMERG); 403 printk("SMP "); 404 nl = 1; 405 #endif 406 #ifdef CONFIG_DEBUG_PAGEALLOC 407 if (!nl) 408 printk(KERN_EMERG); 409 printk("DEBUG_PAGEALLOC"); 410 nl = 1; 411 #endif 412 if (nl) 413 printk("\n"); 414 if (notify_die(DIE_OOPS, str, regs, err, 415 current->thread.trap_no, SIGSEGV) != 416 NOTIFY_STOP) { 417 show_registers(regs); 418 /* Executive summary in case the oops scrolled away */ 419 esp = (unsigned long) (®s->esp); 420 savesegment(ss, ss); 421 if (user_mode(regs)) { 422 esp = regs->esp; 423 ss = regs->xss & 0xffff; 424 } 425 printk(KERN_EMERG "EIP: [<%08lx>] ", regs->eip); 426 print_symbol("%s", regs->eip); 427 printk(" SS:ESP %04x:%08lx\n", ss, esp); 428 } 429 else 430 regs = NULL; 431 } else 432 printk(KERN_EMERG "Recursive die() failure, output suppressed\n"); 433 434 bust_spinlocks(0); 435 die.lock_owner = -1; 436 spin_unlock_irqrestore(&die.lock, flags); 437 438 if (!regs) 439 return; 440 441 if (kexec_should_crash(current)) 442 crash_kexec(regs); 443 444 if (in_interrupt()) 445 panic("Fatal exception in interrupt"); 446 447 if (panic_on_oops) 448 panic("Fatal exception"); 449 450 oops_exit(); 451 do_exit(SIGSEGV); 452 } 453 454 static inline void die_if_kernel(const char * str, struct pt_regs * regs, long err) 455 { 456 if (!user_mode_vm(regs)) 457 die(str, regs, err); 458 } 459 460 static void __kprobes do_trap(int trapnr, int signr, char *str, int vm86, 461 struct pt_regs * regs, long error_code, 462 siginfo_t *info) 463 { 464 struct task_struct *tsk = current; 465 466 if (regs->eflags & VM_MASK) { 467 if (vm86) 468 goto vm86_trap; 469 goto trap_signal; 470 } 471 472 if (!user_mode(regs)) 473 goto kernel_trap; 474 475 trap_signal: { 476 /* 477 * We want error_code and trap_no set for userspace faults and 478 * kernelspace faults which result in die(), but not 479 * kernelspace faults which are fixed up. die() gives the 480 * process no chance to handle the signal and notice the 481 * kernel fault information, so that won't result in polluting 482 * the information about previously queued, but not yet 483 * delivered, faults. See also do_general_protection below. 484 */ 485 tsk->thread.error_code = error_code; 486 tsk->thread.trap_no = trapnr; 487 488 if (info) 489 force_sig_info(signr, info, tsk); 490 else 491 force_sig(signr, tsk); 492 return; 493 } 494 495 kernel_trap: { 496 if (!fixup_exception(regs)) { 497 tsk->thread.error_code = error_code; 498 tsk->thread.trap_no = trapnr; 499 die(str, regs, error_code); 500 } 501 return; 502 } 503 504 vm86_trap: { 505 int ret = handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code, trapnr); 506 if (ret) goto trap_signal; 507 return; 508 } 509 } 510 511 #define DO_ERROR(trapnr, signr, str, name) \ 512 fastcall void do_##name(struct pt_regs * regs, long error_code) \ 513 { \ 514 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \ 515 == NOTIFY_STOP) \ 516 return; \ 517 do_trap(trapnr, signr, str, 0, regs, error_code, NULL); \ 518 } 519 520 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \ 521 fastcall void do_##name(struct pt_regs * regs, long error_code) \ 522 { \ 523 siginfo_t info; \ 524 info.si_signo = signr; \ 525 info.si_errno = 0; \ 526 info.si_code = sicode; \ 527 info.si_addr = (void __user *)siaddr; \ 528 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \ 529 == NOTIFY_STOP) \ 530 return; \ 531 do_trap(trapnr, signr, str, 0, regs, error_code, &info); \ 532 } 533 534 #define DO_VM86_ERROR(trapnr, signr, str, name) \ 535 fastcall void do_##name(struct pt_regs * regs, long error_code) \ 536 { \ 537 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \ 538 == NOTIFY_STOP) \ 539 return; \ 540 do_trap(trapnr, signr, str, 1, regs, error_code, NULL); \ 541 } 542 543 #define DO_VM86_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \ 544 fastcall void do_##name(struct pt_regs * regs, long error_code) \ 545 { \ 546 siginfo_t info; \ 547 info.si_signo = signr; \ 548 info.si_errno = 0; \ 549 info.si_code = sicode; \ 550 info.si_addr = (void __user *)siaddr; \ 551 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \ 552 == NOTIFY_STOP) \ 553 return; \ 554 do_trap(trapnr, signr, str, 1, regs, error_code, &info); \ 555 } 556 557 DO_VM86_ERROR_INFO( 0, SIGFPE, "divide error", divide_error, FPE_INTDIV, regs->eip) 558 #ifndef CONFIG_KPROBES 559 DO_VM86_ERROR( 3, SIGTRAP, "int3", int3) 560 #endif 561 DO_VM86_ERROR( 4, SIGSEGV, "overflow", overflow) 562 DO_VM86_ERROR( 5, SIGSEGV, "bounds", bounds) 563 DO_ERROR_INFO( 6, SIGILL, "invalid opcode", invalid_op, ILL_ILLOPN, regs->eip) 564 DO_ERROR( 9, SIGFPE, "coprocessor segment overrun", coprocessor_segment_overrun) 565 DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS) 566 DO_ERROR(11, SIGBUS, "segment not present", segment_not_present) 567 DO_ERROR(12, SIGBUS, "stack segment", stack_segment) 568 DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0) 569 DO_ERROR_INFO(32, SIGSEGV, "iret exception", iret_error, ILL_BADSTK, 0) 570 571 fastcall void __kprobes do_general_protection(struct pt_regs * regs, 572 long error_code) 573 { 574 int cpu = get_cpu(); 575 struct tss_struct *tss = &per_cpu(init_tss, cpu); 576 struct thread_struct *thread = ¤t->thread; 577 578 /* 579 * Perform the lazy TSS's I/O bitmap copy. If the TSS has an 580 * invalid offset set (the LAZY one) and the faulting thread has 581 * a valid I/O bitmap pointer, we copy the I/O bitmap in the TSS 582 * and we set the offset field correctly. Then we let the CPU to 583 * restart the faulting instruction. 584 */ 585 if (tss->x86_tss.io_bitmap_base == INVALID_IO_BITMAP_OFFSET_LAZY && 586 thread->io_bitmap_ptr) { 587 memcpy(tss->io_bitmap, thread->io_bitmap_ptr, 588 thread->io_bitmap_max); 589 /* 590 * If the previously set map was extending to higher ports 591 * than the current one, pad extra space with 0xff (no access). 592 */ 593 if (thread->io_bitmap_max < tss->io_bitmap_max) 594 memset((char *) tss->io_bitmap + 595 thread->io_bitmap_max, 0xff, 596 tss->io_bitmap_max - thread->io_bitmap_max); 597 tss->io_bitmap_max = thread->io_bitmap_max; 598 tss->x86_tss.io_bitmap_base = IO_BITMAP_OFFSET; 599 tss->io_bitmap_owner = thread; 600 put_cpu(); 601 return; 602 } 603 put_cpu(); 604 605 if (regs->eflags & VM_MASK) 606 goto gp_in_vm86; 607 608 if (!user_mode(regs)) 609 goto gp_in_kernel; 610 611 current->thread.error_code = error_code; 612 current->thread.trap_no = 13; 613 force_sig(SIGSEGV, current); 614 return; 615 616 gp_in_vm86: 617 local_irq_enable(); 618 handle_vm86_fault((struct kernel_vm86_regs *) regs, error_code); 619 return; 620 621 gp_in_kernel: 622 if (!fixup_exception(regs)) { 623 current->thread.error_code = error_code; 624 current->thread.trap_no = 13; 625 if (notify_die(DIE_GPF, "general protection fault", regs, 626 error_code, 13, SIGSEGV) == NOTIFY_STOP) 627 return; 628 die("general protection fault", regs, error_code); 629 } 630 } 631 632 static __kprobes void 633 mem_parity_error(unsigned char reason, struct pt_regs * regs) 634 { 635 printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x on " 636 "CPU %d.\n", reason, smp_processor_id()); 637 printk(KERN_EMERG "You have some hardware problem, likely on the PCI bus.\n"); 638 if (panic_on_unrecovered_nmi) 639 panic("NMI: Not continuing"); 640 641 printk(KERN_EMERG "Dazed and confused, but trying to continue\n"); 642 643 /* Clear and disable the memory parity error line. */ 644 clear_mem_error(reason); 645 } 646 647 static __kprobes void 648 io_check_error(unsigned char reason, struct pt_regs * regs) 649 { 650 unsigned long i; 651 652 printk(KERN_EMERG "NMI: IOCK error (debug interrupt?)\n"); 653 show_registers(regs); 654 655 /* Re-enable the IOCK line, wait for a few seconds */ 656 reason = (reason & 0xf) | 8; 657 outb(reason, 0x61); 658 i = 2000; 659 while (--i) udelay(1000); 660 reason &= ~8; 661 outb(reason, 0x61); 662 } 663 664 static __kprobes void 665 unknown_nmi_error(unsigned char reason, struct pt_regs * regs) 666 { 667 #ifdef CONFIG_MCA 668 /* Might actually be able to figure out what the guilty party 669 * is. */ 670 if( MCA_bus ) { 671 mca_handle_nmi(); 672 return; 673 } 674 #endif 675 printk(KERN_EMERG "Uhhuh. NMI received for unknown reason %02x on " 676 "CPU %d.\n", reason, smp_processor_id()); 677 printk(KERN_EMERG "Do you have a strange power saving mode enabled?\n"); 678 if (panic_on_unrecovered_nmi) 679 panic("NMI: Not continuing"); 680 681 printk(KERN_EMERG "Dazed and confused, but trying to continue\n"); 682 } 683 684 static DEFINE_SPINLOCK(nmi_print_lock); 685 686 void __kprobes die_nmi(struct pt_regs *regs, const char *msg) 687 { 688 if (notify_die(DIE_NMIWATCHDOG, msg, regs, 0, 2, SIGINT) == 689 NOTIFY_STOP) 690 return; 691 692 spin_lock(&nmi_print_lock); 693 /* 694 * We are in trouble anyway, lets at least try 695 * to get a message out. 696 */ 697 bust_spinlocks(1); 698 printk(KERN_EMERG "%s", msg); 699 printk(" on CPU%d, eip %08lx, registers:\n", 700 smp_processor_id(), regs->eip); 701 show_registers(regs); 702 console_silent(); 703 spin_unlock(&nmi_print_lock); 704 bust_spinlocks(0); 705 706 /* If we are in kernel we are probably nested up pretty bad 707 * and might aswell get out now while we still can. 708 */ 709 if (!user_mode_vm(regs)) { 710 current->thread.trap_no = 2; 711 crash_kexec(regs); 712 } 713 714 do_exit(SIGSEGV); 715 } 716 717 static __kprobes void default_do_nmi(struct pt_regs * regs) 718 { 719 unsigned char reason = 0; 720 721 /* Only the BSP gets external NMIs from the system. */ 722 if (!smp_processor_id()) 723 reason = get_nmi_reason(); 724 725 if (!(reason & 0xc0)) { 726 if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 2, SIGINT) 727 == NOTIFY_STOP) 728 return; 729 #ifdef CONFIG_X86_LOCAL_APIC 730 /* 731 * Ok, so this is none of the documented NMI sources, 732 * so it must be the NMI watchdog. 733 */ 734 if (nmi_watchdog_tick(regs, reason)) 735 return; 736 if (!do_nmi_callback(regs, smp_processor_id())) 737 #endif 738 unknown_nmi_error(reason, regs); 739 740 return; 741 } 742 if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP) 743 return; 744 if (reason & 0x80) 745 mem_parity_error(reason, regs); 746 if (reason & 0x40) 747 io_check_error(reason, regs); 748 /* 749 * Reassert NMI in case it became active meanwhile 750 * as it's edge-triggered. 751 */ 752 reassert_nmi(); 753 } 754 755 fastcall __kprobes void do_nmi(struct pt_regs * regs, long error_code) 756 { 757 int cpu; 758 759 nmi_enter(); 760 761 cpu = smp_processor_id(); 762 763 ++nmi_count(cpu); 764 765 default_do_nmi(regs); 766 767 nmi_exit(); 768 } 769 770 #ifdef CONFIG_KPROBES 771 fastcall void __kprobes do_int3(struct pt_regs *regs, long error_code) 772 { 773 if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) 774 == NOTIFY_STOP) 775 return; 776 /* This is an interrupt gate, because kprobes wants interrupts 777 disabled. Normal trap handlers don't. */ 778 restore_interrupts(regs); 779 do_trap(3, SIGTRAP, "int3", 1, regs, error_code, NULL); 780 } 781 #endif 782 783 /* 784 * Our handling of the processor debug registers is non-trivial. 785 * We do not clear them on entry and exit from the kernel. Therefore 786 * it is possible to get a watchpoint trap here from inside the kernel. 787 * However, the code in ./ptrace.c has ensured that the user can 788 * only set watchpoints on userspace addresses. Therefore the in-kernel 789 * watchpoint trap can only occur in code which is reading/writing 790 * from user space. Such code must not hold kernel locks (since it 791 * can equally take a page fault), therefore it is safe to call 792 * force_sig_info even though that claims and releases locks. 793 * 794 * Code in ./signal.c ensures that the debug control register 795 * is restored before we deliver any signal, and therefore that 796 * user code runs with the correct debug control register even though 797 * we clear it here. 798 * 799 * Being careful here means that we don't have to be as careful in a 800 * lot of more complicated places (task switching can be a bit lazy 801 * about restoring all the debug state, and ptrace doesn't have to 802 * find every occurrence of the TF bit that could be saved away even 803 * by user code) 804 */ 805 fastcall void __kprobes do_debug(struct pt_regs * regs, long error_code) 806 { 807 unsigned int condition; 808 struct task_struct *tsk = current; 809 810 get_debugreg(condition, 6); 811 812 if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code, 813 SIGTRAP) == NOTIFY_STOP) 814 return; 815 /* It's safe to allow irq's after DR6 has been saved */ 816 if (regs->eflags & X86_EFLAGS_IF) 817 local_irq_enable(); 818 819 /* Mask out spurious debug traps due to lazy DR7 setting */ 820 if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) { 821 if (!tsk->thread.debugreg[7]) 822 goto clear_dr7; 823 } 824 825 if (regs->eflags & VM_MASK) 826 goto debug_vm86; 827 828 /* Save debug status register where ptrace can see it */ 829 tsk->thread.debugreg[6] = condition; 830 831 /* 832 * Single-stepping through TF: make sure we ignore any events in 833 * kernel space (but re-enable TF when returning to user mode). 834 */ 835 if (condition & DR_STEP) { 836 /* 837 * We already checked v86 mode above, so we can 838 * check for kernel mode by just checking the CPL 839 * of CS. 840 */ 841 if (!user_mode(regs)) 842 goto clear_TF_reenable; 843 } 844 845 /* Ok, finally something we can handle */ 846 send_sigtrap(tsk, regs, error_code); 847 848 /* Disable additional traps. They'll be re-enabled when 849 * the signal is delivered. 850 */ 851 clear_dr7: 852 set_debugreg(0, 7); 853 return; 854 855 debug_vm86: 856 handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code, 1); 857 return; 858 859 clear_TF_reenable: 860 set_tsk_thread_flag(tsk, TIF_SINGLESTEP); 861 regs->eflags &= ~TF_MASK; 862 return; 863 } 864 865 /* 866 * Note that we play around with the 'TS' bit in an attempt to get 867 * the correct behaviour even in the presence of the asynchronous 868 * IRQ13 behaviour 869 */ 870 void math_error(void __user *eip) 871 { 872 struct task_struct * task; 873 siginfo_t info; 874 unsigned short cwd, swd; 875 876 /* 877 * Save the info for the exception handler and clear the error. 878 */ 879 task = current; 880 save_init_fpu(task); 881 task->thread.trap_no = 16; 882 task->thread.error_code = 0; 883 info.si_signo = SIGFPE; 884 info.si_errno = 0; 885 info.si_code = __SI_FAULT; 886 info.si_addr = eip; 887 /* 888 * (~cwd & swd) will mask out exceptions that are not set to unmasked 889 * status. 0x3f is the exception bits in these regs, 0x200 is the 890 * C1 reg you need in case of a stack fault, 0x040 is the stack 891 * fault bit. We should only be taking one exception at a time, 892 * so if this combination doesn't produce any single exception, 893 * then we have a bad program that isn't syncronizing its FPU usage 894 * and it will suffer the consequences since we won't be able to 895 * fully reproduce the context of the exception 896 */ 897 cwd = get_fpu_cwd(task); 898 swd = get_fpu_swd(task); 899 switch (swd & ~cwd & 0x3f) { 900 case 0x000: /* No unmasked exception */ 901 return; 902 default: /* Multiple exceptions */ 903 break; 904 case 0x001: /* Invalid Op */ 905 /* 906 * swd & 0x240 == 0x040: Stack Underflow 907 * swd & 0x240 == 0x240: Stack Overflow 908 * User must clear the SF bit (0x40) if set 909 */ 910 info.si_code = FPE_FLTINV; 911 break; 912 case 0x002: /* Denormalize */ 913 case 0x010: /* Underflow */ 914 info.si_code = FPE_FLTUND; 915 break; 916 case 0x004: /* Zero Divide */ 917 info.si_code = FPE_FLTDIV; 918 break; 919 case 0x008: /* Overflow */ 920 info.si_code = FPE_FLTOVF; 921 break; 922 case 0x020: /* Precision */ 923 info.si_code = FPE_FLTRES; 924 break; 925 } 926 force_sig_info(SIGFPE, &info, task); 927 } 928 929 fastcall void do_coprocessor_error(struct pt_regs * regs, long error_code) 930 { 931 ignore_fpu_irq = 1; 932 math_error((void __user *)regs->eip); 933 } 934 935 static void simd_math_error(void __user *eip) 936 { 937 struct task_struct * task; 938 siginfo_t info; 939 unsigned short mxcsr; 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 = 19; 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 = eip; 952 /* 953 * The SIMD FPU exceptions are handled a little differently, as there 954 * is only a single status/control register. Thus, to determine which 955 * unmasked exception was caught we must mask the exception mask bits 956 * at 0x1f80, and then use these to mask the exception bits at 0x3f. 957 */ 958 mxcsr = get_fpu_mxcsr(task); 959 switch (~((mxcsr & 0x1f80) >> 7) & (mxcsr & 0x3f)) { 960 case 0x000: 961 default: 962 break; 963 case 0x001: /* Invalid Op */ 964 info.si_code = FPE_FLTINV; 965 break; 966 case 0x002: /* Denormalize */ 967 case 0x010: /* Underflow */ 968 info.si_code = FPE_FLTUND; 969 break; 970 case 0x004: /* Zero Divide */ 971 info.si_code = FPE_FLTDIV; 972 break; 973 case 0x008: /* Overflow */ 974 info.si_code = FPE_FLTOVF; 975 break; 976 case 0x020: /* Precision */ 977 info.si_code = FPE_FLTRES; 978 break; 979 } 980 force_sig_info(SIGFPE, &info, task); 981 } 982 983 fastcall void do_simd_coprocessor_error(struct pt_regs * regs, 984 long error_code) 985 { 986 if (cpu_has_xmm) { 987 /* Handle SIMD FPU exceptions on PIII+ processors. */ 988 ignore_fpu_irq = 1; 989 simd_math_error((void __user *)regs->eip); 990 } else { 991 /* 992 * Handle strange cache flush from user space exception 993 * in all other cases. This is undocumented behaviour. 994 */ 995 if (regs->eflags & VM_MASK) { 996 handle_vm86_fault((struct kernel_vm86_regs *)regs, 997 error_code); 998 return; 999 } 1000 current->thread.trap_no = 19; 1001 current->thread.error_code = error_code; 1002 die_if_kernel("cache flush denied", regs, error_code); 1003 force_sig(SIGSEGV, current); 1004 } 1005 } 1006 1007 fastcall void do_spurious_interrupt_bug(struct pt_regs * regs, 1008 long error_code) 1009 { 1010 #if 0 1011 /* No need to warn about this any longer. */ 1012 printk("Ignoring P6 Local APIC Spurious Interrupt Bug...\n"); 1013 #endif 1014 } 1015 1016 fastcall unsigned long patch_espfix_desc(unsigned long uesp, 1017 unsigned long kesp) 1018 { 1019 struct desc_struct *gdt = __get_cpu_var(gdt_page).gdt; 1020 unsigned long base = (kesp - uesp) & -THREAD_SIZE; 1021 unsigned long new_kesp = kesp - base; 1022 unsigned long lim_pages = (new_kesp | (THREAD_SIZE - 1)) >> PAGE_SHIFT; 1023 __u64 desc = *(__u64 *)&gdt[GDT_ENTRY_ESPFIX_SS]; 1024 /* Set up base for espfix segment */ 1025 desc &= 0x00f0ff0000000000ULL; 1026 desc |= ((((__u64)base) << 16) & 0x000000ffffff0000ULL) | 1027 ((((__u64)base) << 32) & 0xff00000000000000ULL) | 1028 ((((__u64)lim_pages) << 32) & 0x000f000000000000ULL) | 1029 (lim_pages & 0xffff); 1030 *(__u64 *)&gdt[GDT_ENTRY_ESPFIX_SS] = desc; 1031 return new_kesp; 1032 } 1033 1034 /* 1035 * 'math_state_restore()' saves the current math information in the 1036 * old math state array, and gets the new ones from the current task 1037 * 1038 * Careful.. There are problems with IBM-designed IRQ13 behaviour. 1039 * Don't touch unless you *really* know how it works. 1040 * 1041 * Must be called with kernel preemption disabled (in this case, 1042 * local interrupts are disabled at the call-site in entry.S). 1043 */ 1044 asmlinkage void math_state_restore(void) 1045 { 1046 struct thread_info *thread = current_thread_info(); 1047 struct task_struct *tsk = thread->task; 1048 1049 clts(); /* Allow maths ops (or we recurse) */ 1050 if (!tsk_used_math(tsk)) 1051 init_fpu(tsk); 1052 restore_fpu(tsk); 1053 thread->status |= TS_USEDFPU; /* So we fnsave on switch_to() */ 1054 tsk->fpu_counter++; 1055 } 1056 1057 #ifndef CONFIG_MATH_EMULATION 1058 1059 asmlinkage void math_emulate(long arg) 1060 { 1061 printk(KERN_EMERG "math-emulation not enabled and no coprocessor found.\n"); 1062 printk(KERN_EMERG "killing %s.\n",current->comm); 1063 force_sig(SIGFPE,current); 1064 schedule(); 1065 } 1066 1067 #endif /* CONFIG_MATH_EMULATION */ 1068 1069 #ifdef CONFIG_X86_F00F_BUG 1070 void __init trap_init_f00f_bug(void) 1071 { 1072 __set_fixmap(FIX_F00F_IDT, __pa(&idt_table), PAGE_KERNEL_RO); 1073 1074 /* 1075 * Update the IDT descriptor and reload the IDT so that 1076 * it uses the read-only mapped virtual address. 1077 */ 1078 idt_descr.address = fix_to_virt(FIX_F00F_IDT); 1079 load_idt(&idt_descr); 1080 } 1081 #endif 1082 1083 /* 1084 * This needs to use 'idt_table' rather than 'idt', and 1085 * thus use the _nonmapped_ version of the IDT, as the 1086 * Pentium F0 0F bugfix can have resulted in the mapped 1087 * IDT being write-protected. 1088 */ 1089 void set_intr_gate(unsigned int n, void *addr) 1090 { 1091 _set_gate(n, DESCTYPE_INT, addr, __KERNEL_CS); 1092 } 1093 1094 /* 1095 * This routine sets up an interrupt gate at directory privilege level 3. 1096 */ 1097 static inline void set_system_intr_gate(unsigned int n, void *addr) 1098 { 1099 _set_gate(n, DESCTYPE_INT | DESCTYPE_DPL3, addr, __KERNEL_CS); 1100 } 1101 1102 static void __init set_trap_gate(unsigned int n, void *addr) 1103 { 1104 _set_gate(n, DESCTYPE_TRAP, addr, __KERNEL_CS); 1105 } 1106 1107 static void __init set_system_gate(unsigned int n, void *addr) 1108 { 1109 _set_gate(n, DESCTYPE_TRAP | DESCTYPE_DPL3, addr, __KERNEL_CS); 1110 } 1111 1112 static void __init set_task_gate(unsigned int n, unsigned int gdt_entry) 1113 { 1114 _set_gate(n, DESCTYPE_TASK, (void *)0, (gdt_entry<<3)); 1115 } 1116 1117 1118 void __init trap_init(void) 1119 { 1120 #ifdef CONFIG_EISA 1121 void __iomem *p = ioremap(0x0FFFD9, 4); 1122 if (readl(p) == 'E'+('I'<<8)+('S'<<16)+('A'<<24)) { 1123 EISA_bus = 1; 1124 } 1125 iounmap(p); 1126 #endif 1127 1128 #ifdef CONFIG_X86_LOCAL_APIC 1129 init_apic_mappings(); 1130 #endif 1131 1132 set_trap_gate(0,÷_error); 1133 set_intr_gate(1,&debug); 1134 set_intr_gate(2,&nmi); 1135 set_system_intr_gate(3, &int3); /* int3/4 can be called from all */ 1136 set_system_gate(4,&overflow); 1137 set_trap_gate(5,&bounds); 1138 set_trap_gate(6,&invalid_op); 1139 set_trap_gate(7,&device_not_available); 1140 set_task_gate(8,GDT_ENTRY_DOUBLEFAULT_TSS); 1141 set_trap_gate(9,&coprocessor_segment_overrun); 1142 set_trap_gate(10,&invalid_TSS); 1143 set_trap_gate(11,&segment_not_present); 1144 set_trap_gate(12,&stack_segment); 1145 set_trap_gate(13,&general_protection); 1146 set_intr_gate(14,&page_fault); 1147 set_trap_gate(15,&spurious_interrupt_bug); 1148 set_trap_gate(16,&coprocessor_error); 1149 set_trap_gate(17,&alignment_check); 1150 #ifdef CONFIG_X86_MCE 1151 set_trap_gate(18,&machine_check); 1152 #endif 1153 set_trap_gate(19,&simd_coprocessor_error); 1154 1155 if (cpu_has_fxsr) { 1156 /* 1157 * Verify that the FXSAVE/FXRSTOR data will be 16-byte aligned. 1158 * Generates a compile-time "error: zero width for bit-field" if 1159 * the alignment is wrong. 1160 */ 1161 struct fxsrAlignAssert { 1162 int _:!(offsetof(struct task_struct, 1163 thread.i387.fxsave) & 15); 1164 }; 1165 1166 printk(KERN_INFO "Enabling fast FPU save and restore... "); 1167 set_in_cr4(X86_CR4_OSFXSR); 1168 printk("done.\n"); 1169 } 1170 if (cpu_has_xmm) { 1171 printk(KERN_INFO "Enabling unmasked SIMD FPU exception " 1172 "support... "); 1173 set_in_cr4(X86_CR4_OSXMMEXCPT); 1174 printk("done.\n"); 1175 } 1176 1177 set_system_gate(SYSCALL_VECTOR,&system_call); 1178 1179 /* 1180 * Should be a barrier for any external CPU state. 1181 */ 1182 cpu_init(); 1183 1184 trap_init_hook(); 1185 } 1186 1187 static int __init kstack_setup(char *s) 1188 { 1189 kstack_depth_to_print = simple_strtoul(s, NULL, 0); 1190 return 1; 1191 } 1192 __setup("kstack=", kstack_setup); 1193 1194 static int __init code_bytes_setup(char *s) 1195 { 1196 code_bytes = simple_strtoul(s, NULL, 0); 1197 if (code_bytes > 8192) 1198 code_bytes = 8192; 1199 1200 return 1; 1201 } 1202 __setup("code_bytes=", code_bytes_setup);
Cache object: 6118195a52627c47a816ec892764c73b
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]