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