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 * Handle hardware traps and faults. 11 */ 12 #include <linux/interrupt.h> 13 #include <linux/kallsyms.h> 14 #include <linux/spinlock.h> 15 #include <linux/kprobes.h> 16 #include <linux/uaccess.h> 17 #include <linux/kdebug.h> 18 #include <linux/kgdb.h> 19 #include <linux/kernel.h> 20 #include <linux/module.h> 21 #include <linux/ptrace.h> 22 #include <linux/string.h> 23 #include <linux/delay.h> 24 #include <linux/errno.h> 25 #include <linux/kexec.h> 26 #include <linux/sched.h> 27 #include <linux/timer.h> 28 #include <linux/init.h> 29 #include <linux/bug.h> 30 #include <linux/nmi.h> 31 #include <linux/mm.h> 32 #include <linux/smp.h> 33 #include <linux/io.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 #if defined(CONFIG_EDAC) 45 #include <linux/edac.h> 46 #endif 47 48 #include <asm/kmemcheck.h> 49 #include <asm/stacktrace.h> 50 #include <asm/processor.h> 51 #include <asm/debugreg.h> 52 #include <asm/atomic.h> 53 #include <asm/system.h> 54 #include <asm/traps.h> 55 #include <asm/desc.h> 56 #include <asm/i387.h> 57 #include <asm/mce.h> 58 59 #include <asm/mach_traps.h> 60 61 #ifdef CONFIG_X86_64 62 #include <asm/x86_init.h> 63 #include <asm/pgalloc.h> 64 #include <asm/proto.h> 65 #else 66 #include <asm/processor-flags.h> 67 #include <asm/setup.h> 68 69 asmlinkage int system_call(void); 70 71 /* Do we ignore FPU interrupts ? */ 72 char ignore_fpu_irq; 73 74 /* 75 * The IDT has to be page-aligned to simplify the Pentium 76 * F0 0F bug workaround. 77 */ 78 gate_desc idt_table[NR_VECTORS] __page_aligned_data = { { { { 0, 0 } } }, }; 79 #endif 80 81 DECLARE_BITMAP(used_vectors, NR_VECTORS); 82 EXPORT_SYMBOL_GPL(used_vectors); 83 84 static int ignore_nmis; 85 86 static inline void conditional_sti(struct pt_regs *regs) 87 { 88 if (regs->flags & X86_EFLAGS_IF) 89 local_irq_enable(); 90 } 91 92 static inline void preempt_conditional_sti(struct pt_regs *regs) 93 { 94 inc_preempt_count(); 95 if (regs->flags & X86_EFLAGS_IF) 96 local_irq_enable(); 97 } 98 99 static inline void conditional_cli(struct pt_regs *regs) 100 { 101 if (regs->flags & X86_EFLAGS_IF) 102 local_irq_disable(); 103 } 104 105 static inline void preempt_conditional_cli(struct pt_regs *regs) 106 { 107 if (regs->flags & X86_EFLAGS_IF) 108 local_irq_disable(); 109 dec_preempt_count(); 110 } 111 112 static void __kprobes 113 do_trap(int trapnr, int signr, char *str, struct pt_regs *regs, 114 long error_code, siginfo_t *info) 115 { 116 struct task_struct *tsk = current; 117 118 #ifdef CONFIG_X86_32 119 if (regs->flags & X86_VM_MASK) { 120 /* 121 * traps 0, 1, 3, 4, and 5 should be forwarded to vm86. 122 * On nmi (interrupt 2), do_trap should not be called. 123 */ 124 if (trapnr < 6) 125 goto vm86_trap; 126 goto trap_signal; 127 } 128 #endif 129 130 if (!user_mode(regs)) 131 goto kernel_trap; 132 133 #ifdef CONFIG_X86_32 134 trap_signal: 135 #endif 136 /* 137 * We want error_code and trap_no set for userspace faults and 138 * kernelspace faults which result in die(), but not 139 * kernelspace faults which are fixed up. die() gives the 140 * process no chance to handle the signal and notice the 141 * kernel fault information, so that won't result in polluting 142 * the information about previously queued, but not yet 143 * delivered, faults. See also do_general_protection below. 144 */ 145 tsk->thread.error_code = error_code; 146 tsk->thread.trap_no = trapnr; 147 148 #ifdef CONFIG_X86_64 149 if (show_unhandled_signals && unhandled_signal(tsk, signr) && 150 printk_ratelimit()) { 151 printk(KERN_INFO 152 "%s[%d] trap %s ip:%lx sp:%lx error:%lx", 153 tsk->comm, tsk->pid, str, 154 regs->ip, regs->sp, error_code); 155 print_vma_addr(" in ", regs->ip); 156 printk("\n"); 157 } 158 #endif 159 160 if (info) 161 force_sig_info(signr, info, tsk); 162 else 163 force_sig(signr, tsk); 164 return; 165 166 kernel_trap: 167 if (!fixup_exception(regs)) { 168 tsk->thread.error_code = error_code; 169 tsk->thread.trap_no = trapnr; 170 die(str, regs, error_code); 171 } 172 return; 173 174 #ifdef CONFIG_X86_32 175 vm86_trap: 176 if (handle_vm86_trap((struct kernel_vm86_regs *) regs, 177 error_code, trapnr)) 178 goto trap_signal; 179 return; 180 #endif 181 } 182 183 #define DO_ERROR(trapnr, signr, str, name) \ 184 dotraplinkage void do_##name(struct pt_regs *regs, long error_code) \ 185 { \ 186 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \ 187 == NOTIFY_STOP) \ 188 return; \ 189 conditional_sti(regs); \ 190 do_trap(trapnr, signr, str, regs, error_code, NULL); \ 191 } 192 193 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \ 194 dotraplinkage void do_##name(struct pt_regs *regs, long error_code) \ 195 { \ 196 siginfo_t info; \ 197 info.si_signo = signr; \ 198 info.si_errno = 0; \ 199 info.si_code = sicode; \ 200 info.si_addr = (void __user *)siaddr; \ 201 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \ 202 == NOTIFY_STOP) \ 203 return; \ 204 conditional_sti(regs); \ 205 do_trap(trapnr, signr, str, regs, error_code, &info); \ 206 } 207 208 DO_ERROR_INFO(0, SIGFPE, "divide error", divide_error, FPE_INTDIV, regs->ip) 209 DO_ERROR(4, SIGSEGV, "overflow", overflow) 210 DO_ERROR(5, SIGSEGV, "bounds", bounds) 211 DO_ERROR_INFO(6, SIGILL, "invalid opcode", invalid_op, ILL_ILLOPN, regs->ip) 212 DO_ERROR(9, SIGFPE, "coprocessor segment overrun", coprocessor_segment_overrun) 213 DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS) 214 DO_ERROR(11, SIGBUS, "segment not present", segment_not_present) 215 #ifdef CONFIG_X86_32 216 DO_ERROR(12, SIGBUS, "stack segment", stack_segment) 217 #endif 218 DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0) 219 220 #ifdef CONFIG_X86_64 221 /* Runs on IST stack */ 222 dotraplinkage void do_stack_segment(struct pt_regs *regs, long error_code) 223 { 224 if (notify_die(DIE_TRAP, "stack segment", regs, error_code, 225 12, SIGBUS) == NOTIFY_STOP) 226 return; 227 preempt_conditional_sti(regs); 228 do_trap(12, SIGBUS, "stack segment", regs, error_code, NULL); 229 preempt_conditional_cli(regs); 230 } 231 232 dotraplinkage void do_double_fault(struct pt_regs *regs, long error_code) 233 { 234 static const char str[] = "double fault"; 235 struct task_struct *tsk = current; 236 237 /* Return not checked because double check cannot be ignored */ 238 notify_die(DIE_TRAP, str, regs, error_code, 8, SIGSEGV); 239 240 tsk->thread.error_code = error_code; 241 tsk->thread.trap_no = 8; 242 243 /* 244 * This is always a kernel trap and never fixable (and thus must 245 * never return). 246 */ 247 for (;;) 248 die(str, regs, error_code); 249 } 250 #endif 251 252 dotraplinkage void __kprobes 253 do_general_protection(struct pt_regs *regs, long error_code) 254 { 255 struct task_struct *tsk; 256 257 conditional_sti(regs); 258 259 #ifdef CONFIG_X86_32 260 if (regs->flags & X86_VM_MASK) 261 goto gp_in_vm86; 262 #endif 263 264 tsk = current; 265 if (!user_mode(regs)) 266 goto gp_in_kernel; 267 268 tsk->thread.error_code = error_code; 269 tsk->thread.trap_no = 13; 270 271 if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) && 272 printk_ratelimit()) { 273 printk(KERN_INFO 274 "%s[%d] general protection ip:%lx sp:%lx error:%lx", 275 tsk->comm, task_pid_nr(tsk), 276 regs->ip, regs->sp, error_code); 277 print_vma_addr(" in ", regs->ip); 278 printk("\n"); 279 } 280 281 force_sig(SIGSEGV, tsk); 282 return; 283 284 #ifdef CONFIG_X86_32 285 gp_in_vm86: 286 local_irq_enable(); 287 handle_vm86_fault((struct kernel_vm86_regs *) regs, error_code); 288 return; 289 #endif 290 291 gp_in_kernel: 292 if (fixup_exception(regs)) 293 return; 294 295 tsk->thread.error_code = error_code; 296 tsk->thread.trap_no = 13; 297 if (notify_die(DIE_GPF, "general protection fault", regs, 298 error_code, 13, SIGSEGV) == NOTIFY_STOP) 299 return; 300 die("general protection fault", regs, error_code); 301 } 302 303 static notrace __kprobes void 304 mem_parity_error(unsigned char reason, struct pt_regs *regs) 305 { 306 printk(KERN_EMERG 307 "Uhhuh. NMI received for unknown reason %02x on CPU %d.\n", 308 reason, smp_processor_id()); 309 310 printk(KERN_EMERG 311 "You have some hardware problem, likely on the PCI bus.\n"); 312 313 #if defined(CONFIG_EDAC) 314 if (edac_handler_set()) { 315 edac_atomic_assert_error(); 316 return; 317 } 318 #endif 319 320 if (panic_on_unrecovered_nmi) 321 panic("NMI: Not continuing"); 322 323 printk(KERN_EMERG "Dazed and confused, but trying to continue\n"); 324 325 /* Clear and disable the memory parity error line. */ 326 reason = (reason & 0xf) | 4; 327 outb(reason, 0x61); 328 } 329 330 static notrace __kprobes void 331 io_check_error(unsigned char reason, struct pt_regs *regs) 332 { 333 unsigned long i; 334 335 printk(KERN_EMERG "NMI: IOCK error (debug interrupt?)\n"); 336 show_registers(regs); 337 338 if (panic_on_io_nmi) 339 panic("NMI IOCK error: Not continuing"); 340 341 /* Re-enable the IOCK line, wait for a few seconds */ 342 reason = (reason & 0xf) | 8; 343 outb(reason, 0x61); 344 345 i = 2000; 346 while (--i) 347 udelay(1000); 348 349 reason &= ~8; 350 outb(reason, 0x61); 351 } 352 353 static notrace __kprobes void 354 unknown_nmi_error(unsigned char reason, struct pt_regs *regs) 355 { 356 if (notify_die(DIE_NMIUNKNOWN, "nmi", regs, reason, 2, SIGINT) == 357 NOTIFY_STOP) 358 return; 359 #ifdef CONFIG_MCA 360 /* 361 * Might actually be able to figure out what the guilty party 362 * is: 363 */ 364 if (MCA_bus) { 365 mca_handle_nmi(); 366 return; 367 } 368 #endif 369 printk(KERN_EMERG 370 "Uhhuh. NMI received for unknown reason %02x on CPU %d.\n", 371 reason, smp_processor_id()); 372 373 printk(KERN_EMERG "Do you have a strange power saving mode enabled?\n"); 374 if (panic_on_unrecovered_nmi) 375 panic("NMI: Not continuing"); 376 377 printk(KERN_EMERG "Dazed and confused, but trying to continue\n"); 378 } 379 380 static notrace __kprobes void default_do_nmi(struct pt_regs *regs) 381 { 382 unsigned char reason = 0; 383 int cpu; 384 385 cpu = smp_processor_id(); 386 387 /* Only the BSP gets external NMIs from the system. */ 388 if (!cpu) 389 reason = get_nmi_reason(); 390 391 if (!(reason & 0xc0)) { 392 if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 2, SIGINT) 393 == NOTIFY_STOP) 394 return; 395 #ifdef CONFIG_X86_LOCAL_APIC 396 /* 397 * Ok, so this is none of the documented NMI sources, 398 * so it must be the NMI watchdog. 399 */ 400 if (nmi_watchdog_tick(regs, reason)) 401 return; 402 if (!do_nmi_callback(regs, cpu)) 403 unknown_nmi_error(reason, regs); 404 #else 405 unknown_nmi_error(reason, regs); 406 #endif 407 408 return; 409 } 410 if (notify_die(DIE_NMI, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP) 411 return; 412 413 /* AK: following checks seem to be broken on modern chipsets. FIXME */ 414 if (reason & 0x80) 415 mem_parity_error(reason, regs); 416 if (reason & 0x40) 417 io_check_error(reason, regs); 418 #ifdef CONFIG_X86_32 419 /* 420 * Reassert NMI in case it became active meanwhile 421 * as it's edge-triggered: 422 */ 423 reassert_nmi(); 424 #endif 425 } 426 427 dotraplinkage notrace __kprobes void 428 do_nmi(struct pt_regs *regs, long error_code) 429 { 430 nmi_enter(); 431 432 inc_irq_stat(__nmi_count); 433 434 if (!ignore_nmis) 435 default_do_nmi(regs); 436 437 nmi_exit(); 438 } 439 440 void stop_nmi(void) 441 { 442 acpi_nmi_disable(); 443 ignore_nmis++; 444 } 445 446 void restart_nmi(void) 447 { 448 ignore_nmis--; 449 acpi_nmi_enable(); 450 } 451 452 /* May run on IST stack. */ 453 dotraplinkage void __kprobes do_int3(struct pt_regs *regs, long error_code) 454 { 455 #ifdef CONFIG_KGDB_LOW_LEVEL_TRAP 456 if (kgdb_ll_trap(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) 457 == NOTIFY_STOP) 458 return; 459 #endif /* CONFIG_KGDB_LOW_LEVEL_TRAP */ 460 #ifdef CONFIG_KPROBES 461 if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) 462 == NOTIFY_STOP) 463 return; 464 #else 465 if (notify_die(DIE_TRAP, "int3", regs, error_code, 3, SIGTRAP) 466 == NOTIFY_STOP) 467 return; 468 #endif 469 470 preempt_conditional_sti(regs); 471 do_trap(3, SIGTRAP, "int3", regs, error_code, NULL); 472 preempt_conditional_cli(regs); 473 } 474 475 #ifdef CONFIG_X86_64 476 /* 477 * Help handler running on IST stack to switch back to user stack 478 * for scheduling or signal handling. The actual stack switch is done in 479 * entry.S 480 */ 481 asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs) 482 { 483 struct pt_regs *regs = eregs; 484 /* Did already sync */ 485 if (eregs == (struct pt_regs *)eregs->sp) 486 ; 487 /* Exception from user space */ 488 else if (user_mode(eregs)) 489 regs = task_pt_regs(current); 490 /* 491 * Exception from kernel and interrupts are enabled. Move to 492 * kernel process stack. 493 */ 494 else if (eregs->flags & X86_EFLAGS_IF) 495 regs = (struct pt_regs *)(eregs->sp -= sizeof(struct pt_regs)); 496 if (eregs != regs) 497 *regs = *eregs; 498 return regs; 499 } 500 #endif 501 502 /* 503 * Our handling of the processor debug registers is non-trivial. 504 * We do not clear them on entry and exit from the kernel. Therefore 505 * it is possible to get a watchpoint trap here from inside the kernel. 506 * However, the code in ./ptrace.c has ensured that the user can 507 * only set watchpoints on userspace addresses. Therefore the in-kernel 508 * watchpoint trap can only occur in code which is reading/writing 509 * from user space. Such code must not hold kernel locks (since it 510 * can equally take a page fault), therefore it is safe to call 511 * force_sig_info even though that claims and releases locks. 512 * 513 * Code in ./signal.c ensures that the debug control register 514 * is restored before we deliver any signal, and therefore that 515 * user code runs with the correct debug control register even though 516 * we clear it here. 517 * 518 * Being careful here means that we don't have to be as careful in a 519 * lot of more complicated places (task switching can be a bit lazy 520 * about restoring all the debug state, and ptrace doesn't have to 521 * find every occurrence of the TF bit that could be saved away even 522 * by user code) 523 * 524 * May run on IST stack. 525 */ 526 dotraplinkage void __kprobes do_debug(struct pt_regs *regs, long error_code) 527 { 528 struct task_struct *tsk = current; 529 unsigned long dr6; 530 int si_code; 531 532 get_debugreg(dr6, 6); 533 534 /* Filter out all the reserved bits which are preset to 1 */ 535 dr6 &= ~DR6_RESERVED; 536 537 /* Catch kmemcheck conditions first of all! */ 538 if ((dr6 & DR_STEP) && kmemcheck_trap(regs)) 539 return; 540 541 /* DR6 may or may not be cleared by the CPU */ 542 set_debugreg(0, 6); 543 544 /* 545 * The processor cleared BTF, so don't mark that we need it set. 546 */ 547 clear_tsk_thread_flag(tsk, TIF_BLOCKSTEP); 548 549 /* Store the virtualized DR6 value */ 550 tsk->thread.debugreg6 = dr6; 551 552 if (notify_die(DIE_DEBUG, "debug", regs, PTR_ERR(&dr6), error_code, 553 SIGTRAP) == NOTIFY_STOP) 554 return; 555 556 /* It's safe to allow irq's after DR6 has been saved */ 557 preempt_conditional_sti(regs); 558 559 if (regs->flags & X86_VM_MASK) { 560 handle_vm86_trap((struct kernel_vm86_regs *) regs, 561 error_code, 1); 562 return; 563 } 564 565 /* 566 * Single-stepping through system calls: ignore any exceptions in 567 * kernel space, but re-enable TF when returning to user mode. 568 * 569 * We already checked v86 mode above, so we can check for kernel mode 570 * by just checking the CPL of CS. 571 */ 572 if ((dr6 & DR_STEP) && !user_mode(regs)) { 573 tsk->thread.debugreg6 &= ~DR_STEP; 574 set_tsk_thread_flag(tsk, TIF_SINGLESTEP); 575 regs->flags &= ~X86_EFLAGS_TF; 576 } 577 si_code = get_si_code(tsk->thread.debugreg6); 578 if (tsk->thread.debugreg6 & (DR_STEP | DR_TRAP_BITS)) 579 send_sigtrap(tsk, regs, error_code, si_code); 580 preempt_conditional_cli(regs); 581 582 return; 583 } 584 585 /* 586 * Note that we play around with the 'TS' bit in an attempt to get 587 * the correct behaviour even in the presence of the asynchronous 588 * IRQ13 behaviour 589 */ 590 void math_error(struct pt_regs *regs, int error_code, int trapnr) 591 { 592 struct task_struct *task = current; 593 siginfo_t info; 594 unsigned short err; 595 char *str = (trapnr == 16) ? "fpu exception" : "simd exception"; 596 597 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, SIGFPE) == NOTIFY_STOP) 598 return; 599 conditional_sti(regs); 600 601 if (!user_mode_vm(regs)) 602 { 603 if (!fixup_exception(regs)) { 604 task->thread.error_code = error_code; 605 task->thread.trap_no = trapnr; 606 die(str, regs, error_code); 607 } 608 return; 609 } 610 611 /* 612 * Save the info for the exception handler and clear the error. 613 */ 614 save_init_fpu(task); 615 task->thread.trap_no = trapnr; 616 task->thread.error_code = error_code; 617 info.si_signo = SIGFPE; 618 info.si_errno = 0; 619 info.si_addr = (void __user *)regs->ip; 620 if (trapnr == 16) { 621 unsigned short cwd, swd; 622 /* 623 * (~cwd & swd) will mask out exceptions that are not set to unmasked 624 * status. 0x3f is the exception bits in these regs, 0x200 is the 625 * C1 reg you need in case of a stack fault, 0x040 is the stack 626 * fault bit. We should only be taking one exception at a time, 627 * so if this combination doesn't produce any single exception, 628 * then we have a bad program that isn't synchronizing its FPU usage 629 * and it will suffer the consequences since we won't be able to 630 * fully reproduce the context of the exception 631 */ 632 cwd = get_fpu_cwd(task); 633 swd = get_fpu_swd(task); 634 635 err = swd & ~cwd; 636 } else { 637 /* 638 * The SIMD FPU exceptions are handled a little differently, as there 639 * is only a single status/control register. Thus, to determine which 640 * unmasked exception was caught we must mask the exception mask bits 641 * at 0x1f80, and then use these to mask the exception bits at 0x3f. 642 */ 643 unsigned short mxcsr = get_fpu_mxcsr(task); 644 err = ~(mxcsr >> 7) & mxcsr; 645 } 646 647 if (err & 0x001) { /* Invalid op */ 648 /* 649 * swd & 0x240 == 0x040: Stack Underflow 650 * swd & 0x240 == 0x240: Stack Overflow 651 * User must clear the SF bit (0x40) if set 652 */ 653 info.si_code = FPE_FLTINV; 654 } else if (err & 0x004) { /* Divide by Zero */ 655 info.si_code = FPE_FLTDIV; 656 } else if (err & 0x008) { /* Overflow */ 657 info.si_code = FPE_FLTOVF; 658 } else if (err & 0x012) { /* Denormal, Underflow */ 659 info.si_code = FPE_FLTUND; 660 } else if (err & 0x020) { /* Precision */ 661 info.si_code = FPE_FLTRES; 662 } else { 663 /* 664 * If we're using IRQ 13, or supposedly even some trap 16 665 * implementations, it's possible we get a spurious trap... 666 */ 667 return; /* Spurious trap, no error */ 668 } 669 force_sig_info(SIGFPE, &info, task); 670 } 671 672 dotraplinkage void do_coprocessor_error(struct pt_regs *regs, long error_code) 673 { 674 #ifdef CONFIG_X86_32 675 ignore_fpu_irq = 1; 676 #endif 677 678 math_error(regs, error_code, 16); 679 } 680 681 dotraplinkage void 682 do_simd_coprocessor_error(struct pt_regs *regs, long error_code) 683 { 684 math_error(regs, error_code, 19); 685 } 686 687 dotraplinkage void 688 do_spurious_interrupt_bug(struct pt_regs *regs, long error_code) 689 { 690 conditional_sti(regs); 691 #if 0 692 /* No need to warn about this any longer. */ 693 printk(KERN_INFO "Ignoring P6 Local APIC Spurious Interrupt Bug...\n"); 694 #endif 695 } 696 697 asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void) 698 { 699 } 700 701 asmlinkage void __attribute__((weak)) smp_threshold_interrupt(void) 702 { 703 } 704 705 /* 706 * __math_state_restore assumes that cr0.TS is already clear and the 707 * fpu state is all ready for use. Used during context switch. 708 */ 709 void __math_state_restore(void) 710 { 711 struct thread_info *thread = current_thread_info(); 712 struct task_struct *tsk = thread->task; 713 714 /* 715 * Paranoid restore. send a SIGSEGV if we fail to restore the state. 716 */ 717 if (unlikely(restore_fpu_checking(tsk))) { 718 stts(); 719 force_sig(SIGSEGV, tsk); 720 return; 721 } 722 723 thread->status |= TS_USEDFPU; /* So we fnsave on switch_to() */ 724 tsk->fpu_counter++; 725 } 726 727 /* 728 * 'math_state_restore()' saves the current math information in the 729 * old math state array, and gets the new ones from the current task 730 * 731 * Careful.. There are problems with IBM-designed IRQ13 behaviour. 732 * Don't touch unless you *really* know how it works. 733 * 734 * Must be called with kernel preemption disabled (in this case, 735 * local interrupts are disabled at the call-site in entry.S). 736 */ 737 asmlinkage void math_state_restore(void) 738 { 739 struct thread_info *thread = current_thread_info(); 740 struct task_struct *tsk = thread->task; 741 742 if (!tsk_used_math(tsk)) { 743 local_irq_enable(); 744 /* 745 * does a slab alloc which can sleep 746 */ 747 if (init_fpu(tsk)) { 748 /* 749 * ran out of memory! 750 */ 751 do_group_exit(SIGKILL); 752 return; 753 } 754 local_irq_disable(); 755 } 756 757 clts(); /* Allow maths ops (or we recurse) */ 758 759 __math_state_restore(); 760 } 761 EXPORT_SYMBOL_GPL(math_state_restore); 762 763 #ifndef CONFIG_MATH_EMULATION 764 void math_emulate(struct math_emu_info *info) 765 { 766 printk(KERN_EMERG 767 "math-emulation not enabled and no coprocessor found.\n"); 768 printk(KERN_EMERG "killing %s.\n", current->comm); 769 force_sig(SIGFPE, current); 770 schedule(); 771 } 772 #endif /* CONFIG_MATH_EMULATION */ 773 774 dotraplinkage void __kprobes 775 do_device_not_available(struct pt_regs *regs, long error_code) 776 { 777 #ifdef CONFIG_X86_32 778 if (read_cr0() & X86_CR0_EM) { 779 struct math_emu_info info = { }; 780 781 conditional_sti(regs); 782 783 info.regs = regs; 784 math_emulate(&info); 785 } else { 786 math_state_restore(); /* interrupts still off */ 787 conditional_sti(regs); 788 } 789 #else 790 math_state_restore(); 791 #endif 792 } 793 794 #ifdef CONFIG_X86_32 795 dotraplinkage void do_iret_error(struct pt_regs *regs, long error_code) 796 { 797 siginfo_t info; 798 local_irq_enable(); 799 800 info.si_signo = SIGILL; 801 info.si_errno = 0; 802 info.si_code = ILL_BADSTK; 803 info.si_addr = NULL; 804 if (notify_die(DIE_TRAP, "iret exception", 805 regs, error_code, 32, SIGILL) == NOTIFY_STOP) 806 return; 807 do_trap(32, SIGILL, "iret exception", regs, error_code, &info); 808 } 809 #endif 810 811 /* Set of traps needed for early debugging. */ 812 void __init early_trap_init(void) 813 { 814 set_intr_gate_ist(1, &debug, DEBUG_STACK); 815 /* int3 can be called from all */ 816 set_system_intr_gate_ist(3, &int3, DEBUG_STACK); 817 set_intr_gate(14, &page_fault); 818 load_idt(&idt_descr); 819 } 820 821 void __init trap_init(void) 822 { 823 int i; 824 825 #ifdef CONFIG_EISA 826 void __iomem *p = early_ioremap(0x0FFFD9, 4); 827 828 if (readl(p) == 'E' + ('I'<<8) + ('S'<<16) + ('A'<<24)) 829 EISA_bus = 1; 830 early_iounmap(p, 4); 831 #endif 832 833 set_intr_gate(0, ÷_error); 834 set_intr_gate_ist(2, &nmi, NMI_STACK); 835 /* int4 can be called from all */ 836 set_system_intr_gate(4, &overflow); 837 set_intr_gate(5, &bounds); 838 set_intr_gate(6, &invalid_op); 839 set_intr_gate(7, &device_not_available); 840 #ifdef CONFIG_X86_32 841 set_task_gate(8, GDT_ENTRY_DOUBLEFAULT_TSS); 842 #else 843 set_intr_gate_ist(8, &double_fault, DOUBLEFAULT_STACK); 844 #endif 845 set_intr_gate(9, &coprocessor_segment_overrun); 846 set_intr_gate(10, &invalid_TSS); 847 set_intr_gate(11, &segment_not_present); 848 set_intr_gate_ist(12, &stack_segment, STACKFAULT_STACK); 849 set_intr_gate(13, &general_protection); 850 set_intr_gate(15, &spurious_interrupt_bug); 851 set_intr_gate(16, &coprocessor_error); 852 set_intr_gate(17, &alignment_check); 853 #ifdef CONFIG_X86_MCE 854 set_intr_gate_ist(18, &machine_check, MCE_STACK); 855 #endif 856 set_intr_gate(19, &simd_coprocessor_error); 857 858 /* Reserve all the builtin and the syscall vector: */ 859 for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++) 860 set_bit(i, used_vectors); 861 862 #ifdef CONFIG_IA32_EMULATION 863 set_system_intr_gate(IA32_SYSCALL_VECTOR, ia32_syscall); 864 set_bit(IA32_SYSCALL_VECTOR, used_vectors); 865 #endif 866 867 #ifdef CONFIG_X86_32 868 if (cpu_has_fxsr) { 869 printk(KERN_INFO "Enabling fast FPU save and restore... "); 870 set_in_cr4(X86_CR4_OSFXSR); 871 printk("done.\n"); 872 } 873 if (cpu_has_xmm) { 874 printk(KERN_INFO 875 "Enabling unmasked SIMD FPU exception support... "); 876 set_in_cr4(X86_CR4_OSXMMEXCPT); 877 printk("done.\n"); 878 } 879 880 set_system_trap_gate(SYSCALL_VECTOR, &system_call); 881 set_bit(SYSCALL_VECTOR, used_vectors); 882 #endif 883 884 /* 885 * Should be a barrier for any external CPU state: 886 */ 887 cpu_init(); 888 889 x86_init.irqs.trap_init(); 890 } 891