arch/x86/include/asm/idtentry.h

   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_on_irqstack_cond(__##func, regs, 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 safe_stack_##func(struct pt_regs *regs, unsigned long error_code)
 322
 323 /**
 324  * DEFINE_IDTENTRY_IST - Emit code for IST entry points
 325  * @func:       Function name of the entry point
 326  *
 327  * Maps to DEFINE_IDTENTRY_RAW
 328  */
 329 #define DEFINE_IDTENTRY_IST(func)                                       \
 330         DEFINE_IDTENTRY_RAW(func)
 331
 332 /**
 333  * DEFINE_IDTENTRY_NOIST - Emit code for NOIST entry points which
 334  *                         belong to a IST entry point (MCE, DB)
 335  * @func:       Function name of the entry point. Must be the same as
 336  *              the function name of the corresponding IST variant
 337  *
 338  * Maps to DEFINE_IDTENTRY_RAW().
 339  */
 340 #define DEFINE_IDTENTRY_NOIST(func)                                     \
 341         DEFINE_IDTENTRY_RAW(noist_##func)
 342
 343 /**
 344  * DECLARE_IDTENTRY_DF - Declare functions for double fault
 345  * @vector:     Vector number (ignored for C)
 346  * @func:       Function name of the entry point
 347  *
 348  * Maps to DECLARE_IDTENTRY_RAW_ERRORCODE
 349  */
 350 #define DECLARE_IDTENTRY_DF(vector, func)                               \
 351         DECLARE_IDTENTRY_RAW_ERRORCODE(vector, func)
 352
 353 /**
 354  * DEFINE_IDTENTRY_DF - Emit code for double fault
 355  * @func:       Function name of the entry point
 356  *
 357  * Maps to DEFINE_IDTENTRY_RAW_ERRORCODE
 358  */
 359 #define DEFINE_IDTENTRY_DF(func)                                        \
 360         DEFINE_IDTENTRY_RAW_ERRORCODE(func)
 361
 362 /**
 363  * DEFINE_IDTENTRY_VC_SAFE_STACK - Emit code for VMM communication handler
 364                                    which runs on a safe stack.
 365  * @func:       Function name of the entry point
 366  *
 367  * Maps to DEFINE_IDTENTRY_RAW_ERRORCODE
 368  */
 369 #define DEFINE_IDTENTRY_VC_SAFE_STACK(func)                             \
 370         DEFINE_IDTENTRY_RAW_ERRORCODE(safe_stack_##func)
 371
 372 /**
 373  * DEFINE_IDTENTRY_VC_IST - Emit code for VMM communication handler
 374                             which runs on the VC fall-back stack
 375  * @func:       Function name of the entry point
 376  *
 377  * Maps to DEFINE_IDTENTRY_RAW_ERRORCODE
 378  */
 379 #define DEFINE_IDTENTRY_VC_IST(func)                            \
 380         DEFINE_IDTENTRY_RAW_ERRORCODE(ist_##func)
 381
 382 /**
 383  * DEFINE_IDTENTRY_VC - Emit code for VMM communication handler
 384  * @func:       Function name of the entry point
 385  *
 386  * Maps to DEFINE_IDTENTRY_RAW_ERRORCODE
 387  */
 388 #define DEFINE_IDTENTRY_VC(func)                                        \
 389         DEFINE_IDTENTRY_RAW_ERRORCODE(func)
 390
 391 #else   /* CONFIG_X86_64 */
 392
 393 /**
 394  * DECLARE_IDTENTRY_DF - Declare functions for double fault 32bit variant
 395  * @vector:     Vector number (ignored for C)
 396  * @func:       Function name of the entry point
 397  *
 398  * Declares two functions:
 399  * - The ASM entry point: asm_##func
 400  * - The C handler called from the C shim
 401  */
 402 #define DECLARE_IDTENTRY_DF(vector, func)                               \
 403         asmlinkage void asm_##func(void);                               \
 404         __visible void func(struct pt_regs *regs,                       \
 405                             unsigned long error_code,                   \
 406                             unsigned long address)
 407
 408 /**
 409  * DEFINE_IDTENTRY_DF - Emit code for double fault on 32bit
 410  * @func:       Function name of the entry point
 411  *
 412  * This is called through the doublefault shim which already provides
 413  * cr2 in the address argument.
 414  */
 415 #define DEFINE_IDTENTRY_DF(func)                                        \
 416 __visible noinstr void func(struct pt_regs *regs,                       \
 417                             unsigned long error_code,                   \
 418                             unsigned long address)
 419
 420 #endif  /* !CONFIG_X86_64 */
 421
 422 /* C-Code mapping */
 423 #define DECLARE_IDTENTRY_NMI            DECLARE_IDTENTRY_RAW
 424 #define DEFINE_IDTENTRY_NMI             DEFINE_IDTENTRY_RAW
 425
 426 #ifdef CONFIG_X86_64
 427 #define DECLARE_IDTENTRY_MCE            DECLARE_IDTENTRY_IST
 428 #define DEFINE_IDTENTRY_MCE             DEFINE_IDTENTRY_IST
 429 #define DEFINE_IDTENTRY_MCE_USER        DEFINE_IDTENTRY_NOIST
 430
 431 #define DECLARE_IDTENTRY_DEBUG          DECLARE_IDTENTRY_IST
 432 #define DEFINE_IDTENTRY_DEBUG           DEFINE_IDTENTRY_IST
 433 #define DEFINE_IDTENTRY_DEBUG_USER      DEFINE_IDTENTRY_NOIST
 434 #endif
 435
 436 #else /* !__ASSEMBLY__ */
 437
 438 /*
 439  * The ASM variants for DECLARE_IDTENTRY*() which emit the ASM entry stubs.
 440  */
 441 #define DECLARE_IDTENTRY(vector, func)                                  \
 442         idtentry vector asm_##func func has_error_code=0
 443
 444 #define DECLARE_IDTENTRY_ERRORCODE(vector, func)                        \
 445         idtentry vector asm_##func func has_error_code=1
 446
 447 /* Special case for 32bit IRET 'trap'. Do not emit ASM code */
 448 #define DECLARE_IDTENTRY_SW(vector, func)
 449
 450 #define DECLARE_IDTENTRY_RAW(vector, func)                              \
 451         DECLARE_IDTENTRY(vector, func)
 452
 453 #define DECLARE_IDTENTRY_RAW_ERRORCODE(vector, func)                    \
 454         DECLARE_IDTENTRY_ERRORCODE(vector, func)
 455
 456 /* Entries for common/spurious (device) interrupts */
 457 #define DECLARE_IDTENTRY_IRQ(vector, func)                              \
 458         idtentry_irq vector func
 459
 460 /* System vector entries */
 461 #define DECLARE_IDTENTRY_SYSVEC(vector, func)                           \
 462         idtentry_sysvec vector func
 463
 464 #ifdef CONFIG_X86_64
 465 # define DECLARE_IDTENTRY_MCE(vector, func)                             \
 466         idtentry_mce_db vector asm_##func func
 467
 468 # define DECLARE_IDTENTRY_DEBUG(vector, func)                           \
 469         idtentry_mce_db vector asm_##func func
 470
 471 # define DECLARE_IDTENTRY_DF(vector, func)                              \
 472         idtentry_df vector asm_##func func
 473
 474 # define DECLARE_IDTENTRY_XENCB(vector, func)                           \
 475         DECLARE_IDTENTRY(vector, func)
 476
 477 # define DECLARE_IDTENTRY_VC(vector, func)                              \
 478         idtentry_vc vector asm_##func func
 479
 480 #else
 481 # define DECLARE_IDTENTRY_MCE(vector, func)                             \
 482         DECLARE_IDTENTRY(vector, func)
 483
 484 /* No ASM emitted for DF as this goes through a C shim */
 485 # define DECLARE_IDTENTRY_DF(vector, func)
 486
 487 /* No ASM emitted for XEN hypervisor callback */
 488 # define DECLARE_IDTENTRY_XENCB(vector, func)
 489
 490 #endif
 491
 492 /* No ASM code emitted for NMI */
 493 #define DECLARE_IDTENTRY_NMI(vector, func)
 494
 495 /*
 496  * ASM code to emit the common vector entry stubs where each stub is
 497  * packed into 8 bytes.
 498  *
 499  * Note, that the 'pushq imm8' is emitted via '.byte 0x6a, vector' because
 500  * GCC treats the local vector variable as unsigned int and would expand
 501  * all vectors above 0x7F to a 5 byte push. The original code did an
 502  * adjustment of the vector number to be in the signed byte range to avoid
 503  * this. While clever it's mindboggling counterintuitive and requires the
 504  * odd conversion back to a real vector number in the C entry points. Using
 505  * .byte achieves the same thing and the only fixup needed in the C entry
 506  * point is to mask off the bits above bit 7 because the push is sign
 507  * extending.
 508  */
 509         .align 8
 510 SYM_CODE_START(irq_entries_start)
 511     vector=FIRST_EXTERNAL_VECTOR
 512     .rept (FIRST_SYSTEM_VECTOR - FIRST_EXTERNAL_VECTOR)
 513         UNWIND_HINT_IRET_REGS
 514 0 :
 515         .byte   0x6a, vector
 516         jmp     asm_common_interrupt
 517         nop
 518         /* Ensure that the above is 8 bytes max */
 519         . = 0b + 8
 520         vector = vector+1
 521     .endr
 522 SYM_CODE_END(irq_entries_start)
 523
 524 #ifdef CONFIG_X86_LOCAL_APIC
 525         .align 8
 526 SYM_CODE_START(spurious_entries_start)
 527     vector=FIRST_SYSTEM_VECTOR
 528     .rept (NR_VECTORS - FIRST_SYSTEM_VECTOR)
 529         UNWIND_HINT_IRET_REGS
 530 0 :
 531         .byte   0x6a, vector
 532         jmp     asm_spurious_interrupt
 533         nop
 534         /* Ensure that the above is 8 bytes max */
 535         . = 0b + 8
 536         vector = vector+1
 537     .endr
 538 SYM_CODE_END(spurious_entries_start)
 539 #endif
 540
 541 #endif /* __ASSEMBLY__ */
 542
 543 /*
 544  * The actual entry points. Note that DECLARE_IDTENTRY*() serves two
 545  * purposes:
 546  *  - provide the function declarations when included from C-Code
 547  *  - emit the ASM stubs when included from entry_32/64.S
 548  *
 549  * This avoids duplicate defines and ensures that everything is consistent.
 550  */
 551
 552 /*
 553  * Dummy trap number so the low level ASM macro vector number checks do not
 554  * match which results in emitting plain IDTENTRY stubs without bells and
 555  * whistels.
 556  */
 557 #define X86_TRAP_OTHER          0xFFFF
 558
 559 /* Simple exception entry points. No hardware error code */
 560 DECLARE_IDTENTRY(X86_TRAP_DE,           exc_divide_error);
 561 DECLARE_IDTENTRY(X86_TRAP_OF,           exc_overflow);
 562 DECLARE_IDTENTRY(X86_TRAP_BR,           exc_bounds);
 563 DECLARE_IDTENTRY(X86_TRAP_NM,           exc_device_not_available);
 564 DECLARE_IDTENTRY(X86_TRAP_OLD_MF,       exc_coproc_segment_overrun);
 565 DECLARE_IDTENTRY(X86_TRAP_SPURIOUS,     exc_spurious_interrupt_bug);
 566 DECLARE_IDTENTRY(X86_TRAP_MF,           exc_coprocessor_error);
 567 DECLARE_IDTENTRY(X86_TRAP_XF,           exc_simd_coprocessor_error);
 568
 569 /* 32bit software IRET trap. Do not emit ASM code */
 570 DECLARE_IDTENTRY_SW(X86_TRAP_IRET,      iret_error);
 571
 572 /* Simple exception entries with error code pushed by hardware */
 573 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_TS, exc_invalid_tss);
 574 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_NP, exc_segment_not_present);
 575 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_SS, exc_stack_segment);
 576 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_GP, exc_general_protection);
 577 DECLARE_IDTENTRY_ERRORCODE(X86_TRAP_AC, exc_alignment_check);
 578
 579 /* Raw exception entries which need extra work */
 580 DECLARE_IDTENTRY_RAW(X86_TRAP_UD,               exc_invalid_op);
 581 DECLARE_IDTENTRY_RAW(X86_TRAP_BP,               exc_int3);
 582 DECLARE_IDTENTRY_RAW_ERRORCODE(X86_TRAP_PF,     exc_page_fault);
 583
 584 #ifdef CONFIG_X86_MCE
 585 #ifdef CONFIG_X86_64
 586 DECLARE_IDTENTRY_MCE(X86_TRAP_MC,       exc_machine_check);
 587 #else
 588 DECLARE_IDTENTRY_RAW(X86_TRAP_MC,       exc_machine_check);
 589 #endif
 590 #endif
 591
 592 /* NMI */
 593 DECLARE_IDTENTRY_NMI(X86_TRAP_NMI,      exc_nmi);
 594 #if defined(CONFIG_XEN_PV) && defined(CONFIG_X86_64)
 595 DECLARE_IDTENTRY_RAW(X86_TRAP_NMI,      xenpv_exc_nmi);
 596 #endif
 597
 598 /* #DB */
 599 #ifdef CONFIG_X86_64
 600 DECLARE_IDTENTRY_DEBUG(X86_TRAP_DB,     exc_debug);
 601 #else
 602 DECLARE_IDTENTRY_RAW(X86_TRAP_DB,       exc_debug);
 603 #endif
 604 #if defined(CONFIG_XEN_PV) && defined(CONFIG_X86_64)
 605 DECLARE_IDTENTRY_RAW(X86_TRAP_DB,       xenpv_exc_debug);
 606 #endif
 607
 608 /* #DF */
 609 DECLARE_IDTENTRY_DF(X86_TRAP_DF,        exc_double_fault);
 610
 611 #ifdef CONFIG_XEN_PV
 612 DECLARE_IDTENTRY_XENCB(X86_TRAP_OTHER,  exc_xen_hypervisor_callback);
 613 #endif
 614
 615 /* Device interrupts common/spurious */
 616 DECLARE_IDTENTRY_IRQ(X86_TRAP_OTHER,    common_interrupt);
 617 #ifdef CONFIG_X86_LOCAL_APIC
 618 DECLARE_IDTENTRY_IRQ(X86_TRAP_OTHER,    spurious_interrupt);
 619 #endif
 620
 621 /* System vector entry points */
 622 #ifdef CONFIG_X86_LOCAL_APIC
 623 DECLARE_IDTENTRY_SYSVEC(ERROR_APIC_VECTOR,              sysvec_error_interrupt);
 624 DECLARE_IDTENTRY_SYSVEC(SPURIOUS_APIC_VECTOR,           sysvec_spurious_apic_interrupt);
 625 DECLARE_IDTENTRY_SYSVEC(LOCAL_TIMER_VECTOR,             sysvec_apic_timer_interrupt);
 626 DECLARE_IDTENTRY_SYSVEC(X86_PLATFORM_IPI_VECTOR,        sysvec_x86_platform_ipi);
 627 #endif
 628
 629 #ifdef CONFIG_SMP
 630 DECLARE_IDTENTRY(RESCHEDULE_VECTOR,                     sysvec_reschedule_ipi);
 631 DECLARE_IDTENTRY_SYSVEC(IRQ_MOVE_CLEANUP_VECTOR,        sysvec_irq_move_cleanup);
 632 DECLARE_IDTENTRY_SYSVEC(REBOOT_VECTOR,                  sysvec_reboot);
 633 DECLARE_IDTENTRY_SYSVEC(CALL_FUNCTION_SINGLE_VECTOR,    sysvec_call_function_single);
 634 DECLARE_IDTENTRY_SYSVEC(CALL_FUNCTION_VECTOR,           sysvec_call_function);
 635 #endif
 636
 637 #ifdef CONFIG_X86_LOCAL_APIC
 638 # ifdef CONFIG_X86_UV
 639 DECLARE_IDTENTRY_SYSVEC(UV_BAU_MESSAGE,                 sysvec_uv_bau_message);
 640 # endif
 641
 642 # ifdef CONFIG_X86_MCE_THRESHOLD
 643 DECLARE_IDTENTRY_SYSVEC(THRESHOLD_APIC_VECTOR,          sysvec_threshold);
 644 # endif
 645
 646 # ifdef CONFIG_X86_MCE_AMD
 647 DECLARE_IDTENTRY_SYSVEC(DEFERRED_ERROR_VECTOR,          sysvec_deferred_error);
 648 # endif
 649
 650 # ifdef CONFIG_X86_THERMAL_VECTOR
 651 DECLARE_IDTENTRY_SYSVEC(THERMAL_APIC_VECTOR,            sysvec_thermal);
 652 # endif
 653
 654 # ifdef CONFIG_IRQ_WORK
 655 DECLARE_IDTENTRY_SYSVEC(IRQ_WORK_VECTOR,                sysvec_irq_work);
 656 # endif
 657 #endif
 658
 659 #ifdef CONFIG_HAVE_KVM
 660 DECLARE_IDTENTRY_SYSVEC(POSTED_INTR_VECTOR,             sysvec_kvm_posted_intr_ipi);
 661 DECLARE_IDTENTRY_SYSVEC(POSTED_INTR_WAKEUP_VECTOR,      sysvec_kvm_posted_intr_wakeup_ipi);
 662 DECLARE_IDTENTRY_SYSVEC(POSTED_INTR_NESTED_VECTOR,      sysvec_kvm_posted_intr_nested_ipi);
 663 #endif
 664
 665 #if IS_ENABLED(CONFIG_HYPERV)
 666 DECLARE_IDTENTRY_SYSVEC(HYPERVISOR_CALLBACK_VECTOR,     sysvec_hyperv_callback);
 667 DECLARE_IDTENTRY_SYSVEC(HYPERV_REENLIGHTENMENT_VECTOR,  sysvec_hyperv_reenlightenment);
 668 DECLARE_IDTENTRY_SYSVEC(HYPERV_STIMER0_VECTOR,  sysvec_hyperv_stimer0);
 669 #endif
 670
 671 #if IS_ENABLED(CONFIG_ACRN_GUEST)
 672 DECLARE_IDTENTRY_SYSVEC(HYPERVISOR_CALLBACK_VECTOR,     sysvec_acrn_hv_callback);
 673 #endif
 674
 675 #ifdef CONFIG_XEN_PVHVM
 676 DECLARE_IDTENTRY_SYSVEC(HYPERVISOR_CALLBACK_VECTOR,     sysvec_xen_hvm_callback);
 677 #endif
 678
 679 #ifdef CONFIG_KVM_GUEST
 680 DECLARE_IDTENTRY_SYSVEC(HYPERVISOR_CALLBACK_VECTOR,     sysvec_kvm_asyncpf_interrupt);
 681 #endif
 682
 683 #undef X86_TRAP_OTHER
 684
 685 #endif