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