arch/x86/entry/entry_64.S

   1 /*
   2  *  linux/arch/x86_64/entry.S
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *  Copyright (C) 2000, 2001, 2002  Andi Kleen SuSE Labs
   6  *  Copyright (C) 2000  Pavel Machek <pavel@suse.cz>
   7  *
   8  * entry.S contains the system-call and fault low-level handling routines.
   9  *
  10  * Some of this is documented in Documentation/x86/entry_64.txt
  11  *
  12  * A note on terminology:
  13  * - iret frame:        Architecture defined interrupt frame from SS to RIP
  14  *                      at the top of the kernel process stack.
  15  *
  16  * Some macro usage:
  17  * - ENTRY/END:         Define functions in the symbol table.
  18  * - TRACE_IRQ_*:       Trace hardirq state for lock debugging.
  19  * - idtentry:          Define exception entry points.
  20  */
  21 #include <linux/linkage.h>
  22 #include <asm/segment.h>
  23 #include <asm/cache.h>
  24 #include <asm/errno.h>
  25 #include "calling.h"
  26 #include <asm/asm-offsets.h>
  27 #include <asm/msr.h>
  28 #include <asm/unistd.h>
  29 #include <asm/thread_info.h>
  30 #include <asm/hw_irq.h>
  31 #include <asm/page_types.h>
  32 #include <asm/irqflags.h>
  33 #include <asm/paravirt.h>
  34 #include <asm/percpu.h>
  35 #include <asm/asm.h>
  36 #include <asm/smap.h>
  37 #include <asm/pgtable_types.h>
  38 #include <linux/err.h>
  39
  40 /* Avoid __ASSEMBLER__'ifying <linux/audit.h> just for this.  */
  41 #include <linux/elf-em.h>
  42 #define AUDIT_ARCH_X86_64                       (EM_X86_64|__AUDIT_ARCH_64BIT|__AUDIT_ARCH_LE)
  43 #define __AUDIT_ARCH_64BIT                      0x80000000
  44 #define __AUDIT_ARCH_LE                         0x40000000
  45
  46 .code64
  47 .section .entry.text, "ax"
  48
  49 #ifdef CONFIG_PARAVIRT
  50 ENTRY(native_usergs_sysret64)
  51         swapgs
  52         sysretq
  53 ENDPROC(native_usergs_sysret64)
  54 #endif /* CONFIG_PARAVIRT */
  55
  56 .macro TRACE_IRQS_IRETQ
  57 #ifdef CONFIG_TRACE_IRQFLAGS
  58         bt      $9, EFLAGS(%rsp)                /* interrupts off? */
  59         jnc     1f
  60         TRACE_IRQS_ON
  61 1:
  62 #endif
  63 .endm
  64
  65 /*
  66  * When dynamic function tracer is enabled it will add a breakpoint
  67  * to all locations that it is about to modify, sync CPUs, update
  68  * all the code, sync CPUs, then remove the breakpoints. In this time
  69  * if lockdep is enabled, it might jump back into the debug handler
  70  * outside the updating of the IST protection. (TRACE_IRQS_ON/OFF).
  71  *
  72  * We need to change the IDT table before calling TRACE_IRQS_ON/OFF to
  73  * make sure the stack pointer does not get reset back to the top
  74  * of the debug stack, and instead just reuses the current stack.
  75  */
  76 #if defined(CONFIG_DYNAMIC_FTRACE) && defined(CONFIG_TRACE_IRQFLAGS)
  77
  78 .macro TRACE_IRQS_OFF_DEBUG
  79         call    debug_stack_set_zero
  80         TRACE_IRQS_OFF
  81         call    debug_stack_reset
  82 .endm
  83
  84 .macro TRACE_IRQS_ON_DEBUG
  85         call    debug_stack_set_zero
  86         TRACE_IRQS_ON
  87         call    debug_stack_reset
  88 .endm
  89
  90 .macro TRACE_IRQS_IRETQ_DEBUG
  91         bt      $9, EFLAGS(%rsp)                /* interrupts off? */
  92         jnc     1f
  93         TRACE_IRQS_ON_DEBUG
  94 1:
  95 .endm
  96
  97 #else
  98 # define TRACE_IRQS_OFF_DEBUG                   TRACE_IRQS_OFF
  99 # define TRACE_IRQS_ON_DEBUG                    TRACE_IRQS_ON
 100 # define TRACE_IRQS_IRETQ_DEBUG                 TRACE_IRQS_IRETQ
 101 #endif
 102
 103 /*
 104  * 64-bit SYSCALL instruction entry. Up to 6 arguments in registers.
 105  *
 106  * 64-bit SYSCALL saves rip to rcx, clears rflags.RF, then saves rflags to r11,
 107  * then loads new ss, cs, and rip from previously programmed MSRs.
 108  * rflags gets masked by a value from another MSR (so CLD and CLAC
 109  * are not needed). SYSCALL does not save anything on the stack
 110  * and does not change rsp.
 111  *
 112  * Registers on entry:
 113  * rax  system call number
 114  * rcx  return address
 115  * r11  saved rflags (note: r11 is callee-clobbered register in C ABI)
 116  * rdi  arg0
 117  * rsi  arg1
 118  * rdx  arg2
 119  * r10  arg3 (needs to be moved to rcx to conform to C ABI)
 120  * r8   arg4
 121  * r9   arg5
 122  * (note: r12-r15, rbp, rbx are callee-preserved in C ABI)
 123  *
 124  * Only called from user space.
 125  *
 126  * When user can change pt_regs->foo always force IRET. That is because
 127  * it deals with uncanonical addresses better. SYSRET has trouble
 128  * with them due to bugs in both AMD and Intel CPUs.
 129  */
 130
 131 ENTRY(entry_SYSCALL_64)
 132         /*
 133          * Interrupts are off on entry.
 134          * We do not frame this tiny irq-off block with TRACE_IRQS_OFF/ON,
 135          * it is too small to ever cause noticeable irq latency.
 136          */
 137         SWAPGS_UNSAFE_STACK
 138         /*
 139          * A hypervisor implementation might want to use a label
 140          * after the swapgs, so that it can do the swapgs
 141          * for the guest and jump here on syscall.
 142          */
 143 GLOBAL(entry_SYSCALL_64_after_swapgs)
 144
 145         movq    %rsp, PER_CPU_VAR(rsp_scratch)
 146         movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp
 147
 148         TRACE_IRQS_OFF
 149
 150         /* Construct struct pt_regs on stack */
 151         pushq   $__USER_DS                      /* pt_regs->ss */
 152         pushq   PER_CPU_VAR(rsp_scratch)        /* pt_regs->sp */
 153         pushq   %r11                            /* pt_regs->flags */
 154         pushq   $__USER_CS                      /* pt_regs->cs */
 155         pushq   %rcx                            /* pt_regs->ip */
 156         pushq   %rax                            /* pt_regs->orig_ax */
 157         pushq   %rdi                            /* pt_regs->di */
 158         pushq   %rsi                            /* pt_regs->si */
 159         pushq   %rdx                            /* pt_regs->dx */
 160         pushq   %rcx                            /* pt_regs->cx */
 161         pushq   $-ENOSYS                        /* pt_regs->ax */
 162         pushq   %r8                             /* pt_regs->r8 */
 163         pushq   %r9                             /* pt_regs->r9 */
 164         pushq   %r10                            /* pt_regs->r10 */
 165         pushq   %r11                            /* pt_regs->r11 */
 166         sub     $(6*8), %rsp                    /* pt_regs->bp, bx, r12-15 not saved */
 167
 168         /*
 169          * If we need to do entry work or if we guess we'll need to do
 170          * exit work, go straight to the slow path.
 171          */
 172         testl   $_TIF_WORK_SYSCALL_ENTRY|_TIF_ALLWORK_MASK, ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 173         jnz     entry_SYSCALL64_slow_path
 174
 175 entry_SYSCALL_64_fastpath:
 176         /*
 177          * Easy case: enable interrupts and issue the syscall.  If the syscall
 178          * needs pt_regs, we'll call a stub that disables interrupts again
 179          * and jumps to the slow path.
 180          */
 181         TRACE_IRQS_ON
 182         ENABLE_INTERRUPTS(CLBR_NONE)
 183 #if __SYSCALL_MASK == ~0
 184         cmpq    $__NR_syscall_max, %rax
 185 #else
 186         andl    $__SYSCALL_MASK, %eax
 187         cmpl    $__NR_syscall_max, %eax
 188 #endif
 189         ja      1f                              /* return -ENOSYS (already in pt_regs->ax) */
 190         movq    %r10, %rcx
 191
 192         /*
 193          * This call instruction is handled specially in stub_ptregs_64.
 194          * It might end up jumping to the slow path.  If it jumps, RAX
 195          * and all argument registers are clobbered.
 196          */
 197         call    *sys_call_table(, %rax, 8)
 198 .Lentry_SYSCALL_64_after_fastpath_call:
 199
 200         movq    %rax, RAX(%rsp)
 201 1:
 202
 203         /*
 204          * If we get here, then we know that pt_regs is clean for SYSRET64.
 205          * If we see that no exit work is required (which we are required
 206          * to check with IRQs off), then we can go straight to SYSRET64.
 207          */
 208         DISABLE_INTERRUPTS(CLBR_NONE)
 209         TRACE_IRQS_OFF
 210         testl   $_TIF_ALLWORK_MASK, ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 211         jnz     1f
 212
 213         LOCKDEP_SYS_EXIT
 214         TRACE_IRQS_ON           /* user mode is traced as IRQs on */
 215         movq    RIP(%rsp), %rcx
 216         movq    EFLAGS(%rsp), %r11
 217         RESTORE_C_REGS_EXCEPT_RCX_R11
 218         movq    RSP(%rsp), %rsp
 219         USERGS_SYSRET64
 220
 221 1:
 222         /*
 223          * The fast path looked good when we started, but something changed
 224          * along the way and we need to switch to the slow path.  Calling
 225          * raise(3) will trigger this, for example.  IRQs are off.
 226          */
 227         TRACE_IRQS_ON
 228         ENABLE_INTERRUPTS(CLBR_NONE)
 229         SAVE_EXTRA_REGS
 230         movq    %rsp, %rdi
 231         call    syscall_return_slowpath /* returns with IRQs disabled */
 232         jmp     return_from_SYSCALL_64
 233
 234 entry_SYSCALL64_slow_path:
 235         /* IRQs are off. */
 236         SAVE_EXTRA_REGS
 237         movq    %rsp, %rdi
 238         call    do_syscall_64           /* returns with IRQs disabled */
 239
 240 return_from_SYSCALL_64:
 241         RESTORE_EXTRA_REGS
 242         TRACE_IRQS_IRETQ                /* we're about to change IF */
 243
 244         /*
 245          * Try to use SYSRET instead of IRET if we're returning to
 246          * a completely clean 64-bit userspace context.
 247          */
 248         movq    RCX(%rsp), %rcx
 249         movq    RIP(%rsp), %r11
 250         cmpq    %rcx, %r11                      /* RCX == RIP */
 251         jne     opportunistic_sysret_failed
 252
 253         /*
 254          * On Intel CPUs, SYSRET with non-canonical RCX/RIP will #GP
 255          * in kernel space.  This essentially lets the user take over
 256          * the kernel, since userspace controls RSP.
 257          *
 258          * If width of "canonical tail" ever becomes variable, this will need
 259          * to be updated to remain correct on both old and new CPUs.
 260          */
 261         .ifne __VIRTUAL_MASK_SHIFT - 47
 262         .error "virtual address width changed -- SYSRET checks need update"
 263         .endif
 264
 265         /* Change top 16 bits to be the sign-extension of 47th bit */
 266         shl     $(64 - (__VIRTUAL_MASK_SHIFT+1)), %rcx
 267         sar     $(64 - (__VIRTUAL_MASK_SHIFT+1)), %rcx
 268
 269         /* If this changed %rcx, it was not canonical */
 270         cmpq    %rcx, %r11
 271         jne     opportunistic_sysret_failed
 272
 273         cmpq    $__USER_CS, CS(%rsp)            /* CS must match SYSRET */
 274         jne     opportunistic_sysret_failed
 275
 276         movq    R11(%rsp), %r11
 277         cmpq    %r11, EFLAGS(%rsp)              /* R11 == RFLAGS */
 278         jne     opportunistic_sysret_failed
 279
 280         /*
 281          * SYSRET can't restore RF.  SYSRET can restore TF, but unlike IRET,
 282          * restoring TF results in a trap from userspace immediately after
 283          * SYSRET.  This would cause an infinite loop whenever #DB happens
 284          * with register state that satisfies the opportunistic SYSRET
 285          * conditions.  For example, single-stepping this user code:
 286          *
 287          *           movq       $stuck_here, %rcx
 288          *           pushfq
 289          *           popq %r11
 290          *   stuck_here:
 291          *
 292          * would never get past 'stuck_here'.
 293          */
 294         testq   $(X86_EFLAGS_RF|X86_EFLAGS_TF), %r11
 295         jnz     opportunistic_sysret_failed
 296
 297         /* nothing to check for RSP */
 298
 299         cmpq    $__USER_DS, SS(%rsp)            /* SS must match SYSRET */
 300         jne     opportunistic_sysret_failed
 301
 302         /*
 303          * We win! This label is here just for ease of understanding
 304          * perf profiles. Nothing jumps here.
 305          */
 306 syscall_return_via_sysret:
 307         /* rcx and r11 are already restored (see code above) */
 308         RESTORE_C_REGS_EXCEPT_RCX_R11
 309         movq    RSP(%rsp), %rsp
 310         USERGS_SYSRET64
 311
 312 opportunistic_sysret_failed:
 313         SWAPGS
 314         jmp     restore_c_regs_and_iret
 315 END(entry_SYSCALL_64)
 316
 317 ENTRY(stub_ptregs_64)
 318         /*
 319          * Syscalls marked as needing ptregs land here.
 320          * If we are on the fast path, we need to save the extra regs,
 321          * which we achieve by trying again on the slow path.  If we are on
 322          * the slow path, the extra regs are already saved.
 323          *
 324          * RAX stores a pointer to the C function implementing the syscall.
 325          * IRQs are on.
 326          */
 327         cmpq    $.Lentry_SYSCALL_64_after_fastpath_call, (%rsp)
 328         jne     1f
 329
 330         /*
 331          * Called from fast path -- disable IRQs again, pop return address
 332          * and jump to slow path
 333          */
 334         DISABLE_INTERRUPTS(CLBR_NONE)
 335         TRACE_IRQS_OFF
 336         popq    %rax
 337         jmp     entry_SYSCALL64_slow_path
 338
 339 1:
 340         /* Called from C */
 341         jmp     *%rax                           /* called from C */
 342 END(stub_ptregs_64)
 343
 344 .macro ptregs_stub func
 345 ENTRY(ptregs_\func)
 346         leaq    \func(%rip), %rax
 347         jmp     stub_ptregs_64
 348 END(ptregs_\func)
 349 .endm
 350
 351 /* Instantiate ptregs_stub for each ptregs-using syscall */
 352 #define __SYSCALL_64_QUAL_(sym)
 353 #define __SYSCALL_64_QUAL_ptregs(sym) ptregs_stub sym
 354 #define __SYSCALL_64(nr, sym, qual) __SYSCALL_64_QUAL_##qual(sym)
 355 #include <asm/syscalls_64.h>
 356
 357 /*
 358  * A newly forked process directly context switches into this address.
 359  *
 360  * rdi: prev task we switched from
 361  */
 362 ENTRY(ret_from_fork)
 363         LOCK ; btr $TIF_FORK, TI_flags(%r8)
 364
 365         pushq   $0x0002
 366         popfq                                   /* reset kernel eflags */
 367
 368         call    schedule_tail                   /* rdi: 'prev' task parameter */
 369
 370         testb   $3, CS(%rsp)                    /* from kernel_thread? */
 371         jnz     1f
 372
 373         /*
 374          * We came from kernel_thread.  This code path is quite twisted, and
 375          * someone should clean it up.
 376          *
 377          * copy_thread_tls stashes the function pointer in RBX and the
 378          * parameter to be passed in RBP.  The called function is permitted
 379          * to call do_execve and thereby jump to user mode.
 380          */
 381         movq    RBP(%rsp), %rdi
 382         call    *RBX(%rsp)
 383         movl    $0, RAX(%rsp)
 384
 385         /*
 386          * Fall through as though we're exiting a syscall.  This makes a
 387          * twisted sort of sense if we just called do_execve.
 388          */
 389
 390 1:
 391         movq    %rsp, %rdi
 392         call    syscall_return_slowpath /* returns with IRQs disabled */
 393         TRACE_IRQS_ON                   /* user mode is traced as IRQS on */
 394         SWAPGS
 395         jmp     restore_regs_and_iret
 396 END(ret_from_fork)
 397
 398 /*
 399  * Build the entry stubs with some assembler magic.
 400  * We pack 1 stub into every 8-byte block.
 401  */
 402         .align 8
 403 ENTRY(irq_entries_start)
 404     vector=FIRST_EXTERNAL_VECTOR
 405     .rept (FIRST_SYSTEM_VECTOR - FIRST_EXTERNAL_VECTOR)
 406         pushq   $(~vector+0x80)                 /* Note: always in signed byte range */
 407     vector=vector+1
 408         jmp     common_interrupt
 409         .align  8
 410     .endr
 411 END(irq_entries_start)
 412
 413 /*
 414  * Interrupt entry/exit.
 415  *
 416  * Interrupt entry points save only callee clobbered registers in fast path.
 417  *
 418  * Entry runs with interrupts off.
 419  */
 420
 421 /* 0(%rsp): ~(interrupt number) */
 422         .macro interrupt func
 423         cld
 424         ALLOC_PT_GPREGS_ON_STACK
 425         SAVE_C_REGS
 426         SAVE_EXTRA_REGS
 427
 428         testb   $3, CS(%rsp)
 429         jz      1f
 430
 431         /*
 432          * IRQ from user mode.  Switch to kernel gsbase and inform context
 433          * tracking that we're in kernel mode.
 434          */
 435         SWAPGS
 436
 437         /*
 438          * We need to tell lockdep that IRQs are off.  We can't do this until
 439          * we fix gsbase, and we should do it before enter_from_user_mode
 440          * (which can take locks).  Since TRACE_IRQS_OFF idempotent,
 441          * the simplest way to handle it is to just call it twice if
 442          * we enter from user mode.  There's no reason to optimize this since
 443          * TRACE_IRQS_OFF is a no-op if lockdep is off.
 444          */
 445         TRACE_IRQS_OFF
 446
 447         CALL_enter_from_user_mode
 448
 449 1:
 450         /*
 451          * Save previous stack pointer, optionally switch to interrupt stack.
 452          * irq_count is used to check if a CPU is already on an interrupt stack
 453          * or not. While this is essentially redundant with preempt_count it is
 454          * a little cheaper to use a separate counter in the PDA (short of
 455          * moving irq_enter into assembly, which would be too much work)
 456          */
 457         movq    %rsp, %rdi
 458         incl    PER_CPU_VAR(irq_count)
 459         cmovzq  PER_CPU_VAR(irq_stack_ptr), %rsp
 460         pushq   %rdi
 461         /* We entered an interrupt context - irqs are off: */
 462         TRACE_IRQS_OFF
 463
 464         call    \func   /* rdi points to pt_regs */
 465         .endm
 466
 467         /*
 468          * The interrupt stubs push (~vector+0x80) onto the stack and
 469          * then jump to common_interrupt.
 470          */
 471         .p2align CONFIG_X86_L1_CACHE_SHIFT
 472 common_interrupt:
 473         ASM_CLAC
 474         addq    $-0x80, (%rsp)                  /* Adjust vector to [-256, -1] range */
 475         interrupt do_IRQ
 476         /* 0(%rsp): old RSP */
 477 ret_from_intr:
 478         DISABLE_INTERRUPTS(CLBR_NONE)
 479         TRACE_IRQS_OFF
 480         decl    PER_CPU_VAR(irq_count)
 481
 482         /* Restore saved previous stack */
 483         popq    %rsp
 484
 485         testb   $3, CS(%rsp)
 486         jz      retint_kernel
 487
 488         /* Interrupt came from user space */
 489 GLOBAL(retint_user)
 490         mov     %rsp,%rdi
 491         call    prepare_exit_to_usermode
 492         TRACE_IRQS_IRETQ
 493         SWAPGS
 494         jmp     restore_regs_and_iret
 495
 496 /* Returning to kernel space */
 497 retint_kernel:
 498 #ifdef CONFIG_PREEMPT
 499         /* Interrupts are off */
 500         /* Check if we need preemption */
 501         bt      $9, EFLAGS(%rsp)                /* were interrupts off? */
 502         jnc     1f
 503 0:      cmpl    $0, PER_CPU_VAR(__preempt_count)
 504         jnz     1f
 505         call    preempt_schedule_irq
 506         jmp     0b
 507 1:
 508 #endif
 509         /*
 510          * The iretq could re-enable interrupts:
 511          */
 512         TRACE_IRQS_IRETQ
 513
 514 /*
 515  * At this label, code paths which return to kernel and to user,
 516  * which come from interrupts/exception and from syscalls, merge.
 517  */
 518 GLOBAL(restore_regs_and_iret)
 519         RESTORE_EXTRA_REGS
 520 restore_c_regs_and_iret:
 521         RESTORE_C_REGS
 522         REMOVE_PT_GPREGS_FROM_STACK 8
 523         INTERRUPT_RETURN
 524
 525 ENTRY(native_iret)
 526         /*
 527          * Are we returning to a stack segment from the LDT?  Note: in
 528          * 64-bit mode SS:RSP on the exception stack is always valid.
 529          */
 530 #ifdef CONFIG_X86_ESPFIX64
 531         testb   $4, (SS-RIP)(%rsp)
 532         jnz     native_irq_return_ldt
 533 #endif
 534
 535 .global native_irq_return_iret
 536 native_irq_return_iret:
 537         /*
 538          * This may fault.  Non-paranoid faults on return to userspace are
 539          * handled by fixup_bad_iret.  These include #SS, #GP, and #NP.
 540          * Double-faults due to espfix64 are handled in do_double_fault.
 541          * Other faults here are fatal.
 542          */
 543         iretq
 544
 545 #ifdef CONFIG_X86_ESPFIX64
 546 native_irq_return_ldt:
 547         pushq   %rax
 548         pushq   %rdi
 549         SWAPGS
 550         movq    PER_CPU_VAR(espfix_waddr), %rdi
 551         movq    %rax, (0*8)(%rdi)               /* RAX */
 552         movq    (2*8)(%rsp), %rax               /* RIP */
 553         movq    %rax, (1*8)(%rdi)
 554         movq    (3*8)(%rsp), %rax               /* CS */
 555         movq    %rax, (2*8)(%rdi)
 556         movq    (4*8)(%rsp), %rax               /* RFLAGS */
 557         movq    %rax, (3*8)(%rdi)
 558         movq    (6*8)(%rsp), %rax               /* SS */
 559         movq    %rax, (5*8)(%rdi)
 560         movq    (5*8)(%rsp), %rax               /* RSP */
 561         movq    %rax, (4*8)(%rdi)
 562         andl    $0xffff0000, %eax
 563         popq    %rdi
 564         orq     PER_CPU_VAR(espfix_stack), %rax
 565         SWAPGS
 566         movq    %rax, %rsp
 567         popq    %rax
 568         jmp     native_irq_return_iret
 569 #endif
 570 END(common_interrupt)
 571
 572 /*
 573  * APIC interrupts.
 574  */
 575 .macro apicinterrupt3 num sym do_sym
 576 ENTRY(\sym)
 577         ASM_CLAC
 578         pushq   $~(\num)
 579 .Lcommon_\sym:
 580         interrupt \do_sym
 581         jmp     ret_from_intr
 582 END(\sym)
 583 .endm
 584
 585 #ifdef CONFIG_TRACING
 586 #define trace(sym) trace_##sym
 587 #define smp_trace(sym) smp_trace_##sym
 588
 589 .macro trace_apicinterrupt num sym
 590 apicinterrupt3 \num trace(\sym) smp_trace(\sym)
 591 .endm
 592 #else
 593 .macro trace_apicinterrupt num sym do_sym
 594 .endm
 595 #endif
 596
 597 .macro apicinterrupt num sym do_sym
 598 apicinterrupt3 \num \sym \do_sym
 599 trace_apicinterrupt \num \sym
 600 .endm
 601
 602 #ifdef CONFIG_SMP
 603 apicinterrupt3 IRQ_MOVE_CLEANUP_VECTOR          irq_move_cleanup_interrupt      smp_irq_move_cleanup_interrupt
 604 apicinterrupt3 REBOOT_VECTOR                    reboot_interrupt                smp_reboot_interrupt
 605 #endif
 606
 607 #ifdef CONFIG_X86_UV
 608 apicinterrupt3 UV_BAU_MESSAGE                   uv_bau_message_intr1            uv_bau_message_interrupt
 609 #endif
 610
 611 apicinterrupt LOCAL_TIMER_VECTOR                apic_timer_interrupt            smp_apic_timer_interrupt
 612 apicinterrupt X86_PLATFORM_IPI_VECTOR           x86_platform_ipi                smp_x86_platform_ipi
 613
 614 #ifdef CONFIG_HAVE_KVM
 615 apicinterrupt3 POSTED_INTR_VECTOR               kvm_posted_intr_ipi             smp_kvm_posted_intr_ipi
 616 apicinterrupt3 POSTED_INTR_WAKEUP_VECTOR        kvm_posted_intr_wakeup_ipi      smp_kvm_posted_intr_wakeup_ipi
 617 #endif
 618
 619 #ifdef CONFIG_X86_MCE_THRESHOLD
 620 apicinterrupt THRESHOLD_APIC_VECTOR             threshold_interrupt             smp_threshold_interrupt
 621 #endif
 622
 623 #ifdef CONFIG_X86_MCE_AMD
 624 apicinterrupt DEFERRED_ERROR_VECTOR             deferred_error_interrupt        smp_deferred_error_interrupt
 625 #endif
 626
 627 #ifdef CONFIG_X86_THERMAL_VECTOR
 628 apicinterrupt THERMAL_APIC_VECTOR               thermal_interrupt               smp_thermal_interrupt
 629 #endif
 630
 631 #ifdef CONFIG_SMP
 632 apicinterrupt CALL_FUNCTION_SINGLE_VECTOR       call_function_single_interrupt  smp_call_function_single_interrupt
 633 apicinterrupt CALL_FUNCTION_VECTOR              call_function_interrupt         smp_call_function_interrupt
 634 apicinterrupt RESCHEDULE_VECTOR                 reschedule_interrupt            smp_reschedule_interrupt
 635 #endif
 636
 637 apicinterrupt ERROR_APIC_VECTOR                 error_interrupt                 smp_error_interrupt
 638 apicinterrupt SPURIOUS_APIC_VECTOR              spurious_interrupt              smp_spurious_interrupt
 639
 640 #ifdef CONFIG_IRQ_WORK
 641 apicinterrupt IRQ_WORK_VECTOR                   irq_work_interrupt              smp_irq_work_interrupt
 642 #endif
 643
 644 /*
 645  * Exception entry points.
 646  */
 647 #define CPU_TSS_IST(x) PER_CPU_VAR(cpu_tss) + (TSS_ist + ((x) - 1) * 8)
 648
 649 .macro idtentry sym do_sym has_error_code:req paranoid=0 shift_ist=-1
 650 ENTRY(\sym)
 651         /* Sanity check */
 652         .if \shift_ist != -1 && \paranoid == 0
 653         .error "using shift_ist requires paranoid=1"
 654         .endif
 655
 656         ASM_CLAC
 657         PARAVIRT_ADJUST_EXCEPTION_FRAME
 658
 659         .ifeq \has_error_code
 660         pushq   $-1                             /* ORIG_RAX: no syscall to restart */
 661         .endif
 662
 663         ALLOC_PT_GPREGS_ON_STACK
 664
 665         .if \paranoid
 666         .if \paranoid == 1
 667         testb   $3, CS(%rsp)                    /* If coming from userspace, switch stacks */
 668         jnz     1f
 669         .endif
 670         call    paranoid_entry
 671         .else
 672         call    error_entry
 673         .endif
 674         /* returned flag: ebx=0: need swapgs on exit, ebx=1: don't need it */
 675
 676         .if \paranoid
 677         .if \shift_ist != -1
 678         TRACE_IRQS_OFF_DEBUG                    /* reload IDT in case of recursion */
 679         .else
 680         TRACE_IRQS_OFF
 681         .endif
 682         .endif
 683
 684         movq    %rsp, %rdi                      /* pt_regs pointer */
 685
 686         .if \has_error_code
 687         movq    ORIG_RAX(%rsp), %rsi            /* get error code */
 688         movq    $-1, ORIG_RAX(%rsp)             /* no syscall to restart */
 689         .else
 690         xorl    %esi, %esi                      /* no error code */
 691         .endif
 692
 693         .if \shift_ist != -1
 694         subq    $EXCEPTION_STKSZ, CPU_TSS_IST(\shift_ist)
 695         .endif
 696
 697         call    \do_sym
 698
 699         .if \shift_ist != -1
 700         addq    $EXCEPTION_STKSZ, CPU_TSS_IST(\shift_ist)
 701         .endif
 702
 703         /* these procedures expect "no swapgs" flag in ebx */
 704         .if \paranoid
 705         jmp     paranoid_exit
 706         .else
 707         jmp     error_exit
 708         .endif
 709
 710         .if \paranoid == 1
 711         /*
 712          * Paranoid entry from userspace.  Switch stacks and treat it
 713          * as a normal entry.  This means that paranoid handlers
 714          * run in real process context if user_mode(regs).
 715          */
 716 1:
 717         call    error_entry
 718
 719
 720         movq    %rsp, %rdi                      /* pt_regs pointer */
 721         call    sync_regs
 722         movq    %rax, %rsp                      /* switch stack */
 723
 724         movq    %rsp, %rdi                      /* pt_regs pointer */
 725
 726         .if \has_error_code
 727         movq    ORIG_RAX(%rsp), %rsi            /* get error code */
 728         movq    $-1, ORIG_RAX(%rsp)             /* no syscall to restart */
 729         .else
 730         xorl    %esi, %esi                      /* no error code */
 731         .endif
 732
 733         call    \do_sym
 734
 735         jmp     error_exit                      /* %ebx: no swapgs flag */
 736         .endif
 737 END(\sym)
 738 .endm
 739
 740 #ifdef CONFIG_TRACING
 741 .macro trace_idtentry sym do_sym has_error_code:req
 742 idtentry trace(\sym) trace(\do_sym) has_error_code=\has_error_code
 743 idtentry \sym \do_sym has_error_code=\has_error_code
 744 .endm
 745 #else
 746 .macro trace_idtentry sym do_sym has_error_code:req
 747 idtentry \sym \do_sym has_error_code=\has_error_code
 748 .endm
 749 #endif
 750
 751 idtentry divide_error                   do_divide_error                 has_error_code=0
 752 idtentry overflow                       do_overflow                     has_error_code=0
 753 idtentry bounds                         do_bounds                       has_error_code=0
 754 idtentry invalid_op                     do_invalid_op                   has_error_code=0
 755 idtentry device_not_available           do_device_not_available         has_error_code=0
 756 idtentry double_fault                   do_double_fault                 has_error_code=1 paranoid=2
 757 idtentry coprocessor_segment_overrun    do_coprocessor_segment_overrun  has_error_code=0
 758 idtentry invalid_TSS                    do_invalid_TSS                  has_error_code=1
 759 idtentry segment_not_present            do_segment_not_present          has_error_code=1
 760 idtentry spurious_interrupt_bug         do_spurious_interrupt_bug       has_error_code=0
 761 idtentry coprocessor_error              do_coprocessor_error            has_error_code=0
 762 idtentry alignment_check                do_alignment_check              has_error_code=1
 763 idtentry simd_coprocessor_error         do_simd_coprocessor_error       has_error_code=0
 764
 765
 766         /*
 767          * Reload gs selector with exception handling
 768          * edi:  new selector
 769          */
 770 ENTRY(native_load_gs_index)
 771         pushfq
 772         DISABLE_INTERRUPTS(CLBR_ANY & ~CLBR_RDI)
 773         SWAPGS
 774 gs_change:
 775         movl    %edi, %gs
 776 2:      mfence                                  /* workaround */
 777         SWAPGS
 778         popfq
 779         ret
 780 END(native_load_gs_index)
 781
 782         _ASM_EXTABLE(gs_change, bad_gs)
 783         .section .fixup, "ax"
 784         /* running with kernelgs */
 785 bad_gs:
 786         SWAPGS                                  /* switch back to user gs */
 787         xorl    %eax, %eax
 788         movl    %eax, %gs
 789         jmp     2b
 790         .previous
 791
 792 /* Call softirq on interrupt stack. Interrupts are off. */
 793 ENTRY(do_softirq_own_stack)
 794         pushq   %rbp
 795         mov     %rsp, %rbp
 796         incl    PER_CPU_VAR(irq_count)
 797         cmove   PER_CPU_VAR(irq_stack_ptr), %rsp
 798         push    %rbp                            /* frame pointer backlink */
 799         call    __do_softirq
 800         leaveq
 801         decl    PER_CPU_VAR(irq_count)
 802         ret
 803 END(do_softirq_own_stack)
 804
 805 #ifdef CONFIG_XEN
 806 idtentry xen_hypervisor_callback xen_do_hypervisor_callback has_error_code=0
 807
 808 /*
 809  * A note on the "critical region" in our callback handler.
 810  * We want to avoid stacking callback handlers due to events occurring
 811  * during handling of the last event. To do this, we keep events disabled
 812  * until we've done all processing. HOWEVER, we must enable events before
 813  * popping the stack frame (can't be done atomically) and so it would still
 814  * be possible to get enough handler activations to overflow the stack.
 815  * Although unlikely, bugs of that kind are hard to track down, so we'd
 816  * like to avoid the possibility.
 817  * So, on entry to the handler we detect whether we interrupted an
 818  * existing activation in its critical region -- if so, we pop the current
 819  * activation and restart the handler using the previous one.
 820  */
 821 ENTRY(xen_do_hypervisor_callback)               /* do_hypervisor_callback(struct *pt_regs) */
 822
 823 /*
 824  * Since we don't modify %rdi, evtchn_do_upall(struct *pt_regs) will
 825  * see the correct pointer to the pt_regs
 826  */
 827         movq    %rdi, %rsp                      /* we don't return, adjust the stack frame */
 828 11:     incl    PER_CPU_VAR(irq_count)
 829         movq    %rsp, %rbp
 830         cmovzq  PER_CPU_VAR(irq_stack_ptr), %rsp
 831         pushq   %rbp                            /* frame pointer backlink */
 832         call    xen_evtchn_do_upcall
 833         popq    %rsp
 834         decl    PER_CPU_VAR(irq_count)
 835 #ifndef CONFIG_PREEMPT
 836         call    xen_maybe_preempt_hcall
 837 #endif
 838         jmp     error_exit
 839 END(xen_do_hypervisor_callback)
 840
 841 /*
 842  * Hypervisor uses this for application faults while it executes.
 843  * We get here for two reasons:
 844  *  1. Fault while reloading DS, ES, FS or GS
 845  *  2. Fault while executing IRET
 846  * Category 1 we do not need to fix up as Xen has already reloaded all segment
 847  * registers that could be reloaded and zeroed the others.
 848  * Category 2 we fix up by killing the current process. We cannot use the
 849  * normal Linux return path in this case because if we use the IRET hypercall
 850  * to pop the stack frame we end up in an infinite loop of failsafe callbacks.
 851  * We distinguish between categories by comparing each saved segment register
 852  * with its current contents: any discrepancy means we in category 1.
 853  */
 854 ENTRY(xen_failsafe_callback)
 855         movl    %ds, %ecx
 856         cmpw    %cx, 0x10(%rsp)
 857         jne     1f
 858         movl    %es, %ecx
 859         cmpw    %cx, 0x18(%rsp)
 860         jne     1f
 861         movl    %fs, %ecx
 862         cmpw    %cx, 0x20(%rsp)
 863         jne     1f
 864         movl    %gs, %ecx
 865         cmpw    %cx, 0x28(%rsp)
 866         jne     1f
 867         /* All segments match their saved values => Category 2 (Bad IRET). */
 868         movq    (%rsp), %rcx
 869         movq    8(%rsp), %r11
 870         addq    $0x30, %rsp
 871         pushq   $0                              /* RIP */
 872         pushq   %r11
 873         pushq   %rcx
 874         jmp     general_protection
 875 1:      /* Segment mismatch => Category 1 (Bad segment). Retry the IRET. */
 876         movq    (%rsp), %rcx
 877         movq    8(%rsp), %r11
 878         addq    $0x30, %rsp
 879         pushq   $-1 /* orig_ax = -1 => not a system call */
 880         ALLOC_PT_GPREGS_ON_STACK
 881         SAVE_C_REGS
 882         SAVE_EXTRA_REGS
 883         jmp     error_exit
 884 END(xen_failsafe_callback)
 885
 886 apicinterrupt3 HYPERVISOR_CALLBACK_VECTOR \
 887         xen_hvm_callback_vector xen_evtchn_do_upcall
 888
 889 #endif /* CONFIG_XEN */
 890
 891 #if IS_ENABLED(CONFIG_HYPERV)
 892 apicinterrupt3 HYPERVISOR_CALLBACK_VECTOR \
 893         hyperv_callback_vector hyperv_vector_handler
 894 #endif /* CONFIG_HYPERV */
 895
 896 idtentry debug                  do_debug                has_error_code=0        paranoid=1 shift_ist=DEBUG_STACK
 897 idtentry int3                   do_int3                 has_error_code=0        paranoid=1 shift_ist=DEBUG_STACK
 898 idtentry stack_segment          do_stack_segment        has_error_code=1
 899
 900 #ifdef CONFIG_XEN
 901 idtentry xen_debug              do_debug                has_error_code=0
 902 idtentry xen_int3               do_int3                 has_error_code=0
 903 idtentry xen_stack_segment      do_stack_segment        has_error_code=1
 904 #endif
 905
 906 idtentry general_protection     do_general_protection   has_error_code=1
 907 trace_idtentry page_fault       do_page_fault           has_error_code=1
 908
 909 #ifdef CONFIG_KVM_GUEST
 910 idtentry async_page_fault       do_async_page_fault     has_error_code=1
 911 #endif
 912
 913 #ifdef CONFIG_X86_MCE
 914 idtentry machine_check                                  has_error_code=0        paranoid=1 do_sym=*machine_check_vector(%rip)
 915 #endif
 916
 917 /*
 918  * Save all registers in pt_regs, and switch gs if needed.
 919  * Use slow, but surefire "are we in kernel?" check.
 920  * Return: ebx=0: need swapgs on exit, ebx=1: otherwise
 921  */
 922 ENTRY(paranoid_entry)
 923         cld
 924         SAVE_C_REGS 8
 925         SAVE_EXTRA_REGS 8
 926         movl    $1, %ebx
 927         movl    $MSR_GS_BASE, %ecx
 928         rdmsr
 929         testl   %edx, %edx
 930         js      1f                              /* negative -> in kernel */
 931         SWAPGS
 932         xorl    %ebx, %ebx
 933 1:      ret
 934 END(paranoid_entry)
 935
 936 /*
 937  * "Paranoid" exit path from exception stack.  This is invoked
 938  * only on return from non-NMI IST interrupts that came
 939  * from kernel space.
 940  *
 941  * We may be returning to very strange contexts (e.g. very early
 942  * in syscall entry), so checking for preemption here would
 943  * be complicated.  Fortunately, we there's no good reason
 944  * to try to handle preemption here.
 945  *
 946  * On entry, ebx is "no swapgs" flag (1: don't need swapgs, 0: need it)
 947  */
 948 ENTRY(paranoid_exit)
 949         DISABLE_INTERRUPTS(CLBR_NONE)
 950         TRACE_IRQS_OFF_DEBUG
 951         testl   %ebx, %ebx                      /* swapgs needed? */
 952         jnz     paranoid_exit_no_swapgs
 953         TRACE_IRQS_IRETQ
 954         SWAPGS_UNSAFE_STACK
 955         jmp     paranoid_exit_restore
 956 paranoid_exit_no_swapgs:
 957         TRACE_IRQS_IRETQ_DEBUG
 958 paranoid_exit_restore:
 959         RESTORE_EXTRA_REGS
 960         RESTORE_C_REGS
 961         REMOVE_PT_GPREGS_FROM_STACK 8
 962         INTERRUPT_RETURN
 963 END(paranoid_exit)
 964
 965 /*
 966  * Save all registers in pt_regs, and switch gs if needed.
 967  * Return: EBX=0: came from user mode; EBX=1: otherwise
 968  */
 969 ENTRY(error_entry)
 970         cld
 971         SAVE_C_REGS 8
 972         SAVE_EXTRA_REGS 8
 973         xorl    %ebx, %ebx
 974         testb   $3, CS+8(%rsp)
 975         jz      .Lerror_kernelspace
 976
 977 .Lerror_entry_from_usermode_swapgs:
 978         /*
 979          * We entered from user mode or we're pretending to have entered
 980          * from user mode due to an IRET fault.
 981          */
 982         SWAPGS
 983
 984 .Lerror_entry_from_usermode_after_swapgs:
 985         /*
 986          * We need to tell lockdep that IRQs are off.  We can't do this until
 987          * we fix gsbase, and we should do it before enter_from_user_mode
 988          * (which can take locks).
 989          */
 990         TRACE_IRQS_OFF
 991         CALL_enter_from_user_mode
 992         ret
 993
 994 .Lerror_entry_done:
 995         TRACE_IRQS_OFF
 996         ret
 997
 998         /*
 999          * There are two places in the kernel that can potentially fault with
1000          * usergs. Handle them here.  B stepping K8s sometimes report a
1001          * truncated RIP for IRET exceptions returning to compat mode. Check
1002          * for these here too.
1003          */
1004 .Lerror_kernelspace:
1005         incl    %ebx
1006         leaq    native_irq_return_iret(%rip), %rcx
1007         cmpq    %rcx, RIP+8(%rsp)
1008         je      .Lerror_bad_iret
1009         movl    %ecx, %eax                      /* zero extend */
1010         cmpq    %rax, RIP+8(%rsp)
1011         je      .Lbstep_iret
1012         cmpq    $gs_change, RIP+8(%rsp)
1013         jne     .Lerror_entry_done
1014
1015         /*
1016          * hack: gs_change can fail with user gsbase.  If this happens, fix up
1017          * gsbase and proceed.  We'll fix up the exception and land in
1018          * gs_change's error handler with kernel gsbase.
1019          */
1020         jmp     .Lerror_entry_from_usermode_swapgs
1021
1022 .Lbstep_iret:
1023         /* Fix truncated RIP */
1024         movq    %rcx, RIP+8(%rsp)
1025         /* fall through */
1026
1027 .Lerror_bad_iret:
1028         /*
1029          * We came from an IRET to user mode, so we have user gsbase.
1030          * Switch to kernel gsbase:
1031          */
1032         SWAPGS
1033
1034         /*
1035          * Pretend that the exception came from user mode: set up pt_regs
1036          * as if we faulted immediately after IRET and clear EBX so that
1037          * error_exit knows that we will be returning to user mode.
1038          */
1039         mov     %rsp, %rdi
1040         call    fixup_bad_iret
1041         mov     %rax, %rsp
1042         decl    %ebx
1043         jmp     .Lerror_entry_from_usermode_after_swapgs
1044 END(error_entry)
1045
1046
1047 /*
1048  * On entry, EBS is a "return to kernel mode" flag:
1049  *   1: already in kernel mode, don't need SWAPGS
1050  *   0: user gsbase is loaded, we need SWAPGS and standard preparation for return to usermode
1051  */
1052 ENTRY(error_exit)
1053         movl    %ebx, %eax
1054         DISABLE_INTERRUPTS(CLBR_NONE)
1055         TRACE_IRQS_OFF
1056         testl   %eax, %eax
1057         jnz     retint_kernel
1058         jmp     retint_user
1059 END(error_exit)
1060
1061 /* Runs on exception stack */
1062 ENTRY(nmi)
1063         /*
1064          * Fix up the exception frame if we're on Xen.
1065          * PARAVIRT_ADJUST_EXCEPTION_FRAME is guaranteed to push at most
1066          * one value to the stack on native, so it may clobber the rdx
1067          * scratch slot, but it won't clobber any of the important
1068          * slots past it.
1069          *
1070          * Xen is a different story, because the Xen frame itself overlaps
1071          * the "NMI executing" variable.
1072          */
1073         PARAVIRT_ADJUST_EXCEPTION_FRAME
1074
1075         /*
1076          * We allow breakpoints in NMIs. If a breakpoint occurs, then
1077          * the iretq it performs will take us out of NMI context.
1078          * This means that we can have nested NMIs where the next
1079          * NMI is using the top of the stack of the previous NMI. We
1080          * can't let it execute because the nested NMI will corrupt the
1081          * stack of the previous NMI. NMI handlers are not re-entrant
1082          * anyway.
1083          *
1084          * To handle this case we do the following:
1085          *  Check the a special location on the stack that contains
1086          *  a variable that is set when NMIs are executing.
1087          *  The interrupted task's stack is also checked to see if it
1088          *  is an NMI stack.
1089          *  If the variable is not set and the stack is not the NMI
1090          *  stack then:
1091          *    o Set the special variable on the stack
1092          *    o Copy the interrupt frame into an "outermost" location on the
1093          *      stack
1094          *    o Copy the interrupt frame into an "iret" location on the stack
1095          *    o Continue processing the NMI
1096          *  If the variable is set or the previous stack is the NMI stack:
1097          *    o Modify the "iret" location to jump to the repeat_nmi
1098          *    o return back to the first NMI
1099          *
1100          * Now on exit of the first NMI, we first clear the stack variable
1101          * The NMI stack will tell any nested NMIs at that point that it is
1102          * nested. Then we pop the stack normally with iret, and if there was
1103          * a nested NMI that updated the copy interrupt stack frame, a
1104          * jump will be made to the repeat_nmi code that will handle the second
1105          * NMI.
1106          *
1107          * However, espfix prevents us from directly returning to userspace
1108          * with a single IRET instruction.  Similarly, IRET to user mode
1109          * can fault.  We therefore handle NMIs from user space like
1110          * other IST entries.
1111          */
1112
1113         /* Use %rdx as our temp variable throughout */
1114         pushq   %rdx
1115
1116         testb   $3, CS-RIP+8(%rsp)
1117         jz      .Lnmi_from_kernel
1118
1119         /*
1120          * NMI from user mode.  We need to run on the thread stack, but we
1121          * can't go through the normal entry paths: NMIs are masked, and
1122          * we don't want to enable interrupts, because then we'll end
1123          * up in an awkward situation in which IRQs are on but NMIs
1124          * are off.
1125          *
1126          * We also must not push anything to the stack before switching
1127          * stacks lest we corrupt the "NMI executing" variable.
1128          */
1129
1130         SWAPGS_UNSAFE_STACK
1131         cld
1132         movq    %rsp, %rdx
1133         movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp
1134         pushq   5*8(%rdx)       /* pt_regs->ss */
1135         pushq   4*8(%rdx)       /* pt_regs->rsp */
1136         pushq   3*8(%rdx)       /* pt_regs->flags */
1137         pushq   2*8(%rdx)       /* pt_regs->cs */
1138         pushq   1*8(%rdx)       /* pt_regs->rip */
1139         pushq   $-1             /* pt_regs->orig_ax */
1140         pushq   %rdi            /* pt_regs->di */
1141         pushq   %rsi            /* pt_regs->si */
1142         pushq   (%rdx)          /* pt_regs->dx */
1143         pushq   %rcx            /* pt_regs->cx */
1144         pushq   %rax            /* pt_regs->ax */
1145         pushq   %r8             /* pt_regs->r8 */
1146         pushq   %r9             /* pt_regs->r9 */
1147         pushq   %r10            /* pt_regs->r10 */
1148         pushq   %r11            /* pt_regs->r11 */
1149         pushq   %rbx            /* pt_regs->rbx */
1150         pushq   %rbp            /* pt_regs->rbp */
1151         pushq   %r12            /* pt_regs->r12 */
1152         pushq   %r13            /* pt_regs->r13 */
1153         pushq   %r14            /* pt_regs->r14 */
1154         pushq   %r15            /* pt_regs->r15 */
1155
1156         /*
1157          * At this point we no longer need to worry about stack damage
1158          * due to nesting -- we're on the normal thread stack and we're
1159          * done with the NMI stack.
1160          */
1161
1162         movq    %rsp, %rdi
1163         movq    $-1, %rsi
1164         call    do_nmi
1165
1166         /*
1167          * Return back to user mode.  We must *not* do the normal exit
1168          * work, because we don't want to enable interrupts.  Fortunately,
1169          * do_nmi doesn't modify pt_regs.
1170          */
1171         SWAPGS
1172         jmp     restore_c_regs_and_iret
1173
1174 .Lnmi_from_kernel:
1175         /*
1176          * Here's what our stack frame will look like:
1177          * +---------------------------------------------------------+
1178          * | original SS                                             |
1179          * | original Return RSP                                     |
1180          * | original RFLAGS                                         |
1181          * | original CS                                             |
1182          * | original RIP                                            |
1183          * +---------------------------------------------------------+
1184          * | temp storage for rdx                                    |
1185          * +---------------------------------------------------------+
1186          * | "NMI executing" variable                                |
1187          * +---------------------------------------------------------+
1188          * | iret SS          } Copied from "outermost" frame        |
1189          * | iret Return RSP  } on each loop iteration; overwritten  |
1190          * | iret RFLAGS      } by a nested NMI to force another     |
1191          * | iret CS          } iteration if needed.                 |
1192          * | iret RIP         }                                      |
1193          * +---------------------------------------------------------+
1194          * | outermost SS          } initialized in first_nmi;       |
1195          * | outermost Return RSP  } will not be changed before      |
1196          * | outermost RFLAGS      } NMI processing is done.         |
1197          * | outermost CS          } Copied to "iret" frame on each  |
1198          * | outermost RIP         } iteration.                      |
1199          * +---------------------------------------------------------+
1200          * | pt_regs                                                 |
1201          * +---------------------------------------------------------+
1202          *
1203          * The "original" frame is used by hardware.  Before re-enabling
1204          * NMIs, we need to be done with it, and we need to leave enough
1205          * space for the asm code here.
1206          *
1207          * We return by executing IRET while RSP points to the "iret" frame.
1208          * That will either return for real or it will loop back into NMI
1209          * processing.
1210          *
1211          * The "outermost" frame is copied to the "iret" frame on each
1212          * iteration of the loop, so each iteration starts with the "iret"
1213          * frame pointing to the final return target.
1214          */
1215
1216         /*
1217          * Determine whether we're a nested NMI.
1218          *
1219          * If we interrupted kernel code between repeat_nmi and
1220          * end_repeat_nmi, then we are a nested NMI.  We must not
1221          * modify the "iret" frame because it's being written by
1222          * the outer NMI.  That's okay; the outer NMI handler is
1223          * about to about to call do_nmi anyway, so we can just
1224          * resume the outer NMI.
1225          */
1226
1227         movq    $repeat_nmi, %rdx
1228         cmpq    8(%rsp), %rdx
1229         ja      1f
1230         movq    $end_repeat_nmi, %rdx
1231         cmpq    8(%rsp), %rdx
1232         ja      nested_nmi_out
1233 1:
1234
1235         /*
1236          * Now check "NMI executing".  If it's set, then we're nested.
1237          * This will not detect if we interrupted an outer NMI just
1238          * before IRET.
1239          */
1240         cmpl    $1, -8(%rsp)
1241         je      nested_nmi
1242
1243         /*
1244          * Now test if the previous stack was an NMI stack.  This covers
1245          * the case where we interrupt an outer NMI after it clears
1246          * "NMI executing" but before IRET.  We need to be careful, though:
1247          * there is one case in which RSP could point to the NMI stack
1248          * despite there being no NMI active: naughty userspace controls
1249          * RSP at the very beginning of the SYSCALL targets.  We can
1250          * pull a fast one on naughty userspace, though: we program
1251          * SYSCALL to mask DF, so userspace cannot cause DF to be set
1252          * if it controls the kernel's RSP.  We set DF before we clear
1253          * "NMI executing".
1254          */
1255         lea     6*8(%rsp), %rdx
1256         /* Compare the NMI stack (rdx) with the stack we came from (4*8(%rsp)) */
1257         cmpq    %rdx, 4*8(%rsp)
1258         /* If the stack pointer is above the NMI stack, this is a normal NMI */
1259         ja      first_nmi
1260
1261         subq    $EXCEPTION_STKSZ, %rdx
1262         cmpq    %rdx, 4*8(%rsp)
1263         /* If it is below the NMI stack, it is a normal NMI */
1264         jb      first_nmi
1265
1266         /* Ah, it is within the NMI stack. */
1267
1268         testb   $(X86_EFLAGS_DF >> 8), (3*8 + 1)(%rsp)
1269         jz      first_nmi       /* RSP was user controlled. */
1270
1271         /* This is a nested NMI. */
1272
1273 nested_nmi:
1274         /*
1275          * Modify the "iret" frame to point to repeat_nmi, forcing another
1276          * iteration of NMI handling.
1277          */
1278         subq    $8, %rsp
1279         leaq    -10*8(%rsp), %rdx
1280         pushq   $__KERNEL_DS
1281         pushq   %rdx
1282         pushfq
1283         pushq   $__KERNEL_CS
1284         pushq   $repeat_nmi
1285
1286         /* Put stack back */
1287         addq    $(6*8), %rsp
1288
1289 nested_nmi_out:
1290         popq    %rdx
1291
1292         /* We are returning to kernel mode, so this cannot result in a fault. */
1293         INTERRUPT_RETURN
1294
1295 first_nmi:
1296         /* Restore rdx. */
1297         movq    (%rsp), %rdx
1298
1299         /* Make room for "NMI executing". */
1300         pushq   $0
1301
1302         /* Leave room for the "iret" frame */
1303         subq    $(5*8), %rsp
1304
1305         /* Copy the "original" frame to the "outermost" frame */
1306         .rept 5
1307         pushq   11*8(%rsp)
1308         .endr
1309
1310         /* Everything up to here is safe from nested NMIs */
1311
1312 #ifdef CONFIG_DEBUG_ENTRY
1313         /*
1314          * For ease of testing, unmask NMIs right away.  Disabled by
1315          * default because IRET is very expensive.
1316          */
1317         pushq   $0              /* SS */
1318         pushq   %rsp            /* RSP (minus 8 because of the previous push) */
1319         addq    $8, (%rsp)      /* Fix up RSP */
1320         pushfq                  /* RFLAGS */
1321         pushq   $__KERNEL_CS    /* CS */
1322         pushq   $1f             /* RIP */
1323         INTERRUPT_RETURN        /* continues at repeat_nmi below */
1324 1:
1325 #endif
1326
1327 repeat_nmi:
1328         /*
1329          * If there was a nested NMI, the first NMI's iret will return
1330          * here. But NMIs are still enabled and we can take another
1331          * nested NMI. The nested NMI checks the interrupted RIP to see
1332          * if it is between repeat_nmi and end_repeat_nmi, and if so
1333          * it will just return, as we are about to repeat an NMI anyway.
1334          * This makes it safe to copy to the stack frame that a nested
1335          * NMI will update.
1336          *
1337          * RSP is pointing to "outermost RIP".  gsbase is unknown, but, if
1338          * we're repeating an NMI, gsbase has the same value that it had on
1339          * the first iteration.  paranoid_entry will load the kernel
1340          * gsbase if needed before we call do_nmi.  "NMI executing"
1341          * is zero.
1342          */
1343         movq    $1, 10*8(%rsp)          /* Set "NMI executing". */
1344
1345         /*
1346          * Copy the "outermost" frame to the "iret" frame.  NMIs that nest
1347          * here must not modify the "iret" frame while we're writing to
1348          * it or it will end up containing garbage.
1349          */
1350         addq    $(10*8), %rsp
1351         .rept 5
1352         pushq   -6*8(%rsp)
1353         .endr
1354         subq    $(5*8), %rsp
1355 end_repeat_nmi:
1356
1357         /*
1358          * Everything below this point can be preempted by a nested NMI.
1359          * If this happens, then the inner NMI will change the "iret"
1360          * frame to point back to repeat_nmi.
1361          */
1362         pushq   $-1                             /* ORIG_RAX: no syscall to restart */
1363         ALLOC_PT_GPREGS_ON_STACK
1364
1365         /*
1366          * Use paranoid_entry to handle SWAPGS, but no need to use paranoid_exit
1367          * as we should not be calling schedule in NMI context.
1368          * Even with normal interrupts enabled. An NMI should not be
1369          * setting NEED_RESCHED or anything that normal interrupts and
1370          * exceptions might do.
1371          */
1372         call    paranoid_entry
1373
1374         /* paranoidentry do_nmi, 0; without TRACE_IRQS_OFF */
1375         movq    %rsp, %rdi
1376         movq    $-1, %rsi
1377         call    do_nmi
1378
1379         testl   %ebx, %ebx                      /* swapgs needed? */
1380         jnz     nmi_restore
1381 nmi_swapgs:
1382         SWAPGS_UNSAFE_STACK
1383 nmi_restore:
1384         RESTORE_EXTRA_REGS
1385         RESTORE_C_REGS
1386
1387         /* Point RSP at the "iret" frame. */
1388         REMOVE_PT_GPREGS_FROM_STACK 6*8
1389
1390         /*
1391          * Clear "NMI executing".  Set DF first so that we can easily
1392          * distinguish the remaining code between here and IRET from
1393          * the SYSCALL entry and exit paths.  On a native kernel, we
1394          * could just inspect RIP, but, on paravirt kernels,
1395          * INTERRUPT_RETURN can translate into a jump into a
1396          * hypercall page.
1397          */
1398         std
1399         movq    $0, 5*8(%rsp)           /* clear "NMI executing" */
1400
1401         /*
1402          * INTERRUPT_RETURN reads the "iret" frame and exits the NMI
1403          * stack in a single instruction.  We are returning to kernel
1404          * mode, so this cannot result in a fault.
1405          */
1406         INTERRUPT_RETURN
1407 END(nmi)
1408
1409 ENTRY(ignore_sysret)
1410         mov     $-ENOSYS, %eax
1411         sysret
1412 END(ignore_sysret)