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 preempt_conditional_sti(regs); 315 do_trap(3, SIGTRAP, "int3", regs, error_code, NULL); 316 preempt_conditional_cli(regs); 317 } 318 319 #ifdef CONFIG_X86_64 320 /* 321 * Help handler running on IST stack to switch back to user stack 322 * for scheduling or signal handling. The actual stack switch is done in 323 * entry.S 324 */ 325 asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs) 326 { 327 struct pt_regs *regs = eregs; 328 /* Did already sync */ 329 if (eregs == (struct pt_regs *)eregs->sp) 330 ; 331 /* Exception from user space */ 332 else if (user_mode(eregs)) 333 regs = task_pt_regs(current); 334 /* 335 * Exception from kernel and interrupts are enabled. Move to 336 * kernel process stack. 337 */ 338 else if (eregs->flags & X86_EFLAGS_IF) 339 regs = (struct pt_regs *)(eregs->sp -= sizeof(struct pt_regs)); 340 if (eregs != regs) 341 *regs = *eregs; 342 return regs; 343 } 344 #endif 345 346 /* 347 * Our handling of the processor debug registers is non-trivial. 348 * We do not clear them on entry and exit from the kernel. Therefore 349 * it is possible to get a watchpoint trap here from inside the kernel. 350 * However, the code in ./ptrace.c has ensured that the user can 351 * only set watchpoints on userspace addresses. Therefore the in-kernel 352 * watchpoint trap can only occur in code which is reading/writing 353 * from user space. Such code must not hold kernel locks (since it 354 * can equally take a page fault), therefore it is safe to call 355 * force_sig_info even though that claims and releases locks. 356 * 357 * Code in ./signal.c ensures that the debug control register 358 * is restored before we deliver any signal, and therefore that 359 * user code runs with the correct debug control register even though 360 * we clear it here. 361 * 362 * Being careful here means that we don't have to be as careful in a 363 * lot of more complicated places (task switching can be a bit lazy 364 * about restoring all the debug state, and ptrace doesn't have to 365 * find every occurrence of the TF bit that could be saved away even 366 * by user code) 367 * 368 * May run on IST stack. 369 */ 370 dotraplinkage void __kprobes do_debug(struct pt_regs *regs, long error_code) 371 { 372 struct task_struct *tsk = current; 373 int user_icebp = 0; 374 unsigned long dr6; 375 int si_code; 376 377 get_debugreg(dr6, 6); 378 379 /* Filter out all the reserved bits which are preset to 1 */ 380 dr6 &= ~DR6_RESERVED; 381 382 /* 383 * If dr6 has no reason to give us about the origin of this trap, 384 * then it's very likely the result of an icebp/int01 trap. 385 * User wants a sigtrap for that. 386 */ 387 if (!dr6 && user_mode(regs)) 388 user_icebp = 1; 389 390 /* Catch kmemcheck conditions first of all! */ 391 if ((dr6 & DR_STEP) && kmemcheck_trap(regs)) 392 return; 393 394 /* DR6 may or may not be cleared by the CPU */ 395 set_debugreg(0, 6); 396 397 /* 398 * The processor cleared BTF, so don't mark that we need it set. 399 */ 400 clear_tsk_thread_flag(tsk, TIF_BLOCKSTEP); 401 402 /* Store the virtualized DR6 value */ 403 tsk->thread.debugreg6 = dr6; 404 405 if (notify_die(DIE_DEBUG, "debug", regs, PTR_ERR(&dr6), error_code, 406 SIGTRAP) == NOTIFY_STOP) 407 return; 408 409 /* It's safe to allow irq's after DR6 has been saved */ 410 preempt_conditional_sti(regs); 411 412 if (regs->flags & X86_VM_MASK) { 413 handle_vm86_trap((struct kernel_vm86_regs *) regs, 414 error_code, 1); 415 preempt_conditional_cli(regs); 416 return; 417 } 418 419 /* 420 * Single-stepping through system calls: ignore any exceptions in 421 * kernel space, but re-enable TF when returning to user mode. 422 * 423 * We already checked v86 mode above, so we can check for kernel mode 424 * by just checking the CPL of CS. 425 */ 426 if ((dr6 & DR_STEP) && !user_mode(regs)) { 427 tsk->thread.debugreg6 &= ~DR_STEP; 428 set_tsk_thread_flag(tsk, TIF_SINGLESTEP); 429 regs->flags &= ~X86_EFLAGS_TF; 430 } 431 si_code = get_si_code(tsk->thread.debugreg6); 432 if (tsk->thread.debugreg6 & (DR_STEP | DR_TRAP_BITS) || user_icebp) 433 send_sigtrap(tsk, regs, error_code, si_code); 434 preempt_conditional_cli(regs); 435 436 return; 437 } 438 439 /* 440 * Note that we play around with the 'TS' bit in an attempt to get 441 * the correct behaviour even in the presence of the asynchronous 442 * IRQ13 behaviour 443 */ 444 void math_error(struct pt_regs *regs, int error_code, int trapnr) 445 { 446 struct task_struct *task = current; 447 siginfo_t info; 448 unsigned short err; 449 char *str = (trapnr == 16) ? "fpu exception" : "simd exception"; 450 451 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, SIGFPE) == NOTIFY_STOP) 452 return; 453 conditional_sti(regs); 454 455 if (!user_mode_vm(regs)) 456 { 457 if (!fixup_exception(regs)) { 458 task->thread.error_code = error_code; 459 task->thread.trap_no = trapnr; 460 die(str, regs, error_code); 461 } 462 return; 463 } 464 465 /* 466 * Save the info for the exception handler and clear the error. 467 */ 468 save_init_fpu(task); 469 task->thread.trap_no = trapnr; 470 task->thread.error_code = error_code; 471 info.si_signo = SIGFPE; 472 info.si_errno = 0; 473 info.si_addr = (void __user *)regs->ip; 474 if (trapnr == 16) { 475 unsigned short cwd, swd; 476 /* 477 * (~cwd & swd) will mask out exceptions that are not set to unmasked 478 * status. 0x3f is the exception bits in these regs, 0x200 is the 479 * C1 reg you need in case of a stack fault, 0x040 is the stack 480 * fault bit. We should only be taking one exception at a time, 481 * so if this combination doesn't produce any single exception, 482 * then we have a bad program that isn't synchronizing its FPU usage 483 * and it will suffer the consequences since we won't be able to 484 * fully reproduce the context of the exception 485 */ 486 cwd = get_fpu_cwd(task); 487 swd = get_fpu_swd(task); 488 489 err = swd & ~cwd; 490 } else { 491 /* 492 * The SIMD FPU exceptions are handled a little differently, as there 493 * is only a single status/control register. Thus, to determine which 494 * unmasked exception was caught we must mask the exception mask bits 495 * at 0x1f80, and then use these to mask the exception bits at 0x3f. 496 */ 497 unsigned short mxcsr = get_fpu_mxcsr(task); 498 err = ~(mxcsr >> 7) & mxcsr; 499 } 500 501 if (err & 0x001) { /* Invalid op */ 502 /* 503 * swd & 0x240 == 0x040: Stack Underflow 504 * swd & 0x240 == 0x240: Stack Overflow 505 * User must clear the SF bit (0x40) if set 506 */ 507 info.si_code = FPE_FLTINV; 508 } else if (err & 0x004) { /* Divide by Zero */ 509 info.si_code = FPE_FLTDIV; 510 } else if (err & 0x008) { /* Overflow */ 511 info.si_code = FPE_FLTOVF; 512 } else if (err & 0x012) { /* Denormal, Underflow */ 513 info.si_code = FPE_FLTUND; 514 } else if (err & 0x020) { /* Precision */ 515 info.si_code = FPE_FLTRES; 516 } else { 517 /* 518 * If we're using IRQ 13, or supposedly even some trap 16 519 * implementations, it's possible we get a spurious trap... 520 */ 521 return; /* Spurious trap, no error */ 522 } 523 force_sig_info(SIGFPE, &info, task); 524 } 525 526 dotraplinkage void do_coprocessor_error(struct pt_regs *regs, long error_code) 527 { 528 #ifdef CONFIG_X86_32 529 ignore_fpu_irq = 1; 530 #endif 531 532 math_error(regs, error_code, 16); 533 } 534 535 dotraplinkage void 536 do_simd_coprocessor_error(struct pt_regs *regs, long error_code) 537 { 538 math_error(regs, error_code, 19); 539 } 540 541 dotraplinkage void 542 do_spurious_interrupt_bug(struct pt_regs *regs, long error_code) 543 { 544 conditional_sti(regs); 545 #if 0 546 /* No need to warn about this any longer. */ 547 printk(KERN_INFO "Ignoring P6 Local APIC Spurious Interrupt Bug...\n"); 548 #endif 549 } 550 551 asmlinkage void __attribute__((weak)) smp_thermal_interrupt(void) 552 { 553 } 554 555 asmlinkage void __attribute__((weak)) smp_threshold_interrupt(void) 556 { 557 } 558 559 /* 560 * __math_state_restore assumes that cr0.TS is already clear and the 561 * fpu state is all ready for use. Used during context switch. 562 */ 563 void __math_state_restore(void) 564 { 565 struct thread_info *thread = current_thread_info(); 566 struct task_struct *tsk = thread->task; 567 568 /* 569 * Paranoid restore. send a SIGSEGV if we fail to restore the state. 570 */ 571 if (unlikely(restore_fpu_checking(tsk))) { 572 stts(); 573 force_sig(SIGSEGV, tsk); 574 return; 575 } 576 577 thread->status |= TS_USEDFPU; /* So we fnsave on switch_to() */ 578 tsk->fpu_counter++; 579 } 580 581 /* 582 * 'math_state_restore()' saves the current math information in the 583 * old math state array, and gets the new ones from the current task 584 * 585 * Careful.. There are problems with IBM-designed IRQ13 behaviour. 586 * Don't touch unless you *really* know how it works. 587 * 588 * Must be called with kernel preemption disabled (in this case, 589 * local interrupts are disabled at the call-site in entry.S). 590 */ 591 asmlinkage void math_state_restore(void) 592 { 593 struct thread_info *thread = current_thread_info(); 594 struct task_struct *tsk = thread->task; 595 596 if (!tsk_used_math(tsk)) { 597 local_irq_enable(); 598 /* 599 * does a slab alloc which can sleep 600 */ 601 if (init_fpu(tsk)) { 602 /* 603 * ran out of memory! 604 */ 605 do_group_exit(SIGKILL); 606 return; 607 } 608 local_irq_disable(); 609 } 610 611 clts(); /* Allow maths ops (or we recurse) */ 612 613 __math_state_restore(); 614 } 615 EXPORT_SYMBOL_GPL(math_state_restore); 616 617 dotraplinkage void __kprobes 618 do_device_not_available(struct pt_regs *regs, long error_code) 619 { 620 #ifdef CONFIG_MATH_EMULATION 621 if (read_cr0() & X86_CR0_EM) { 622 struct math_emu_info info = { }; 623 624 conditional_sti(regs); 625 626 info.regs = regs; 627 math_emulate(&info); 628 return; 629 } 630 #endif 631 math_state_restore(); /* interrupts still off */ 632 #ifdef CONFIG_X86_32 633 conditional_sti(regs); 634 #endif 635 } 636 637 #ifdef CONFIG_X86_32 638 dotraplinkage void do_iret_error(struct pt_regs *regs, long error_code) 639 { 640 siginfo_t info; 641 local_irq_enable(); 642 643 info.si_signo = SIGILL; 644 info.si_errno = 0; 645 info.si_code = ILL_BADSTK; 646 info.si_addr = NULL; 647 if (notify_die(DIE_TRAP, "iret exception", 648 regs, error_code, 32, SIGILL) == NOTIFY_STOP) 649 return; 650 do_trap(32, SIGILL, "iret exception", regs, error_code, &info); 651 } 652 #endif 653 654 /* Set of traps needed for early debugging. */ 655 void __init early_trap_init(void) 656 { 657 set_intr_gate_ist(1, &debug, DEBUG_STACK); 658 /* int3 can be called from all */ 659 set_system_intr_gate_ist(3, &int3, DEBUG_STACK); 660 set_intr_gate(14, &page_fault); 661 load_idt(&idt_descr); 662 } 663 664 void __init trap_init(void) 665 { 666 int i; 667 668 #ifdef CONFIG_EISA 669 void __iomem *p = early_ioremap(0x0FFFD9, 4); 670 671 if (readl(p) == 'E' + ('I'<<8) + ('S'<<16) + ('A'<<24)) 672 EISA_bus = 1; 673 early_iounmap(p, 4); 674 #endif 675 676 set_intr_gate(0, ÷_error); 677 set_intr_gate_ist(2, &nmi, NMI_STACK); 678 /* int4 can be called from all */ 679 set_system_intr_gate(4, &overflow); 680 set_intr_gate(5, &bounds); 681 set_intr_gate(6, &invalid_op); 682 set_intr_gate(7, &device_not_available); 683 #ifdef CONFIG_X86_32 684 set_task_gate(8, GDT_ENTRY_DOUBLEFAULT_TSS); 685 #else 686 set_intr_gate_ist(8, &double_fault, DOUBLEFAULT_STACK); 687 #endif 688 set_intr_gate(9, &coprocessor_segment_overrun); 689 set_intr_gate(10, &invalid_TSS); 690 set_intr_gate(11, &segment_not_present); 691 set_intr_gate_ist(12, &stack_segment, STACKFAULT_STACK); 692 set_intr_gate(13, &general_protection); 693 set_intr_gate(15, &spurious_interrupt_bug); 694 set_intr_gate(16, &coprocessor_error); 695 set_intr_gate(17, &alignment_check); 696 #ifdef CONFIG_X86_MCE 697 set_intr_gate_ist(18, &machine_check, MCE_STACK); 698 #endif 699 set_intr_gate(19, &simd_coprocessor_error); 700 701 /* Reserve all the builtin and the syscall vector: */ 702 for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++) 703 set_bit(i, used_vectors); 704 705 #ifdef CONFIG_IA32_EMULATION 706 set_system_intr_gate(IA32_SYSCALL_VECTOR, ia32_syscall); 707 set_bit(IA32_SYSCALL_VECTOR, used_vectors); 708 #endif 709 710 #ifdef CONFIG_X86_32 711 set_system_trap_gate(SYSCALL_VECTOR, &system_call); 712 set_bit(SYSCALL_VECTOR, used_vectors); 713 #endif 714 715 /* 716 * Should be a barrier for any external CPU state: 717 */ 718 cpu_init(); 719 720 x86_init.irqs.trap_init(); 721 } 722