arch/x86/entry/ia32entry.S

   1 /*
   2  * Compatibility mode system call entry point for x86-64.
   3  *
   4  * Copyright 2000-2002 Andi Kleen, SuSE Labs.
   5  */
   6 #include "calling.h"
   7 #include <asm/asm-offsets.h>
   8 #include <asm/current.h>
   9 #include <asm/errno.h>
  10 #include <asm/ia32_unistd.h>
  11 #include <asm/thread_info.h>
  12 #include <asm/segment.h>
  13 #include <asm/irqflags.h>
  14 #include <asm/asm.h>
  15 #include <asm/smap.h>
  16 #include <linux/linkage.h>
  17 #include <linux/err.h>
  18
  19 /* Avoid __ASSEMBLER__'ifying <linux/audit.h> just for this.  */
  20 #include <linux/elf-em.h>
  21 #define AUDIT_ARCH_I386         (EM_386|__AUDIT_ARCH_LE)
  22 #define __AUDIT_ARCH_LE         0x40000000
  23
  24 #ifndef CONFIG_AUDITSYSCALL
  25 # define sysexit_audit          ia32_ret_from_sys_call
  26 # define sysretl_audit          ia32_ret_from_sys_call
  27 #endif
  28
  29         .section .entry.text, "ax"
  30
  31 #ifdef CONFIG_PARAVIRT
  32 ENTRY(native_usergs_sysret32)
  33         swapgs
  34         sysretl
  35 ENDPROC(native_usergs_sysret32)
  36 #endif
  37
  38 /*
  39  * 32-bit SYSENTER instruction entry.
  40  *
  41  * SYSENTER loads ss, rsp, cs, and rip from previously programmed MSRs.
  42  * IF and VM in rflags are cleared (IOW: interrupts are off).
  43  * SYSENTER does not save anything on the stack,
  44  * and does not save old rip (!!!) and rflags.
  45  *
  46  * Arguments:
  47  * eax  system call number
  48  * ebx  arg1
  49  * ecx  arg2
  50  * edx  arg3
  51  * esi  arg4
  52  * edi  arg5
  53  * ebp  user stack
  54  * 0(%ebp) arg6
  55  *
  56  * This is purely a fast path. For anything complicated we use the int 0x80
  57  * path below. We set up a complete hardware stack frame to share code
  58  * with the int 0x80 path.
  59  */
  60 ENTRY(ia32_sysenter_target)
  61         /*
  62          * Interrupts are off on entry.
  63          * We do not frame this tiny irq-off block with TRACE_IRQS_OFF/ON,
  64          * it is too small to ever cause noticeable irq latency.
  65          */
  66         SWAPGS_UNSAFE_STACK
  67         movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp
  68         ENABLE_INTERRUPTS(CLBR_NONE)
  69
  70         /* Zero-extending 32-bit regs, do not remove */
  71         movl    %ebp, %ebp
  72         movl    %eax, %eax
  73
  74         movl    ASM_THREAD_INFO(TI_sysenter_return, %rsp, 0), %r10d
  75
  76         /* Construct struct pt_regs on stack */
  77         pushq   $__USER32_DS            /* pt_regs->ss */
  78         pushq   %rbp                    /* pt_regs->sp */
  79         pushfq                          /* pt_regs->flags */
  80         pushq   $__USER32_CS            /* pt_regs->cs */
  81         pushq   %r10                    /* pt_regs->ip = thread_info->sysenter_return */
  82         pushq   %rax                    /* pt_regs->orig_ax */
  83         pushq   %rdi                    /* pt_regs->di */
  84         pushq   %rsi                    /* pt_regs->si */
  85         pushq   %rdx                    /* pt_regs->dx */
  86         pushq   %rcx                    /* pt_regs->cx */
  87         pushq   $-ENOSYS                /* pt_regs->ax */
  88         cld
  89         sub     $(10*8), %rsp /* pt_regs->r8-11, bp, bx, r12-15 not saved */
  90
  91         /*
  92          * no need to do an access_ok check here because rbp has been
  93          * 32-bit zero extended
  94          */
  95         ASM_STAC
  96 1:      movl    (%rbp), %ebp
  97         _ASM_EXTABLE(1b, ia32_badarg)
  98         ASM_CLAC
  99
 100         /*
 101          * Sysenter doesn't filter flags, so we need to clear NT
 102          * ourselves.  To save a few cycles, we can check whether
 103          * NT was set instead of doing an unconditional popfq.
 104          */
 105         testl   $X86_EFLAGS_NT, EFLAGS(%rsp)
 106         jnz     sysenter_fix_flags
 107 sysenter_flags_fixed:
 108
 109         orl     $TS_COMPAT, ASM_THREAD_INFO(TI_status, %rsp, SIZEOF_PTREGS)
 110         testl   $_TIF_WORK_SYSCALL_ENTRY, ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 111         jnz     sysenter_tracesys
 112
 113 sysenter_do_call:
 114         /* 32-bit syscall -> 64-bit C ABI argument conversion */
 115         movl    %edi, %r8d              /* arg5 */
 116         movl    %ebp, %r9d              /* arg6 */
 117         xchg    %ecx, %esi              /* rsi:arg2, rcx:arg4 */
 118         movl    %ebx, %edi              /* arg1 */
 119         movl    %edx, %edx              /* arg3 (zero extension) */
 120 sysenter_dispatch:
 121         cmpq    $(IA32_NR_syscalls-1), %rax
 122         ja      1f
 123         call    *ia32_sys_call_table(, %rax, 8)
 124         movq    %rax, RAX(%rsp)
 125 1:
 126         DISABLE_INTERRUPTS(CLBR_NONE)
 127         TRACE_IRQS_OFF
 128         testl   $_TIF_ALLWORK_MASK, ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 129         jnz     sysexit_audit
 130 sysexit_from_sys_call:
 131         /*
 132          * NB: SYSEXIT is not obviously safe for 64-bit kernels -- an
 133          * NMI between STI and SYSEXIT has poorly specified behavior,
 134          * and and NMI followed by an IRQ with usergs is fatal.  So
 135          * we just pretend we're using SYSEXIT but we really use
 136          * SYSRETL instead.
 137          *
 138          * This code path is still called 'sysexit' because it pairs
 139          * with 'sysenter' and it uses the SYSENTER calling convention.
 140          */
 141         andl    $~TS_COMPAT, ASM_THREAD_INFO(TI_status, %rsp, SIZEOF_PTREGS)
 142         movl    RIP(%rsp), %ecx         /* User %eip */
 143         RESTORE_RSI_RDI
 144         xorl    %edx, %edx              /* Do not leak kernel information */
 145         xorq    %r8, %r8
 146         xorq    %r9, %r9
 147         xorq    %r10, %r10
 148         movl    EFLAGS(%rsp), %r11d     /* User eflags */
 149         TRACE_IRQS_ON
 150
 151         /*
 152          * SYSRETL works even on Intel CPUs.  Use it in preference to SYSEXIT,
 153          * since it avoids a dicey window with interrupts enabled.
 154          */
 155         movl    RSP(%rsp), %esp
 156
 157         /*
 158          * USERGS_SYSRET32 does:
 159          *  gsbase = user's gs base
 160          *  eip = ecx
 161          *  rflags = r11
 162          *  cs = __USER32_CS
 163          *  ss = __USER_DS
 164          *
 165          * The prologue set RIP(%rsp) to VDSO32_SYSENTER_RETURN, which does:
 166          *
 167          *  pop %ebp
 168          *  pop %edx
 169          *  pop %ecx
 170          *
 171          * Therefore, we invoke SYSRETL with EDX and R8-R10 zeroed to
 172          * avoid info leaks.  R11 ends up with VDSO32_SYSENTER_RETURN's
 173          * address (already known to user code), and R12-R15 are
 174          * callee-saved and therefore don't contain any interesting
 175          * kernel data.
 176          */
 177         USERGS_SYSRET32
 178
 179 #ifdef CONFIG_AUDITSYSCALL
 180         .macro auditsys_entry_common
 181         movl    %esi, %r8d              /* 5th arg: 4th syscall arg */
 182         movl    %ecx, %r9d              /* swap with edx */
 183         movl    %edx, %ecx              /* 4th arg: 3rd syscall arg */
 184         movl    %r9d, %edx              /* 3rd arg: 2nd syscall arg */
 185         movl    %ebx, %esi              /* 2nd arg: 1st syscall arg */
 186         movl    %eax, %edi              /* 1st arg: syscall number */
 187         call    __audit_syscall_entry
 188         movl    ORIG_RAX(%rsp), %eax    /* reload syscall number */
 189         movl    %ebx, %edi              /* reload 1st syscall arg */
 190         movl    RCX(%rsp), %esi         /* reload 2nd syscall arg */
 191         movl    RDX(%rsp), %edx         /* reload 3rd syscall arg */
 192         movl    RSI(%rsp), %ecx         /* reload 4th syscall arg */
 193         movl    RDI(%rsp), %r8d         /* reload 5th syscall arg */
 194         .endm
 195
 196         .macro auditsys_exit exit
 197         testl   $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT), ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 198         jnz     ia32_ret_from_sys_call
 199         TRACE_IRQS_ON
 200         ENABLE_INTERRUPTS(CLBR_NONE)
 201         movl    %eax, %esi              /* second arg, syscall return value */
 202         cmpl    $-MAX_ERRNO, %eax       /* is it an error ? */
 203         jbe     1f
 204         movslq  %eax, %rsi              /* if error sign extend to 64 bits */
 205 1:      setbe   %al                     /* 1 if error, 0 if not */
 206         movzbl  %al, %edi               /* zero-extend that into %edi */
 207         call    __audit_syscall_exit
 208         movq    RAX(%rsp), %rax         /* reload syscall return value */
 209         movl    $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT), %edi
 210         DISABLE_INTERRUPTS(CLBR_NONE)
 211         TRACE_IRQS_OFF
 212         testl   %edi, ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 213         jz      \exit
 214         xorl    %eax, %eax              /* Do not leak kernel information */
 215         movq    %rax, R11(%rsp)
 216         movq    %rax, R10(%rsp)
 217         movq    %rax, R9(%rsp)
 218         movq    %rax, R8(%rsp)
 219         jmp     int_with_check
 220         .endm
 221
 222 sysenter_auditsys:
 223         auditsys_entry_common
 224         movl    %ebp, %r9d              /* reload 6th syscall arg */
 225         jmp     sysenter_dispatch
 226
 227 sysexit_audit:
 228         auditsys_exit sysexit_from_sys_call
 229 #endif
 230
 231 sysenter_fix_flags:
 232         pushq $(X86_EFLAGS_IF|X86_EFLAGS_FIXED)
 233         popfq
 234         jmp     sysenter_flags_fixed
 235
 236 sysenter_tracesys:
 237 #ifdef CONFIG_AUDITSYSCALL
 238         testl   $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT), ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 239         jz      sysenter_auditsys
 240 #endif
 241         SAVE_EXTRA_REGS
 242         xorl    %eax, %eax              /* Do not leak kernel information */
 243         movq    %rax, R11(%rsp)
 244         movq    %rax, R10(%rsp)
 245         movq    %rax, R9(%rsp)
 246         movq    %rax, R8(%rsp)
 247         movq    %rsp, %rdi              /* &pt_regs -> arg1 */
 248         call    syscall_trace_enter
 249
 250         /* Reload arg registers from stack. (see sysenter_tracesys) */
 251         movl    RCX(%rsp), %ecx
 252         movl    RDX(%rsp), %edx
 253         movl    RSI(%rsp), %esi
 254         movl    RDI(%rsp), %edi
 255         movl    %eax, %eax              /* zero extension */
 256
 257         RESTORE_EXTRA_REGS
 258         jmp     sysenter_do_call
 259 ENDPROC(ia32_sysenter_target)
 260
 261 /*
 262  * 32-bit SYSCALL instruction entry.
 263  *
 264  * 32-bit SYSCALL saves rip to rcx, clears rflags.RF, then saves rflags to r11,
 265  * then loads new ss, cs, and rip from previously programmed MSRs.
 266  * rflags gets masked by a value from another MSR (so CLD and CLAC
 267  * are not needed). SYSCALL does not save anything on the stack
 268  * and does not change rsp.
 269  *
 270  * Note: rflags saving+masking-with-MSR happens only in Long mode
 271  * (in legacy 32-bit mode, IF, RF and VM bits are cleared and that's it).
 272  * Don't get confused: rflags saving+masking depends on Long Mode Active bit
 273  * (EFER.LMA=1), NOT on bitness of userspace where SYSCALL executes
 274  * or target CS descriptor's L bit (SYSCALL does not read segment descriptors).
 275  *
 276  * Arguments:
 277  * eax  system call number
 278  * ecx  return address
 279  * ebx  arg1
 280  * ebp  arg2    (note: not saved in the stack frame, should not be touched)
 281  * edx  arg3
 282  * esi  arg4
 283  * edi  arg5
 284  * esp  user stack
 285  * 0(%esp) arg6
 286  *
 287  * This is purely a fast path. For anything complicated we use the int 0x80
 288  * path below. We set up a complete hardware stack frame to share code
 289  * with the int 0x80 path.
 290  */
 291 ENTRY(ia32_cstar_target)
 292         /*
 293          * Interrupts are off on entry.
 294          * We do not frame this tiny irq-off block with TRACE_IRQS_OFF/ON,
 295          * it is too small to ever cause noticeable irq latency.
 296          */
 297         SWAPGS_UNSAFE_STACK
 298         movl    %esp, %r8d
 299         movq    PER_CPU_VAR(cpu_current_top_of_stack), %rsp
 300         ENABLE_INTERRUPTS(CLBR_NONE)
 301
 302         /* Zero-extending 32-bit regs, do not remove */
 303         movl    %eax, %eax
 304
 305         /* Construct struct pt_regs on stack */
 306         pushq   $__USER32_DS            /* pt_regs->ss */
 307         pushq   %r8                     /* pt_regs->sp */
 308         pushq   %r11                    /* pt_regs->flags */
 309         pushq   $__USER32_CS            /* pt_regs->cs */
 310         pushq   %rcx                    /* pt_regs->ip */
 311         pushq   %rax                    /* pt_regs->orig_ax */
 312         pushq   %rdi                    /* pt_regs->di */
 313         pushq   %rsi                    /* pt_regs->si */
 314         pushq   %rdx                    /* pt_regs->dx */
 315         pushq   %rbp                    /* pt_regs->cx */
 316         movl    %ebp, %ecx
 317         pushq   $-ENOSYS                /* pt_regs->ax */
 318         sub     $(10*8), %rsp           /* pt_regs->r8-11, bp, bx, r12-15 not saved */
 319
 320         /*
 321          * No need to do an access_ok check here because r8 has been
 322          * 32-bit zero extended:
 323          */
 324         ASM_STAC
 325 1:      movl    (%r8), %ebp
 326         _ASM_EXTABLE(1b, ia32_badarg)
 327         ASM_CLAC
 328         orl     $TS_COMPAT, ASM_THREAD_INFO(TI_status, %rsp, SIZEOF_PTREGS)
 329         testl   $_TIF_WORK_SYSCALL_ENTRY, ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 330         jnz   cstar_tracesys
 331
 332 cstar_do_call:
 333         /* 32-bit syscall -> 64-bit C ABI argument conversion */
 334         movl    %edi, %r8d              /* arg5 */
 335         movl    %ebp, %r9d              /* arg6 */
 336         xchg    %ecx, %esi              /* rsi:arg2, rcx:arg4 */
 337         movl    %ebx, %edi              /* arg1 */
 338         movl    %edx, %edx              /* arg3 (zero extension) */
 339
 340 cstar_dispatch:
 341         cmpq    $(IA32_NR_syscalls-1), %rax
 342         ja      1f
 343
 344         call    *ia32_sys_call_table(, %rax, 8)
 345         movq    %rax, RAX(%rsp)
 346 1:
 347         DISABLE_INTERRUPTS(CLBR_NONE)
 348         TRACE_IRQS_OFF
 349         testl   $_TIF_ALLWORK_MASK, ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 350         jnz     sysretl_audit
 351
 352 sysretl_from_sys_call:
 353         andl    $~TS_COMPAT, ASM_THREAD_INFO(TI_status, %rsp, SIZEOF_PTREGS)
 354         movl    RCX(%rsp), %ebp
 355         RESTORE_RSI_RDI_RDX
 356         movl    RIP(%rsp), %ecx
 357         movl    EFLAGS(%rsp), %r11d
 358         xorq    %r10, %r10
 359         xorq    %r9, %r9
 360         xorq    %r8, %r8
 361         TRACE_IRQS_ON
 362         movl    RSP(%rsp), %esp
 363         /*
 364          * 64-bit->32-bit SYSRET restores eip from ecx,
 365          * eflags from r11 (but RF and VM bits are forced to 0),
 366          * cs and ss are loaded from MSRs.
 367          * (Note: 32-bit->32-bit SYSRET is different: since r11
 368          * does not exist, it merely sets eflags.IF=1).
 369          *
 370          * NB: On AMD CPUs with the X86_BUG_SYSRET_SS_ATTRS bug, the ss
 371          * descriptor is not reinitialized.  This means that we must
 372          * avoid SYSRET with SS == NULL, which could happen if we schedule,
 373          * exit the kernel, and re-enter using an interrupt vector.  (All
 374          * interrupt entries on x86_64 set SS to NULL.)  We prevent that
 375          * from happening by reloading SS in __switch_to.
 376          */
 377         USERGS_SYSRET32
 378
 379 #ifdef CONFIG_AUDITSYSCALL
 380 cstar_auditsys:
 381         auditsys_entry_common
 382         movl    %ebp, %r9d              /* reload 6th syscall arg */
 383         jmp     cstar_dispatch
 384
 385 sysretl_audit:
 386         auditsys_exit sysretl_from_sys_call
 387 #endif
 388
 389 cstar_tracesys:
 390 #ifdef CONFIG_AUDITSYSCALL
 391         testl   $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT), ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 392         jz      cstar_auditsys
 393 #endif
 394         SAVE_EXTRA_REGS
 395         xorl    %eax, %eax              /* Do not leak kernel information */
 396         movq    %rax, R11(%rsp)
 397         movq    %rax, R10(%rsp)
 398         movq    %rax, R9(%rsp)
 399         movq    %rax, R8(%rsp)
 400         movq    %rsp, %rdi              /* &pt_regs -> arg1 */
 401         call    syscall_trace_enter
 402
 403         /* Reload arg registers from stack. (see sysenter_tracesys) */
 404         movl    RCX(%rsp), %ecx
 405         movl    RDX(%rsp), %edx
 406         movl    RSI(%rsp), %esi
 407         movl    RDI(%rsp), %edi
 408         movl    %eax, %eax              /* zero extension */
 409
 410         RESTORE_EXTRA_REGS
 411         jmp     cstar_do_call
 412 END(ia32_cstar_target)
 413
 414 ia32_badarg:
 415         ASM_CLAC
 416         movq    $-EFAULT, %rax
 417         jmp     ia32_sysret
 418
 419 ia32_ret_from_sys_call:
 420         xorl    %eax, %eax              /* Do not leak kernel information */
 421         movq    %rax, R11(%rsp)
 422         movq    %rax, R10(%rsp)
 423         movq    %rax, R9(%rsp)
 424         movq    %rax, R8(%rsp)
 425         jmp     int_ret_from_sys_call
 426
 427 /*
 428  * Emulated IA32 system calls via int 0x80.
 429  *
 430  * Arguments:
 431  * eax  system call number
 432  * ebx  arg1
 433  * ecx  arg2
 434  * edx  arg3
 435  * esi  arg4
 436  * edi  arg5
 437  * ebp  arg6    (note: not saved in the stack frame, should not be touched)
 438  *
 439  * Notes:
 440  * Uses the same stack frame as the x86-64 version.
 441  * All registers except eax must be saved (but ptrace may violate that).
 442  * Arguments are zero extended. For system calls that want sign extension and
 443  * take long arguments a wrapper is needed. Most calls can just be called
 444  * directly.
 445  * Assumes it is only called from user space and entered with interrupts off.
 446  */
 447
 448 ENTRY(ia32_syscall)
 449         /*
 450          * Interrupts are off on entry.
 451          * We do not frame this tiny irq-off block with TRACE_IRQS_OFF/ON,
 452          * it is too small to ever cause noticeable irq latency.
 453          */
 454         PARAVIRT_ADJUST_EXCEPTION_FRAME
 455         SWAPGS
 456         ENABLE_INTERRUPTS(CLBR_NONE)
 457
 458         /* Zero-extending 32-bit regs, do not remove */
 459         movl    %eax, %eax
 460
 461         /* Construct struct pt_regs on stack (iret frame is already on stack) */
 462         pushq   %rax                    /* pt_regs->orig_ax */
 463         pushq   %rdi                    /* pt_regs->di */
 464         pushq   %rsi                    /* pt_regs->si */
 465         pushq   %rdx                    /* pt_regs->dx */
 466         pushq   %rcx                    /* pt_regs->cx */
 467         pushq   $-ENOSYS                /* pt_regs->ax */
 468         pushq   $0                      /* pt_regs->r8 */
 469         pushq   $0                      /* pt_regs->r9 */
 470         pushq   $0                      /* pt_regs->r10 */
 471         pushq   $0                      /* pt_regs->r11 */
 472         cld
 473         sub     $(6*8), %rsp /* pt_regs->bp, bx, r12-15 not saved */
 474
 475         orl     $TS_COMPAT, ASM_THREAD_INFO(TI_status, %rsp, SIZEOF_PTREGS)
 476         testl   $_TIF_WORK_SYSCALL_ENTRY, ASM_THREAD_INFO(TI_flags, %rsp, SIZEOF_PTREGS)
 477         jnz     ia32_tracesys
 478
 479 ia32_do_call:
 480         /* 32-bit syscall -> 64-bit C ABI argument conversion */
 481         movl    %edi, %r8d              /* arg5 */
 482         movl    %ebp, %r9d              /* arg6 */
 483         xchg    %ecx, %esi              /* rsi:arg2, rcx:arg4 */
 484         movl    %ebx, %edi              /* arg1 */
 485         movl    %edx, %edx              /* arg3 (zero extension) */
 486         cmpq    $(IA32_NR_syscalls-1), %rax
 487         ja      1f
 488
 489         call    *ia32_sys_call_table(, %rax, 8) /* RIP relative */
 490
 491 ia32_sysret:
 492         movq    %rax, RAX(%rsp)
 493 1:
 494         jmp     int_ret_from_sys_call
 495
 496 ia32_tracesys:
 497         SAVE_EXTRA_REGS
 498         movq    %rsp, %rdi                      /* &pt_regs -> arg1 */
 499         call    syscall_trace_enter
 500         /*
 501          * Reload arg registers from stack in case ptrace changed them.
 502          * Don't reload %eax because syscall_trace_enter() returned
 503          * the %rax value we should see.  But do truncate it to 32 bits.
 504          * If it's -1 to make us punt the syscall, then (u32)-1 is still
 505          * an appropriately invalid value.
 506          */
 507         movl    RCX(%rsp), %ecx
 508         movl    RDX(%rsp), %edx
 509         movl    RSI(%rsp), %esi
 510         movl    RDI(%rsp), %edi
 511         movl    %eax, %eax              /* zero extension */
 512         RESTORE_EXTRA_REGS
 513         jmp     ia32_do_call
 514 END(ia32_syscall)
 515
 516         .macro PTREGSCALL label, func
 517         ALIGN
 518 GLOBAL(\label)
 519         leaq    \func(%rip), %rax
 520         jmp     ia32_ptregs_common
 521         .endm
 522
 523         PTREGSCALL stub32_rt_sigreturn, sys32_rt_sigreturn
 524         PTREGSCALL stub32_sigreturn,    sys32_sigreturn
 525         PTREGSCALL stub32_fork,         sys_fork
 526         PTREGSCALL stub32_vfork,        sys_vfork
 527
 528         ALIGN
 529 GLOBAL(stub32_clone)
 530         leaq    sys_clone(%rip), %rax
 531         mov     %r8, %rcx
 532         jmp     ia32_ptregs_common
 533
 534         ALIGN
 535 ia32_ptregs_common:
 536         SAVE_EXTRA_REGS 8
 537         call    *%rax
 538         RESTORE_EXTRA_REGS 8
 539         ret
 540 END(ia32_ptregs_common)