1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _ASM_X86_IDTENTRY_H 3 #define _ASM_X86_IDTENTRY_H 4 5 /* Interrupts/Exceptions */ 6 #include <asm/trapnr.h> 7 8 #ifndef __ASSEMBLY__ 9 #include <linux/entry-common.h> 10 #include <linux/hardirq.h> 11 12 #include <asm/irq_stack.h> 13 14 /** 15 * DECLARE_IDTENTRY - Declare functions for simple IDT entry points 16 * No error code pushed by hardware 17 * @vector: Vector number (ignored for C) 18 * @func: Function name of the entry point 19 * 20 * Declares three functions: 21 * - The ASM entry point: asm_##func 22 * - The XEN PV trap entry point: xen_##func (maybe unused) 23 * - The C handler called from the ASM entry point 24 * 25 * Note: This is the C variant of DECLARE_IDTENTRY(). As the name says it 26 * declares the entry points for usage in C code. There is an ASM variant 27 * as well which is used to emit the entry stubs in entry_32/64.S. 28 */ 29 #define DECLARE_IDTENTRY(vector, func) \ 30 asmlinkage void asm_##func(void); \ 31 asmlinkage void xen_asm_##func(void); \ 32 __visible void func(struct pt_regs *regs) 33 34 /** 35 * DEFINE_IDTENTRY - Emit code for simple IDT entry points 36 * @func: Function name of the entry point 37 * 38 * @func is called from ASM entry code with interrupts disabled. 39 * 40 * The macro is written so it acts as function definition. Append the 41 * body with a pair of curly brackets. 42 * 43 * irqentry_enter() contains common code which has to be invoked before 44 * arbitrary code in the body. irqentry_exit() contains common code 45 * which has to run before returning to the low level assembly code. 46 */ 47 #define DEFINE_IDTENTRY(func) \ 48 static __always_inline void __##func(struct pt_regs *regs); \ 49 \ 50 __visible noinstr void func(struct pt_regs *regs) \ 51 { \ 52 irqentry_state_t state = irqentry_enter(regs); \ 53 \ 54 instrumentation_begin(); \ 55 __##func (regs); \ 56 instrumentation_end(); \ 57 irqentry_exit(regs, state); \ 58 } \ 59 \ 60 static __always_inline void __##func(struct pt_regs *regs) 61 62 /* Special case for 32bit IRET 'trap' */ 63 #define DECLARE_IDTENTRY_SW DECLARE_IDTENTRY 64 #define DEFINE_IDTENTRY_SW DEFINE_IDTENTRY 65 66 /** 67 * DECLARE_IDTENTRY_ERRORCODE - Declare functions for simple IDT entry points 68 * Error code pushed by hardware 69 * @vector: Vector number (ignored for C) 70 * @func: Function name of the entry point 71 * 72 * Declares three functions: 73 * - The ASM entry point: asm_##func 74 * - The XEN PV trap entry point: xen_##func (maybe unused) 75 * - The C handler called from the ASM entry point 76 * 77 * Same as DECLARE_IDTENTRY, but has an extra error_code argument for the 78 * C-handler. 79 */ 80 #define DECLARE_IDTENTRY_ERRORCODE(vector, func) \ 81 asmlinkage void asm_##func(void); \ 82 asmlinkage void xen_asm_##func(void); \ 83 __visible void func(struct pt_regs *regs, unsigned long error_code) 84 85 /** 86 * DEFINE_IDTENTRY_ERRORCODE - Emit code for simple IDT entry points 87 * Error code pushed by hardware 88 * @func: Function name of the entry point 89 * 90 * Same as DEFINE_IDTENTRY, but has an extra error_code argument 91 */ 92 #define DEFINE_IDTENTRY_ERRORCODE(func) \ 93 static __always_inline void __##func(struct pt_regs *regs, \ 94 unsigned long error_code); \ 95 \ 96 __visible noinstr void func(struct pt_regs *regs, \ 97 unsigned long error_code) \ 98 { \ 99 irqentry_state_t state = irqentry_enter(regs); \ 100 \ 101 instrumentation_begin(); \ 102 __##func (regs, error_code); \ 103 instrumentation_end(); \ 104 irqentry_exit(regs, state); \ 105 } \ 106 \ 107 static __always_inline void __##func(struct pt_regs *regs, \ 108 unsigned long error_code) 109 110 /** 111 * DECLARE_IDTENTRY_RAW - Declare functions for raw IDT entry points 112 * No error code pushed by hardware 113 * @vector: Vector number (ignored for C) 114 * @func: Function name of the entry point 115 * 116 * Maps to DECLARE_IDTENTRY(). 117 */ 118 #define DECLARE_IDTENTRY_RAW(vector, func) \ 119 DECLARE_IDTENTRY(vector, func) 120 121 /** 122 * DEFINE_IDTENTRY_RAW - Emit code for raw IDT entry points 123 * @func: Function name of the entry point 124 * 125 * @func is called from ASM entry code with interrupts disabled. 126 * 127 * The macro is written so it acts as function definition. Append the 128 * body with a pair of curly brackets. 129 * 130 * Contrary to DEFINE_IDTENTRY() this does not invoke the 131 * idtentry_enter/exit() helpers before and after the body invocation. This 132 * needs to be done in the body itself if applicable. Use if extra work 133 * is required before the enter/exit() helpers are invoked. 134 */ 135 #define DEFINE_IDTENTRY_RAW(func) \ 136 __visible noinstr void func(struct pt_regs *regs) 137 138 /** 139 * DECLARE_IDTENTRY_RAW_ERRORCODE - Declare functions for raw IDT entry points 140 * Error code pushed by hardware 141 * @vector: Vector number (ignored for C) 142 * @func: Function name of the entry point 143 * 144 * Maps to DECLARE_IDTENTRY_ERRORCODE() 145 */ 146 #define DECLARE_IDTENTRY_RAW_ERRORCODE(vector, func) \ 147 DECLARE_IDTENTRY_ERRORCODE(vector, func) 148 149 /** 150 * DEFINE_IDTENTRY_RAW_ERRORCODE - Emit code for raw IDT entry points 151 * @func: Function name of the entry point 152 * 153 * @func is called from ASM entry code with interrupts disabled. 154 * 155 * The macro is written so it acts as function definition. Append the 156 * body with a pair of curly brackets. 157 * 158 * Contrary to DEFINE_IDTENTRY_ERRORCODE() this does not invoke the 159 * irqentry_enter/exit() helpers before and after the body invocation. This 160 * needs to be done in the body itself if applicable. Use if extra work 161 * is required before the enter/exit() helpers are invoked. 162 */ 163 #define DEFINE_IDTENTRY_RAW_ERRORCODE(func) \ 164 __visible noinstr void func(struct pt_regs *regs, unsigned long error_code) 165 166 /** 167 * DECLARE_IDTENTRY_IRQ - Declare functions for device interrupt IDT entry 168 * points (common/spurious) 169 * @vector: Vector number (ignored for C) 170 * @func: Function name of the entry point 171 * 172 * Maps to DECLARE_IDTENTRY_ERRORCODE() 173 */ 174 #define DECLARE_IDTENTRY_IRQ(vector, func) \ 175 DECLARE_IDTENTRY_ERRORCODE(vector, func) 176 177 /** 178 * DEFINE_IDTENTRY_IRQ - Emit code for device interrupt IDT entry points 179 * @func: Function name of the entry point 180 * 181 * The vector number is pushed by the low level entry stub and handed 182 * to the function as error_code argument which needs to be truncated 183 * to an u8 because the push is sign extending. 184 * 185 * irq_enter/exit_rcu() are invoked before the function body and the 186 * KVM L1D flush request is set. Stack switching to the interrupt stack 187 * has to be done in the function body if necessary. 188 */ 189 #define DEFINE_IDTENTRY_IRQ(func) \ 190 static void __##func(struct pt_regs *regs, u32 vector); \ 191 \ 192 __visible noinstr void func(struct pt_regs *regs, \ 193 unsigned long error_code) \ 194 { \ 195 irqentry_state_t state = irqentry_enter(regs); \ 196 u32 vector = (u32)(u8)error_code; \ 197 \ 198 instrumentation_begin(); \ 199 kvm_set_cpu_l1tf_flush_l1d(); \ 200 run_irq_on_irqstack_cond(__##func, regs, vector); \ 201 instrumentation_end(); \ 202 irqentry_exit(regs, state); \ 203 } \ 204 \ 205 static noinline void __##func(struct pt_regs *regs, u32 vector) 206 207 /** 208 * DECLARE_IDTENTRY_SYSVEC - Declare functions for system vector entry points 209 * @vector: Vector number (ignored for C) 210 * @func: Function name of the entry point 211 * 212 * Declares three functions: 213 * - The ASM entry point: asm_##func 214 * - The XEN PV trap entry point: xen_##func (maybe unused) 215 * - The C handler called from the ASM entry point 216 * 217 * Maps to DECLARE_IDTENTRY(). 218 */ 219 #define DECLARE_IDTENTRY_SYSVEC(vector, func) \ 220 DECLARE_IDTENTRY(vector, func) 221 222 /** 223 * DEFINE_IDTENTRY_SYSVEC - Emit code for system vector IDT entry points 224 * @func: Function name of the entry point 225 * 226 * irqentry_enter/exit() and irq_enter/exit_rcu() are invoked before the 227 * function body. KVM L1D flush request is set. 228 * 229 * Runs the function on the interrupt stack if the entry hit kernel mode 230 */ 231 #define DEFINE_IDTENTRY_SYSVEC(func) \ 232 static void __##func(struct pt_regs *regs); \ 233 \ 234 __visible noinstr void func(struct pt_regs *regs) \ 235 { \ 236 irqentry_state_t state = irqentry_enter(regs); \ 237 \ 238 instrumentation_begin(); \ 239 kvm_set_cpu_l1tf_flush_l1d(); \ 240 run_sysvec_on_irqstack_cond(__##func, regs); \ 241 instrumentation_end(); \ 242 irqentry_exit(regs, state); \ 243 } \ 244 \ 245 static noinline void __##func(struct pt_regs *regs) 246 247 /** 248 * DEFINE_IDTENTRY_SYSVEC_SIMPLE - Emit code for simple system vector IDT 249 * entry points 250 * @func: Function name of the entry point 251 * 252 * Runs the function on the interrupted stack. No switch to IRQ stack and 253 * only the minimal __irq_enter/exit() handling. 254 * 255 * Only use for 'empty' vectors like reschedule IPI and KVM posted 256 * interrupt vectors. 257 */ 258 #define DEFINE_IDTENTRY_SYSVEC_SIMPLE(func) \ 259 static __always_inline void __##func(struct pt_regs *regs); \ 260 \ 261 __visible noinstr void func(struct pt_regs *regs) \ 262 { \ 263 irqentry_state_t state = irqentry_enter(regs); \ 264 \ 265 instrumentation_begin(); \ 266 __irq_enter_raw(); \ 267 kvm_set_cpu_l1tf_flush_l1d(); \ 268 __##func (regs); \ 269 __irq_exit_raw(); \ 270 instrumentation_end(); \ 271 irqentry_exit(regs, state); \ 272 } \ 273 \ 274 static __always_inline void __##func(struct pt_regs *regs) 275 276 /** 277 * DECLARE_IDTENTRY_XENCB - Declare functions for XEN HV callback entry point 278 * @vector: Vector number (ignored for C) 279 * @func: Function name of the entry point 280 * 281 * Declares three functions: 282 * - The ASM entry point: asm_##func 283 * - The XEN PV trap entry point: xen_##func (maybe unused) 284 * - The C handler called from the ASM entry point 285 * 286 * Maps to DECLARE_IDTENTRY(). Distinct entry point to handle the 32/64-bit 287 * difference 288 */ 289 #define DECLARE_IDTENTRY_XENCB(vector, func) \ 290 DECLARE_IDTENTRY(vector, func) 291 292 #ifdef CONFIG_X86_64 293 /** 294 * DECLARE_IDTENTRY_IST - Declare functions for IST handling IDT entry points 295 * @vector: Vector number (ignored for C) 296 * @func: Function name of the entry point 297 * 298 * Maps to DECLARE_IDTENTRY_RAW, but declares also the NOIST C handler 299 * which is called from the ASM entry point on user mode entry 300 */ 301 #define DECLARE_IDTENTRY_IST(vector, func) \ 302 DECLARE_IDTENTRY_RAW(vector, func); \ 303 __visible void noist_##func(struct pt_regs *regs) 304 305 /** 306 * DECLARE_IDTENTRY_VC - Declare functions for the VC entry point 307 * @vector: Vector number (ignored for C) 308 * @func: Function name of the entry point 309 * 310 * Maps to DECLARE_IDTENTRY_RAW_ERRORCODE, but declares also the 311 * safe_stack C handler. 312 */ 313 #define DECLARE_IDTENTRY_VC(vector, func) \ 314 DECLARE_IDTENTRY_RAW_ERRORCODE(vector, func); \ 315 __visible noinstr void ist_##func(struct pt_regs *regs, unsigned long error_code); \ 316 __visible noinstr void safe_stack_##func(struct pt_regs *regs, unsigned long error_code) 317 318 /** 319 * DEFINE_IDTENTRY_IST - Emit code for IST entry points 320 * @func: Function name of the entry point 321 * 322 * Maps to DEFINE_IDTENTRY_RAW 323 */ 324 #define DEFINE_IDTENTRY_IST(func) \ 325 DEFINE_IDTENTRY_RAW(func) 326 327 /** 328 * DEFINE_IDTENTRY_NOIST - Emit code for NOIST entry points which 329 * belong to a IST entry point (MCE, DB) 330 * @func: Function name of the entry point. Must be the same as 331 * the function name of the corresponding IST variant 332 * 333 * Maps to DEFINE_IDTENTRY_RAW(). 334 */ 335 #define DEFINE_IDTENTRY_NOIST(func) \ 336 DEFINE_IDTENTRY_RAW(noist_##func) 337 338 /** 339 * DECLARE_IDTENTRY_DF - Declare functions for double fault 340 * @vector: Vector number (ignored for C) 341 * @func: Function name of the entry point 342 * 343 * Maps to DECLARE_IDTENTRY_RAW_ERRORCODE 344 */ 345 #define DECLARE_IDTENTRY_DF(vector, func) \ 346 DECLARE_IDTENTRY_RAW_ERRORCODE(vector, func) 347 348 /** 349 * DEFINE_IDTENTRY_DF - Emit code for double fault 350 * @func: Function name of the entry point 351 * 352 * Maps to DEFINE_IDTENTRY_RAW_ERRORCODE 353 */ 354 #define DEFINE_IDTENTRY_DF(func) \ 355 DEFINE_IDTENTRY_RAW_ERRORCODE(func) 356 357 /** 358 * DEFINE_IDTENTRY_VC_SAFE_STACK - Emit code for VMM communication handler 359 which runs on a safe stack. 360 * @func: Function name of the entry point 361 * 362 * Maps to DEFINE_IDTENTRY_RAW_ERRORCODE 363 */ 364 #define DEFINE_IDTENTRY_VC_SAFE_STACK(func) \ 365 DEFINE_IDTENTRY_RAW_ERRORCODE(safe_stack_##func) 366 367 /** 368 * DEFINE_IDTENTRY_VC_IST - Emit code for VMM communication handler 369 which runs on the VC fall-back stack 370 * @func: Function name of the entry point 371 * 372 * Maps to DEFINE_IDTENTRY_RAW_ERRORCODE 373 */ 374 #define DEFINE_IDTENTRY_VC_IST(func) \ 375 DEFINE_IDTENTRY_RAW_ERRORCODE(ist_##func) 376 377 /** 378 * DEFINE_IDTENTRY_VC - Emit code for VMM communication handler 379 * @func: Function name of the entry point 380 * 381 * Maps to DEFINE_IDTENTRY_RAW_ERRORCODE 382 */ 383 #define DEFINE_IDTENTRY_VC(func) \ 384 DEFINE_IDTENTRY_RAW_ERRORCODE(func) 385 386 #else /* CONFIG_X86_64 */ 387 388 /** 389 * DECLARE_IDTENTRY_DF - Declare functions for double fault 32bit variant 390 * @vector: Vector number (ignored for C) 391 * @func: Function name of the entry point 392 * 393 * Declares two functions: 394 * - The ASM entry point: asm_##func 395 * - The C handler called from the C shim 396 */ 397 #define DECLARE_IDTENTRY_DF(vector, func) \ 398 asmlinkage void asm_##func(void); \ 399 __visible void func(struct pt_regs *regs, \ 400 unsigned long error_code, \ 401 unsigned long address) 402 403 /** 404 * DEFINE_IDTENTRY_DF - Emit code for double fault on 32bit 405 * @func: Function name of the entry point 406 * 407 * This is called through the doublefault shim which already provides 408 * cr2 in the address argument. 409 */ 410 #define DEFINE_IDTENTRY_DF(func) \ 411 __visible noinstr void func(struct pt_regs *regs, \ 412 unsigned long error_code, \ 413 unsigned long address) 414 415 #endif /* !CONFIG_X86_64 */ 416 417 /* C-Code mapping */ 418 #define DECLARE_IDTENTRY_NMI DECLARE_IDTENTRY_RAW 419 #define DEFINE_IDTENTRY_NMI DEFINE_IDTENTRY_RAW 420 421 #ifdef CONFIG_X86_64 422 #define DECLARE_IDTENTRY_MCE DECLARE_IDTENTRY_IST 423 #define DEFINE_IDTENTRY_MCE DEFINE_IDTENTRY_IST 424 #define DEFINE_IDTENTRY_MCE_USER DEFINE_IDTENTRY_NOIST 425 426 #define DECLARE_IDTENTRY_DEBUG DECLARE_IDTENTRY_IST 427 #define DEFINE_IDTENTRY_DEBUG DEFINE_IDTENTRY_IST 428 #define DEFINE_IDTENTRY_DEBUG_USER DEFINE_IDTENTRY_NOIST 429 #endif 430 431 #else /* !__ASSEMBLY__ */ 432 433 /* 434 * The ASM variants for DECLARE_IDTENTRY*() which emit the ASM entry stubs. 435 */ 436 #define DECLARE_IDTENTRY(vector, func) \ 437 idtentry vector asm_##func func has_error_code=0 438 439 #define DECLARE_IDTENTRY_ERRORCODE(vector, func) \ 440 idtentry vector asm_##func func has_error_code=1 441 442 /* Special case for 32bit IRET 'trap'. Do not emit ASM code */ 443 #define DECLARE_IDTENTRY_SW(vector, func) 444 445 #define DECLARE_IDTENTRY_RAW(vector, func) \ 446 DECLARE_IDTENTRY(vector, func) 447 448 #define DECLARE_IDTENTRY_RAW_ERRORCODE(vector, func) \ 449 DECLARE_IDTENTRY_ERRORCODE(vector, func) 450 451 /* Entries for common/spurious (device) interrupts */ 452 #define DECLARE_IDTENTRY_IRQ(vector, func) \ 453 idtentry_irq vector func 454 455 /* System vector entries */ 456 #define DECLARE_IDTENTRY_SYSVEC(vector, func) \ 457 idtentry_sysvec vector func 458 459 #ifdef CONFIG_X86_64 460 # define DECLARE_IDTENTRY_MCE(vector, func) \ 461 idtentry_mce_db vector asm_##func func 462 463 # define DECLARE_IDTENTRY_DEBUG(vector, func) \ 464 idtentry_mce_db vector asm_##func func 465 466 # define DECLARE_IDTENTRY_DF(vector, func) \ 467 idtentry_df vector asm_##func func 468 469 # define DECLARE_IDTENTRY_XENCB(vector, func) \ 470 DECLARE_IDTENTRY(vector, func) 471 472 # define DECLARE_IDTENTRY_VC(vector, func) \ 473 idtentry_vc vector asm_##func func 474 475 #else 476 # define DECLARE_IDTENTRY_MCE(vector, func) \ 477 DECLARE_IDTENTRY(vector, func) 478 479 /* No ASM emitted for DF as this goes through a C shim */ 480 # define DECLARE_IDTENTRY_DF(vector, func) 481 482 /* No ASM emitted for XEN hypervisor callback */ 483 # define DECLARE_IDTENTRY_XENCB(vector, func) 484 485 #endif 486 487 /* No ASM code emitted for NMI */ 488 #define DECLARE_IDTENTRY_NMI(vector, func) 489 490 /* 491 * ASM code to emit the common vector entry stubs where each stub is 492 * packed into 8 bytes. 493 * 494 * Note, that the 'pushq imm8' is emitted via '.byte 0x6a, vector' because 495 * GCC treats the local vector variable as unsigned int and would expand 496 * all vectors above 0x7F to a 5 byte push. The original code did an 497 * adjustment of the vector number to be in the signed byte range to avoid 498 * this. While clever it's mindboggling counterintuitive and requires the 499 * odd conversion back to a real vector number in the C entry points. Using 500 * .byte achieves the same thing and the only fixup needed in the C entry 501 * point is to mask off the bits above bit 7 because the push is sign 502 * extending. 503 */ 504 .align 8 505 SYM_CODE_START(irq_entries_start) 506 vector=FIRST_EXTERNAL_VECTOR 507 .rept (FIRST_SYSTEM_VECTOR - FIRST_EXTERNAL_VECTOR) 508 UNWIND_HINT_IRET_REGS 509 0 : 510 .byte 0x6a, vector 511 jmp asm_common_interrupt 512 nop 513 /* Ensure that the above is 8 bytes max */ 514 . = 0b + 8 515 vector = vector+1 516 .endr 517 SYM_CODE_END(irq_entries_start) 518 519 #ifdef CONFIG_X86_LOCAL_APIC 520 .align 8 521 SYM_CODE_START(spurious_entries_start) 522 vector=FIRST_SYSTEM_VECTOR 523 .rept (NR_VECTORS - FIRST_SYSTEM_VECTOR) 524 UNWIND_HINT_IRET_REGS 525 0 : 526 .byte 0x6a, vector 527 jmp asm_spurious_interrupt 528 nop 529 /* Ensure that the above is 8 bytes max */ 530 . = 0b + 8 531 vector = vector+1 532 .endr 533 SYM_CODE_END(spurious_entries_start) 534 #endif 535 536 #endif /* __ASSEMBLY__ */ 537 538 /* 539 * The actual entry points. Note that DECLARE_IDTENTRY*() serves two 540 * purposes: 541 * - provide the function declarations when included from C-Code 542 * - emit the ASM stubs when included from entry_32/64.S 543 * 544 * This avoids duplicate defines and ensures that everything is consistent. 545 */ 546 547 /* 548 * Dummy trap number so the low level ASM macro vector number checks do not 549 * match which results in emitting plain IDTENTRY stubs without bells and 550 * whistles. 551 */ 552 #define X86_TRAP_OTHER 0xFFFF 553 554 /* Simple exception entry points. No hardware error code */ 555 DECLARE_IDTENTRY(X86_TRAP_DE, exc_divide_error); 556 DECLARE_IDTENTRY(X86_TRAP_OF, exc_overflow); 557 DECLARE_IDTENTRY(X86_TRAP_BR, exc_bounds); 558 DECLARE_IDTENTRY(X86_TRAP_NM, exc_device_not_available); 559 DECLARE_IDTENTRY(X86_TRAP_OLD_MF, exc_coproc_segment_overrun); 560 DECLARE_IDTENTRY(X86_TRAP_SPURIOUS, exc_spurious_interrupt_bug); 561 DECLARE_IDTENTRY(X86_TRAP_MF, exc_coprocessor_error); 562 DECLARE_IDTENTRY(X86_TRAP_XF, exc_simd_coprocessor_error); 563 564 /* 32bit software IRET trap. Do not emit ASM code */ 565 DECLARE_IDTENTRY_SW(X86_TRAP_IRET, iret_error); 566 567 /* Simple exception entries with error code pushed by hardware */ 568 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_TS, exc_invalid_tss); 569 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_NP, exc_segment_not_present); 570 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_SS, exc_stack_segment); 571 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_GP, exc_general_protection); 572 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_AC, exc_alignment_check); 573 574 /* Raw exception entries which need extra work */ 575 DECLARE_IDTENTRY_RAW(X86_TRAP_UD, exc_invalid_op); 576 DECLARE_IDTENTRY_RAW(X86_TRAP_BP, exc_int3); 577 DECLARE_IDTENTRY_RAW_ERRORCODE(X86_TRAP_PF, exc_page_fault); 578 579 #ifdef CONFIG_X86_MCE 580 #ifdef CONFIG_X86_64 581 DECLARE_IDTENTRY_MCE(X86_TRAP_MC, exc_machine_check); 582 #else 583 DECLARE_IDTENTRY_RAW(X86_TRAP_MC, exc_machine_check); 584 #endif 585 #ifdef CONFIG_XEN_PV 586 DECLARE_IDTENTRY_RAW(X86_TRAP_MC, xenpv_exc_machine_check); 587 #endif 588 #endif 589 590 /* NMI */ 591 592 #if defined(CONFIG_X86_64) && IS_ENABLED(CONFIG_KVM_INTEL) 593 /* 594 * Special NOIST entry point for VMX which invokes this on the kernel 595 * stack. asm_exc_nmi() requires an IST to work correctly vs. the NMI 596 * 'executing' marker. 597 * 598 * On 32bit this just uses the regular NMI entry point because 32-bit does 599 * not have ISTs. 600 */ 601 DECLARE_IDTENTRY(X86_TRAP_NMI, exc_nmi_noist); 602 #else 603 #define asm_exc_nmi_noist asm_exc_nmi 604 #endif 605 606 DECLARE_IDTENTRY_NMI(X86_TRAP_NMI, exc_nmi); 607 #ifdef CONFIG_XEN_PV 608 DECLARE_IDTENTRY_RAW(X86_TRAP_NMI, xenpv_exc_nmi); 609 #endif 610 611 /* #DB */ 612 #ifdef CONFIG_X86_64 613 DECLARE_IDTENTRY_DEBUG(X86_TRAP_DB, exc_debug); 614 #else 615 DECLARE_IDTENTRY_RAW(X86_TRAP_DB, exc_debug); 616 #endif 617 #ifdef CONFIG_XEN_PV 618 DECLARE_IDTENTRY_RAW(X86_TRAP_DB, xenpv_exc_debug); 619 #endif 620 621 /* #DF */ 622 DECLARE_IDTENTRY_DF(X86_TRAP_DF, exc_double_fault); 623 #ifdef CONFIG_XEN_PV 624 DECLARE_IDTENTRY_RAW_ERRORCODE(X86_TRAP_DF, xenpv_exc_double_fault); 625 #endif 626 627 /* #VC */ 628 #ifdef CONFIG_AMD_MEM_ENCRYPT 629 DECLARE_IDTENTRY_VC(X86_TRAP_VC, exc_vmm_communication); 630 #endif 631 632 #ifdef CONFIG_XEN_PV 633 DECLARE_IDTENTRY_XENCB(X86_TRAP_OTHER, exc_xen_hypervisor_callback); 634 DECLARE_IDTENTRY_RAW(X86_TRAP_OTHER, exc_xen_unknown_trap); 635 #endif 636 637 /* Device interrupts common/spurious */ 638 DECLARE_IDTENTRY_IRQ(X86_TRAP_OTHER, common_interrupt); 639 #ifdef CONFIG_X86_LOCAL_APIC 640 DECLARE_IDTENTRY_IRQ(X86_TRAP_OTHER, spurious_interrupt); 641 #endif 642 643 /* System vector entry points */ 644 #ifdef CONFIG_X86_LOCAL_APIC 645 DECLARE_IDTENTRY_SYSVEC(ERROR_APIC_VECTOR, sysvec_error_interrupt); 646 DECLARE_IDTENTRY_SYSVEC(SPURIOUS_APIC_VECTOR, sysvec_spurious_apic_interrupt); 647 DECLARE_IDTENTRY_SYSVEC(LOCAL_TIMER_VECTOR, sysvec_apic_timer_interrupt); 648 DECLARE_IDTENTRY_SYSVEC(X86_PLATFORM_IPI_VECTOR, sysvec_x86_platform_ipi); 649 #endif 650 651 #ifdef CONFIG_SMP 652 DECLARE_IDTENTRY(RESCHEDULE_VECTOR, sysvec_reschedule_ipi); 653 DECLARE_IDTENTRY_SYSVEC(IRQ_MOVE_CLEANUP_VECTOR, sysvec_irq_move_cleanup); 654 DECLARE_IDTENTRY_SYSVEC(REBOOT_VECTOR, sysvec_reboot); 655 DECLARE_IDTENTRY_SYSVEC(CALL_FUNCTION_SINGLE_VECTOR, sysvec_call_function_single); 656 DECLARE_IDTENTRY_SYSVEC(CALL_FUNCTION_VECTOR, sysvec_call_function); 657 #endif 658 659 #ifdef CONFIG_X86_LOCAL_APIC 660 # ifdef CONFIG_X86_MCE_THRESHOLD 661 DECLARE_IDTENTRY_SYSVEC(THRESHOLD_APIC_VECTOR, sysvec_threshold); 662 # endif 663 664 # ifdef CONFIG_X86_MCE_AMD 665 DECLARE_IDTENTRY_SYSVEC(DEFERRED_ERROR_VECTOR, sysvec_deferred_error); 666 # endif 667 668 # ifdef CONFIG_X86_THERMAL_VECTOR 669 DECLARE_IDTENTRY_SYSVEC(THERMAL_APIC_VECTOR, sysvec_thermal); 670 # endif 671 672 # ifdef CONFIG_IRQ_WORK 673 DECLARE_IDTENTRY_SYSVEC(IRQ_WORK_VECTOR, sysvec_irq_work); 674 # endif 675 #endif 676 677 #ifdef CONFIG_HAVE_KVM 678 DECLARE_IDTENTRY_SYSVEC(POSTED_INTR_VECTOR, sysvec_kvm_posted_intr_ipi); 679 DECLARE_IDTENTRY_SYSVEC(POSTED_INTR_WAKEUP_VECTOR, sysvec_kvm_posted_intr_wakeup_ipi); 680 DECLARE_IDTENTRY_SYSVEC(POSTED_INTR_NESTED_VECTOR, sysvec_kvm_posted_intr_nested_ipi); 681 #endif 682 683 #if IS_ENABLED(CONFIG_HYPERV) 684 DECLARE_IDTENTRY_SYSVEC(HYPERVISOR_CALLBACK_VECTOR, sysvec_hyperv_callback); 685 DECLARE_IDTENTRY_SYSVEC(HYPERV_REENLIGHTENMENT_VECTOR, sysvec_hyperv_reenlightenment); 686 DECLARE_IDTENTRY_SYSVEC(HYPERV_STIMER0_VECTOR, sysvec_hyperv_stimer0); 687 #endif 688 689 #if IS_ENABLED(CONFIG_ACRN_GUEST) 690 DECLARE_IDTENTRY_SYSVEC(HYPERVISOR_CALLBACK_VECTOR, sysvec_acrn_hv_callback); 691 #endif 692 693 #ifdef CONFIG_XEN_PVHVM 694 DECLARE_IDTENTRY_SYSVEC(HYPERVISOR_CALLBACK_VECTOR, sysvec_xen_hvm_callback); 695 #endif 696 697 #ifdef CONFIG_KVM_GUEST 698 DECLARE_IDTENTRY_SYSVEC(HYPERVISOR_CALLBACK_VECTOR, sysvec_kvm_asyncpf_interrupt); 699 #endif 700 701 #undef X86_TRAP_OTHER 702 703 #endif 704