1
2
3
4
5
6
7
8
9
10
11
12
13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15#include <linux/context_tracking.h>
16#include <linux/interrupt.h>
17#include <linux/kallsyms.h>
18#include <linux/spinlock.h>
19#include <linux/kprobes.h>
20#include <linux/uaccess.h>
21#include <linux/kdebug.h>
22#include <linux/kgdb.h>
23#include <linux/kernel.h>
24#include <linux/module.h>
25#include <linux/ptrace.h>
26#include <linux/uprobes.h>
27#include <linux/string.h>
28#include <linux/delay.h>
29#include <linux/errno.h>
30#include <linux/kexec.h>
31#include <linux/sched.h>
32#include <linux/timer.h>
33#include <linux/init.h>
34#include <linux/bug.h>
35#include <linux/nmi.h>
36#include <linux/mm.h>
37#include <linux/smp.h>
38#include <linux/io.h>
39
40#ifdef CONFIG_EISA
41#include <linux/ioport.h>
42#include <linux/eisa.h>
43#endif
44
45#if defined(CONFIG_EDAC)
46#include <linux/edac.h>
47#endif
48
49#include <asm/kmemcheck.h>
50#include <asm/stacktrace.h>
51#include <asm/processor.h>
52#include <asm/debugreg.h>
53#include <linux/atomic.h>
54#include <asm/ftrace.h>
55#include <asm/traps.h>
56#include <asm/desc.h>
57#include <asm/fpu/internal.h>
58#include <asm/mce.h>
59#include <asm/fixmap.h>
60#include <asm/mach_traps.h>
61#include <asm/alternative.h>
62#include <asm/fpu/xstate.h>
63#include <asm/trace/mpx.h>
64#include <asm/mpx.h>
65#include <asm/vm86.h>
66
67#ifdef CONFIG_X86_64
68#include <asm/x86_init.h>
69#include <asm/pgalloc.h>
70#include <asm/proto.h>
71
72
73gate_desc debug_idt_table[NR_VECTORS] __page_aligned_bss;
74#else
75#include <asm/processor-flags.h>
76#include <asm/setup.h>
77#include <asm/proto.h>
78#endif
79
80
81gate_desc idt_table[NR_VECTORS] __page_aligned_bss;
82
83DECLARE_BITMAP(used_vectors, NR_VECTORS);
84EXPORT_SYMBOL_GPL(used_vectors);
85
86static inline void conditional_sti(struct pt_regs *regs)
87{
88 if (regs->flags & X86_EFLAGS_IF)
89 local_irq_enable();
90}
91
92static inline void preempt_conditional_sti(struct pt_regs *regs)
93{
94 preempt_count_inc();
95 if (regs->flags & X86_EFLAGS_IF)
96 local_irq_enable();
97}
98
99static inline void conditional_cli(struct pt_regs *regs)
100{
101 if (regs->flags & X86_EFLAGS_IF)
102 local_irq_disable();
103}
104
105static inline void preempt_conditional_cli(struct pt_regs *regs)
106{
107 if (regs->flags & X86_EFLAGS_IF)
108 local_irq_disable();
109 preempt_count_dec();
110}
111
112void ist_enter(struct pt_regs *regs)
113{
114 if (user_mode(regs)) {
115 RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
116 } else {
117
118
119
120
121
122
123 rcu_nmi_enter();
124 }
125
126
127
128
129
130
131
132 preempt_count_add(HARDIRQ_OFFSET);
133
134
135 RCU_LOCKDEP_WARN(!rcu_is_watching(), "ist_enter didn't work");
136}
137
138void ist_exit(struct pt_regs *regs)
139{
140 preempt_count_sub(HARDIRQ_OFFSET);
141
142 if (!user_mode(regs))
143 rcu_nmi_exit();
144}
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159void ist_begin_non_atomic(struct pt_regs *regs)
160{
161 BUG_ON(!user_mode(regs));
162
163
164
165
166
167
168 BUG_ON((unsigned long)(current_top_of_stack() -
169 current_stack_pointer()) >= THREAD_SIZE);
170
171 preempt_count_sub(HARDIRQ_OFFSET);
172}
173
174
175
176
177
178
179void ist_end_non_atomic(void)
180{
181 preempt_count_add(HARDIRQ_OFFSET);
182}
183
184static nokprobe_inline int
185do_trap_no_signal(struct task_struct *tsk, int trapnr, char *str,
186 struct pt_regs *regs, long error_code)
187{
188 if (v8086_mode(regs)) {
189
190
191
192
193 if (trapnr < X86_TRAP_UD) {
194 if (!handle_vm86_trap((struct kernel_vm86_regs *) regs,
195 error_code, trapnr))
196 return 0;
197 }
198 return -1;
199 }
200
201 if (!user_mode(regs)) {
202 if (!fixup_exception(regs)) {
203 tsk->thread.error_code = error_code;
204 tsk->thread.trap_nr = trapnr;
205 die(str, regs, error_code);
206 }
207 return 0;
208 }
209
210 return -1;
211}
212
213static siginfo_t *fill_trap_info(struct pt_regs *regs, int signr, int trapnr,
214 siginfo_t *info)
215{
216 unsigned long siaddr;
217 int sicode;
218
219 switch (trapnr) {
220 default:
221 return SEND_SIG_PRIV;
222
223 case X86_TRAP_DE:
224 sicode = FPE_INTDIV;
225 siaddr = uprobe_get_trap_addr(regs);
226 break;
227 case X86_TRAP_UD:
228 sicode = ILL_ILLOPN;
229 siaddr = uprobe_get_trap_addr(regs);
230 break;
231 case X86_TRAP_AC:
232 sicode = BUS_ADRALN;
233 siaddr = 0;
234 break;
235 }
236
237 info->si_signo = signr;
238 info->si_errno = 0;
239 info->si_code = sicode;
240 info->si_addr = (void __user *)siaddr;
241 return info;
242}
243
244static void
245do_trap(int trapnr, int signr, char *str, struct pt_regs *regs,
246 long error_code, siginfo_t *info)
247{
248 struct task_struct *tsk = current;
249
250
251 if (!do_trap_no_signal(tsk, trapnr, str, regs, error_code))
252 return;
253
254
255
256
257
258
259
260
261
262 tsk->thread.error_code = error_code;
263 tsk->thread.trap_nr = trapnr;
264
265#ifdef CONFIG_X86_64
266 if (show_unhandled_signals && unhandled_signal(tsk, signr) &&
267 printk_ratelimit()) {
268 pr_info("%s[%d] trap %s ip:%lx sp:%lx error:%lx",
269 tsk->comm, tsk->pid, str,
270 regs->ip, regs->sp, error_code);
271 print_vma_addr(" in ", regs->ip);
272 pr_cont("\n");
273 }
274#endif
275
276 force_sig_info(signr, info ?: SEND_SIG_PRIV, tsk);
277}
278NOKPROBE_SYMBOL(do_trap);
279
280static void do_error_trap(struct pt_regs *regs, long error_code, char *str,
281 unsigned long trapnr, int signr)
282{
283 siginfo_t info;
284
285 RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
286
287 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, signr) !=
288 NOTIFY_STOP) {
289 conditional_sti(regs);
290 do_trap(trapnr, signr, str, regs, error_code,
291 fill_trap_info(regs, signr, trapnr, &info));
292 }
293}
294
295#define DO_ERROR(trapnr, signr, str, name) \
296dotraplinkage void do_##name(struct pt_regs *regs, long error_code) \
297{ \
298 do_error_trap(regs, error_code, str, trapnr, signr); \
299}
300
301DO_ERROR(X86_TRAP_DE, SIGFPE, "divide error", divide_error)
302DO_ERROR(X86_TRAP_OF, SIGSEGV, "overflow", overflow)
303DO_ERROR(X86_TRAP_UD, SIGILL, "invalid opcode", invalid_op)
304DO_ERROR(X86_TRAP_OLD_MF, SIGFPE, "coprocessor segment overrun",coprocessor_segment_overrun)
305DO_ERROR(X86_TRAP_TS, SIGSEGV, "invalid TSS", invalid_TSS)
306DO_ERROR(X86_TRAP_NP, SIGBUS, "segment not present", segment_not_present)
307DO_ERROR(X86_TRAP_SS, SIGBUS, "stack segment", stack_segment)
308DO_ERROR(X86_TRAP_AC, SIGBUS, "alignment check", alignment_check)
309
310#ifdef CONFIG_X86_64
311
312dotraplinkage void do_double_fault(struct pt_regs *regs, long error_code)
313{
314 static const char str[] = "double fault";
315 struct task_struct *tsk = current;
316
317#ifdef CONFIG_X86_ESPFIX64
318 extern unsigned char native_irq_return_iret[];
319
320
321
322
323
324
325
326
327
328 if (((long)regs->sp >> PGDIR_SHIFT) == ESPFIX_PGD_ENTRY &&
329 regs->cs == __KERNEL_CS &&
330 regs->ip == (unsigned long)native_irq_return_iret)
331 {
332 struct pt_regs *normal_regs = task_pt_regs(current);
333
334
335 memmove(&normal_regs->ip, (void *)regs->sp, 5*8);
336 normal_regs->orig_ax = 0;
337 regs->ip = (unsigned long)general_protection;
338 regs->sp = (unsigned long)&normal_regs->orig_ax;
339
340 return;
341 }
342#endif
343
344 ist_enter(regs);
345 notify_die(DIE_TRAP, str, regs, error_code, X86_TRAP_DF, SIGSEGV);
346
347 tsk->thread.error_code = error_code;
348 tsk->thread.trap_nr = X86_TRAP_DF;
349
350#ifdef CONFIG_DOUBLEFAULT
351 df_debug(regs, error_code);
352#endif
353
354
355
356
357 for (;;)
358 die(str, regs, error_code);
359}
360#endif
361
362dotraplinkage void do_bounds(struct pt_regs *regs, long error_code)
363{
364 const struct bndcsr *bndcsr;
365 siginfo_t *info;
366
367 RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
368 if (notify_die(DIE_TRAP, "bounds", regs, error_code,
369 X86_TRAP_BR, SIGSEGV) == NOTIFY_STOP)
370 return;
371 conditional_sti(regs);
372
373 if (!user_mode(regs))
374 die("bounds", regs, error_code);
375
376 if (!cpu_feature_enabled(X86_FEATURE_MPX)) {
377
378 goto exit_trap;
379 }
380
381
382
383
384
385
386
387 bndcsr = get_xsave_field_ptr(XSTATE_BNDCSR);
388 if (!bndcsr)
389 goto exit_trap;
390
391 trace_bounds_exception_mpx(bndcsr);
392
393
394
395
396
397 switch (bndcsr->bndstatus & MPX_BNDSTA_ERROR_CODE) {
398 case 2:
399 if (mpx_handle_bd_fault())
400 goto exit_trap;
401 break;
402 case 1:
403 info = mpx_generate_siginfo(regs);
404 if (IS_ERR(info)) {
405
406
407
408
409 goto exit_trap;
410 }
411
412
413
414
415
416
417
418 do_trap(X86_TRAP_BR, SIGSEGV, "bounds", regs, error_code, info);
419 kfree(info);
420 break;
421 case 0:
422 goto exit_trap;
423 default:
424 die("bounds", regs, error_code);
425 }
426
427 return;
428
429exit_trap:
430
431
432
433
434
435
436
437 do_trap(X86_TRAP_BR, SIGSEGV, "bounds", regs, error_code, NULL);
438}
439
440dotraplinkage void
441do_general_protection(struct pt_regs *regs, long error_code)
442{
443 struct task_struct *tsk;
444
445 RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
446 conditional_sti(regs);
447
448 if (v8086_mode(regs)) {
449 local_irq_enable();
450 handle_vm86_fault((struct kernel_vm86_regs *) regs, error_code);
451 return;
452 }
453
454 tsk = current;
455 if (!user_mode(regs)) {
456 if (fixup_exception(regs))
457 return;
458
459 tsk->thread.error_code = error_code;
460 tsk->thread.trap_nr = X86_TRAP_GP;
461 if (notify_die(DIE_GPF, "general protection fault", regs, error_code,
462 X86_TRAP_GP, SIGSEGV) != NOTIFY_STOP)
463 die("general protection fault", regs, error_code);
464 return;
465 }
466
467 tsk->thread.error_code = error_code;
468 tsk->thread.trap_nr = X86_TRAP_GP;
469
470 if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) &&
471 printk_ratelimit()) {
472 pr_info("%s[%d] general protection ip:%lx sp:%lx error:%lx",
473 tsk->comm, task_pid_nr(tsk),
474 regs->ip, regs->sp, error_code);
475 print_vma_addr(" in ", regs->ip);
476 pr_cont("\n");
477 }
478
479 force_sig_info(SIGSEGV, SEND_SIG_PRIV, tsk);
480}
481NOKPROBE_SYMBOL(do_general_protection);
482
483
484dotraplinkage void notrace do_int3(struct pt_regs *regs, long error_code)
485{
486#ifdef CONFIG_DYNAMIC_FTRACE
487
488
489
490
491 if (unlikely(atomic_read(&modifying_ftrace_code)) &&
492 ftrace_int3_handler(regs))
493 return;
494#endif
495 if (poke_int3_handler(regs))
496 return;
497
498 ist_enter(regs);
499 RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
500#ifdef CONFIG_KGDB_LOW_LEVEL_TRAP
501 if (kgdb_ll_trap(DIE_INT3, "int3", regs, error_code, X86_TRAP_BP,
502 SIGTRAP) == NOTIFY_STOP)
503 goto exit;
504#endif
505
506#ifdef CONFIG_KPROBES
507 if (kprobe_int3_handler(regs))
508 goto exit;
509#endif
510
511 if (notify_die(DIE_INT3, "int3", regs, error_code, X86_TRAP_BP,
512 SIGTRAP) == NOTIFY_STOP)
513 goto exit;
514
515
516
517
518
519 debug_stack_usage_inc();
520 preempt_conditional_sti(regs);
521 do_trap(X86_TRAP_BP, SIGTRAP, "int3", regs, error_code, NULL);
522 preempt_conditional_cli(regs);
523 debug_stack_usage_dec();
524exit:
525 ist_exit(regs);
526}
527NOKPROBE_SYMBOL(do_int3);
528
529#ifdef CONFIG_X86_64
530
531
532
533
534
535asmlinkage __visible notrace struct pt_regs *sync_regs(struct pt_regs *eregs)
536{
537 struct pt_regs *regs = task_pt_regs(current);
538 *regs = *eregs;
539 return regs;
540}
541NOKPROBE_SYMBOL(sync_regs);
542
543struct bad_iret_stack {
544 void *error_entry_ret;
545 struct pt_regs regs;
546};
547
548asmlinkage __visible notrace
549struct bad_iret_stack *fixup_bad_iret(struct bad_iret_stack *s)
550{
551
552
553
554
555
556
557
558 struct bad_iret_stack *new_stack =
559 container_of(task_pt_regs(current),
560 struct bad_iret_stack, regs);
561
562
563 memmove(&new_stack->regs.ip, (void *)s->regs.sp, 5*8);
564
565
566 memmove(new_stack, s, offsetof(struct bad_iret_stack, regs.ip));
567
568 BUG_ON(!user_mode(&new_stack->regs));
569 return new_stack;
570}
571NOKPROBE_SYMBOL(fixup_bad_iret);
572#endif
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598dotraplinkage void do_debug(struct pt_regs *regs, long error_code)
599{
600 struct task_struct *tsk = current;
601 int user_icebp = 0;
602 unsigned long dr6;
603 int si_code;
604
605 ist_enter(regs);
606
607 get_debugreg(dr6, 6);
608
609
610 dr6 &= ~DR6_RESERVED;
611
612
613
614
615
616
617 if (!dr6 && user_mode(regs))
618 user_icebp = 1;
619
620
621 if ((dr6 & DR_STEP) && kmemcheck_trap(regs))
622 goto exit;
623
624
625 set_debugreg(0, 6);
626
627
628
629
630 clear_tsk_thread_flag(tsk, TIF_BLOCKSTEP);
631
632
633 tsk->thread.debugreg6 = dr6;
634
635#ifdef CONFIG_KPROBES
636 if (kprobe_debug_handler(regs))
637 goto exit;
638#endif
639
640 if (notify_die(DIE_DEBUG, "debug", regs, (long)&dr6, error_code,
641 SIGTRAP) == NOTIFY_STOP)
642 goto exit;
643
644
645
646
647
648 debug_stack_usage_inc();
649
650
651 preempt_conditional_sti(regs);
652
653 if (v8086_mode(regs)) {
654 handle_vm86_trap((struct kernel_vm86_regs *) regs, error_code,
655 X86_TRAP_DB);
656 preempt_conditional_cli(regs);
657 debug_stack_usage_dec();
658 goto exit;
659 }
660
661
662
663
664
665
666
667
668 if ((dr6 & DR_STEP) && !user_mode(regs)) {
669 tsk->thread.debugreg6 &= ~DR_STEP;
670 set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
671 regs->flags &= ~X86_EFLAGS_TF;
672 }
673 si_code = get_si_code(tsk->thread.debugreg6);
674 if (tsk->thread.debugreg6 & (DR_STEP | DR_TRAP_BITS) || user_icebp)
675 send_sigtrap(tsk, regs, error_code, si_code);
676 preempt_conditional_cli(regs);
677 debug_stack_usage_dec();
678
679exit:
680 ist_exit(regs);
681}
682NOKPROBE_SYMBOL(do_debug);
683
684
685
686
687
688
689static void math_error(struct pt_regs *regs, int error_code, int trapnr)
690{
691 struct task_struct *task = current;
692 struct fpu *fpu = &task->thread.fpu;
693 siginfo_t info;
694 char *str = (trapnr == X86_TRAP_MF) ? "fpu exception" :
695 "simd exception";
696
697 if (notify_die(DIE_TRAP, str, regs, error_code, trapnr, SIGFPE) == NOTIFY_STOP)
698 return;
699 conditional_sti(regs);
700
701 if (!user_mode(regs)) {
702 if (!fixup_exception(regs)) {
703 task->thread.error_code = error_code;
704 task->thread.trap_nr = trapnr;
705 die(str, regs, error_code);
706 }
707 return;
708 }
709
710
711
712
713 fpu__save(fpu);
714
715 task->thread.trap_nr = trapnr;
716 task->thread.error_code = error_code;
717 info.si_signo = SIGFPE;
718 info.si_errno = 0;
719 info.si_addr = (void __user *)uprobe_get_trap_addr(regs);
720
721 info.si_code = fpu__exception_code(fpu, trapnr);
722
723
724 if (!info.si_code)
725 return;
726
727 force_sig_info(SIGFPE, &info, task);
728}
729
730dotraplinkage void do_coprocessor_error(struct pt_regs *regs, long error_code)
731{
732 RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
733 math_error(regs, error_code, X86_TRAP_MF);
734}
735
736dotraplinkage void
737do_simd_coprocessor_error(struct pt_regs *regs, long error_code)
738{
739 RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
740 math_error(regs, error_code, X86_TRAP_XF);
741}
742
743dotraplinkage void
744do_spurious_interrupt_bug(struct pt_regs *regs, long error_code)
745{
746 conditional_sti(regs);
747}
748
749dotraplinkage void
750do_device_not_available(struct pt_regs *regs, long error_code)
751{
752 RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
753 BUG_ON(use_eager_fpu());
754
755#ifdef CONFIG_MATH_EMULATION
756 if (read_cr0() & X86_CR0_EM) {
757 struct math_emu_info info = { };
758
759 conditional_sti(regs);
760
761 info.regs = regs;
762 math_emulate(&info);
763 return;
764 }
765#endif
766 fpu__restore(¤t->thread.fpu);
767#ifdef CONFIG_X86_32
768 conditional_sti(regs);
769#endif
770}
771NOKPROBE_SYMBOL(do_device_not_available);
772
773#ifdef CONFIG_X86_32
774dotraplinkage void do_iret_error(struct pt_regs *regs, long error_code)
775{
776 siginfo_t info;
777
778 RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
779 local_irq_enable();
780
781 info.si_signo = SIGILL;
782 info.si_errno = 0;
783 info.si_code = ILL_BADSTK;
784 info.si_addr = NULL;
785 if (notify_die(DIE_TRAP, "iret exception", regs, error_code,
786 X86_TRAP_IRET, SIGILL) != NOTIFY_STOP) {
787 do_trap(X86_TRAP_IRET, SIGILL, "iret exception", regs, error_code,
788 &info);
789 }
790}
791#endif
792
793
794void __init early_trap_init(void)
795{
796
797
798
799
800
801
802
803
804
805
806
807
808 set_intr_gate_notrace(X86_TRAP_DB, debug);
809
810 set_system_intr_gate(X86_TRAP_BP, &int3);
811#ifdef CONFIG_X86_32
812 set_intr_gate(X86_TRAP_PF, page_fault);
813#endif
814 load_idt(&idt_descr);
815}
816
817void __init early_trap_pf_init(void)
818{
819#ifdef CONFIG_X86_64
820 set_intr_gate(X86_TRAP_PF, page_fault);
821#endif
822}
823
824void __init trap_init(void)
825{
826 int i;
827
828#ifdef CONFIG_EISA
829 void __iomem *p = early_ioremap(0x0FFFD9, 4);
830
831 if (readl(p) == 'E' + ('I'<<8) + ('S'<<16) + ('A'<<24))
832 EISA_bus = 1;
833 early_iounmap(p, 4);
834#endif
835
836 set_intr_gate(X86_TRAP_DE, divide_error);
837 set_intr_gate_ist(X86_TRAP_NMI, &nmi, NMI_STACK);
838
839 set_system_intr_gate(X86_TRAP_OF, &overflow);
840 set_intr_gate(X86_TRAP_BR, bounds);
841 set_intr_gate(X86_TRAP_UD, invalid_op);
842 set_intr_gate(X86_TRAP_NM, device_not_available);
843#ifdef CONFIG_X86_32
844 set_task_gate(X86_TRAP_DF, GDT_ENTRY_DOUBLEFAULT_TSS);
845#else
846 set_intr_gate_ist(X86_TRAP_DF, &double_fault, DOUBLEFAULT_STACK);
847#endif
848 set_intr_gate(X86_TRAP_OLD_MF, coprocessor_segment_overrun);
849 set_intr_gate(X86_TRAP_TS, invalid_TSS);
850 set_intr_gate(X86_TRAP_NP, segment_not_present);
851 set_intr_gate(X86_TRAP_SS, stack_segment);
852 set_intr_gate(X86_TRAP_GP, general_protection);
853 set_intr_gate(X86_TRAP_SPURIOUS, spurious_interrupt_bug);
854 set_intr_gate(X86_TRAP_MF, coprocessor_error);
855 set_intr_gate(X86_TRAP_AC, alignment_check);
856#ifdef CONFIG_X86_MCE
857 set_intr_gate_ist(X86_TRAP_MC, &machine_check, MCE_STACK);
858#endif
859 set_intr_gate(X86_TRAP_XF, simd_coprocessor_error);
860
861
862 for (i = 0; i < FIRST_EXTERNAL_VECTOR; i++)
863 set_bit(i, used_vectors);
864
865#ifdef CONFIG_IA32_EMULATION
866 set_system_intr_gate(IA32_SYSCALL_VECTOR, entry_INT80_compat);
867 set_bit(IA32_SYSCALL_VECTOR, used_vectors);
868#endif
869
870#ifdef CONFIG_X86_32
871 set_system_trap_gate(IA32_SYSCALL_VECTOR, entry_INT80_32);
872 set_bit(IA32_SYSCALL_VECTOR, used_vectors);
873#endif
874
875
876
877
878
879
880 __set_fixmap(FIX_RO_IDT, __pa_symbol(idt_table), PAGE_KERNEL_RO);
881 idt_descr.address = fix_to_virt(FIX_RO_IDT);
882
883
884
885
886 cpu_init();
887
888
889
890
891
892
893 set_intr_gate_ist(X86_TRAP_DB, &debug, DEBUG_STACK);
894
895 set_system_intr_gate_ist(X86_TRAP_BP, &int3, DEBUG_STACK);
896
897 x86_init.irqs.trap_init();
898
899#ifdef CONFIG_X86_64
900 memcpy(&debug_idt_table, &idt_table, IDT_ENTRIES * 16);
901 set_nmi_gate(X86_TRAP_DB, &debug);
902 set_nmi_gate(X86_TRAP_BP, &int3);
903#endif
904}
905