arch/x86/kernel/entry_64.S

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