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