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