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 <linux/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 inline void conditional_sti(struct pt_regs *regs) 85 { 86 if (regs->flags & X86_EFLAGS_IF) 87 local_irq_enable(); 88 } 89 90 static inline void preempt_conditional_sti(struct pt_regs *regs) 91 { 92 inc_preempt_count(); 93 if (regs->flags & X86_EFLAGS_IF) 94 local_irq_enable(); 95 } 96 97 static inline void conditional_cli(struct pt_regs *regs) 98 { 99 if (regs->flags & X86_EFLAGS_IF) 100 local_irq_disable(); 101 } 102 103 static inline void preempt_conditional_cli(struct pt_regs *regs) 104 { 105 if (regs->flags & X86_EFLAGS_IF) 106 local_irq_disable(); 107 dec_preempt_count(); 108 } 109 110 static void __kprobes 111 do_trap(int trapnr, int signr, char *str, struct pt_regs *regs, 112 long error_code, siginfo_t *info) 113 { 114 struct task_struct *tsk = current; 115 116 #ifdef CONFIG_X86_32 117 if (regs->flags & X86_VM_MASK) { 118 /* 119 * traps 0, 1, 3, 4, and 5 should be forwarded to vm86. 120 * On nmi (interrupt 2), do_trap should not be called. 121 */ 122 if (trapnr < 6) 123 goto vm86_trap; 124 goto trap_signal; 125 } 126 #endif 127 128 if (!user_mode(regs)) 129 goto kernel_trap; 130 131 #ifdef CONFIG_X86_32 132 trap_signal: 133 #endif 134 /* 135 * We want error_code and trap_no set for userspace faults and 136 * kernelspace faults which result in die(), but not 137 * kernelspace faults which are fixed up. die() gives the 138 * process no chance to handle the signal and notice the 139 * kernel fault information, so that won't result in polluting 140 * the information about previously queued, but not yet 141 * delivered, faults. See also do_general_protection below. 142 */ 143 tsk->thread.error_code = error_code; 144 tsk->thread.trap_no = trapnr; 145 146 #ifdef CONFIG_X86_64 147 if (show_unhandled_signals && unhandled_signal(tsk, signr) && 148 printk_ratelimit()) { 149 printk(KERN_INFO 150 "%s[%d] trap %s ip:%lx sp:%lx error:%lx", 151 tsk->comm, tsk->pid, str, 152 regs->ip, regs->sp, error_code); 153 print_vma_addr(" in ", regs->ip); 154 printk("\n"); 155 } 156 #endif 157 158 if (info) 159 force_sig_info(signr, info, tsk); 160 else 161 force_sig(signr, tsk); 162 return; 163 164 kernel_trap: 165 if (!fixup_exception(regs)) { 166 tsk->thread.error_code = error_code; 167 tsk->thread.trap_no = trapnr; 168 die(str, regs, error_code); 169 } 170 return; 171 172 #ifdef CONFIG_X86_32 173 vm86_trap: 174 if (handle_vm86_trap((struct kernel_vm86_regs *) regs, 175 error_code, trapnr)) 176 goto trap_signal; 177 return; 178 #endif 179 } 180 181 #define DO_ERROR(trapnr, signr, str, name) \ 182 dotraplinkage void do_##name(struct pt_regs *regs, long error_code) \ 183 { \ 184 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \ 185 == NOTIFY_STOP) \ 186 return; \ 187 conditional_sti(regs); \ 188 do_trap(trapnr, signr, str, regs, error_code, NULL); \ 189 } 190 191 #define DO_ERROR_INFO(trapnr, signr, str, name, sicode, siaddr) \ 192 dotraplinkage void do_##name(struct pt_regs *regs, long error_code) \ 193 { \ 194 siginfo_t info; \ 195 info.si_signo = signr; \ 196 info.si_errno = 0; \ 197 info.si_code = sicode; \ 198 info.si_addr = (void __user *)siaddr; \ 199 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) \ 200 == NOTIFY_STOP) \ 201 return; \ 202 conditional_sti(regs); \ 203 do_trap(trapnr, signr, str, regs, error_code, &info); \ 204 } 205 206 DO_ERROR_INFO(0, SIGFPE, "divide error", divide_error, FPE_INTDIV, regs->ip) 207 DO_ERROR(4, SIGSEGV, "overflow", overflow) 208 DO_ERROR(5, SIGSEGV, "bounds", bounds) 209 DO_ERROR_INFO(6, SIGILL, "invalid opcode", invalid_op, ILL_ILLOPN, regs->ip) 210 DO_ERROR(9, SIGFPE, "coprocessor segment overrun", coprocessor_segment_overrun) 211 DO_ERROR(10, SIGSEGV, "invalid TSS", invalid_TSS) 212 DO_ERROR(11, SIGBUS, "segment not present", segment_not_present) 213 #ifdef CONFIG_X86_32 214 DO_ERROR(12, SIGBUS, "stack segment", stack_segment) 215 #endif 216 DO_ERROR_INFO(17, SIGBUS, "alignment check", alignment_check, BUS_ADRALN, 0) 217 218 #ifdef CONFIG_X86_64 219 /* Runs on IST stack */ 220 dotraplinkage void do_stack_segment(struct pt_regs *regs, long error_code) 221 { 222 if (notify_die(DIE_TRAP, "stack segment", regs, error_code, 223 12, SIGBUS) == NOTIFY_STOP) 224 return; 225 preempt_conditional_sti(regs); 226 do_trap(12, SIGBUS, "stack segment", regs, error_code, NULL); 227 preempt_conditional_cli(regs); 228 } 229 230 dotraplinkage void do_double_fault(struct pt_regs *regs, long error_code) 231 { 232 static const char str[] = "double fault"; 233 struct task_struct *tsk = current; 234 235 /* Return not checked because double check cannot be ignored */ 236 notify_die(DIE_TRAP, str, regs, error_code, 8, SIGSEGV); 237 238 tsk->thread.error_code = error_code; 239 tsk->thread.trap_no = 8; 240 241 /* 242 * This is always a kernel trap and never fixable (and thus must 243 * never return). 244 */ 245 for (;;) 246 die(str, regs, error_code); 247 } 248 #endif 249 250 dotraplinkage void __kprobes 251 do_general_protection(struct pt_regs *regs, long error_code) 252 { 253 struct task_struct *tsk; 254 255 conditional_sti(regs); 256 257 #ifdef CONFIG_X86_32 258 if (regs->flags & X86_VM_MASK) 259 goto gp_in_vm86; 260 #endif 261 262 tsk = current; 263 if (!user_mode(regs)) 264 goto gp_in_kernel; 265 266 tsk->thread.error_code = error_code; 267 tsk->thread.trap_no = 13; 268 269 if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) && 270 printk_ratelimit()) { 271 printk(KERN_INFO 272 "%s[%d] general protection ip:%lx sp:%lx error:%lx", 273 tsk->comm, task_pid_nr(tsk), 274 regs->ip, regs->sp, error_code); 275 print_vma_addr(" in ", regs->ip); 276 printk("\n"); 277 } 278 279 force_sig(SIGSEGV, tsk); 280 return; 281 282 #ifdef CONFIG_X86_32 283 gp_in_vm86: 284 local_irq_enable(); 285 handle_vm86_fault((struct kernel_vm86_regs *) regs, error_code); 286 return; 287 #endif 288 289 gp_in_kernel: 290 if (fixup_exception(regs)) 291 return; 292 293 tsk->thread.error_code = error_code; 294 tsk->thread.trap_no = 13; 295 if (notify_die(DIE_GPF, "general protection fault", regs, 296 error_code, 13, SIGSEGV) == NOTIFY_STOP) 297 return; 298 die("general protection fault", regs, error_code); 299 } 300 301 /* May run on IST stack. */ 302 dotraplinkage void __kprobes do_int3(struct pt_regs *regs, long error_code) 303 { 304 #ifdef CONFIG_KGDB_LOW_LEVEL_TRAP 305 if (kgdb_ll_trap(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) 306 == NOTIFY_STOP) 307 return; 308 #endif /* CONFIG_KGDB_LOW_LEVEL_TRAP */ 309 310 if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP) 311 == NOTIFY_STOP) 312 return; 313 314 /* 315 * Let others (NMI) know that the debug stack is in use 316 * as we may switch to the interrupt stack. 317 */ 318 debug_stack_usage_inc(); 319 preempt_conditional_sti(regs); 320 do_trap(3, SIGTRAP, "int3", regs, error_code, NULL); 321 preempt_conditional_cli(regs); 322 debug_stack_usage_dec(); 323 } 324 325 #ifdef CONFIG_X86_64 326 /* 327 * Help handler running on IST stack to switch back to user stack 328 * for scheduling or signal handling. The actual stack switch is done in 329 * entry.S 330 */ 331 asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs) 332 { 333 struct pt_regs *regs = eregs; 334 /* Did already sync */ 335 if (eregs == (struct pt_regs *)eregs->sp) 336 ; 337 /* Exception from user space */ 338 else if (user_mode(eregs)) 339 regs = task_pt_regs(current); 340 /* 341 * Exception from kernel and interrupts are enabled. Move to 342 * kernel process stack. 343 */ 344 else if (eregs->flags & X86_EFLAGS_IF) 345 regs = (struct pt_regs *)(eregs->sp -= sizeof(struct pt_regs)); 346 if (eregs != regs) 347 *regs = *eregs; 348 return regs; 349 } 350 #endif 351 352 /* 353 * Our handling of the processor debug registers is non-trivial. 354 * We do not clear them on entry and exit from the kernel. Therefore 355 * it is possible to get a watchpoint trap here from inside the kernel. 356 * However, the code in ./ptrace.c has ensured that the user can 357 * only set watchpoints on userspace addresses. Therefore the in-kernel 358 * watchpoint trap can only occur in code which is reading/writing 359 * from user space. Such code must not hold kernel locks (since it 360 * can equally take a page fault), therefore it is safe to call 361 * force_sig_info even though that claims and releases locks. 362 * 363 * Code in ./signal.c ensures that the debug control register 364 * is restored before we deliver any signal, and therefore that 365 * user code runs with the correct debug control register even though 366 * we clear it here. 367 * 368 * Being careful here means that we don't have to be as careful in a 369 * lot of more complicated places (task switching can be a bit lazy 370 * about restoring all the debug state, and ptrace doesn't have to 371 * find every occurrence of the TF bit that could be saved away even 372 * by user code) 373 * 374 * May run on IST stack. 375 */ 376 dotraplinkage void __kprobes do_debug(struct pt_regs *regs, long error_code) 377 { 378 struct task_struct *tsk = current; 379 int user_icebp = 0; 380 unsigned long dr6; 381 int si_code; 382 383 get_debugreg(dr6, 6); 384 385 /* Filter out all the reserved bits which are preset to 1 */ 386 dr6 &= ~DR6_RESERVED; 387 388 /* 389 * If dr6 has no reason to give us about the origin of this trap, 390 * then it's very likely the result of an icebp/int01 trap. 391 * User wants a sigtrap for that. 392 */ 393 if (!dr6 && user_mode(regs)) 394 user_icebp = 1; 395 396 /* Catch kmemcheck conditions first of all! */ 397 if ((dr6 & DR_STEP) && kmemcheck_trap(regs)) 398 return; 399 400 /* DR6 may or may not be cleared by the CPU */ 401 set_debugreg(0, 6); 402 403 /* 404 * The processor cleared BTF, so don't mark that we need it set. 405 */ 406 clear_tsk_thread_flag(tsk, TIF_BLOCKSTEP); 407 408 /* Store the virtualized DR6 value */ 409 tsk->thread.debugreg6 = dr6; 410 411 if (notify_die(DIE_DEBUG, "debug", regs, PTR_ERR(&dr6), error_code, 412 SIGTRAP) == NOTIFY_STOP) 413 return; 414 415 /* 416 * Let others (NMI) know that the debug stack is in use 417 * as we may switch to the interrupt stack. 418 */ 419 debug_stack_usage_inc(); 420 421 /* It's safe to allow irq's after DR6 has been saved */ 422 preempt_conditional_sti(regs); 423 424 if (regs->flags & X86_VM_MASK) { 425 handle_vm86_trap((struct kernel_vm86_regs *) regs, 426 error_code, 1); 427 preempt_conditional_cli(regs); 428 debug_stack_usage_dec(); 429 return; 430 } 431 432 /* 433 * Single-stepping through system calls: ignore any exceptions in 434 * kernel space, but re-enable TF when returning to user mode. 435 * 436 * We already checked v86 mode above, so we can check for kernel mode 437 * by just checking the CPL of CS. 438 */ 439 if ((dr6 & DR_STEP) && !user_mode(regs)) { 440 tsk->thread.debugreg6 &= ~DR_STEP; 441 set_tsk_thread_flag(tsk, TIF_SINGLESTEP); 442 regs->flags &= ~X86_EFLAGS_TF; 443 } 444 si_code = get_si_code(tsk->thread.debugreg6); 445 if (tsk->thread.debugreg6 & (DR_STEP | DR_TRAP_BITS) || user_icebp) 446 send_sigtrap(tsk, regs, error_code, si_code); 447 preempt_conditional_cli(regs); 448 debug_stack_usage_dec(); 449 450 return; 451 } 452 453 /* 454 * Note that we play around with the 'TS' bit in an attempt to get 455 * the correct behaviour even in the presence of the asynchronous 456 * IRQ13 behaviour 457 */ 458 void math_error(struct pt_regs *regs, int error_code, int trapnr) 459 { 460 struct task_struct *task = current; 461 siginfo_t info; 462 unsigned short err; 463 char *str = (trapnr == 16) ? "fpu exception" : "simd exception"; 464 465 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, SIGFPE) == NOTIFY_STOP) 466 return; 467 conditional_sti(regs); 468 469 if (!user_mode_vm(regs)) 470 { 471 if (!fixup_exception(regs)) { 472 task->thread.error_code = error_code; 473 task->thread.trap_no = trapnr; 474 die(str, regs, error_code); 475 } 476 return; 477 } 478 479 /* 480 * Save the info for the exception handler and clear the error. 481 */ 482 save_init_fpu(task); 483 task->thread.trap_no = trapnr; 484 task->thread.error_code = error_code; 485 info.si_signo = SIGFPE; 486 info.si_errno = 0; 487 info.si_addr = (void __user *)regs->ip; 488 if (trapnr == 16) { 489 unsigned short cwd, swd; 490 /* 491 * (~cwd & swd) will mask out exceptions that are not set to unmasked 492 * status. 0x3f is the exception bits in these regs, 0x200 is the 493 * C1 reg you need in case of a stack fault, 0x040 is the stack 494 * fault bit. We should only be taking one exception at a time, 495 * so if this combination doesn't produce any single exception, 496 * then we have a bad program that isn't synchronizing its FPU usage 497 * and it will suffer the consequences since we won't be able to 498 * fully reproduce the context of the exception 499 */ 500 cwd = get_fpu_cwd(task); 501 swd = get_fpu_swd(task); 502 503 err = swd & ~cwd; 504 } else { 505 /* 506 * The SIMD FPU exceptions are handled a little differently, as there 507 * is only a single status/control register. Thus, to determine which 508 * unmasked exception was caught we must mask the exception mask bits 509 * at 0x1f80, and then use these to mask the exception bits at 0x3f. 510 */ 511 unsigned short mxcsr = get_fpu_mxcsr(task); 512 err = ~(mxcsr >> 7) & mxcsr; 513 } 514 515 if (err & 0x001) { /* Invalid op */ 516 /* 517 * swd & 0x240 == 0x040: Stack Underflow 518 * swd & 0x240 == 0x240: Stack Overflow 519 * User must clear the SF bit (0x40) if set 520 */ 521 info.si_code = FPE_FLTINV; 522 } else if (err & 0x004) { /* Divide by Zero */ 523 info.si_code = FPE_FLTDIV; 524 } else if (err & 0x008) { /* Overflow */ 525 info.si_code = FPE_FLTOVF; 526 } else if (err & 0x012) { /* Denormal, Underflow */ 527 info.si_code = FPE_FLTUND; 528 } else if (err & 0x020) { /* Precision */ 529 info.si_code = FPE_FLTRES; 530 } else { 531 /* 532 * If we're using IRQ 13, or supposedly even some trap 16 533 * implementations, it's possible we get a spurious trap... 534 */ 535 return; /* Spurious trap, no error */ 536 } 537 force_sig_info(SIGFPE, &info, task); 538 } 539 540 dotraplinkage void do_coprocessor_error(struct pt_regs *regs, long error_code) 541 { 542 #ifdef CONFIG_X86_32 543 ignore_fpu_irq = 1; 544 #endif 545 546 math_error(regs, error_code, 16); 547 } 548 549 dotraplinkage void 550 do_simd_coprocessor_error(struct pt_regs *regs, long error_code) 551 { 552 math_error(regs, error_code, 19); 553 } 554 555 dotraplinkage void 556 do_spurious_interrupt_bug(struct pt_regs *regs, long error_code) 557 { 558 conditional_sti(regs); 559 #if 0 560 /* No need to warn about this any longer. */ 561 printk(KERN_INFO "Ignoring P6 Local APIC Spurious Interrupt Bug...\n"); 562 #endif 563 } 564 565 asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void) 566 { 567 } 568 569 asmlinkage void __attribute__((weak)) smp_threshold_interrupt(void) 570 { 571 } 572 573 /* 574 * __math_state_restore assumes that cr0.TS is already clear and the 575 * fpu state is all ready for use. Used during context switch. 576 */ 577 void __math_state_restore(void) 578 { 579 struct thread_info *thread = current_thread_info(); 580 struct task_struct *tsk = thread->task; 581 582 /* 583 * Paranoid restore. send a SIGSEGV if we fail to restore the state. 584 */ 585 if (unlikely(restore_fpu_checking(tsk))) { 586 stts(); 587 force_sig(SIGSEGV, tsk); 588 return; 589 } 590 591 thread->status |= TS_USEDFPU; /* So we fnsave on switch_to() */ 592 tsk->fpu_counter++; 593 } 594 595 /* 596 * 'math_state_restore()' saves the current math information in the 597 * old math state array, and gets the new ones from the current task 598 * 599 * Careful.. There are problems with IBM-designed IRQ13 behaviour. 600 * Don't touch unless you *really* know how it works. 601 * 602 * Must be called with kernel preemption disabled (in this case, 603 * local interrupts are disabled at the call-site in entry.S). 604 */ 605 asmlinkage void math_state_restore(void) 606 { 607 struct thread_info *thread = current_thread_info(); 608 struct task_struct *tsk = thread->task; 609 610 if (!tsk_used_math(tsk)) { 611 local_irq_enable(); 612 /* 613 * does a slab alloc which can sleep 614 */ 615 if (init_fpu(tsk)) { 616 /* 617 * ran out of memory! 618 */ 619 do_group_exit(SIGKILL); 620 return; 621 } 622 local_irq_disable(); 623 } 624 625 clts(); /* Allow maths ops (or we recurse) */ 626 627 __math_state_restore(); 628 } 629 EXPORT_SYMBOL_GPL(math_state_restore); 630 631 dotraplinkage void __kprobes 632 do_device_not_available(struct pt_regs *regs, long error_code) 633 { 634 #ifdef CONFIG_MATH_EMULATION 635 if (read_cr0() & X86_CR0_EM) { 636 struct math_emu_info info = { }; 637 638 conditional_sti(regs); 639 640 info.regs = regs; 641 math_emulate(&info); 642 return; 643 } 644 #endif 645 math_state_restore(); /* interrupts still off */ 646 #ifdef CONFIG_X86_32 647 conditional_sti(regs); 648 #endif 649 } 650 651 #ifdef CONFIG_X86_32 652 dotraplinkage void do_iret_error(struct pt_regs *regs, long error_code) 653 { 654 siginfo_t info; 655 local_irq_enable(); 656 657 info.si_signo = SIGILL; 658 info.si_errno = 0; 659 info.si_code = ILL_BADSTK; 660 info.si_addr = NULL; 661 if (notify_die(DIE_TRAP, "iret exception", 662 regs, error_code, 32, SIGILL) == NOTIFY_STOP) 663 return; 664 do_trap(32, SIGILL, "iret exception", regs, error_code, &info); 665 } 666 #endif 667 668 /* Set of traps needed for early debugging. */ 669 void __init early_trap_init(void) 670 { 671 set_intr_gate_ist(1, &debug, DEBUG_STACK); 672 /* int3 can be called from all */ 673 set_system_intr_gate_ist(3, &int3, DEBUG_STACK); 674 set_intr_gate(14, &page_fault); 675 load_idt(&idt_descr); 676 } 677 678 void __init trap_init(void) 679 { 680 int i; 681 682 #ifdef CONFIG_EISA 683 void __iomem *p = early_ioremap(0x0FFFD9, 4); 684 685 if (readl(p) == 'E' + ('I'<<8) + ('S'<<16) + ('A'<<24)) 686 EISA_bus = 1; 687 early_iounmap(p, 4); 688 #endif 689 690 set_intr_gate(0, ÷_error); 691 set_intr_gate_ist(2, &nmi, NMI_STACK); 692 /* int4 can be called from all */ 693 set_system_intr_gate(4, &overflow); 694 set_intr_gate(5, &bounds); 695 set_intr_gate(6, &invalid_op); 696 set_intr_gate(7, &device_not_available); 697 #ifdef CONFIG_X86_32 698 set_task_gate(8, GDT_ENTRY_DOUBLEFAULT_TSS); 699 #else 700 set_intr_gate_ist(8, &double_fault, DOUBLEFAULT_STACK); 701 #endif 702 set_intr_gate(9, &coprocessor_segment_overrun); 703 set_intr_gate(10, &invalid_TSS); 704 set_intr_gate(11, &segment_not_present); 705 set_intr_gate_ist(12, &stack_segment, STACKFAULT_STACK); 706 set_intr_gate(13, &general_protection); 707 set_intr_gate(15, &spurious_interrupt_bug); 708 set_intr_gate(16, &coprocessor_error); 709 set_intr_gate(17, &alignment_check); 710 #ifdef CONFIG_X86_MCE 711 set_intr_gate_ist(18, &machine_check, MCE_STACK); 712 #endif 713 set_intr_gate(19, &simd_coprocessor_error); 714 715 /* Reserve all the builtin and the syscall vector: */ 716 for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++) 717 set_bit(i, used_vectors); 718 719 #ifdef CONFIG_IA32_EMULATION 720 set_system_intr_gate(IA32_SYSCALL_VECTOR, ia32_syscall); 721 set_bit(IA32_SYSCALL_VECTOR, used_vectors); 722 #endif 723 724 #ifdef CONFIG_X86_32 725 set_system_trap_gate(SYSCALL_VECTOR, &system_call); 726 set_bit(SYSCALL_VECTOR, used_vectors); 727 #endif 728 729 /* 730 * Should be a barrier for any external CPU state: 731 */ 732 cpu_init(); 733 734 x86_init.irqs.trap_init(); 735 736 #ifdef CONFIG_X86_64 737 memcpy(&nmi_idt_table, &idt_table, IDT_ENTRIES * 16); 738 set_nmi_gate(1, &debug); 739 set_nmi_gate(3, &int3); 740 #endif 741 } 742