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 #ifdef CONFIG_PARAVIRT
 586         INTERRUPT_RETURN
 587 #endif
 588 ENTRY(native_iret)
 589         iretq
 590
 591         .section __ex_table,"a"
 592         .quad native_iret, bad_iret
 593         .previous
 594         .section .fixup,"ax"
 595 bad_iret:
 596         /*
 597          * The iret traps when the %cs or %ss being restored is bogus.
 598          * We've lost the original trap vector and error code.
 599          * #GPF is the most likely one to get for an invalid selector.
 600          * So pretend we completed the iret and took the #GPF in user mode.
 601          *
 602          * We are now running with the kernel GS after exception recovery.
 603          * But error_entry expects us to have user GS to match the user %cs,
 604          * so swap back.
 605          */
 606         pushq $0
 607
 608         SWAPGS
 609         jmp general_protection
 610
 611         .previous
 612
 613         /* edi: workmask, edx: work */
 614 retint_careful:
 615         CFI_RESTORE_STATE
 616         bt    $TIF_NEED_RESCHED,%edx
 617         jnc   retint_signal
 618         TRACE_IRQS_ON
 619         ENABLE_INTERRUPTS(CLBR_NONE)
 620         pushq %rdi
 621         CFI_ADJUST_CFA_OFFSET   8
 622         call  schedule
 623         popq %rdi
 624         CFI_ADJUST_CFA_OFFSET   -8
 625         GET_THREAD_INFO(%rcx)
 626         DISABLE_INTERRUPTS(CLBR_NONE)
 627         TRACE_IRQS_OFF
 628         jmp retint_check
 629
 630 retint_signal:
 631         testl $_TIF_DO_NOTIFY_MASK,%edx
 632         jz    retint_swapgs
 633         TRACE_IRQS_ON
 634         ENABLE_INTERRUPTS(CLBR_NONE)
 635         SAVE_REST
 636         movq $-1,ORIG_RAX(%rsp)
 637         xorl %esi,%esi          # oldset
 638         movq %rsp,%rdi          # &pt_regs
 639         call do_notify_resume
 640         RESTORE_REST
 641         DISABLE_INTERRUPTS(CLBR_NONE)
 642         TRACE_IRQS_OFF
 643         movl $_TIF_NEED_RESCHED,%edi
 644         GET_THREAD_INFO(%rcx)
 645         jmp retint_check
 646
 647 #ifdef CONFIG_PREEMPT
 648         /* Returning to kernel space. Check if we need preemption */
 649         /* rcx:  threadinfo. interrupts off. */
 650 ENTRY(retint_kernel)
 651         cmpl $0,threadinfo_preempt_count(%rcx)
 652         jnz  retint_restore_args
 653         bt  $TIF_NEED_RESCHED,threadinfo_flags(%rcx)
 654         jnc  retint_restore_args
 655         bt   $9,EFLAGS-ARGOFFSET(%rsp)  /* interrupts off? */
 656         jnc  retint_restore_args
 657         call preempt_schedule_irq
 658         jmp exit_intr
 659 #endif
 660
 661         CFI_ENDPROC
 662 END(common_interrupt)
 663
 664 /*
 665  * APIC interrupts.
 666  */
 667         .macro apicinterrupt num,func
 668         INTR_FRAME
 669         pushq $~(\num)
 670         CFI_ADJUST_CFA_OFFSET 8
 671         interrupt \func
 672         jmp ret_from_intr
 673         CFI_ENDPROC
 674         .endm
 675
 676 ENTRY(thermal_interrupt)
 677         apicinterrupt THERMAL_APIC_VECTOR,smp_thermal_interrupt
 678 END(thermal_interrupt)
 679
 680 ENTRY(threshold_interrupt)
 681         apicinterrupt THRESHOLD_APIC_VECTOR,mce_threshold_interrupt
 682 END(threshold_interrupt)
 683
 684 #ifdef CONFIG_SMP
 685 ENTRY(reschedule_interrupt)
 686         apicinterrupt RESCHEDULE_VECTOR,smp_reschedule_interrupt
 687 END(reschedule_interrupt)
 688
 689         .macro INVALIDATE_ENTRY num
 690 ENTRY(invalidate_interrupt\num)
 691         apicinterrupt INVALIDATE_TLB_VECTOR_START+\num,smp_invalidate_interrupt
 692 END(invalidate_interrupt\num)
 693         .endm
 694
 695         INVALIDATE_ENTRY 0
 696         INVALIDATE_ENTRY 1
 697         INVALIDATE_ENTRY 2
 698         INVALIDATE_ENTRY 3
 699         INVALIDATE_ENTRY 4
 700         INVALIDATE_ENTRY 5
 701         INVALIDATE_ENTRY 6
 702         INVALIDATE_ENTRY 7
 703
 704 ENTRY(call_function_interrupt)
 705         apicinterrupt CALL_FUNCTION_VECTOR,smp_call_function_interrupt
 706 END(call_function_interrupt)
 707 ENTRY(irq_move_cleanup_interrupt)
 708         apicinterrupt IRQ_MOVE_CLEANUP_VECTOR,smp_irq_move_cleanup_interrupt
 709 END(irq_move_cleanup_interrupt)
 710 #endif
 711
 712 ENTRY(apic_timer_interrupt)
 713         apicinterrupt LOCAL_TIMER_VECTOR,smp_apic_timer_interrupt
 714 END(apic_timer_interrupt)
 715
 716 ENTRY(error_interrupt)
 717         apicinterrupt ERROR_APIC_VECTOR,smp_error_interrupt
 718 END(error_interrupt)
 719
 720 ENTRY(spurious_interrupt)
 721         apicinterrupt SPURIOUS_APIC_VECTOR,smp_spurious_interrupt
 722 END(spurious_interrupt)
 723
 724 /*
 725  * Exception entry points.
 726  */
 727         .macro zeroentry sym
 728         INTR_FRAME
 729         pushq $0        /* push error code/oldrax */
 730         CFI_ADJUST_CFA_OFFSET 8
 731         pushq %rax      /* push real oldrax to the rdi slot */
 732         CFI_ADJUST_CFA_OFFSET 8
 733         CFI_REL_OFFSET rax,0
 734         leaq  \sym(%rip),%rax
 735         jmp error_entry
 736         CFI_ENDPROC
 737         .endm
 738
 739         .macro errorentry sym
 740         XCPT_FRAME
 741         pushq %rax
 742         CFI_ADJUST_CFA_OFFSET 8
 743         CFI_REL_OFFSET rax,0
 744         leaq  \sym(%rip),%rax
 745         jmp error_entry
 746         CFI_ENDPROC
 747         .endm
 748
 749         /* error code is on the stack already */
 750         /* handle NMI like exceptions that can happen everywhere */
 751         .macro paranoidentry sym, ist=0, irqtrace=1
 752         SAVE_ALL
 753         cld
 754         movl $1,%ebx
 755         movl  $MSR_GS_BASE,%ecx
 756         rdmsr
 757         testl %edx,%edx
 758         js    1f
 759         SWAPGS
 760         xorl  %ebx,%ebx
 761 1:
 762         .if \ist
 763         movq    %gs:pda_data_offset, %rbp
 764         .endif
 765         movq %rsp,%rdi
 766         movq ORIG_RAX(%rsp),%rsi
 767         movq $-1,ORIG_RAX(%rsp)
 768         .if \ist
 769         subq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
 770         .endif
 771         call \sym
 772         .if \ist
 773         addq    $EXCEPTION_STKSZ, per_cpu__init_tss + TSS_ist + (\ist - 1) * 8(%rbp)
 774         .endif
 775         DISABLE_INTERRUPTS(CLBR_NONE)
 776         .if \irqtrace
 777         TRACE_IRQS_OFF
 778         .endif
 779         .endm
 780
 781         /*
 782          * "Paranoid" exit path from exception stack.
 783          * Paranoid because this is used by NMIs and cannot take
 784          * any kernel state for granted.
 785          * We don't do kernel preemption checks here, because only
 786          * NMI should be common and it does not enable IRQs and
 787          * cannot get reschedule ticks.
 788          *
 789          * "trace" is 0 for the NMI handler only, because irq-tracing
 790          * is fundamentally NMI-unsafe. (we cannot change the soft and
 791          * hard flags at once, atomically)
 792          */
 793         .macro paranoidexit trace=1
 794         /* ebx: no swapgs flag */
 795 paranoid_exit\trace:
 796         testl %ebx,%ebx                         /* swapgs needed? */
 797         jnz paranoid_restore\trace
 798         testl $3,CS(%rsp)
 799         jnz   paranoid_userspace\trace
 800 paranoid_swapgs\trace:
 801         .if \trace
 802         TRACE_IRQS_IRETQ 0
 803         .endif
 804         SWAPGS_UNSAFE_STACK
 805 paranoid_restore\trace:
 806         RESTORE_ALL 8
 807         INTERRUPT_RETURN
 808 paranoid_userspace\trace:
 809         GET_THREAD_INFO(%rcx)
 810         movl threadinfo_flags(%rcx),%ebx
 811         andl $_TIF_WORK_MASK,%ebx
 812         jz paranoid_swapgs\trace
 813         movq %rsp,%rdi                  /* &pt_regs */
 814         call sync_regs
 815         movq %rax,%rsp                  /* switch stack for scheduling */
 816         testl $_TIF_NEED_RESCHED,%ebx
 817         jnz paranoid_schedule\trace
 818         movl %ebx,%edx                  /* arg3: thread flags */
 819         .if \trace
 820         TRACE_IRQS_ON
 821         .endif
 822         ENABLE_INTERRUPTS(CLBR_NONE)
 823         xorl %esi,%esi                  /* arg2: oldset */
 824         movq %rsp,%rdi                  /* arg1: &pt_regs */
 825         call do_notify_resume
 826         DISABLE_INTERRUPTS(CLBR_NONE)
 827         .if \trace
 828         TRACE_IRQS_OFF
 829         .endif
 830         jmp paranoid_userspace\trace
 831 paranoid_schedule\trace:
 832         .if \trace
 833         TRACE_IRQS_ON
 834         .endif
 835         ENABLE_INTERRUPTS(CLBR_ANY)
 836         call schedule
 837         DISABLE_INTERRUPTS(CLBR_ANY)
 838         .if \trace
 839         TRACE_IRQS_OFF
 840         .endif
 841         jmp paranoid_userspace\trace
 842         CFI_ENDPROC
 843         .endm
 844
 845 /*
 846  * Exception entry point. This expects an error code/orig_rax on the stack
 847  * and the exception handler in %rax.
 848  */
 849 KPROBE_ENTRY(error_entry)
 850         _frame RDI
 851         CFI_REL_OFFSET rax,0
 852         /* rdi slot contains rax, oldrax contains error code */
 853         cld
 854         subq  $14*8,%rsp
 855         CFI_ADJUST_CFA_OFFSET   (14*8)
 856         movq %rsi,13*8(%rsp)
 857         CFI_REL_OFFSET  rsi,RSI
 858         movq 14*8(%rsp),%rsi    /* load rax from rdi slot */
 859         CFI_REGISTER    rax,rsi
 860         movq %rdx,12*8(%rsp)
 861         CFI_REL_OFFSET  rdx,RDX
 862         movq %rcx,11*8(%rsp)
 863         CFI_REL_OFFSET  rcx,RCX
 864         movq %rsi,10*8(%rsp)    /* store rax */
 865         CFI_REL_OFFSET  rax,RAX
 866         movq %r8, 9*8(%rsp)
 867         CFI_REL_OFFSET  r8,R8
 868         movq %r9, 8*8(%rsp)
 869         CFI_REL_OFFSET  r9,R9
 870         movq %r10,7*8(%rsp)
 871         CFI_REL_OFFSET  r10,R10
 872         movq %r11,6*8(%rsp)
 873         CFI_REL_OFFSET  r11,R11
 874         movq %rbx,5*8(%rsp)
 875         CFI_REL_OFFSET  rbx,RBX
 876         movq %rbp,4*8(%rsp)
 877         CFI_REL_OFFSET  rbp,RBP
 878         movq %r12,3*8(%rsp)
 879         CFI_REL_OFFSET  r12,R12
 880         movq %r13,2*8(%rsp)
 881         CFI_REL_OFFSET  r13,R13
 882         movq %r14,1*8(%rsp)
 883         CFI_REL_OFFSET  r14,R14
 884         movq %r15,(%rsp)
 885         CFI_REL_OFFSET  r15,R15
 886         xorl %ebx,%ebx
 887         testl $3,CS(%rsp)
 888         je  error_kernelspace
 889 error_swapgs:
 890         SWAPGS
 891 error_sti:
 892         movq %rdi,RDI(%rsp)
 893         CFI_REL_OFFSET  rdi,RDI
 894         movq %rsp,%rdi
 895         movq ORIG_RAX(%rsp),%rsi        /* get error code */
 896         movq $-1,ORIG_RAX(%rsp)
 897         call *%rax
 898         /* ebx: no swapgs flag (1: don't need swapgs, 0: need it) */
 899 error_exit:
 900         movl %ebx,%eax
 901         RESTORE_REST
 902         DISABLE_INTERRUPTS(CLBR_NONE)
 903         TRACE_IRQS_OFF
 904         GET_THREAD_INFO(%rcx)
 905         testl %eax,%eax
 906         jne  retint_kernel
 907         LOCKDEP_SYS_EXIT_IRQ
 908         movl  threadinfo_flags(%rcx),%edx
 909         movl  $_TIF_WORK_MASK,%edi
 910         andl  %edi,%edx
 911         jnz  retint_careful
 912         jmp retint_swapgs
 913         CFI_ENDPROC
 914
 915 error_kernelspace:
 916         incl %ebx
 917        /* There are two places in the kernel that can potentially fault with
 918           usergs. Handle them here. The exception handlers after
 919            iret run with kernel gs again, so don't set the user space flag.
 920            B stepping K8s sometimes report an truncated RIP for IRET
 921            exceptions returning to compat mode. Check for these here too. */
 922         leaq native_iret(%rip),%rbp
 923         cmpq %rbp,RIP(%rsp)
 924         je   error_swapgs
 925         movl %ebp,%ebp  /* zero extend */
 926         cmpq %rbp,RIP(%rsp)
 927         je   error_swapgs
 928         cmpq $gs_change,RIP(%rsp)
 929         je   error_swapgs
 930         jmp  error_sti
 931 KPROBE_END(error_entry)
 932
 933        /* Reload gs selector with exception handling */
 934        /* edi:  new selector */
 935 ENTRY(load_gs_index)
 936         CFI_STARTPROC
 937         pushf
 938         CFI_ADJUST_CFA_OFFSET 8
 939         DISABLE_INTERRUPTS(CLBR_ANY | ~(CLBR_RDI))
 940         SWAPGS
 941 gs_change:
 942         movl %edi,%gs
 943 2:      mfence          /* workaround */
 944         SWAPGS
 945         popf
 946         CFI_ADJUST_CFA_OFFSET -8
 947         ret
 948         CFI_ENDPROC
 949 ENDPROC(load_gs_index)
 950
 951         .section __ex_table,"a"
 952         .align 8
 953         .quad gs_change,bad_gs
 954         .previous
 955         .section .fixup,"ax"
 956         /* running with kernelgs */
 957 bad_gs:
 958         SWAPGS                  /* switch back to user gs */
 959         xorl %eax,%eax
 960         movl %eax,%gs
 961         jmp  2b
 962         .previous
 963
 964 /*
 965  * Create a kernel thread.
 966  *
 967  * C extern interface:
 968  *      extern long kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 969  *
 970  * asm input arguments:
 971  *      rdi: fn, rsi: arg, rdx: flags
 972  */
 973 ENTRY(kernel_thread)
 974         CFI_STARTPROC
 975         FAKE_STACK_FRAME $child_rip
 976         SAVE_ALL
 977
 978         # rdi: flags, rsi: usp, rdx: will be &pt_regs
 979         movq %rdx,%rdi
 980         orq  kernel_thread_flags(%rip),%rdi
 981         movq $-1, %rsi
 982         movq %rsp, %rdx
 983
 984         xorl %r8d,%r8d
 985         xorl %r9d,%r9d
 986
 987         # clone now
 988         call do_fork
 989         movq %rax,RAX(%rsp)
 990         xorl %edi,%edi
 991
 992         /*
 993          * It isn't worth to check for reschedule here,
 994          * so internally to the x86_64 port you can rely on kernel_thread()
 995          * not to reschedule the child before returning, this avoids the need
 996          * of hacks for example to fork off the per-CPU idle tasks.
 997          * [Hopefully no generic code relies on the reschedule -AK]
 998          */
 999         RESTORE_ALL
1000         UNFAKE_STACK_FRAME
1001         ret
1002         CFI_ENDPROC
1003 ENDPROC(kernel_thread)
1004
1005 child_rip:
1006         pushq $0                # fake return address
1007         CFI_STARTPROC
1008         /*
1009          * Here we are in the child and the registers are set as they were
1010          * at kernel_thread() invocation in the parent.
1011          */
1012         movq %rdi, %rax
1013         movq %rsi, %rdi
1014         call *%rax
1015         # exit
1016         mov %eax, %edi
1017         call do_exit
1018         CFI_ENDPROC
1019 ENDPROC(child_rip)
1020
1021 /*
1022  * execve(). This function needs to use IRET, not SYSRET, to set up all state properly.
1023  *
1024  * C extern interface:
1025  *       extern long execve(char *name, char **argv, char **envp)
1026  *
1027  * asm input arguments:
1028  *      rdi: name, rsi: argv, rdx: envp
1029  *
1030  * We want to fallback into:
1031  *      extern long sys_execve(char *name, char **argv,char **envp, struct pt_regs regs)
1032  *
1033  * do_sys_execve asm fallback arguments:
1034  *      rdi: name, rsi: argv, rdx: envp, fake frame on the stack
1035  */
1036 ENTRY(kernel_execve)
1037         CFI_STARTPROC
1038         FAKE_STACK_FRAME $0
1039         SAVE_ALL
1040         call sys_execve
1041         movq %rax, RAX(%rsp)
1042         RESTORE_REST
1043         testq %rax,%rax
1044         je int_ret_from_sys_call
1045         RESTORE_ARGS
1046         UNFAKE_STACK_FRAME
1047         ret
1048         CFI_ENDPROC
1049 ENDPROC(kernel_execve)
1050
1051 KPROBE_ENTRY(page_fault)
1052         errorentry do_page_fault
1053 KPROBE_END(page_fault)
1054
1055 ENTRY(coprocessor_error)
1056         zeroentry do_coprocessor_error
1057 END(coprocessor_error)
1058
1059 ENTRY(simd_coprocessor_error)
1060         zeroentry do_simd_coprocessor_error
1061 END(simd_coprocessor_error)
1062
1063 ENTRY(device_not_available)
1064         zeroentry math_state_restore
1065 END(device_not_available)
1066
1067         /* runs on exception stack */
1068 KPROBE_ENTRY(debug)
1069         INTR_FRAME
1070         pushq $0
1071         CFI_ADJUST_CFA_OFFSET 8
1072         paranoidentry do_debug, DEBUG_STACK
1073         paranoidexit
1074 KPROBE_END(debug)
1075
1076         /* runs on exception stack */
1077 KPROBE_ENTRY(nmi)
1078         INTR_FRAME
1079         pushq $-1
1080         CFI_ADJUST_CFA_OFFSET 8
1081         paranoidentry do_nmi, 0, 0
1082 #ifdef CONFIG_TRACE_IRQFLAGS
1083         paranoidexit 0
1084 #else
1085         jmp paranoid_exit1
1086         CFI_ENDPROC
1087 #endif
1088 KPROBE_END(nmi)
1089
1090 KPROBE_ENTRY(int3)
1091         INTR_FRAME
1092         pushq $0
1093         CFI_ADJUST_CFA_OFFSET 8
1094         paranoidentry do_int3, DEBUG_STACK
1095         jmp paranoid_exit1
1096         CFI_ENDPROC
1097 KPROBE_END(int3)
1098
1099 ENTRY(overflow)
1100         zeroentry do_overflow
1101 END(overflow)
1102
1103 ENTRY(bounds)
1104         zeroentry do_bounds
1105 END(bounds)
1106
1107 ENTRY(invalid_op)
1108         zeroentry do_invalid_op
1109 END(invalid_op)
1110
1111 ENTRY(coprocessor_segment_overrun)
1112         zeroentry do_coprocessor_segment_overrun
1113 END(coprocessor_segment_overrun)
1114
1115 ENTRY(reserved)
1116         zeroentry do_reserved
1117 END(reserved)
1118
1119         /* runs on exception stack */
1120 ENTRY(double_fault)
1121         XCPT_FRAME
1122         paranoidentry do_double_fault
1123         jmp paranoid_exit1
1124         CFI_ENDPROC
1125 END(double_fault)
1126
1127 ENTRY(invalid_TSS)
1128         errorentry do_invalid_TSS
1129 END(invalid_TSS)
1130
1131 ENTRY(segment_not_present)
1132         errorentry do_segment_not_present
1133 END(segment_not_present)
1134
1135         /* runs on exception stack */
1136 ENTRY(stack_segment)
1137         XCPT_FRAME
1138         paranoidentry do_stack_segment
1139         jmp paranoid_exit1
1140         CFI_ENDPROC
1141 END(stack_segment)
1142
1143 KPROBE_ENTRY(general_protection)
1144         errorentry do_general_protection
1145 KPROBE_END(general_protection)
1146
1147 ENTRY(alignment_check)
1148         errorentry do_alignment_check
1149 END(alignment_check)
1150
1151 ENTRY(divide_error)
1152         zeroentry do_divide_error
1153 END(divide_error)
1154
1155 ENTRY(spurious_interrupt_bug)
1156         zeroentry do_spurious_interrupt_bug
1157 END(spurious_interrupt_bug)
1158
1159 #ifdef CONFIG_X86_MCE
1160         /* runs on exception stack */
1161 ENTRY(machine_check)
1162         INTR_FRAME
1163         pushq $0
1164         CFI_ADJUST_CFA_OFFSET 8
1165         paranoidentry do_machine_check
1166         jmp paranoid_exit1
1167         CFI_ENDPROC
1168 END(machine_check)
1169 #endif
1170
1171 /* Call softirq on interrupt stack. Interrupts are off. */
1172 ENTRY(call_softirq)
1173         CFI_STARTPROC
1174         push %rbp
1175         CFI_ADJUST_CFA_OFFSET   8
1176         CFI_REL_OFFSET rbp,0
1177         mov  %rsp,%rbp
1178         CFI_DEF_CFA_REGISTER rbp
1179         incl %gs:pda_irqcount
1180         cmove %gs:pda_irqstackptr,%rsp
1181         push  %rbp                      # backlink for old unwinder
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 KPROBE_ENTRY(ignore_sysret)
1192         CFI_STARTPROC
1193         mov $-ENOSYS,%eax
1194         sysret
1195         CFI_ENDPROC
1196 ENDPROC(ignore_sysret)