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