arch/x86/kernel/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
   9 /*
  10  * entry.S contains the system-call and fault low-level handling routines.
  11  *
  12  * Some of this is documented in Documentation/x86/entry_64.txt
  13  *
  14  * NOTE: This code handles signal-recognition, which happens every time
  15  * after an interrupt and after each system call.
  16  *
  17  * Normal syscalls and interrupts don't save a full stack frame, this is
  18  * only done for syscall tracing, signals or fork/exec et.al.
  19  *
  20  * A note on terminology:
  21  * - top of stack: Architecture defined interrupt frame from SS to RIP
  22  * at the top of the kernel process stack.
  23  * - partial stack frame: partially saved registers up to R11.
  24  * - full stack frame: Like partial stack frame, but all register saved.
  25  *
  26  * Some macro usage:
  27  * - CFI macros are used to generate dwarf2 unwind information for better
  28  * backtraces. They don't change any code.
  29  * - SAVE_ALL/RESTORE_ALL - Save/restore all registers
  30  * - SAVE_ARGS/RESTORE_ARGS - Save/restore registers that C functions modify.
  31  * There are unfortunately lots of special cases where some registers
  32  * not touched. The macro is a big mess that should be cleaned up.
  33  * - SAVE_REST/RESTORE_REST - Handle the registers not saved by SAVE_ARGS.
  34  * Gives a full stack frame.
  35  * - ENTRY/END Define functions in the symbol table.
  36  * - FIXUP_TOP_OF_STACK/RESTORE_TOP_OF_STACK - Fix up the hardware stack
  37  * frame that is otherwise undefined after a SYSCALL
  38  * - TRACE_IRQ_* - Trace hard interrupt state for lock debugging.
  39  * - errorentry/paranoidentry/zeroentry - Define exception entry points.
  40  */
  41
  42 #include <linux/linkage.h>
  43 #include <asm/segment.h>
  44 #include <asm/cache.h>
  45 #include <asm/errno.h>
  46 #include <asm/dwarf2.h>
  47 #include <asm/calling.h>
  48 #include <asm/asm-offsets.h>
  49 #include <asm/msr.h>
  50 #include <asm/unistd.h>
  51 #include <asm/thread_info.h>
  52 #include <asm/hw_irq.h>
  53 #include <asm/page_types.h>
  54 #include <asm/irqflags.h>
  55 #include <asm/paravirt.h>
  56 #include <asm/ftrace.h>
  57 #include <asm/percpu.h>
  58 #include <asm/pgtable_types.h>
  59 #include <asm/alternative-asm.h>
  60 #include <asm/cpufeature.h>
  61 #include <asm/kaiser.h>
  62
  63 /* Avoid __ASSEMBLER__'ifying <linux/audit.h> just for this.  */
  64 #include <linux/elf-em.h>
  65 #define AUDIT_ARCH_X86_64       (EM_X86_64|__AUDIT_ARCH_64BIT|__AUDIT_ARCH_LE)
  66 #define __AUDIT_ARCH_64BIT 0x80000000
  67 #define __AUDIT_ARCH_LE    0x40000000
  68
  69         .code64
  70         .section .entry.text, "ax"
  71
  72 #ifdef CONFIG_FUNCTION_TRACER
  73 #ifdef CONFIG_DYNAMIC_FTRACE
  74 ENTRY(mcount)
  75         retq
  76 END(mcount)
  77
  78 ENTRY(ftrace_caller)
  79         cmpl $0, function_trace_stop
  80         jne  ftrace_stub
  81
  82         MCOUNT_SAVE_FRAME
  83
  84         movq 0x38(%rsp), %rdi
  85         movq 8(%rbp), %rsi
  86         subq $MCOUNT_INSN_SIZE, %rdi
  87
  88 GLOBAL(ftrace_call)
  89         call ftrace_stub
  90
  91         MCOUNT_RESTORE_FRAME
  92
  93 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
  94 GLOBAL(ftrace_graph_call)
  95         jmp ftrace_stub
  96 #endif
  97
  98 GLOBAL(ftrace_stub)
  99         retq
 100 END(ftrace_caller)
 101
 102 #else /* ! CONFIG_DYNAMIC_FTRACE */
 103 ENTRY(mcount)
 104         cmpl $0, function_trace_stop
 105         jne  ftrace_stub
 106
 107         cmpq $ftrace_stub, ftrace_trace_function
 108         jnz trace
 109
 110 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 111         cmpq $ftrace_stub, ftrace_graph_return
 112         jnz ftrace_graph_caller
 113
 114         cmpq $ftrace_graph_entry_stub, ftrace_graph_entry
 115         jnz ftrace_graph_caller
 116 #endif
 117
 118 GLOBAL(ftrace_stub)
 119         retq
 120
 121 trace:
 122         MCOUNT_SAVE_FRAME
 123
 124         movq 0x38(%rsp), %rdi
 125         movq 8(%rbp), %rsi
 126         subq $MCOUNT_INSN_SIZE, %rdi
 127
 128         call   *ftrace_trace_function
 129
 130         MCOUNT_RESTORE_FRAME
 131
 132         jmp ftrace_stub
 133 END(mcount)
 134 #endif /* CONFIG_DYNAMIC_FTRACE */
 135 #endif /* CONFIG_FUNCTION_TRACER */
 136
 137 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 138 ENTRY(ftrace_graph_caller)
 139         cmpl $0, function_trace_stop
 140         jne ftrace_stub
 141
 142         MCOUNT_SAVE_FRAME
 143
 144         leaq 8(%rbp), %rdi
 145         movq 0x38(%rsp), %rsi
 146         movq (%rbp), %rdx
 147         subq $MCOUNT_INSN_SIZE, %rsi
 148
 149         call    prepare_ftrace_return
 150
 151         MCOUNT_RESTORE_FRAME
 152
 153         retq
 154 END(ftrace_graph_caller)
 155
 156 GLOBAL(return_to_handler)
 157         subq  $24, %rsp
 158
 159         /* Save the return values */
 160         movq %rax, (%rsp)
 161         movq %rdx, 8(%rsp)
 162         movq %rbp, %rdi
 163
 164         call ftrace_return_to_handler
 165
 166         movq %rax, %rdi
 167         movq 8(%rsp), %rdx
 168         movq (%rsp), %rax
 169         addq $24, %rsp
 170         jmp *%rdi
 171 #endif
 172
 173
 174 #ifndef CONFIG_PREEMPT
 175 #define retint_kernel retint_restore_args
 176 #endif
 177
 178 #ifdef CONFIG_PARAVIRT
 179 ENTRY(native_usergs_sysret64)
 180         swapgs
 181         sysretq
 182 ENDPROC(native_usergs_sysret64)
 183 #endif /* CONFIG_PARAVIRT */
 184
 185
 186 .macro TRACE_IRQS_IRETQ offset=ARGOFFSET
 187 #ifdef CONFIG_TRACE_IRQFLAGS
 188         bt   $9,EFLAGS-\offset(%rsp)    /* interrupts off? */
 189         jnc  1f
 190         TRACE_IRQS_ON
 191 1:
 192 #endif
 193 .endm
 194
 195 /*
 196  * C code is not supposed to know about undefined top of stack. Every time
 197  * a C function with an pt_regs argument is called from the SYSCALL based
 198  * fast path FIXUP_TOP_OF_STACK is needed.
 199  * RESTORE_TOP_OF_STACK syncs the syscall state after any possible ptregs
 200  * manipulation.
 201  */
 202
 203         /* %rsp:at FRAMEEND */
 204         .macro FIXUP_TOP_OF_STACK tmp offset=0
 205         movq PER_CPU_VAR(old_rsp),\tmp
 206         movq \tmp,RSP+\offset(%rsp)
 207         movq $__USER_DS,SS+\offset(%rsp)
 208         movq $__USER_CS,CS+\offset(%rsp)
 209         movq $-1,RCX+\offset(%rsp)
 210         movq R11+\offset(%rsp),\tmp  /* get eflags */
 211         movq \tmp,EFLAGS+\offset(%rsp)
 212         .endm
 213
 214         .macro RESTORE_TOP_OF_STACK tmp offset=0
 215         movq RSP+\offset(%rsp),\tmp
 216         movq \tmp,PER_CPU_VAR(old_rsp)
 217         movq EFLAGS+\offset(%rsp),\tmp
 218         movq \tmp,R11+\offset(%rsp)
 219         .endm
 220
 221         .macro FAKE_STACK_FRAME child_rip
 222         /* push in order ss, rsp, eflags, cs, rip */
 223         xorl %eax, %eax
 224         pushq_cfi $__KERNEL_DS /* ss */
 225         /*CFI_REL_OFFSET        ss,0*/
 226         pushq_cfi %rax /* rsp */
 227         CFI_REL_OFFSET  rsp,0
 228         pushq_cfi $X86_EFLAGS_IF /* eflags - interrupts on */
 229         /*CFI_REL_OFFSET        rflags,0*/
 230         pushq_cfi $__KERNEL_CS /* cs */
 231         /*CFI_REL_OFFSET        cs,0*/
 232         pushq_cfi \child_rip /* rip */
 233         CFI_REL_OFFSET  rip,0
 234         pushq_cfi %rax /* orig rax */
 235         .endm
 236
 237         .macro UNFAKE_STACK_FRAME
 238         addq $8*6, %rsp
 239         CFI_ADJUST_CFA_OFFSET   -(6*8)
 240         .endm
 241
 242 /*
 243  * initial frame state for interrupts (and exceptions without error code)
 244  */
 245         .macro EMPTY_FRAME start=1 offset=0
 246         .if \start
 247         CFI_STARTPROC simple
 248         CFI_SIGNAL_FRAME
 249         CFI_DEF_CFA rsp,8+\offset
 250         .else
 251         CFI_DEF_CFA_OFFSET 8+\offset
 252         .endif
 253         .endm
 254
 255 /*
 256  * initial frame state for interrupts (and exceptions without error code)
 257  */
 258         .macro INTR_FRAME start=1 offset=0
 259         EMPTY_FRAME \start, SS+8+\offset-RIP
 260         /*CFI_REL_OFFSET ss, SS+\offset-RIP*/
 261         CFI_REL_OFFSET rsp, RSP+\offset-RIP
 262         /*CFI_REL_OFFSET rflags, EFLAGS+\offset-RIP*/
 263         /*CFI_REL_OFFSET cs, CS+\offset-RIP*/
 264         CFI_REL_OFFSET rip, RIP+\offset-RIP
 265         .endm
 266
 267 /*
 268  * initial frame state for exceptions with error code (and interrupts
 269  * with vector already pushed)
 270  */
 271         .macro XCPT_FRAME start=1 offset=0
 272         INTR_FRAME \start, RIP+\offset-ORIG_RAX
 273         /*CFI_REL_OFFSET orig_rax, ORIG_RAX-ORIG_RAX*/
 274         .endm
 275
 276 /*
 277  * frame that enables calling into C.
 278  */
 279         .macro PARTIAL_FRAME start=1 offset=0
 280         XCPT_FRAME \start, ORIG_RAX+\offset-ARGOFFSET
 281         CFI_REL_OFFSET rdi, RDI+\offset-ARGOFFSET
 282         CFI_REL_OFFSET rsi, RSI+\offset-ARGOFFSET
 283         CFI_REL_OFFSET rdx, RDX+\offset-ARGOFFSET
 284         CFI_REL_OFFSET rcx, RCX+\offset-ARGOFFSET
 285         CFI_REL_OFFSET rax, RAX+\offset-ARGOFFSET
 286         CFI_REL_OFFSET r8, R8+\offset-ARGOFFSET
 287         CFI_REL_OFFSET r9, R9+\offset-ARGOFFSET
 288         CFI_REL_OFFSET r10, R10+\offset-ARGOFFSET
 289         CFI_REL_OFFSET r11, R11+\offset-ARGOFFSET
 290         .endm
 291
 292 /*
 293  * frame that enables passing a complete pt_regs to a C function.
 294  */
 295         .macro DEFAULT_FRAME start=1 offset=0
 296         PARTIAL_FRAME \start, R11+\offset-R15
 297         CFI_REL_OFFSET rbx, RBX+\offset
 298         CFI_REL_OFFSET rbp, RBP+\offset
 299         CFI_REL_OFFSET r12, R12+\offset
 300         CFI_REL_OFFSET r13, R13+\offset
 301         CFI_REL_OFFSET r14, R14+\offset
 302         CFI_REL_OFFSET r15, R15+\offset
 303         .endm
 304
 305 /* save partial stack frame */
 306         .macro SAVE_ARGS_IRQ
 307         cld
 308         /* start from rbp in pt_regs and jump over */
 309         movq_cfi rdi, RDI-RBP
 310         movq_cfi rsi, RSI-RBP
 311         movq_cfi rdx, RDX-RBP
 312         movq_cfi rcx, RCX-RBP
 313         movq_cfi rax, RAX-RBP
 314         movq_cfi  r8,  R8-RBP
 315         movq_cfi  r9,  R9-RBP
 316         movq_cfi r10, R10-RBP
 317         movq_cfi r11, R11-RBP
 318
 319         /* Save rbp so that we can unwind from get_irq_regs() */
 320         movq_cfi rbp, 0
 321
 322         /* Save previous stack value */
 323         movq %rsp, %rsi
 324
 325         leaq -RBP(%rsp),%rdi    /* arg1 for handler */
 326         testl $3, CS(%rdi)
 327         je 1f
 328         SWAPGS
 329         SWITCH_KERNEL_CR3
 330         /*
 331          * irq_count is used to check if a CPU is already on an interrupt stack
 332          * or not. While this is essentially redundant with preempt_count it is
 333          * a little cheaper to use a separate counter in the PDA (short of
 334          * moving irq_enter into assembly, which would be too much work)
 335          */
 336 1:      incl PER_CPU_VAR(irq_count)
 337         jne 2f
 338         mov PER_CPU_VAR(irq_stack_ptr),%rsp
 339         CFI_DEF_CFA_REGISTER    rsi
 340
 341 2:      /* Store previous stack value */
 342         pushq %rsi
 343         CFI_ESCAPE      0x0f /* DW_CFA_def_cfa_expression */, 6, \
 344                         0x77 /* DW_OP_breg7 */, 0, \
 345                         0x06 /* DW_OP_deref */, \
 346                         0x08 /* DW_OP_const1u */, SS+8-RBP, \
 347                         0x22 /* DW_OP_plus */
 348         /* We entered an interrupt context - irqs are off: */
 349         TRACE_IRQS_OFF
 350         .endm
 351
 352 ENTRY(save_rest)
 353         PARTIAL_FRAME 1 REST_SKIP+8
 354         movq 5*8+16(%rsp), %r11 /* save return address */
 355         movq_cfi rbx, RBX+16
 356         movq_cfi rbp, RBP+16
 357         movq_cfi r12, R12+16
 358         movq_cfi r13, R13+16
 359         movq_cfi r14, R14+16
 360         movq_cfi r15, R15+16
 361         movq %r11, 8(%rsp)      /* return address */
 362         FIXUP_TOP_OF_STACK %r11, 16
 363         ret
 364         CFI_ENDPROC
 365 END(save_rest)
 366
 367 /* save complete stack frame */
 368         .pushsection .kprobes.text, "ax"
 369 /*
 370  * Return: ebx=0: needs swapgs but not SWITCH_USER_CR3 in paranoid_exit
 371  *         ebx=1: needs neither swapgs nor SWITCH_USER_CR3 in paranoid_exit
 372  *         ebx=2: needs both swapgs and SWITCH_USER_CR3 in paranoid_exit
 373  *         ebx=3: needs SWITCH_USER_CR3 but not swapgs in paranoid_exit
 374  */
 375 ENTRY(save_paranoid)
 376         XCPT_FRAME 1 RDI+8
 377         cld
 378         movq_cfi rdi, RDI+8
 379         movq_cfi rsi, RSI+8
 380         movq_cfi rdx, RDX+8
 381         movq_cfi rcx, RCX+8
 382         movq_cfi rax, RAX+8
 383         movq_cfi r8, R8+8
 384         movq_cfi r9, R9+8
 385         movq_cfi r10, R10+8
 386         movq_cfi r11, R11+8
 387         movq_cfi rbx, RBX+8
 388         movq_cfi rbp, RBP+8
 389         movq_cfi r12, R12+8
 390         movq_cfi r13, R13+8
 391         movq_cfi r14, R14+8
 392         movq_cfi r15, R15+8
 393         movl $1,%ebx
 394         movl $MSR_GS_BASE,%ecx
 395         rdmsr
 396         testl %edx,%edx
 397         js 1f   /* negative -> in kernel */
 398         SWAPGS
 399         xorl %ebx,%ebx
 400 1:
 401 #ifdef CONFIG_PAGE_TABLE_ISOLATION
 402         /*
 403          * We might have come in between a swapgs and a SWITCH_KERNEL_CR3
 404          * on entry, or between a SWITCH_USER_CR3 and a swapgs on exit.
 405          * Do a conditional SWITCH_KERNEL_CR3: this could safely be done
 406          * unconditionally, but we need to find out whether the reverse
 407          * should be done on return (conveyed to paranoid_exit in %ebx).
 408          */
 409         ALTERNATIVE "jmp 2f", "movq %cr3, %rax", X86_FEATURE_KAISER
 410         testl   $KAISER_SHADOW_PGD_OFFSET, %eax
 411         jz      2f
 412         orl     $2, %ebx
 413         andq    $(~(X86_CR3_PCID_ASID_MASK | KAISER_SHADOW_PGD_OFFSET)), %rax
 414         /* If PCID enabled, set X86_CR3_PCID_NOFLUSH_BIT */
 415         ALTERNATIVE "", "bts $63, %rax", X86_FEATURE_PCID
 416         movq    %rax, %cr3
 417 2:
 418 #endif
 419         ret
 420         CFI_ENDPROC
 421 END(save_paranoid)
 422         .popsection
 423
 424 /*
 425  * A newly forked process directly context switches into this address.
 426  *
 427  * rdi: prev task we switched from
 428  */
 429 ENTRY(ret_from_fork)
 430         DEFAULT_FRAME
 431
 432         LOCK ; btr $TIF_FORK,TI_flags(%r8)
 433
 434         pushq_cfi kernel_eflags(%rip)
 435         popfq_cfi                               # reset kernel eflags
 436
 437         call schedule_tail                      # rdi: 'prev' task parameter
 438
 439         GET_THREAD_INFO(%rcx)
 440
 441         RESTORE_REST
 442
 443         testl $3, CS-ARGOFFSET(%rsp)            # from kernel_thread?
 444         je   int_ret_from_sys_call
 445
 446         /*
 447          * By the time we get here, we have no idea whether our pt_regs,
 448          * ti flags, and ti status came from the 64-bit SYSCALL fast path,
 449          * the slow path, or one of the ia32entry paths.
 450          * Use int_ret_from_sys_call to return, since it can safely handle
 451          * all of the above.
 452          */
 453         jmp  int_ret_from_sys_call
 454
 455         CFI_ENDPROC
 456 END(ret_from_fork)
 457
 458 /*
 459  * System call entry. Up to 6 arguments in registers are supported.
 460  *
 461  * SYSCALL does not save anything on the stack and does not change the
 462  * stack pointer.
 463  */
 464
 465 /*
 466  * Register setup:
 467  * rax  system call number
 468  * rdi  arg0
 469  * rcx  return address for syscall/sysret, C arg3
 470  * rsi  arg1
 471  * rdx  arg2
 472  * r10  arg3    (--> moved to rcx for C)
 473  * r8   arg4
 474  * r9   arg5
 475  * r11  eflags for syscall/sysret, temporary for C
 476  * r12-r15,rbp,rbx saved by C code, not touched.
 477  *
 478  * Interrupts are off on entry.
 479  * Only called from user space.
 480  *
 481  * XXX  if we had a free scratch register we could save the RSP into the stack frame
 482  *      and report it properly in ps. Unfortunately we haven't.
 483  *
 484  * When user can change the frames always force IRET. That is because
 485  * it deals with uncanonical addresses better. SYSRET has trouble
 486  * with them due to bugs in both AMD and Intel CPUs.
 487  */
 488
 489 ENTRY(system_call)
 490         CFI_STARTPROC   simple
 491         CFI_SIGNAL_FRAME
 492         CFI_DEF_CFA     rsp,KERNEL_STACK_OFFSET
 493         CFI_REGISTER    rip,rcx
 494         /*CFI_REGISTER  rflags,r11*/
 495         SWAPGS_UNSAFE_STACK
 496         SWITCH_KERNEL_CR3_NO_STACK
 497         /*
 498          * A hypervisor implementation might want to use a label
 499          * after the swapgs, so that it can do the swapgs
 500          * for the guest and jump here on syscall.
 501          */
 502 ENTRY(system_call_after_swapgs)
 503
 504         movq    %rsp,PER_CPU_VAR(old_rsp)
 505         movq    PER_CPU_VAR(kernel_stack),%rsp
 506         /*
 507          * No need to follow this irqs off/on section - it's straight
 508          * and short:
 509          */
 510         ENABLE_INTERRUPTS(CLBR_NONE)
 511         SAVE_ARGS 8,0
 512         movq  %rax,ORIG_RAX-ARGOFFSET(%rsp)
 513         movq  %rcx,RIP-ARGOFFSET(%rsp)
 514         CFI_REL_OFFSET rip,RIP-ARGOFFSET
 515         GET_THREAD_INFO(%rcx)
 516         testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%rcx)
 517         jnz tracesys
 518 system_call_fastpath:
 519         cmpq $__NR_syscall_max,%rax
 520         ja badsys
 521         movq %r10,%rcx
 522         call *sys_call_table(,%rax,8)  # XXX:    rip relative
 523         movq %rax,RAX-ARGOFFSET(%rsp)
 524 /*
 525  * Syscall return path ending with SYSRET (fast path)
 526  * Has incomplete stack frame and undefined top of stack.
 527  */
 528 ret_from_sys_call:
 529         movl $_TIF_ALLWORK_MASK,%edi
 530         /* edi: flagmask */
 531 sysret_check:
 532         LOCKDEP_SYS_EXIT
 533         GET_THREAD_INFO(%rcx)
 534         DISABLE_INTERRUPTS(CLBR_NONE)
 535         TRACE_IRQS_OFF
 536         movl TI_flags(%rcx),%edx
 537         andl %edi,%edx
 538         jnz  sysret_careful
 539         CFI_REMEMBER_STATE
 540         /*
 541          * sysretq will re-enable interrupts:
 542          */
 543         TRACE_IRQS_ON
 544         movq RIP-ARGOFFSET(%rsp),%rcx
 545         CFI_REGISTER    rip,rcx
 546         RESTORE_ARGS 1,-ARG_SKIP,0
 547         /*CFI_REGISTER  rflags,r11*/
 548         /*
 549          * This opens a window where we have a user CR3, but are
 550          * running in the kernel.  This makes using the CS
 551          * register useless for telling whether or not we need to
 552          * switch CR3 in NMIs.  Normal interrupts are OK because
 553          * they are off here.
 554          */
 555         SWITCH_USER_CR3
 556         movq    PER_CPU_VAR(old_rsp), %rsp
 557         USERGS_SYSRET64
 558
 559         CFI_RESTORE_STATE
 560         /* Handle reschedules */
 561         /* edx: work, edi: workmask */
 562 sysret_careful:
 563         bt $TIF_NEED_RESCHED,%edx
 564         jnc sysret_signal
 565         TRACE_IRQS_ON
 566         ENABLE_INTERRUPTS(CLBR_NONE)
 567         pushq_cfi %rdi
 568         call schedule
 569         popq_cfi %rdi
 570         jmp sysret_check
 571
 572         /* Handle a signal */
 573 sysret_signal:
 574         TRACE_IRQS_ON
 575         ENABLE_INTERRUPTS(CLBR_NONE)
 576 #ifdef CONFIG_AUDITSYSCALL
 577         bt $TIF_SYSCALL_AUDIT,%edx
 578         jc sysret_audit
 579 #endif
 580         /*
 581          * We have a signal, or exit tracing or single-step.
 582          * These all wind up with the iret return path anyway,
 583          * so just join that path right now.
 584          */
 585         FIXUP_TOP_OF_STACK %r11, -ARGOFFSET
 586         jmp int_check_syscall_exit_work
 587
 588 badsys:
 589         movq $-ENOSYS,RAX-ARGOFFSET(%rsp)
 590         jmp ret_from_sys_call
 591
 592 #ifdef CONFIG_AUDITSYSCALL
 593         /*
 594          * Fast path for syscall audit without full syscall trace.
 595          * We just call audit_syscall_entry() directly, and then
 596          * jump back to the normal fast path.
 597          */
 598 auditsys:
 599         movq %r10,%r9                   /* 6th arg: 4th syscall arg */
 600         movq %rdx,%r8                   /* 5th arg: 3rd syscall arg */
 601         movq %rsi,%rcx                  /* 4th arg: 2nd syscall arg */
 602         movq %rdi,%rdx                  /* 3rd arg: 1st syscall arg */
 603         movq %rax,%rsi                  /* 2nd arg: syscall number */
 604         movl $AUDIT_ARCH_X86_64,%edi    /* 1st arg: audit arch */
 605         call audit_syscall_entry
 606         LOAD_ARGS 0             /* reload call-clobbered registers */
 607         jmp system_call_fastpath
 608
 609         /*
 610          * Return fast path for syscall audit.  Call audit_syscall_exit()
 611          * directly and then jump back to the fast path with TIF_SYSCALL_AUDIT
 612          * masked off.
 613          */
 614 sysret_audit:
 615         movq RAX-ARGOFFSET(%rsp),%rsi   /* second arg, syscall return value */
 616         cmpq $0,%rsi            /* is it < 0? */
 617         setl %al                /* 1 if so, 0 if not */
 618         movzbl %al,%edi         /* zero-extend that into %edi */
 619         inc %edi /* first arg, 0->1(AUDITSC_SUCCESS), 1->2(AUDITSC_FAILURE) */
 620         call audit_syscall_exit
 621         movl $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT),%edi
 622         jmp sysret_check
 623 #endif  /* CONFIG_AUDITSYSCALL */
 624
 625         /* Do syscall tracing */
 626 tracesys:
 627 #ifdef CONFIG_AUDITSYSCALL
 628         testl $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT),TI_flags(%rcx)
 629         jz auditsys
 630 #endif
 631         SAVE_REST
 632         movq $-ENOSYS,RAX(%rsp) /* ptrace can change this for a bad syscall */
 633         FIXUP_TOP_OF_STACK %rdi
 634         movq %rsp,%rdi
 635         call syscall_trace_enter
 636         /*
 637          * Reload arg registers from stack in case ptrace changed them.
 638          * We don't reload %rax because syscall_trace_enter() returned
 639          * the value it wants us to use in the table lookup.
 640          */
 641         LOAD_ARGS ARGOFFSET, 1
 642         RESTORE_REST
 643         cmpq $__NR_syscall_max,%rax
 644         ja   int_ret_from_sys_call      /* RAX(%rsp) set to -ENOSYS above */
 645         movq %r10,%rcx  /* fixup for C */
 646         call *sys_call_table(,%rax,8)
 647         movq %rax,RAX-ARGOFFSET(%rsp)
 648         /* Use IRET because user could have changed frame */
 649
 650 /*
 651  * Syscall return path ending with IRET.
 652  * Has correct top of stack, but partial stack frame.
 653  */
 654 GLOBAL(int_ret_from_sys_call)
 655         DISABLE_INTERRUPTS(CLBR_NONE)
 656         TRACE_IRQS_OFF
 657         testl $3,CS-ARGOFFSET(%rsp)
 658         je retint_restore_args
 659         movl $_TIF_ALLWORK_MASK,%edi
 660         /* edi: mask to check */
 661 GLOBAL(int_with_check)
 662         LOCKDEP_SYS_EXIT_IRQ
 663         GET_THREAD_INFO(%rcx)
 664         movl TI_flags(%rcx),%edx
 665         andl %edi,%edx
 666         jnz   int_careful
 667         andl    $~TS_COMPAT,TI_status(%rcx)
 668         jmp   retint_swapgs
 669
 670         /* Either reschedule or signal or syscall exit tracking needed. */
 671         /* First do a reschedule test. */
 672         /* edx: work, edi: workmask */
 673 int_careful:
 674         bt $TIF_NEED_RESCHED,%edx
 675         jnc  int_very_careful
 676         TRACE_IRQS_ON
 677         ENABLE_INTERRUPTS(CLBR_NONE)
 678         pushq_cfi %rdi
 679         call schedule
 680         popq_cfi %rdi
 681         DISABLE_INTERRUPTS(CLBR_NONE)
 682         TRACE_IRQS_OFF
 683         jmp int_with_check
 684
 685         /* handle signals and tracing -- both require a full stack frame */
 686 int_very_careful:
 687         TRACE_IRQS_ON
 688         ENABLE_INTERRUPTS(CLBR_NONE)
 689 int_check_syscall_exit_work:
 690         SAVE_REST
 691         /* Check for syscall exit trace */
 692         testl $_TIF_WORK_SYSCALL_EXIT,%edx
 693         jz int_signal
 694         pushq_cfi %rdi
 695         leaq 8(%rsp),%rdi       # &ptregs -> arg1
 696         call syscall_trace_leave
 697         popq_cfi %rdi
 698         andl $~(_TIF_WORK_SYSCALL_EXIT|_TIF_SYSCALL_EMU),%edi
 699         jmp int_restore_rest
 700
 701 int_signal:
 702         testl $_TIF_DO_NOTIFY_MASK,%edx
 703         jz 1f
 704         movq %rsp,%rdi          # &ptregs -> arg1
 705         xorl %esi,%esi          # oldset -> arg2
 706         call do_notify_resume
 707 1:      movl $_TIF_WORK_MASK,%edi
 708 int_restore_rest:
 709         RESTORE_REST
 710         DISABLE_INTERRUPTS(CLBR_NONE)
 711         TRACE_IRQS_OFF
 712         jmp int_with_check
 713         CFI_ENDPROC
 714 END(system_call)
 715
 716 /*
 717  * Certain special system calls that need to save a complete full stack frame.
 718  */
 719         .macro PTREGSCALL label,func,arg
 720 ENTRY(\label)
 721         PARTIAL_FRAME 1 8               /* offset 8: return address */
 722         subq $REST_SKIP, %rsp
 723         CFI_ADJUST_CFA_OFFSET REST_SKIP
 724         call save_rest
 725         DEFAULT_FRAME 0 8               /* offset 8: return address */
 726         leaq 8(%rsp), \arg      /* pt_regs pointer */
 727         call \func
 728         jmp ptregscall_common
 729         CFI_ENDPROC
 730 END(\label)
 731         .endm
 732
 733         PTREGSCALL stub_clone, sys_clone, %r8
 734         PTREGSCALL stub_fork, sys_fork, %rdi
 735         PTREGSCALL stub_vfork, sys_vfork, %rdi
 736         PTREGSCALL stub_sigaltstack, sys_sigaltstack, %rdx
 737         PTREGSCALL stub_iopl, sys_iopl, %rsi
 738
 739 ENTRY(ptregscall_common)
 740         DEFAULT_FRAME 1 8       /* offset 8: return address */
 741         RESTORE_TOP_OF_STACK %r11, 8
 742         movq_cfi_restore R15+8, r15
 743         movq_cfi_restore R14+8, r14
 744         movq_cfi_restore R13+8, r13
 745         movq_cfi_restore R12+8, r12
 746         movq_cfi_restore RBP+8, rbp
 747         movq_cfi_restore RBX+8, rbx
 748         ret $REST_SKIP          /* pop extended registers */
 749         CFI_ENDPROC
 750 END(ptregscall_common)
 751
 752 ENTRY(stub_execve)
 753         CFI_STARTPROC
 754         addq $8, %rsp
 755         PARTIAL_FRAME 0
 756         SAVE_REST
 757         FIXUP_TOP_OF_STACK %r11
 758         movq %rsp, %rcx
 759         call sys_execve
 760         RESTORE_TOP_OF_STACK %r11
 761         movq %rax,RAX(%rsp)
 762         RESTORE_REST
 763         jmp int_ret_from_sys_call
 764         CFI_ENDPROC
 765 END(stub_execve)
 766
 767 /*
 768  * sigreturn is special because it needs to restore all registers on return.
 769  * This cannot be done with SYSRET, so use the IRET return path instead.
 770  */
 771 ENTRY(stub_rt_sigreturn)
 772         CFI_STARTPROC
 773         addq $8, %rsp
 774         PARTIAL_FRAME 0
 775         SAVE_REST
 776         movq %rsp,%rdi
 777         FIXUP_TOP_OF_STACK %r11
 778         call sys_rt_sigreturn
 779         movq %rax,RAX(%rsp) # fixme, this could be done at the higher layer
 780         RESTORE_REST
 781         jmp int_ret_from_sys_call
 782         CFI_ENDPROC
 783 END(stub_rt_sigreturn)
 784
 785 /*
 786  * Build the entry stubs and pointer table with some assembler magic.
 787  * We pack 7 stubs into a single 32-byte chunk, which will fit in a
 788  * single cache line on all modern x86 implementations.
 789  */
 790         .section .init.rodata,"a"
 791 ENTRY(interrupt)
 792         .section .entry.text
 793         .p2align 5
 794         .p2align CONFIG_X86_L1_CACHE_SHIFT
 795 ENTRY(irq_entries_start)
 796         INTR_FRAME
 797 vector=FIRST_EXTERNAL_VECTOR
 798 .rept (NR_VECTORS-FIRST_EXTERNAL_VECTOR+6)/7
 799         .balign 32
 800   .rept 7
 801     .if vector < NR_VECTORS
 802       .if vector <> FIRST_EXTERNAL_VECTOR
 803         CFI_ADJUST_CFA_OFFSET -8
 804       .endif
 805 1:      pushq_cfi $(~vector+0x80)       /* Note: always in signed byte range */
 806       .if ((vector-FIRST_EXTERNAL_VECTOR)%7) <> 6
 807         jmp 2f
 808       .endif
 809       .previous
 810         .quad 1b
 811       .section .entry.text
 812 vector=vector+1
 813     .endif
 814   .endr
 815 2:      jmp common_interrupt
 816 .endr
 817         CFI_ENDPROC
 818 END(irq_entries_start)
 819
 820 .previous
 821 END(interrupt)
 822 .previous
 823
 824 /*
 825  * Interrupt entry/exit.
 826  *
 827  * Interrupt entry points save only callee clobbered registers in fast path.
 828  *
 829  * Entry runs with interrupts off.
 830  */
 831
 832 /* 0(%rsp): ~(interrupt number) */
 833         .macro interrupt func
 834         /* reserve pt_regs for scratch regs and rbp */
 835         subq $ORIG_RAX-RBP, %rsp
 836         CFI_ADJUST_CFA_OFFSET ORIG_RAX-RBP
 837         SAVE_ARGS_IRQ
 838         call \func
 839         .endm
 840
 841 /*
 842  * Interrupt entry/exit should be protected against kprobes
 843  */
 844         .pushsection .kprobes.text, "ax"
 845         /*
 846          * The interrupt stubs push (~vector+0x80) onto the stack and
 847          * then jump to common_interrupt.
 848          */
 849         .p2align CONFIG_X86_L1_CACHE_SHIFT
 850 common_interrupt:
 851         XCPT_FRAME
 852         addq $-0x80,(%rsp)              /* Adjust vector to [-256,-1] range */
 853         interrupt do_IRQ
 854         /* 0(%rsp): old_rsp-ARGOFFSET */
 855 ret_from_intr:
 856         DISABLE_INTERRUPTS(CLBR_NONE)
 857         TRACE_IRQS_OFF
 858         decl PER_CPU_VAR(irq_count)
 859
 860         /* Restore saved previous stack */
 861         popq %rsi
 862         CFI_DEF_CFA_REGISTER    rsi
 863         leaq ARGOFFSET-RBP(%rsi), %rsp
 864         CFI_DEF_CFA_REGISTER    rsp
 865         CFI_ADJUST_CFA_OFFSET   RBP-ARGOFFSET
 866
 867 exit_intr:
 868         GET_THREAD_INFO(%rcx)
 869         testl $3,CS-ARGOFFSET(%rsp)
 870         je retint_kernel
 871
 872         /* Interrupt came from user space */
 873         /*
 874          * Has a correct top of stack, but a partial stack frame
 875          * %rcx: thread info. Interrupts off.
 876          */
 877 retint_with_reschedule:
 878         movl $_TIF_WORK_MASK,%edi
 879 retint_check:
 880         LOCKDEP_SYS_EXIT_IRQ
 881         movl TI_flags(%rcx),%edx
 882         andl %edi,%edx
 883         CFI_REMEMBER_STATE
 884         jnz  retint_careful
 885
 886 retint_swapgs:          /* return to user-space */
 887         /*
 888          * The iretq could re-enable interrupts:
 889          */
 890         DISABLE_INTERRUPTS(CLBR_ANY)
 891         TRACE_IRQS_IRETQ
 892         /*
 893          * This opens a window where we have a user CR3, but are
 894          * running in the kernel.  This makes using the CS
 895          * register useless for telling whether or not we need to
 896          * switch CR3 in NMIs.  Normal interrupts are OK because
 897          * they are off here.
 898          */
 899         SWITCH_USER_CR3
 900         SWAPGS
 901         jmp restore_args
 902
 903 retint_restore_args:    /* return to kernel space */
 904         DISABLE_INTERRUPTS(CLBR_ANY)
 905         /*
 906          * The iretq could re-enable interrupts:
 907          */
 908         TRACE_IRQS_IRETQ
 909 restore_args:
 910         RESTORE_ARGS 1,8,1
 911
 912 irq_return:
 913         INTERRUPT_RETURN
 914
 915 ENTRY(native_iret)
 916         /*
 917          * Are we returning to a stack segment from the LDT?  Note: in
 918          * 64-bit mode SS:RSP on the exception stack is always valid.
 919          */
 920 #ifdef CONFIG_X86_ESPFIX64
 921         testb $4,(SS-RIP)(%rsp)
 922         jnz native_irq_return_ldt
 923 #endif
 924
 925 .global native_irq_return_iret
 926 native_irq_return_iret:
 927         /*
 928          * This may fault.  Non-paranoid faults on return to userspace are
 929          * handled by fixup_bad_iret.  These include #SS, #GP, and #NP.
 930          * Double-faults due to espfix64 are handled in do_double_fault.
 931          * Other faults here are fatal.
 932          */
 933         iretq
 934
 935 #ifdef CONFIG_X86_ESPFIX64
 936 native_irq_return_ldt:
 937         pushq_cfi %rax
 938         pushq_cfi %rdi
 939         SWAPGS
 940         SWITCH_KERNEL_CR3
 941         movq PER_CPU_VAR(espfix_waddr),%rdi
 942         movq %rax,(0*8)(%rdi)   /* RAX */
 943         movq (2*8)(%rsp),%rax   /* RIP */
 944         movq %rax,(1*8)(%rdi)
 945         movq (3*8)(%rsp),%rax   /* CS */
 946         movq %rax,(2*8)(%rdi)
 947         movq (4*8)(%rsp),%rax   /* RFLAGS */
 948         movq %rax,(3*8)(%rdi)
 949         movq (6*8)(%rsp),%rax   /* SS */
 950         movq %rax,(5*8)(%rdi)
 951         movq (5*8)(%rsp),%rax   /* RSP */
 952         movq %rax,(4*8)(%rdi)
 953         andl $0xffff0000,%eax
 954         popq_cfi %rdi
 955         orq PER_CPU_VAR(espfix_stack),%rax
 956         SWITCH_USER_CR3
 957         SWAPGS
 958         movq %rax,%rsp
 959         popq_cfi %rax
 960         jmp native_irq_return_iret
 961 #endif
 962
 963         /* edi: workmask, edx: work */
 964 retint_careful:
 965         CFI_RESTORE_STATE
 966         bt    $TIF_NEED_RESCHED,%edx
 967         jnc   retint_signal
 968         TRACE_IRQS_ON
 969         ENABLE_INTERRUPTS(CLBR_NONE)
 970         pushq_cfi %rdi
 971         call  schedule
 972         popq_cfi %rdi
 973         GET_THREAD_INFO(%rcx)
 974         DISABLE_INTERRUPTS(CLBR_NONE)
 975         TRACE_IRQS_OFF
 976         jmp retint_check
 977
 978 retint_signal:
 979         testl $_TIF_DO_NOTIFY_MASK,%edx
 980         jz    retint_swapgs
 981         TRACE_IRQS_ON
 982         ENABLE_INTERRUPTS(CLBR_NONE)
 983         SAVE_REST
 984         movq $-1,ORIG_RAX(%rsp)
 985         xorl %esi,%esi          # oldset
 986         movq %rsp,%rdi          # &pt_regs
 987         call do_notify_resume
 988         RESTORE_REST
 989         DISABLE_INTERRUPTS(CLBR_NONE)
 990         TRACE_IRQS_OFF
 991         GET_THREAD_INFO(%rcx)
 992         jmp retint_with_reschedule
 993
 994 #ifdef CONFIG_PREEMPT
 995         /* Returning to kernel space. Check if we need preemption */
 996         /* rcx:  threadinfo. interrupts off. */
 997 ENTRY(retint_kernel)
 998         cmpl $0,TI_preempt_count(%rcx)
 999         jnz  retint_restore_args
1000         bt  $TIF_NEED_RESCHED,TI_flags(%rcx)
1001         jnc  retint_restore_args
1002         bt   $9,EFLAGS-ARGOFFSET(%rsp)  /* interrupts off? */
1003         jnc  retint_restore_args
1004         call preempt_schedule_irq
1005         jmp exit_intr
1006 #endif
1007         CFI_ENDPROC
1008 END(common_interrupt)
1009
1010 /*
1011  * End of kprobes section
1012  */
1013        .popsection
1014
1015 /*
1016  * APIC interrupts.
1017  */
1018 .macro apicinterrupt num sym do_sym
1019 ENTRY(\sym)
1020         INTR_FRAME
1021         pushq_cfi $~(\num)
1022         interrupt \do_sym
1023         jmp ret_from_intr
1024         CFI_ENDPROC
1025 END(\sym)
1026 .endm
1027
1028 #ifdef CONFIG_SMP
1029 apicinterrupt IRQ_MOVE_CLEANUP_VECTOR \
1030         irq_move_cleanup_interrupt smp_irq_move_cleanup_interrupt
1031 apicinterrupt REBOOT_VECTOR \
1032         reboot_interrupt smp_reboot_interrupt
1033 #endif
1034
1035 #ifdef CONFIG_X86_UV
1036 apicinterrupt UV_BAU_MESSAGE \
1037         uv_bau_message_intr1 uv_bau_message_interrupt
1038 #endif
1039 apicinterrupt LOCAL_TIMER_VECTOR \
1040         apic_timer_interrupt smp_apic_timer_interrupt
1041 apicinterrupt X86_PLATFORM_IPI_VECTOR \
1042         x86_platform_ipi smp_x86_platform_ipi
1043
1044 #ifdef CONFIG_SMP
1045 .irp idx,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, \
1046         16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
1047 .if NUM_INVALIDATE_TLB_VECTORS > \idx
1048 apicinterrupt (INVALIDATE_TLB_VECTOR_START)+\idx \
1049         invalidate_interrupt\idx smp_invalidate_interrupt
1050 .endif
1051 .endr
1052 #endif
1053
1054 apicinterrupt THRESHOLD_APIC_VECTOR \
1055         threshold_interrupt smp_threshold_interrupt
1056 apicinterrupt THERMAL_APIC_VECTOR \
1057         thermal_interrupt smp_thermal_interrupt
1058
1059 #ifdef CONFIG_SMP
1060 apicinterrupt CALL_FUNCTION_SINGLE_VECTOR \
1061         call_function_single_interrupt smp_call_function_single_interrupt
1062 apicinterrupt CALL_FUNCTION_VECTOR \
1063         call_function_interrupt smp_call_function_interrupt
1064 apicinterrupt RESCHEDULE_VECTOR \
1065         reschedule_interrupt smp_reschedule_interrupt
1066 #endif
1067
1068 apicinterrupt ERROR_APIC_VECTOR \
1069         error_interrupt smp_error_interrupt
1070 apicinterrupt SPURIOUS_APIC_VECTOR \
1071         spurious_interrupt smp_spurious_interrupt
1072
1073 #ifdef CONFIG_IRQ_WORK
1074 apicinterrupt IRQ_WORK_VECTOR \
1075         irq_work_interrupt smp_irq_work_interrupt
1076 #endif
1077
1078 /*
1079  * Exception entry points.
1080  */
1081 .macro zeroentry sym do_sym
1082 ENTRY(\sym)
1083         INTR_FRAME
1084         PARAVIRT_ADJUST_EXCEPTION_FRAME
1085         pushq_cfi $-1           /* ORIG_RAX: no syscall to restart */
1086         subq $ORIG_RAX-R15, %rsp
1087         CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
1088         call error_entry
1089         DEFAULT_FRAME 0
1090         movq %rsp,%rdi          /* pt_regs pointer */
1091         xorl %esi,%esi          /* no error code */
1092         call \do_sym
1093         jmp error_exit          /* %ebx: no swapgs flag */
1094         CFI_ENDPROC
1095 END(\sym)
1096 .endm
1097
1098 .macro paranoidzeroentry sym do_sym
1099 ENTRY(\sym)
1100         INTR_FRAME
1101         PARAVIRT_ADJUST_EXCEPTION_FRAME
1102         pushq_cfi $-1           /* ORIG_RAX: no syscall to restart */
1103         subq $ORIG_RAX-R15, %rsp
1104         CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
1105         call save_paranoid
1106         TRACE_IRQS_OFF
1107         movq %rsp,%rdi          /* pt_regs pointer */
1108         xorl %esi,%esi          /* no error code */
1109         call \do_sym
1110         jmp paranoid_exit       /* %ebx: no swapgs flag */
1111         CFI_ENDPROC
1112 END(\sym)
1113 .endm
1114
1115 #define INIT_TSS_IST(x) PER_CPU_VAR(init_tss) + (TSS_ist + ((x) - 1) * 8)
1116 .macro paranoidzeroentry_ist sym do_sym ist
1117 ENTRY(\sym)
1118         INTR_FRAME
1119         PARAVIRT_ADJUST_EXCEPTION_FRAME
1120         pushq_cfi $-1           /* ORIG_RAX: no syscall to restart */
1121         subq $ORIG_RAX-R15, %rsp
1122         CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
1123         call save_paranoid
1124         TRACE_IRQS_OFF
1125         movq %rsp,%rdi          /* pt_regs pointer */
1126         xorl %esi,%esi          /* no error code */
1127         subq $EXCEPTION_STKSZ, INIT_TSS_IST(\ist)
1128         call \do_sym
1129         addq $EXCEPTION_STKSZ, INIT_TSS_IST(\ist)
1130         jmp paranoid_exit       /* %ebx: no swapgs flag */
1131         CFI_ENDPROC
1132 END(\sym)
1133 .endm
1134
1135 .macro errorentry sym do_sym
1136 ENTRY(\sym)
1137         XCPT_FRAME
1138         PARAVIRT_ADJUST_EXCEPTION_FRAME
1139         subq $ORIG_RAX-R15, %rsp
1140         CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
1141         call error_entry
1142         DEFAULT_FRAME 0
1143         movq %rsp,%rdi                  /* pt_regs pointer */
1144         movq ORIG_RAX(%rsp),%rsi        /* get error code */
1145         movq $-1,ORIG_RAX(%rsp)         /* no syscall to restart */
1146         call \do_sym
1147         jmp error_exit                  /* %ebx: no swapgs flag */
1148         CFI_ENDPROC
1149 END(\sym)
1150 .endm
1151
1152         /* error code is on the stack already */
1153 .macro paranoiderrorentry sym do_sym
1154 ENTRY(\sym)
1155         XCPT_FRAME
1156         PARAVIRT_ADJUST_EXCEPTION_FRAME
1157         subq $ORIG_RAX-R15, %rsp
1158         CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
1159         call save_paranoid
1160         DEFAULT_FRAME 0
1161         TRACE_IRQS_OFF
1162         movq %rsp,%rdi                  /* pt_regs pointer */
1163         movq ORIG_RAX(%rsp),%rsi        /* get error code */
1164         movq $-1,ORIG_RAX(%rsp)         /* no syscall to restart */
1165         call \do_sym
1166         jmp paranoid_exit               /* %ebx: no swapgs flag */
1167         CFI_ENDPROC
1168 END(\sym)
1169 .endm
1170
1171 zeroentry divide_error do_divide_error
1172 zeroentry overflow do_overflow
1173 zeroentry bounds do_bounds
1174 zeroentry invalid_op do_invalid_op
1175 zeroentry device_not_available do_device_not_available
1176 paranoiderrorentry double_fault do_double_fault
1177 zeroentry coprocessor_segment_overrun do_coprocessor_segment_overrun
1178 errorentry invalid_TSS do_invalid_TSS
1179 errorentry segment_not_present do_segment_not_present
1180 zeroentry spurious_interrupt_bug do_spurious_interrupt_bug
1181 zeroentry coprocessor_error do_coprocessor_error
1182 errorentry alignment_check do_alignment_check
1183 zeroentry simd_coprocessor_error do_simd_coprocessor_error
1184
1185
1186         /* Reload gs selector with exception handling */
1187         /* edi:  new selector */
1188 ENTRY(native_load_gs_index)
1189         CFI_STARTPROC
1190         pushfq_cfi
1191         DISABLE_INTERRUPTS(CLBR_ANY & ~CLBR_RDI)
1192         SWAPGS
1193 gs_change:
1194         movl %edi,%gs
1195 2:      mfence          /* workaround */
1196         SWAPGS
1197         popfq_cfi
1198         ret
1199         CFI_ENDPROC
1200 END(native_load_gs_index)
1201
1202         .section __ex_table,"a"
1203         .align 8
1204         .quad gs_change,bad_gs
1205         .previous
1206         .section .fixup,"ax"
1207         /* running with kernelgs */
1208 bad_gs:
1209         SWAPGS                  /* switch back to user gs */
1210         xorl %eax,%eax
1211         movl %eax,%gs
1212         jmp  2b
1213         .previous
1214
1215 ENTRY(kernel_thread_helper)
1216         pushq $0                # fake return address
1217         CFI_STARTPROC
1218         /*
1219          * Here we are in the child and the registers are set as they were
1220          * at kernel_thread() invocation in the parent.
1221          */
1222         call *%rsi
1223         # exit
1224         mov %eax, %edi
1225         call do_exit
1226         ud2                     # padding for call trace
1227         CFI_ENDPROC
1228 END(kernel_thread_helper)
1229
1230 /*
1231  * execve(). This function needs to use IRET, not SYSRET, to set up all state properly.
1232  *
1233  * C extern interface:
1234  *       extern long execve(const char *name, char **argv, char **envp)
1235  *
1236  * asm input arguments:
1237  *      rdi: name, rsi: argv, rdx: envp
1238  *
1239  * We want to fallback into:
1240  *      extern long sys_execve(const char *name, char **argv,char **envp, struct pt_regs *regs)
1241  *
1242  * do_sys_execve asm fallback arguments:
1243  *      rdi: name, rsi: argv, rdx: envp, rcx: fake frame on the stack
1244  */
1245 ENTRY(kernel_execve)
1246         CFI_STARTPROC
1247         FAKE_STACK_FRAME $0
1248         SAVE_ALL
1249         movq %rsp,%rcx
1250         call sys_execve
1251         movq %rax, RAX(%rsp)
1252         RESTORE_REST
1253         testq %rax,%rax
1254         je int_ret_from_sys_call
1255         RESTORE_ARGS
1256         UNFAKE_STACK_FRAME
1257         ret
1258         CFI_ENDPROC
1259 END(kernel_execve)
1260
1261 /* Call softirq on interrupt stack. Interrupts are off. */
1262 ENTRY(call_softirq)
1263         CFI_STARTPROC
1264         pushq_cfi %rbp
1265         CFI_REL_OFFSET rbp,0
1266         mov  %rsp,%rbp
1267         CFI_DEF_CFA_REGISTER rbp
1268         incl PER_CPU_VAR(irq_count)
1269         cmove PER_CPU_VAR(irq_stack_ptr),%rsp
1270         push  %rbp                      # backlink for old unwinder
1271         call __do_softirq
1272         leaveq
1273         CFI_RESTORE             rbp
1274         CFI_DEF_CFA_REGISTER    rsp
1275         CFI_ADJUST_CFA_OFFSET   -8
1276         decl PER_CPU_VAR(irq_count)
1277         ret
1278         CFI_ENDPROC
1279 END(call_softirq)
1280
1281 #ifdef CONFIG_XEN
1282 zeroentry xen_hypervisor_callback xen_do_hypervisor_callback
1283
1284 /*
1285  * A note on the "critical region" in our callback handler.
1286  * We want to avoid stacking callback handlers due to events occurring
1287  * during handling of the last event. To do this, we keep events disabled
1288  * until we've done all processing. HOWEVER, we must enable events before
1289  * popping the stack frame (can't be done atomically) and so it would still
1290  * be possible to get enough handler activations to overflow the stack.
1291  * Although unlikely, bugs of that kind are hard to track down, so we'd
1292  * like to avoid the possibility.
1293  * So, on entry to the handler we detect whether we interrupted an
1294  * existing activation in its critical region -- if so, we pop the current
1295  * activation and restart the handler using the previous one.
1296  */
1297 ENTRY(xen_do_hypervisor_callback)   # do_hypervisor_callback(struct *pt_regs)
1298         CFI_STARTPROC
1299 /*
1300  * Since we don't modify %rdi, evtchn_do_upall(struct *pt_regs) will
1301  * see the correct pointer to the pt_regs
1302  */
1303         movq %rdi, %rsp            # we don't return, adjust the stack frame
1304         CFI_ENDPROC
1305         DEFAULT_FRAME
1306 11:     incl PER_CPU_VAR(irq_count)
1307         movq %rsp,%rbp
1308         CFI_DEF_CFA_REGISTER rbp
1309         cmovzq PER_CPU_VAR(irq_stack_ptr),%rsp
1310         pushq %rbp                      # backlink for old unwinder
1311         call xen_evtchn_do_upcall
1312         popq %rsp
1313         CFI_DEF_CFA_REGISTER rsp
1314         decl PER_CPU_VAR(irq_count)
1315         jmp  error_exit
1316         CFI_ENDPROC
1317 END(xen_do_hypervisor_callback)
1318
1319 /*
1320  * Hypervisor uses this for application faults while it executes.
1321  * We get here for two reasons:
1322  *  1. Fault while reloading DS, ES, FS or GS
1323  *  2. Fault while executing IRET
1324  * Category 1 we do not need to fix up as Xen has already reloaded all segment
1325  * registers that could be reloaded and zeroed the others.
1326  * Category 2 we fix up by killing the current process. We cannot use the
1327  * normal Linux return path in this case because if we use the IRET hypercall
1328  * to pop the stack frame we end up in an infinite loop of failsafe callbacks.
1329  * We distinguish between categories by comparing each saved segment register
1330  * with its current contents: any discrepancy means we in category 1.
1331  */
1332 ENTRY(xen_failsafe_callback)
1333         INTR_FRAME 1 (6*8)
1334         /*CFI_REL_OFFSET gs,GS*/
1335         /*CFI_REL_OFFSET fs,FS*/
1336         /*CFI_REL_OFFSET es,ES*/
1337         /*CFI_REL_OFFSET ds,DS*/
1338         CFI_REL_OFFSET r11,8
1339         CFI_REL_OFFSET rcx,0
1340         movw %ds,%cx
1341         cmpw %cx,0x10(%rsp)
1342         CFI_REMEMBER_STATE
1343         jne 1f
1344         movw %es,%cx
1345         cmpw %cx,0x18(%rsp)
1346         jne 1f
1347         movw %fs,%cx
1348         cmpw %cx,0x20(%rsp)
1349         jne 1f
1350         movw %gs,%cx
1351         cmpw %cx,0x28(%rsp)
1352         jne 1f
1353         /* All segments match their saved values => Category 2 (Bad IRET). */
1354         movq (%rsp),%rcx
1355         CFI_RESTORE rcx
1356         movq 8(%rsp),%r11
1357         CFI_RESTORE r11
1358         addq $0x30,%rsp
1359         CFI_ADJUST_CFA_OFFSET -0x30
1360         pushq_cfi $0    /* RIP */
1361         pushq_cfi %r11
1362         pushq_cfi %rcx
1363         jmp general_protection
1364         CFI_RESTORE_STATE
1365 1:      /* Segment mismatch => Category 1 (Bad segment). Retry the IRET. */
1366         movq (%rsp),%rcx
1367         CFI_RESTORE rcx
1368         movq 8(%rsp),%r11
1369         CFI_RESTORE r11
1370         addq $0x30,%rsp
1371         CFI_ADJUST_CFA_OFFSET -0x30
1372         pushq_cfi $-1 /* orig_ax = -1 => not a system call */
1373         SAVE_ALL
1374         jmp error_exit
1375         CFI_ENDPROC
1376 END(xen_failsafe_callback)
1377
1378 apicinterrupt XEN_HVM_EVTCHN_CALLBACK \
1379         xen_hvm_callback_vector xen_evtchn_do_upcall
1380
1381 #endif /* CONFIG_XEN */
1382
1383 /*
1384  * Some functions should be protected against kprobes
1385  */
1386         .pushsection .kprobes.text, "ax"
1387
1388 paranoidzeroentry_ist debug do_debug DEBUG_STACK
1389 paranoidzeroentry_ist int3 do_int3 DEBUG_STACK
1390 errorentry stack_segment do_stack_segment
1391 #ifdef CONFIG_XEN
1392 zeroentry xen_debug do_debug
1393 zeroentry xen_int3 do_int3
1394 errorentry xen_stack_segment do_stack_segment
1395 #endif
1396 errorentry general_protection do_general_protection
1397 errorentry page_fault do_page_fault
1398 #ifdef CONFIG_KVM_GUEST
1399 errorentry async_page_fault do_async_page_fault
1400 #endif
1401 #ifdef CONFIG_X86_MCE
1402 paranoidzeroentry machine_check *machine_check_vector(%rip)
1403 #endif
1404
1405         /*
1406          * "Paranoid" exit path from exception stack.
1407          * Paranoid because this is used by NMIs and cannot take
1408          * any kernel state for granted.
1409          * We don't do kernel preemption checks here, because only
1410          * NMI should be common and it does not enable IRQs and
1411          * cannot get reschedule ticks.
1412          *
1413          * "trace" is 0 for the NMI handler only, because irq-tracing
1414          * is fundamentally NMI-unsafe. (we cannot change the soft and
1415          * hard flags at once, atomically)
1416          */
1417 /*
1418  * On entry: ebx=0: needs swapgs but not SWITCH_USER_CR3
1419  *           ebx=1: needs neither swapgs nor SWITCH_USER_CR3
1420  *           ebx=2: needs both swapgs and SWITCH_USER_CR3
1421  *           ebx=3: needs SWITCH_USER_CR3 but not swapgs
1422  */
1423 ENTRY(paranoid_exit)
1424         DEFAULT_FRAME
1425         DISABLE_INTERRUPTS(CLBR_NONE)
1426         TRACE_IRQS_OFF
1427         movq    %rbx, %r12              /* paranoid_userspace uses %ebx */
1428         testl   $3, CS(%rsp)
1429         jnz     paranoid_userspace
1430 paranoid_kernel:
1431         movq    %r12, %rbx              /* restore after paranoid_userspace */
1432         TRACE_IRQS_IRETQ 0
1433 #ifdef CONFIG_PAGE_TABLE_ISOLATION
1434         /* No ALTERNATIVE for X86_FEATURE_KAISER: save_paranoid sets %ebx */
1435         testl   $2, %ebx                /* SWITCH_USER_CR3 needed? */
1436         jz      paranoid_exit_no_switch
1437         SWITCH_USER_CR3
1438 paranoid_exit_no_switch:
1439 #endif
1440         testl   $1, %ebx                /* swapgs needed? */
1441         jnz     paranoid_exit_no_swapgs
1442         SWAPGS_UNSAFE_STACK
1443 paranoid_exit_no_swapgs:
1444         RESTORE_ALL 8
1445         jmp     irq_return
1446
1447 paranoid_userspace:
1448         GET_THREAD_INFO(%rcx)
1449         movl TI_flags(%rcx),%ebx
1450         andl $_TIF_WORK_MASK,%ebx
1451         jz paranoid_kernel
1452         movq %rsp,%rdi                  /* &pt_regs */
1453         call sync_regs
1454         movq %rax,%rsp                  /* switch stack for scheduling */
1455         testl $_TIF_NEED_RESCHED,%ebx
1456         jnz paranoid_schedule
1457         movl %ebx,%edx                  /* arg3: thread flags */
1458         TRACE_IRQS_ON
1459         ENABLE_INTERRUPTS(CLBR_NONE)
1460         xorl %esi,%esi                  /* arg2: oldset */
1461         movq %rsp,%rdi                  /* arg1: &pt_regs */
1462         call do_notify_resume
1463         DISABLE_INTERRUPTS(CLBR_NONE)
1464         TRACE_IRQS_OFF
1465         jmp paranoid_userspace
1466 paranoid_schedule:
1467         TRACE_IRQS_ON
1468         ENABLE_INTERRUPTS(CLBR_ANY)
1469         call schedule
1470         DISABLE_INTERRUPTS(CLBR_ANY)
1471         TRACE_IRQS_OFF
1472         jmp paranoid_userspace
1473         CFI_ENDPROC
1474 END(paranoid_exit)
1475
1476 /*
1477  * Exception entry point. This expects an error code/orig_rax on the stack.
1478  * returns in "no swapgs flag" in %ebx.
1479  */
1480 ENTRY(error_entry)
1481         XCPT_FRAME
1482         CFI_ADJUST_CFA_OFFSET 15*8
1483         /* oldrax contains error code */
1484         cld
1485         movq_cfi rdi, RDI+8
1486         movq_cfi rsi, RSI+8
1487         movq_cfi rdx, RDX+8
1488         movq_cfi rcx, RCX+8
1489         movq_cfi rax, RAX+8
1490         movq_cfi  r8,  R8+8
1491         movq_cfi  r9,  R9+8
1492         movq_cfi r10, R10+8
1493         movq_cfi r11, R11+8
1494         movq_cfi rbx, RBX+8
1495         movq_cfi rbp, RBP+8
1496         movq_cfi r12, R12+8
1497         movq_cfi r13, R13+8
1498         movq_cfi r14, R14+8
1499         movq_cfi r15, R15+8
1500         /*
1501          * error_entry() always returns with a kernel gsbase and
1502          * CR3.  We must also have a kernel CR3/gsbase before
1503          * calling TRACE_IRQS_*.  Just unconditionally switch to
1504          * the kernel CR3 here.
1505          */
1506         SWITCH_KERNEL_CR3
1507         xorl %ebx,%ebx
1508         testl $3,CS+8(%rsp)
1509         je error_kernelspace
1510 error_swapgs:
1511         SWAPGS
1512 error_sti:
1513         TRACE_IRQS_OFF
1514         ret
1515
1516 /*
1517  * There are two places in the kernel that can potentially fault with
1518  * usergs. Handle them here.  B stepping K8s sometimes report a
1519  * truncated RIP for IRET exceptions returning to compat mode. Check
1520  * for these here too.
1521  */
1522 error_kernelspace:
1523         incl %ebx
1524         leaq native_irq_return_iret(%rip),%rcx
1525         cmpq %rcx,RIP+8(%rsp)
1526         je error_bad_iret
1527         movl %ecx,%eax  /* zero extend */
1528         cmpq %rax,RIP+8(%rsp)
1529         je bstep_iret
1530         cmpq $gs_change,RIP+8(%rsp)
1531         je error_swapgs
1532         jmp error_sti
1533
1534 bstep_iret:
1535         /* Fix truncated RIP */
1536         movq %rcx,RIP+8(%rsp)
1537         /* fall through */
1538
1539 error_bad_iret:
1540         SWAPGS
1541         mov %rsp,%rdi
1542         call fixup_bad_iret
1543         mov %rax,%rsp
1544         decl %ebx       /* Return to usergs */
1545         jmp error_sti
1546         CFI_ENDPROC
1547 END(error_entry)
1548
1549
1550 /* ebx: no swapgs flag (1: don't need swapgs, 0: need it) */
1551 ENTRY(error_exit)
1552         DEFAULT_FRAME
1553         movl %ebx,%eax
1554         RESTORE_REST
1555         DISABLE_INTERRUPTS(CLBR_NONE)
1556         TRACE_IRQS_OFF
1557         GET_THREAD_INFO(%rcx)
1558         testl %eax,%eax
1559         jne retint_kernel
1560         LOCKDEP_SYS_EXIT_IRQ
1561         movl TI_flags(%rcx),%edx
1562         movl $_TIF_WORK_MASK,%edi
1563         andl %edi,%edx
1564         jnz retint_careful
1565         jmp retint_swapgs
1566         CFI_ENDPROC
1567 END(error_exit)
1568
1569
1570         /* runs on exception stack */
1571 ENTRY(nmi)
1572         INTR_FRAME
1573         /*
1574          * Fix up the exception frame if we're on Xen.
1575          * PARAVIRT_ADJUST_EXCEPTION_FRAME is guaranteed to push at most
1576          * one value to the stack on native, so it may clobber the rdx
1577          * scratch slot, but it won't clobber any of the important
1578          * slots past it.
1579          *
1580          * Xen is a different story, because the Xen frame itself overlaps
1581          * the "NMI executing" variable.
1582          */
1583         PARAVIRT_ADJUST_EXCEPTION_FRAME
1584
1585         pushq_cfi $-1
1586         subq $ORIG_RAX-R15, %rsp
1587         CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
1588         call save_paranoid
1589         DEFAULT_FRAME 0
1590         /* paranoidentry do_nmi, 0; without TRACE_IRQS_OFF */
1591         movq %rsp,%rdi
1592         movq $-1,%rsi
1593         call do_nmi
1594 #ifdef CONFIG_TRACE_IRQFLAGS
1595         /* paranoidexit; without TRACE_IRQS_OFF */
1596         /* ebx: no-swapgs and kaiser-switch-cr3 flag */
1597         DISABLE_INTERRUPTS(CLBR_NONE)
1598         movq    %rbx, %r12              /* nmi_userspace uses %ebx */
1599         testl   $3, CS(%rsp)
1600         jnz     nmi_userspace
1601 nmi_kernel:
1602         movq    %r12, %rbx              /* restore after nmi_userspace */
1603 #ifdef CONFIG_PAGE_TABLE_ISOLATION
1604         /* No ALTERNATIVE for X86_FEATURE_KAISER: save_paranoid sets %ebx */
1605         testl   $2, %ebx                /* SWITCH_USER_CR3 needed? */
1606         jz      nmi_exit_no_switch
1607         SWITCH_USER_CR3
1608 nmi_exit_no_switch:
1609 #endif
1610         testl   $1, %ebx                /* swapgs needed? */
1611         jnz     nmi_exit_no_swapgs
1612         SWAPGS_UNSAFE_STACK
1613 nmi_exit_no_swapgs:
1614         RESTORE_ALL 8
1615         jmp     irq_return
1616
1617 nmi_userspace:
1618         GET_THREAD_INFO(%rcx)
1619         movl TI_flags(%rcx),%ebx
1620         andl $_TIF_WORK_MASK,%ebx
1621         jz nmi_kernel
1622         movq %rsp,%rdi                  /* &pt_regs */
1623         call sync_regs
1624         movq %rax,%rsp                  /* switch stack for scheduling */
1625         testl $_TIF_NEED_RESCHED,%ebx
1626         jnz nmi_schedule
1627         movl %ebx,%edx                  /* arg3: thread flags */
1628         ENABLE_INTERRUPTS(CLBR_NONE)
1629         xorl %esi,%esi                  /* arg2: oldset */
1630         movq %rsp,%rdi                  /* arg1: &pt_regs */
1631         call do_notify_resume
1632         DISABLE_INTERRUPTS(CLBR_NONE)
1633         jmp nmi_userspace
1634 nmi_schedule:
1635         ENABLE_INTERRUPTS(CLBR_ANY)
1636         call schedule
1637         DISABLE_INTERRUPTS(CLBR_ANY)
1638         jmp nmi_userspace
1639         CFI_ENDPROC
1640 #else
1641         jmp paranoid_exit
1642         CFI_ENDPROC
1643 #endif
1644 END(nmi)
1645
1646 ENTRY(ignore_sysret)
1647         CFI_STARTPROC
1648         mov $-ENOSYS,%eax
1649         sysret
1650         CFI_ENDPROC
1651 END(ignore_sysret)
1652
1653 /*
1654  * End of kprobes section
1655  */
1656         .popsection