arch/x86_64/kernel/entry.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
  54         .code64
  55
  56 #ifndef CONFIG_PREEMPT
  57 #define retint_kernel retint_restore_args
  58 #endif
  59
  60
  61 .macro TRACE_IRQS_IRETQ offset=ARGOFFSET
  62 #ifdef CONFIG_TRACE_IRQFLAGS
  63         bt   $9,EFLAGS-\offset(%rsp)    /* interrupts off? */
  64         jnc  1f
  65         TRACE_IRQS_ON
  66 1:
  67 #endif
  68 .endm
  69
  70 /*
  71  * C code is not supposed to know about undefined top of stack. Every time
  72  * a C function with an pt_regs argument is called from the SYSCALL based
  73  * fast path FIXUP_TOP_OF_STACK is needed.
  74  * RESTORE_TOP_OF_STACK syncs the syscall state after any possible ptregs
  75  * manipulation.
  76  */
  77
  78         /* %rsp:at FRAMEEND */
  79         .macro FIXUP_TOP_OF_STACK tmp
  80         movq    %gs:pda_oldrsp,\tmp
  81         movq    \tmp,RSP(%rsp)
  82         movq    $__USER_DS,SS(%rsp)
  83         movq    $__USER_CS,CS(%rsp)
  84         movq    $-1,RCX(%rsp)
  85         movq    R11(%rsp),\tmp  /* get eflags */
  86         movq    \tmp,EFLAGS(%rsp)
  87         .endm
  88
  89         .macro RESTORE_TOP_OF_STACK tmp,offset=0
  90         movq   RSP-\offset(%rsp),\tmp
  91         movq   \tmp,%gs:pda_oldrsp
  92         movq   EFLAGS-\offset(%rsp),\tmp
  93         movq   \tmp,R11-\offset(%rsp)
  94         .endm
  95
  96         .macro FAKE_STACK_FRAME child_rip
  97         /* push in order ss, rsp, eflags, cs, rip */
  98         xorl %eax, %eax
  99         pushq %rax /* ss */
 100         CFI_ADJUST_CFA_OFFSET   8
 101         /*CFI_REL_OFFSET        ss,0*/
 102         pushq %rax /* rsp */
 103         CFI_ADJUST_CFA_OFFSET   8
 104         CFI_REL_OFFSET  rsp,0
 105         pushq $(1<<9) /* eflags - interrupts on */
 106         CFI_ADJUST_CFA_OFFSET   8
 107         /*CFI_REL_OFFSET        rflags,0*/
 108         pushq $__KERNEL_CS /* cs */
 109         CFI_ADJUST_CFA_OFFSET   8
 110         /*CFI_REL_OFFSET        cs,0*/
 111         pushq \child_rip /* rip */
 112         CFI_ADJUST_CFA_OFFSET   8
 113         CFI_REL_OFFSET  rip,0
 114         pushq   %rax /* orig rax */
 115         CFI_ADJUST_CFA_OFFSET   8
 116         .endm
 117
 118         .macro UNFAKE_STACK_FRAME
 119         addq $8*6, %rsp
 120         CFI_ADJUST_CFA_OFFSET   -(6*8)
 121         .endm
 122
 123         .macro  CFI_DEFAULT_STACK start=1
 124         .if \start
 125         CFI_STARTPROC   simple
 126         CFI_SIGNAL_FRAME
 127         CFI_DEF_CFA     rsp,SS+8
 128         .else
 129         CFI_DEF_CFA_OFFSET SS+8
 130         .endif
 131         CFI_REL_OFFSET  r15,R15
 132         CFI_REL_OFFSET  r14,R14
 133         CFI_REL_OFFSET  r13,R13
 134         CFI_REL_OFFSET  r12,R12
 135         CFI_REL_OFFSET  rbp,RBP
 136         CFI_REL_OFFSET  rbx,RBX
 137         CFI_REL_OFFSET  r11,R11
 138         CFI_REL_OFFSET  r10,R10
 139         CFI_REL_OFFSET  r9,R9
 140         CFI_REL_OFFSET  r8,R8
 141         CFI_REL_OFFSET  rax,RAX
 142         CFI_REL_OFFSET  rcx,RCX
 143         CFI_REL_OFFSET  rdx,RDX
 144         CFI_REL_OFFSET  rsi,RSI
 145         CFI_REL_OFFSET  rdi,RDI
 146         CFI_REL_OFFSET  rip,RIP
 147         /*CFI_REL_OFFSET        cs,CS*/
 148         /*CFI_REL_OFFSET        rflags,EFLAGS*/
 149         CFI_REL_OFFSET  rsp,RSP
 150         /*CFI_REL_OFFSET        ss,SS*/
 151         .endm
 152 /*
 153  * A newly forked process directly context switches into this.
 154  */
 155 /* rdi: prev */
 156 ENTRY(ret_from_fork)
 157         CFI_DEFAULT_STACK
 158         push kernel_eflags(%rip)
 159         CFI_ADJUST_CFA_OFFSET 4
 160         popf                            # reset kernel eflags
 161         CFI_ADJUST_CFA_OFFSET -4
 162         call schedule_tail
 163         GET_THREAD_INFO(%rcx)
 164         testl $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT),threadinfo_flags(%rcx)
 165         jnz rff_trace
 166 rff_action:
 167         RESTORE_REST
 168         testl $3,CS-ARGOFFSET(%rsp)     # from kernel_thread?
 169         je   int_ret_from_sys_call
 170         testl $_TIF_IA32,threadinfo_flags(%rcx)
 171         jnz  int_ret_from_sys_call
 172         RESTORE_TOP_OF_STACK %rdi,ARGOFFSET
 173         jmp ret_from_sys_call
 174 rff_trace:
 175         movq %rsp,%rdi
 176         call syscall_trace_leave
 177         GET_THREAD_INFO(%rcx)
 178         jmp rff_action
 179         CFI_ENDPROC
 180 END(ret_from_fork)
 181
 182 /*
 183  * System call entry. Upto 6 arguments in registers are supported.
 184  *
 185  * SYSCALL does not save anything on the stack and does not change the
 186  * stack pointer.
 187  */
 188
 189 /*
 190  * Register setup:
 191  * rax  system call number
 192  * rdi  arg0
 193  * rcx  return address for syscall/sysret, C arg3
 194  * rsi  arg1
 195  * rdx  arg2
 196  * r10  arg3    (--> moved to rcx for C)
 197  * r8   arg4
 198  * r9   arg5
 199  * r11  eflags for syscall/sysret, temporary for C
 200  * r12-r15,rbp,rbx saved by C code, not touched.
 201  *
 202  * Interrupts are off on entry.
 203  * Only called from user space.
 204  *
 205  * XXX  if we had a free scratch register we could save the RSP into the stack frame
 206  *      and report it properly in ps. Unfortunately we haven't.
 207  *
 208  * When user can change the frames always force IRET. That is because
 209  * it deals with uncanonical addresses better. SYSRET has trouble
 210  * with them due to bugs in both AMD and Intel CPUs.
 211  */
 212
 213 ENTRY(system_call)
 214         CFI_STARTPROC   simple
 215         CFI_SIGNAL_FRAME
 216         CFI_DEF_CFA     rsp,PDA_STACKOFFSET
 217         CFI_REGISTER    rip,rcx
 218         /*CFI_REGISTER  rflags,r11*/
 219         swapgs
 220         movq    %rsp,%gs:pda_oldrsp
 221         movq    %gs:pda_kernelstack,%rsp
 222         /*
 223          * No need to follow this irqs off/on section - it's straight
 224          * and short:
 225          */
 226         sti
 227         SAVE_ARGS 8,1
 228         movq  %rax,ORIG_RAX-ARGOFFSET(%rsp)
 229         movq  %rcx,RIP-ARGOFFSET(%rsp)
 230         CFI_REL_OFFSET rip,RIP-ARGOFFSET
 231         GET_THREAD_INFO(%rcx)
 232         testl $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SECCOMP),threadinfo_flags(%rcx)
 233         CFI_REMEMBER_STATE
 234         jnz tracesys
 235         cmpq $__NR_syscall_max,%rax
 236         ja badsys
 237         movq %r10,%rcx
 238         call *sys_call_table(,%rax,8)  # XXX:    rip relative
 239         movq %rax,RAX-ARGOFFSET(%rsp)
 240 /*
 241  * Syscall return path ending with SYSRET (fast path)
 242  * Has incomplete stack frame and undefined top of stack.
 243  */
 244         .globl ret_from_sys_call
 245 ret_from_sys_call:
 246         movl $_TIF_ALLWORK_MASK,%edi
 247         /* edi: flagmask */
 248 sysret_check:
 249         GET_THREAD_INFO(%rcx)
 250         cli
 251         TRACE_IRQS_OFF
 252         movl threadinfo_flags(%rcx),%edx
 253         andl %edi,%edx
 254         CFI_REMEMBER_STATE
 255         jnz  sysret_careful
 256         /*
 257          * sysretq will re-enable interrupts:
 258          */
 259         TRACE_IRQS_ON
 260         movq RIP-ARGOFFSET(%rsp),%rcx
 261         CFI_REGISTER    rip,rcx
 262         RESTORE_ARGS 0,-ARG_SKIP,1
 263         /*CFI_REGISTER  rflags,r11*/
 264         movq    %gs:pda_oldrsp,%rsp
 265         swapgs
 266         sysretq
 267
 268         /* Handle reschedules */
 269         /* edx: work, edi: workmask */
 270 sysret_careful:
 271         CFI_RESTORE_STATE
 272         bt $TIF_NEED_RESCHED,%edx
 273         jnc sysret_signal
 274         TRACE_IRQS_ON
 275         sti
 276         pushq %rdi
 277         CFI_ADJUST_CFA_OFFSET 8
 278         call schedule
 279         popq  %rdi
 280         CFI_ADJUST_CFA_OFFSET -8
 281         jmp sysret_check
 282
 283         /* Handle a signal */
 284 sysret_signal:
 285         TRACE_IRQS_ON
 286         sti
 287         testl $(_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SINGLESTEP),%edx
 288         jz    1f
 289
 290         /* Really a signal */
 291         /* edx: work flags (arg3) */
 292         leaq do_notify_resume(%rip),%rax
 293         leaq -ARGOFFSET(%rsp),%rdi # &pt_regs -> arg1
 294         xorl %esi,%esi # oldset -> arg2
 295         call ptregscall_common
 296 1:      movl $_TIF_NEED_RESCHED,%edi
 297         /* Use IRET because user could have changed frame. This
 298            works because ptregscall_common has called FIXUP_TOP_OF_STACK. */
 299         cli
 300         TRACE_IRQS_OFF
 301         jmp int_with_check
 302
 303 badsys:
 304         movq $-ENOSYS,RAX-ARGOFFSET(%rsp)
 305         jmp ret_from_sys_call
 306
 307         /* Do syscall tracing */
 308 tracesys:
 309         CFI_RESTORE_STATE
 310         SAVE_REST
 311         movq $-ENOSYS,RAX(%rsp)
 312         FIXUP_TOP_OF_STACK %rdi
 313         movq %rsp,%rdi
 314         call syscall_trace_enter
 315         LOAD_ARGS ARGOFFSET  /* reload args from stack in case ptrace changed it */
 316         RESTORE_REST
 317         cmpq $__NR_syscall_max,%rax
 318         movq $-ENOSYS,%rcx
 319         cmova %rcx,%rax
 320         ja  1f
 321         movq %r10,%rcx  /* fixup for C */
 322         call *sys_call_table(,%rax,8)
 323 1:      movq %rax,RAX-ARGOFFSET(%rsp)
 324         /* Use IRET because user could have changed frame */
 325         jmp int_ret_from_sys_call
 326         CFI_ENDPROC
 327 END(system_call)
 328
 329 /*
 330  * Syscall return path ending with IRET.
 331  * Has correct top of stack, but partial stack frame.
 332  */
 333 ENTRY(int_ret_from_sys_call)
 334         CFI_STARTPROC   simple
 335         CFI_SIGNAL_FRAME
 336         CFI_DEF_CFA     rsp,SS+8-ARGOFFSET
 337         /*CFI_REL_OFFSET        ss,SS-ARGOFFSET*/
 338         CFI_REL_OFFSET  rsp,RSP-ARGOFFSET
 339         /*CFI_REL_OFFSET        rflags,EFLAGS-ARGOFFSET*/
 340         /*CFI_REL_OFFSET        cs,CS-ARGOFFSET*/
 341         CFI_REL_OFFSET  rip,RIP-ARGOFFSET
 342         CFI_REL_OFFSET  rdx,RDX-ARGOFFSET
 343         CFI_REL_OFFSET  rcx,RCX-ARGOFFSET
 344         CFI_REL_OFFSET  rax,RAX-ARGOFFSET
 345         CFI_REL_OFFSET  rdi,RDI-ARGOFFSET
 346         CFI_REL_OFFSET  rsi,RSI-ARGOFFSET
 347         CFI_REL_OFFSET  r8,R8-ARGOFFSET
 348         CFI_REL_OFFSET  r9,R9-ARGOFFSET
 349         CFI_REL_OFFSET  r10,R10-ARGOFFSET
 350         CFI_REL_OFFSET  r11,R11-ARGOFFSET
 351         cli
 352         TRACE_IRQS_OFF
 353         testl $3,CS-ARGOFFSET(%rsp)
 354         je retint_restore_args
 355         movl $_TIF_ALLWORK_MASK,%edi
 356         /* edi: mask to check */
 357 int_with_check:
 358         GET_THREAD_INFO(%rcx)
 359         movl threadinfo_flags(%rcx),%edx
 360         andl %edi,%edx
 361         jnz   int_careful
 362         andl    $~TS_COMPAT,threadinfo_status(%rcx)
 363         jmp   retint_swapgs
 364
 365         /* Either reschedule or signal or syscall exit tracking needed. */
 366         /* First do a reschedule test. */
 367         /* edx: work, edi: workmask */
 368 int_careful:
 369         bt $TIF_NEED_RESCHED,%edx
 370         jnc  int_very_careful
 371         TRACE_IRQS_ON
 372         sti
 373         pushq %rdi
 374         CFI_ADJUST_CFA_OFFSET 8
 375         call schedule
 376         popq %rdi
 377         CFI_ADJUST_CFA_OFFSET -8
 378         cli
 379         TRACE_IRQS_OFF
 380         jmp int_with_check
 381
 382         /* handle signals and tracing -- both require a full stack frame */
 383 int_very_careful:
 384         TRACE_IRQS_ON
 385         sti
 386         SAVE_REST
 387         /* Check for syscall exit trace */
 388         testl $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SINGLESTEP),%edx
 389         jz int_signal
 390         pushq %rdi
 391         CFI_ADJUST_CFA_OFFSET 8
 392         leaq 8(%rsp),%rdi       # &ptregs -> arg1
 393         call syscall_trace_leave
 394         popq %rdi
 395         CFI_ADJUST_CFA_OFFSET -8
 396         andl $~(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT|_TIF_SINGLESTEP),%edi
 397         cli
 398         TRACE_IRQS_OFF
 399         jmp int_restore_rest
 400
 401 int_signal:
 402         testl $(_TIF_NOTIFY_RESUME|_TIF_SIGPENDING|_TIF_SINGLESTEP),%edx
 403         jz 1f
 404         movq %rsp,%rdi          # &ptregs -> arg1
 405         xorl %esi,%esi          # oldset -> arg2
 406         call do_notify_resume
 407 1:      movl $_TIF_NEED_RESCHED,%edi
 408 int_restore_rest:
 409         RESTORE_REST
 410         cli
 411         TRACE_IRQS_OFF
 412         jmp int_with_check
 413         CFI_ENDPROC
 414 END(int_ret_from_sys_call)
 415
 416 /*
 417  * Certain special system calls that need to save a complete full stack frame.
 418  */
 419
 420         .macro PTREGSCALL label,func,arg
 421         .globl \label
 422 \label:
 423         leaq    \func(%rip),%rax
 424         leaq    -ARGOFFSET+8(%rsp),\arg /* 8 for return address */
 425         jmp     ptregscall_common
 426 END(\label)
 427         .endm
 428
 429         CFI_STARTPROC
 430
 431         PTREGSCALL stub_clone, sys_clone, %r8
 432         PTREGSCALL stub_fork, sys_fork, %rdi
 433         PTREGSCALL stub_vfork, sys_vfork, %rdi
 434         PTREGSCALL stub_rt_sigsuspend, sys_rt_sigsuspend, %rdx
 435         PTREGSCALL stub_sigaltstack, sys_sigaltstack, %rdx
 436         PTREGSCALL stub_iopl, sys_iopl, %rsi
 437
 438 ENTRY(ptregscall_common)
 439         popq %r11
 440         CFI_ADJUST_CFA_OFFSET -8
 441         CFI_REGISTER rip, r11
 442         SAVE_REST
 443         movq %r11, %r15
 444         CFI_REGISTER rip, r15
 445         FIXUP_TOP_OF_STACK %r11
 446         call *%rax
 447         RESTORE_TOP_OF_STACK %r11
 448         movq %r15, %r11
 449         CFI_REGISTER rip, r11
 450         RESTORE_REST
 451         pushq %r11
 452         CFI_ADJUST_CFA_OFFSET 8
 453         CFI_REL_OFFSET rip, 0
 454         ret
 455         CFI_ENDPROC
 456 END(ptregscall_common)
 457
 458 ENTRY(stub_execve)
 459         CFI_STARTPROC
 460         popq %r11
 461         CFI_ADJUST_CFA_OFFSET -8
 462         CFI_REGISTER rip, r11
 463         SAVE_REST
 464         FIXUP_TOP_OF_STACK %r11
 465         call sys_execve
 466         RESTORE_TOP_OF_STACK %r11
 467         movq %rax,RAX(%rsp)
 468         RESTORE_REST
 469         jmp int_ret_from_sys_call
 470         CFI_ENDPROC
 471 END(stub_execve)
 472
 473 /*
 474  * sigreturn is special because it needs to restore all registers on return.
 475  * This cannot be done with SYSRET, so use the IRET return path instead.
 476  */
 477 ENTRY(stub_rt_sigreturn)
 478         CFI_STARTPROC
 479         addq $8, %rsp
 480         CFI_ADJUST_CFA_OFFSET   -8
 481         SAVE_REST
 482         movq %rsp,%rdi
 483         FIXUP_TOP_OF_STACK %r11
 484         call sys_rt_sigreturn
 485         movq %rax,RAX(%rsp) # fixme, this could be done at the higher layer
 486         RESTORE_REST
 487         jmp int_ret_from_sys_call
 488         CFI_ENDPROC
 489 END(stub_rt_sigreturn)
 490
 491 /*
 492  * initial frame state for interrupts and exceptions
 493  */
 494         .macro _frame ref
 495         CFI_STARTPROC simple
 496         CFI_SIGNAL_FRAME
 497         CFI_DEF_CFA rsp,SS+8-\ref
 498         /*CFI_REL_OFFSET ss,SS-\ref*/
 499         CFI_REL_OFFSET rsp,RSP-\ref
 500         /*CFI_REL_OFFSET rflags,EFLAGS-\ref*/
 501         /*CFI_REL_OFFSET cs,CS-\ref*/
 502         CFI_REL_OFFSET rip,RIP-\ref
 503         .endm
 504
 505 /* initial frame state for interrupts (and exceptions without error code) */
 506 #define INTR_FRAME _frame RIP
 507 /* initial frame state for exceptions with error code (and interrupts with
 508    vector already pushed) */
 509 #define XCPT_FRAME _frame ORIG_RAX
 510
 511 /*
 512  * Interrupt entry/exit.
 513  *
 514  * Interrupt entry points save only callee clobbered registers in fast path.
 515  *
 516  * Entry runs with interrupts off.
 517  */
 518
 519 /* 0(%rsp): interrupt number */
 520         .macro interrupt func
 521         cld
 522         SAVE_ARGS
 523         leaq -ARGOFFSET(%rsp),%rdi      # arg1 for handler
 524         pushq %rbp
 525         CFI_ADJUST_CFA_OFFSET   8
 526         CFI_REL_OFFSET          rbp, 0
 527         movq %rsp,%rbp
 528         CFI_DEF_CFA_REGISTER    rbp
 529         testl $3,CS(%rdi)
 530         je 1f
 531         swapgs
 532         /* irqcount is used to check if a CPU is already on an interrupt
 533            stack or not. While this is essentially redundant with preempt_count
 534            it is a little cheaper to use a separate counter in the PDA
 535            (short of moving irq_enter into assembly, which would be too
 536             much work) */
 537 1:      incl    %gs:pda_irqcount
 538         cmoveq %gs:pda_irqstackptr,%rsp
 539         push    %rbp                    # backlink for old unwinder
 540         CFI_ADJUST_CFA_OFFSET 8
 541         CFI_REL_OFFSET rbp,0
 542         /*
 543          * We entered an interrupt context - irqs are off:
 544          */
 545         TRACE_IRQS_OFF
 546         call \func
 547         .endm
 548
 549 ENTRY(common_interrupt)
 550         XCPT_FRAME
 551         interrupt do_IRQ
 552         /* 0(%rsp): oldrsp-ARGOFFSET */
 553 ret_from_intr:
 554         cli
 555         TRACE_IRQS_OFF
 556         decl %gs:pda_irqcount
 557         leaveq
 558         CFI_DEF_CFA_REGISTER    rsp
 559         CFI_ADJUST_CFA_OFFSET   -8
 560 exit_intr:
 561         GET_THREAD_INFO(%rcx)
 562         testl $3,CS-ARGOFFSET(%rsp)
 563         je retint_kernel
 564
 565         /* Interrupt came from user space */
 566         /*
 567          * Has a correct top of stack, but a partial stack frame
 568          * %rcx: thread info. Interrupts off.
 569          */
 570 retint_with_reschedule:
 571         movl $_TIF_WORK_MASK,%edi
 572 retint_check:
 573         movl threadinfo_flags(%rcx),%edx
 574         andl %edi,%edx
 575         CFI_REMEMBER_STATE
 576         jnz  retint_careful
 577 retint_swapgs:
 578         /*
 579          * The iretq could re-enable interrupts:
 580          */
 581         cli
 582         TRACE_IRQS_IRETQ
 583         swapgs
 584         jmp restore_args
 585
 586 retint_restore_args:
 587         cli
 588         /*
 589          * The iretq could re-enable interrupts:
 590          */
 591         TRACE_IRQS_IRETQ
 592 restore_args:
 593         RESTORE_ARGS 0,8,0
 594 iret_label:
 595         iretq
 596
 597         .section __ex_table,"a"
 598         .quad iret_label,bad_iret
 599         .previous
 600         .section .fixup,"ax"
 601         /* force a signal here? this matches i386 behaviour */
 602         /* running with kernel gs */
 603 bad_iret:
 604         movq $11,%rdi   /* SIGSEGV */
 605         TRACE_IRQS_ON
 606         sti
 607         jmp do_exit
 608         .previous
 609
 610         /* edi: workmask, edx: work */
 611 retint_careful:
 612         CFI_RESTORE_STATE
 613         bt    $TIF_NEED_RESCHED,%edx
 614         jnc   retint_signal
 615         TRACE_IRQS_ON
 616         sti
 617         pushq %rdi
 618         CFI_ADJUST_CFA_OFFSET   8
 619         call  schedule
 620         popq %rdi
 621         CFI_ADJUST_CFA_OFFSET   -8
 622         GET_THREAD_INFO(%rcx)
 623         cli
 624         TRACE_IRQS_OFF
 625         jmp retint_check
 626
 627 retint_signal:
 628         testl $(_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SINGLESTEP),%edx
 629         jz    retint_swapgs
 630         TRACE_IRQS_ON
 631         sti
 632         SAVE_REST
 633         movq $-1,ORIG_RAX(%rsp)
 634         xorl %esi,%esi          # oldset
 635         movq %rsp,%rdi          # &pt_regs
 636         call do_notify_resume
 637         RESTORE_REST
 638         cli
 639         TRACE_IRQS_OFF
 640         movl $_TIF_NEED_RESCHED,%edi
 641         GET_THREAD_INFO(%rcx)
 642         jmp retint_check
 643
 644 #ifdef CONFIG_PREEMPT
 645         /* Returning to kernel space. Check if we need preemption */
 646         /* rcx:  threadinfo. interrupts off. */
 647 ENTRY(retint_kernel)
 648         cmpl $0,threadinfo_preempt_count(%rcx)
 649         jnz  retint_restore_args
 650         bt  $TIF_NEED_RESCHED,threadinfo_flags(%rcx)
 651         jnc  retint_restore_args
 652         bt   $9,EFLAGS-ARGOFFSET(%rsp)  /* interrupts off? */
 653         jnc  retint_restore_args
 654         call preempt_schedule_irq
 655         jmp exit_intr
 656 #endif
 657
 658         CFI_ENDPROC
 659 END(common_interrupt)
 660
 661 /*
 662  * APIC interrupts.
 663  */
 664         .macro apicinterrupt num,func
 665         INTR_FRAME
 666         pushq $~(\num)
 667         CFI_ADJUST_CFA_OFFSET 8
 668         interrupt \func
 669         jmp ret_from_intr
 670         CFI_ENDPROC
 671         .endm
 672
 673 ENTRY(thermal_interrupt)
 674         apicinterrupt THERMAL_APIC_VECTOR,smp_thermal_interrupt
 675 END(thermal_interrupt)
 676
 677 ENTRY(threshold_interrupt)
 678         apicinterrupt THRESHOLD_APIC_VECTOR,mce_threshold_interrupt
 679 END(threshold_interrupt)
 680
 681 #ifdef CONFIG_SMP
 682 ENTRY(reschedule_interrupt)
 683         apicinterrupt RESCHEDULE_VECTOR,smp_reschedule_interrupt
 684 END(reschedule_interrupt)
 685
 686         .macro INVALIDATE_ENTRY num
 687 ENTRY(invalidate_interrupt\num)
 688         apicinterrupt INVALIDATE_TLB_VECTOR_START+\num,smp_invalidate_interrupt
 689 END(invalidate_interrupt\num)
 690         .endm
 691
 692         INVALIDATE_ENTRY 0
 693         INVALIDATE_ENTRY 1
 694         INVALIDATE_ENTRY 2
 695         INVALIDATE_ENTRY 3
 696         INVALIDATE_ENTRY 4
 697         INVALIDATE_ENTRY 5
 698         INVALIDATE_ENTRY 6
 699         INVALIDATE_ENTRY 7
 700
 701 ENTRY(call_function_interrupt)
 702         apicinterrupt CALL_FUNCTION_VECTOR,smp_call_function_interrupt
 703 END(call_function_interrupt)
 704 #endif
 705
 706 ENTRY(apic_timer_interrupt)
 707         apicinterrupt LOCAL_TIMER_VECTOR,smp_apic_timer_interrupt
 708 END(apic_timer_interrupt)
 709
 710 ENTRY(error_interrupt)
 711         apicinterrupt ERROR_APIC_VECTOR,smp_error_interrupt
 712 END(error_interrupt)
 713
 714 ENTRY(spurious_interrupt)
 715         apicinterrupt SPURIOUS_APIC_VECTOR,smp_spurious_interrupt
 716 END(spurious_interrupt)
 717
 718 /*
 719  * Exception entry points.
 720  */
 721         .macro zeroentry sym
 722         INTR_FRAME
 723         pushq $0        /* push error code/oldrax */
 724         CFI_ADJUST_CFA_OFFSET 8
 725         pushq %rax      /* push real oldrax to the rdi slot */
 726         CFI_ADJUST_CFA_OFFSET 8
 727         leaq  \sym(%rip),%rax
 728         jmp error_entry
 729         CFI_ENDPROC
 730         .endm
 731
 732         .macro errorentry sym
 733         XCPT_FRAME
 734         pushq %rax
 735         CFI_ADJUST_CFA_OFFSET 8
 736         leaq  \sym(%rip),%rax
 737         jmp error_entry
 738         CFI_ENDPROC
 739         .endm
 740
 741         /* error code is on the stack already */
 742         /* handle NMI like exceptions that can happen everywhere */
 743         .macro paranoidentry sym, ist=0, irqtrace=1
 744         SAVE_ALL
 745         cld
 746         movl $1,%ebx
 747         movl  $MSR_GS_BASE,%ecx
 748         rdmsr
 749         testl %edx,%edx
 750         js    1f
 751         swapgs
 752         xorl  %ebx,%ebx
 753 1:
 754         .if \ist
 755         movq    %gs:pda_data_offset, %rbp
 756         .endif
 757         movq %rsp,%rdi
 758         movq ORIG_RAX(%rsp),%rsi
 759         movq $-1,ORIG_RAX(%rsp)
 760         .if \ist
 761         subq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
 762         .endif
 763         call \sym
 764         .if \ist
 765         addq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
 766         .endif
 767         cli
 768         .if \irqtrace
 769         TRACE_IRQS_OFF
 770         .endif
 771         .endm
 772
 773         /*
 774          * "Paranoid" exit path from exception stack.
 775          * Paranoid because this is used by NMIs and cannot take
 776          * any kernel state for granted.
 777          * We don't do kernel preemption checks here, because only
 778          * NMI should be common and it does not enable IRQs and
 779          * cannot get reschedule ticks.
 780          *
 781          * "trace" is 0 for the NMI handler only, because irq-tracing
 782          * is fundamentally NMI-unsafe. (we cannot change the soft and
 783          * hard flags at once, atomically)
 784          */
 785         .macro paranoidexit trace=1
 786         /* ebx: no swapgs flag */
 787 paranoid_exit\trace:
 788         testl %ebx,%ebx                         /* swapgs needed? */
 789         jnz paranoid_restore\trace
 790         testl $3,CS(%rsp)
 791         jnz   paranoid_userspace\trace
 792 paranoid_swapgs\trace:
 793         .if \trace
 794         TRACE_IRQS_IRETQ 0
 795         .endif
 796         swapgs
 797 paranoid_restore\trace:
 798         RESTORE_ALL 8
 799         iretq
 800 paranoid_userspace\trace:
 801         GET_THREAD_INFO(%rcx)
 802         movl threadinfo_flags(%rcx),%ebx
 803         andl $_TIF_WORK_MASK,%ebx
 804         jz paranoid_swapgs\trace
 805         movq %rsp,%rdi                  /* &pt_regs */
 806         call sync_regs
 807         movq %rax,%rsp                  /* switch stack for scheduling */
 808         testl $_TIF_NEED_RESCHED,%ebx
 809         jnz paranoid_schedule\trace
 810         movl %ebx,%edx                  /* arg3: thread flags */
 811         .if \trace
 812         TRACE_IRQS_ON
 813         .endif
 814         sti
 815         xorl %esi,%esi                  /* arg2: oldset */
 816         movq %rsp,%rdi                  /* arg1: &pt_regs */
 817         call do_notify_resume
 818         cli
 819         .if \trace
 820         TRACE_IRQS_OFF
 821         .endif
 822         jmp paranoid_userspace\trace
 823 paranoid_schedule\trace:
 824         .if \trace
 825         TRACE_IRQS_ON
 826         .endif
 827         sti
 828         call schedule
 829         cli
 830         .if \trace
 831         TRACE_IRQS_OFF
 832         .endif
 833         jmp paranoid_userspace\trace
 834         CFI_ENDPROC
 835         .endm
 836
 837 /*
 838  * Exception entry point. This expects an error code/orig_rax on the stack
 839  * and the exception handler in %rax.
 840  */
 841 KPROBE_ENTRY(error_entry)
 842         _frame RDI
 843         /* rdi slot contains rax, oldrax contains error code */
 844         cld
 845         subq  $14*8,%rsp
 846         CFI_ADJUST_CFA_OFFSET   (14*8)
 847         movq %rsi,13*8(%rsp)
 848         CFI_REL_OFFSET  rsi,RSI
 849         movq 14*8(%rsp),%rsi    /* load rax from rdi slot */
 850         movq %rdx,12*8(%rsp)
 851         CFI_REL_OFFSET  rdx,RDX
 852         movq %rcx,11*8(%rsp)
 853         CFI_REL_OFFSET  rcx,RCX
 854         movq %rsi,10*8(%rsp)    /* store rax */
 855         CFI_REL_OFFSET  rax,RAX
 856         movq %r8, 9*8(%rsp)
 857         CFI_REL_OFFSET  r8,R8
 858         movq %r9, 8*8(%rsp)
 859         CFI_REL_OFFSET  r9,R9
 860         movq %r10,7*8(%rsp)
 861         CFI_REL_OFFSET  r10,R10
 862         movq %r11,6*8(%rsp)
 863         CFI_REL_OFFSET  r11,R11
 864         movq %rbx,5*8(%rsp)
 865         CFI_REL_OFFSET  rbx,RBX
 866         movq %rbp,4*8(%rsp)
 867         CFI_REL_OFFSET  rbp,RBP
 868         movq %r12,3*8(%rsp)
 869         CFI_REL_OFFSET  r12,R12
 870         movq %r13,2*8(%rsp)
 871         CFI_REL_OFFSET  r13,R13
 872         movq %r14,1*8(%rsp)
 873         CFI_REL_OFFSET  r14,R14
 874         movq %r15,(%rsp)
 875         CFI_REL_OFFSET  r15,R15
 876         xorl %ebx,%ebx
 877         testl $3,CS(%rsp)
 878         je  error_kernelspace
 879 error_swapgs:
 880         swapgs
 881 error_sti:
 882         movq %rdi,RDI(%rsp)
 883         movq %rsp,%rdi
 884         movq ORIG_RAX(%rsp),%rsi        /* get error code */
 885         movq $-1,ORIG_RAX(%rsp)
 886         call *%rax
 887         /* ebx: no swapgs flag (1: don't need swapgs, 0: need it) */
 888 error_exit:
 889         movl %ebx,%eax
 890         RESTORE_REST
 891         cli
 892         TRACE_IRQS_OFF
 893         GET_THREAD_INFO(%rcx)
 894         testl %eax,%eax
 895         jne  retint_kernel
 896         movl  threadinfo_flags(%rcx),%edx
 897         movl  $_TIF_WORK_MASK,%edi
 898         andl  %edi,%edx
 899         jnz  retint_careful
 900         /*
 901          * The iret might restore flags:
 902          */
 903         TRACE_IRQS_IRETQ
 904         swapgs
 905         RESTORE_ARGS 0,8,0
 906         jmp iret_label
 907         CFI_ENDPROC
 908
 909 error_kernelspace:
 910         incl %ebx
 911        /* There are two places in the kernel that can potentially fault with
 912           usergs. Handle them here. The exception handlers after
 913            iret run with kernel gs again, so don't set the user space flag.
 914            B stepping K8s sometimes report an truncated RIP for IRET
 915            exceptions returning to compat mode. Check for these here too. */
 916         leaq iret_label(%rip),%rbp
 917         cmpq %rbp,RIP(%rsp)
 918         je   error_swapgs
 919         movl %ebp,%ebp  /* zero extend */
 920         cmpq %rbp,RIP(%rsp)
 921         je   error_swapgs
 922         cmpq $gs_change,RIP(%rsp)
 923         je   error_swapgs
 924         jmp  error_sti
 925 KPROBE_END(error_entry)
 926
 927        /* Reload gs selector with exception handling */
 928        /* edi:  new selector */
 929 ENTRY(load_gs_index)
 930         CFI_STARTPROC
 931         pushf
 932         CFI_ADJUST_CFA_OFFSET 8
 933         cli
 934         swapgs
 935 gs_change:
 936         movl %edi,%gs
 937 2:      mfence          /* workaround */
 938         swapgs
 939         popf
 940         CFI_ADJUST_CFA_OFFSET -8
 941         ret
 942         CFI_ENDPROC
 943 ENDPROC(load_gs_index)
 944
 945         .section __ex_table,"a"
 946         .align 8
 947         .quad gs_change,bad_gs
 948         .previous
 949         .section .fixup,"ax"
 950         /* running with kernelgs */
 951 bad_gs:
 952         swapgs                  /* switch back to user gs */
 953         xorl %eax,%eax
 954         movl %eax,%gs
 955         jmp  2b
 956         .previous
 957
 958 /*
 959  * Create a kernel thread.
 960  *
 961  * C extern interface:
 962  *      extern long kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 963  *
 964  * asm input arguments:
 965  *      rdi: fn, rsi: arg, rdx: flags
 966  */
 967 ENTRY(kernel_thread)
 968         CFI_STARTPROC
 969         FAKE_STACK_FRAME $child_rip
 970         SAVE_ALL
 971
 972         # rdi: flags, rsi: usp, rdx: will be &pt_regs
 973         movq %rdx,%rdi
 974         orq  kernel_thread_flags(%rip),%rdi
 975         movq $-1, %rsi
 976         movq %rsp, %rdx
 977
 978         xorl %r8d,%r8d
 979         xorl %r9d,%r9d
 980
 981         # clone now
 982         call do_fork
 983         movq %rax,RAX(%rsp)
 984         xorl %edi,%edi
 985         test %rax,%rax
 986         jnz  1f
 987         /* terminate stack in child */
 988         movq %rdi,RIP(%rsp)
 989 1:
 990
 991         /*
 992          * It isn't worth to check for reschedule here,
 993          * so internally to the x86_64 port you can rely on kernel_thread()
 994          * not to reschedule the child before returning, this avoids the need
 995          * of hacks for example to fork off the per-CPU idle tasks.
 996          * [Hopefully no generic code relies on the reschedule -AK]
 997          */
 998         RESTORE_ALL
 999         UNFAKE_STACK_FRAME
1000         ret
1001         CFI_ENDPROC
1002 ENDPROC(kernel_thread)
1003
1004 child_rip:
1005         pushq $0                # fake return address
1006         CFI_STARTPROC
1007         /*
1008          * Here we are in the child and the registers are set as they were
1009          * at kernel_thread() invocation in the parent.
1010          */
1011         movq %rdi, %rax
1012         movq %rsi, %rdi
1013         call *%rax
1014         # exit
1015         xorl %edi, %edi
1016         call do_exit
1017         CFI_ENDPROC
1018 ENDPROC(child_rip)
1019
1020 /*
1021  * execve(). This function needs to use IRET, not SYSRET, to set up all state properly.
1022  *
1023  * C extern interface:
1024  *       extern long execve(char *name, char **argv, char **envp)
1025  *
1026  * asm input arguments:
1027  *      rdi: name, rsi: argv, rdx: envp
1028  *
1029  * We want to fallback into:
1030  *      extern long sys_execve(char *name, char **argv,char **envp, struct pt_regs regs)
1031  *
1032  * do_sys_execve asm fallback arguments:
1033  *      rdi: name, rsi: argv, rdx: envp, fake frame on the stack
1034  */
1035 ENTRY(kernel_execve)
1036         CFI_STARTPROC
1037         FAKE_STACK_FRAME $0
1038         SAVE_ALL
1039         call sys_execve
1040         movq %rax, RAX(%rsp)
1041         RESTORE_REST
1042         testq %rax,%rax
1043         je int_ret_from_sys_call
1044         RESTORE_ARGS
1045         UNFAKE_STACK_FRAME
1046         ret
1047         CFI_ENDPROC
1048 ENDPROC(kernel_execve)
1049
1050 KPROBE_ENTRY(page_fault)
1051         errorentry do_page_fault
1052 KPROBE_END(page_fault)
1053
1054 ENTRY(coprocessor_error)
1055         zeroentry do_coprocessor_error
1056 END(coprocessor_error)
1057
1058 ENTRY(simd_coprocessor_error)
1059         zeroentry do_simd_coprocessor_error
1060 END(simd_coprocessor_error)
1061
1062 ENTRY(device_not_available)
1063         zeroentry math_state_restore
1064 END(device_not_available)
1065
1066         /* runs on exception stack */
1067 KPROBE_ENTRY(debug)
1068         INTR_FRAME
1069         pushq $0
1070         CFI_ADJUST_CFA_OFFSET 8
1071         paranoidentry do_debug, DEBUG_STACK
1072         paranoidexit
1073 KPROBE_END(debug)
1074
1075         /* runs on exception stack */
1076 KPROBE_ENTRY(nmi)
1077         INTR_FRAME
1078         pushq $-1
1079         CFI_ADJUST_CFA_OFFSET 8
1080         paranoidentry do_nmi, 0, 0
1081 #ifdef CONFIG_TRACE_IRQFLAGS
1082         paranoidexit 0
1083 #else
1084         jmp paranoid_exit1
1085         CFI_ENDPROC
1086 #endif
1087 KPROBE_END(nmi)
1088
1089 KPROBE_ENTRY(int3)
1090         INTR_FRAME
1091         pushq $0
1092         CFI_ADJUST_CFA_OFFSET 8
1093         paranoidentry do_int3, DEBUG_STACK
1094         jmp paranoid_exit1
1095         CFI_ENDPROC
1096 KPROBE_END(int3)
1097
1098 ENTRY(overflow)
1099         zeroentry do_overflow
1100 END(overflow)
1101
1102 ENTRY(bounds)
1103         zeroentry do_bounds
1104 END(bounds)
1105
1106 ENTRY(invalid_op)
1107         zeroentry do_invalid_op
1108 END(invalid_op)
1109
1110 ENTRY(coprocessor_segment_overrun)
1111         zeroentry do_coprocessor_segment_overrun
1112 END(coprocessor_segment_overrun)
1113
1114 ENTRY(reserved)
1115         zeroentry do_reserved
1116 END(reserved)
1117
1118         /* runs on exception stack */
1119 ENTRY(double_fault)
1120         XCPT_FRAME
1121         paranoidentry do_double_fault
1122         jmp paranoid_exit1
1123         CFI_ENDPROC
1124 END(double_fault)
1125
1126 ENTRY(invalid_TSS)
1127         errorentry do_invalid_TSS
1128 END(invalid_TSS)
1129
1130 ENTRY(segment_not_present)
1131         errorentry do_segment_not_present
1132 END(segment_not_present)
1133
1134         /* runs on exception stack */
1135 ENTRY(stack_segment)
1136         XCPT_FRAME
1137         paranoidentry do_stack_segment
1138         jmp paranoid_exit1
1139         CFI_ENDPROC
1140 END(stack_segment)
1141
1142 KPROBE_ENTRY(general_protection)
1143         errorentry do_general_protection
1144 KPROBE_END(general_protection)
1145
1146 ENTRY(alignment_check)
1147         errorentry do_alignment_check
1148 END(alignment_check)
1149
1150 ENTRY(divide_error)
1151         zeroentry do_divide_error
1152 END(divide_error)
1153
1154 ENTRY(spurious_interrupt_bug)
1155         zeroentry do_spurious_interrupt_bug
1156 END(spurious_interrupt_bug)
1157
1158 #ifdef CONFIG_X86_MCE
1159         /* runs on exception stack */
1160 ENTRY(machine_check)
1161         INTR_FRAME
1162         pushq $0
1163         CFI_ADJUST_CFA_OFFSET 8
1164         paranoidentry do_machine_check
1165         jmp paranoid_exit1
1166         CFI_ENDPROC
1167 END(machine_check)
1168 #endif
1169
1170 /* Call softirq on interrupt stack. Interrupts are off. */
1171 ENTRY(call_softirq)
1172         CFI_STARTPROC
1173         push %rbp
1174         CFI_ADJUST_CFA_OFFSET   8
1175         CFI_REL_OFFSET rbp,0
1176         mov  %rsp,%rbp
1177         CFI_DEF_CFA_REGISTER rbp
1178         incl %gs:pda_irqcount
1179         cmove %gs:pda_irqstackptr,%rsp
1180         push  %rbp                      # backlink for old unwinder
1181         CFI_ADJUST_CFA_OFFSET    8
1182         call __do_softirq
1183         leaveq
1184         CFI_DEF_CFA_REGISTER    rsp
1185         CFI_ADJUST_CFA_OFFSET   -8
1186         decl %gs:pda_irqcount
1187         ret
1188         CFI_ENDPROC
1189 ENDPROC(call_softirq)
1190
1191 #ifdef CONFIG_STACK_UNWIND
1192 ENTRY(arch_unwind_init_running)
1193         CFI_STARTPROC
1194         movq    %r15, R15(%rdi)
1195         movq    %r14, R14(%rdi)
1196         xchgq   %rsi, %rdx
1197         movq    %r13, R13(%rdi)
1198         movq    %r12, R12(%rdi)
1199         xorl    %eax, %eax
1200         movq    %rbp, RBP(%rdi)
1201         movq    %rbx, RBX(%rdi)
1202         movq    (%rsp), %rcx
1203         movq    %rax, R11(%rdi)
1204         movq    %rax, R10(%rdi)
1205         movq    %rax, R9(%rdi)
1206         movq    %rax, R8(%rdi)
1207         movq    %rax, RAX(%rdi)
1208         movq    %rax, RCX(%rdi)
1209         movq    %rax, RDX(%rdi)
1210         movq    %rax, RSI(%rdi)
1211         movq    %rax, RDI(%rdi)
1212         movq    %rax, ORIG_RAX(%rdi)
1213         movq    %rcx, RIP(%rdi)
1214         leaq    8(%rsp), %rcx
1215         movq    $__KERNEL_CS, CS(%rdi)
1216         movq    %rax, EFLAGS(%rdi)
1217         movq    %rcx, RSP(%rdi)
1218         movq    $__KERNEL_DS, SS(%rdi)
1219         jmpq    *%rdx
1220         CFI_ENDPROC
1221 ENDPROC(arch_unwind_init_running)
1222 #endif