arch/x86/kernel/entry_64.S

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