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