root/compat/linux/linux_exec.c

DEFINITIONS

1. linux_e_proc_init
2. linux_e_proc_exec
3. linux_e_proc_exit
4. linux_e_proc_fork
5. linux_aout_copyargs
6. exec_linux_aout_makecmds
7. exec_linux_aout_prep_zmagic
8. exec_linux_aout_prep_nmagic
9. exec_linux_aout_prep_omagic
10. exec_linux_aout_prep_qmagic
11. exec_linux_elf32_makecmds
12. linux_elf_probe
13. linux_sys_uselib
14. linux_sys_execve

    1 /*      $OpenBSD: linux_exec.c,v 1.25 2006/01/19 17:54:52 mickey Exp $  */
    2 /*      $NetBSD: linux_exec.c,v 1.13 1996/04/05 00:01:10 christos Exp $ */
    4 /*-
    5  * Copyright (c) 1994, 1995, 1998, 2000 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Christos Zoulas, Frank van der Linden, Eric Haszlakiewicz and
   10  * Thor Lancelot Simon.
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  * 3. All advertising materials mentioning features or use of this software
   21  *    must display the following acknowledgement:
   22  *        This product includes software developed by the NetBSD
   23  *        Foundation, Inc. and its contributors.
   24  * 4. Neither the name of The NetBSD Foundation nor the names of its
   25  *    contributors may be used to endorse or promote products derived
   26  *    from this software without specific prior written permission.
   27  *
   28  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   29  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   31  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   32  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   38  * POSSIBILITY OF SUCH DAMAGE.
   39  */
   41 #include <sys/param.h>
   42 #include <sys/systm.h>
   43 #include <sys/kernel.h>
   44 #include <sys/proc.h>
   45 #include <sys/malloc.h>
   46 #include <sys/namei.h>
   47 #include <sys/vnode.h>
   48 #include <sys/mount.h>
   49 #include <sys/exec.h>
   50 #include <sys/exec_elf.h>
   51 #include <sys/exec_olf.h>
   53 #include <sys/mman.h>
   54 #include <sys/syscallargs.h>
   56 #include <uvm/uvm_extern.h>
   58 #include <machine/cpu.h>
   59 #include <machine/reg.h>
   60 #include <machine/linux_machdep.h>
   62 #include <compat/linux/linux_types.h>
   63 #include <compat/linux/linux_syscall.h>
   64 #include <compat/linux/linux_signal.h>
   65 #include <compat/linux/linux_syscallargs.h>
   66 #include <compat/linux/linux_util.h>
   67 #include <compat/linux/linux_exec.h>
   68 #include <compat/linux/linux_emuldata.h>
   70 static void *linux_aout_copyargs(struct exec_package *,
   71         struct ps_strings *, void *, void *);
   73 #define LINUX_AOUT_AUX_ARGSIZ   2
   74 #define LINUX_ELF_AUX_ARGSIZ (sizeof(AuxInfo) * 8 / sizeof(char *))
   77 const char linux_emul_path[] = "/emul/linux";
   78 extern int linux_error[];
   79 extern char linux_sigcode[], linux_esigcode[];
   80 extern struct sysent linux_sysent[];
   81 #ifdef SYSCALL_DEBUG
   82 extern char *linux_syscallnames[];
   83 #endif
   85 int exec_linux_aout_prep_zmagic(struct proc *, struct exec_package *);
   86 int exec_linux_aout_prep_nmagic(struct proc *, struct exec_package *);
   87 int exec_linux_aout_prep_omagic(struct proc *, struct exec_package *);
   88 int exec_linux_aout_prep_qmagic(struct proc *, struct exec_package *);
   90 void linux_e_proc_exec(struct proc *, struct exec_package *);
   91 void linux_e_proc_fork(struct proc *, struct proc *);
   92 void linux_e_proc_exit(struct proc *);
   93 void linux_e_proc_init(struct proc *, struct vmspace *);
   95 struct emul emul_linux_aout = {
   96         "linux",
linux_error,
linux_sendsig,
LINUX_SYS_syscall,
LINUX_SYS_MAXSYSCALL,
linux_sysent,
  102 #ifdef SYSCALL_DEBUG
linux_syscallnames,
  104 #else
NULL,
  106 #endif
LINUX_AOUT_AUX_ARGSIZ,
linux_aout_copyargs,
setregs,
NULL,
linux_sigcode,
linux_esigcode,
  113         0,
NULL,
linux_e_proc_exec,
linux_e_proc_fork,
linux_e_proc_exit,
  118 };
  120 struct emul emul_linux_elf = {
  121         "linux",
linux_error,
linux_sendsig,
LINUX_SYS_syscall,
LINUX_SYS_MAXSYSCALL,
linux_sysent,
  127 #ifdef SYSCALL_DEBUG
linux_syscallnames,
  129 #else
NULL,
  131 #endif
LINUX_ELF_AUX_ARGSIZ,
elf32_copyargs,
setregs,
exec_elf32_fixup,
linux_sigcode,
linux_esigcode,
  138         0,
NULL,
linux_e_proc_exec,
linux_e_proc_fork,
linux_e_proc_exit,
  143 };
  145 /*
  146  * Allocate per-process structures. Called when executing Linux
  147  * process. We can reuse the old emuldata - if it's not null,
  148  * the executed process is of same emulation as original forked one.
  149  */
  150 void
linux_e_proc_init(p, vmspace)
  152         struct proc *p;
  153         struct vmspace *vmspace;
  154 {
  155         if (!p->p_emuldata) {
  156                 /* allocate new Linux emuldata */
MALLOC(p->p_emuldata, void *, sizeof(struct linux_emuldata),
M_EMULDATA, M_WAITOK);
  159         }
memset(p->p_emuldata, '\0', sizeof(struct linux_emuldata));
  163         /* Set the process idea of the break to the real value */
  164         ((struct linux_emuldata *)(p->p_emuldata))->p_break = 
vmspace->vm_daddr + ctob(vmspace->vm_dsize);
  166 }
  168 void
linux_e_proc_exec(p, epp)
  170         struct proc *p;
  171         struct exec_package *epp;
  172 {
  173         /* exec, use our vmspace */
linux_e_proc_init(p, p->p_vmspace);
  175 }
  177 /*
  178  * Emulation per-process exit hook.
  179  */
  180 void
linux_e_proc_exit(p)
  182         struct proc *p;
  183 {
  184         /* free Linux emuldata and set the pointer to null */
FREE(p->p_emuldata, M_EMULDATA);
p->p_emuldata = NULL;
  187 }
  189 /*
  190  * Emulation fork hook.
  191  */
  192 void
linux_e_proc_fork(p, parent)
  194         struct proc *p, *parent;
  195 {
  196         /*
  197          * It could be desirable to copy some stuff from parent's
  198          * emuldata. We don't need anything like that for now.
  199          * So just allocate new emuldata for the new process.
  200          */
p->p_emuldata = NULL;
  203         /* fork, use parent's vmspace (our vmspace may not be setup yet) */
linux_e_proc_init(p, parent->p_vmspace);
  205 }
  207 static void *
linux_aout_copyargs(pack, arginfo, stack, argp)
  209         struct exec_package *pack;
  210         struct ps_strings *arginfo;
  211         void *stack;
  212         void *argp;
  213 {
  214         char **cpp = stack;
  215         char **stk = stack;
  216         char *dp, *sp;
size_t len;
  218         void *nullp = NULL;
  219         int argc = arginfo->ps_nargvstr;
  220         int envc = arginfo->ps_nenvstr;
  222         if (copyout(&argc, cpp++, sizeof(argc)))
  223                 return (NULL);
  225         /* leave room for envp and argv */
cpp += 2;
  227         if (copyout(&cpp, &stk[1], sizeof (cpp)))
  228                 return (NULL);
dp = (char *)(cpp + argc + envc + 2);
sp = argp;
  233         /* XXX don't copy them out, remap them! */
arginfo->ps_argvstr = cpp; /* remember location of argv for later */
  236         for (; --argc >= 0; sp += len, dp += len)
  237                 if (copyout(&dp, cpp++, sizeof(dp)) ||
copyoutstr(sp, dp, ARG_MAX, &len))
  239                         return (NULL);
  241         if (copyout(&nullp, cpp++, sizeof(nullp)))
  242                 return (NULL);
  244         if (copyout(&cpp, &stk[2], sizeof (cpp)))
  245                 return (NULL);
arginfo->ps_envstr = cpp; /* remember location of envp for later */
  249         for (; --envc >= 0; sp += len, dp += len)
  250                 if (copyout(&dp, cpp++, sizeof(dp)) ||
copyoutstr(sp, dp, ARG_MAX, &len))
  252                         return (NULL);
  254         if (copyout(&nullp, cpp++, sizeof(nullp)))
  255                 return (NULL);
  257         return (cpp);
  258 }
  260 int
exec_linux_aout_makecmds(p, epp)
  262         struct proc *p;
  263         struct exec_package *epp;
  264 {
  265         struct exec *linux_ep = epp->ep_hdr;
  266         int machtype, magic;
  267         int error = ENOEXEC;
  269         if (epp->ep_hdrvalid < sizeof(struct exec))
  270                 return (ENOEXEC);
magic = LINUX_N_MAGIC(linux_ep);
machtype = LINUX_N_MACHTYPE(linux_ep);
  276         if (machtype != LINUX_MID_MACHINE)
  277                 return (ENOEXEC);
  279         switch (magic) {
  280         case QMAGIC:
error = exec_linux_aout_prep_qmagic(p, epp);
  282                 break;
  283         case ZMAGIC:
error = exec_linux_aout_prep_zmagic(p, epp);
  285                 break;
  286         case NMAGIC:
error = exec_linux_aout_prep_nmagic(p, epp);
  288                 break;
  289         case OMAGIC:
error = exec_linux_aout_prep_omagic(p, epp);
  291                 break;
  292         }
  293         if (error == 0)
epp->ep_emul = &emul_linux_aout;
  295         return (error);
  296 }
  298 /*
  299  * Since text starts at 0x400 in Linux ZMAGIC executables, and 0x400
  300  * is very likely not page aligned on most architectures, it is treated
  301  * as an NMAGIC here. XXX
  302  */
  304 int
exec_linux_aout_prep_zmagic(p, epp)
  306         struct proc *p;
  307         struct exec_package *epp;
  308 {
  309         struct exec *execp = epp->ep_hdr;
epp->ep_taddr = LINUX_N_TXTADDR(*execp, ZMAGIC);
epp->ep_tsize = execp->a_text;
epp->ep_daddr = LINUX_N_DATADDR(*execp, ZMAGIC);
epp->ep_dsize = execp->a_data + execp->a_bss;
epp->ep_entry = execp->a_entry;
  317         /* set up command for text segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, execp->a_text,
epp->ep_taddr, epp->ep_vp, LINUX_N_TXTOFF(*execp, ZMAGIC),
VM_PROT_READ|VM_PROT_EXECUTE);
  322         /* set up command for data segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, execp->a_data,
epp->ep_daddr, epp->ep_vp, LINUX_N_DATOFF(*execp, ZMAGIC),
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  327         /* set up command for bss segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, execp->a_bss,
epp->ep_daddr + execp->a_data, NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  332         return (exec_setup_stack(p, epp));
  333 }
  335 /*
  336  * exec_aout_prep_nmagic(): Prepare Linux NMAGIC package.
  337  * Not different from the normal stuff.
  338  */
  340 int
exec_linux_aout_prep_nmagic(p, epp)
  342         struct proc *p;
  343         struct exec_package *epp;
  344 {
  345         struct exec *execp = epp->ep_hdr;
  346         long bsize, baddr;
epp->ep_taddr = LINUX_N_TXTADDR(*execp, NMAGIC);
epp->ep_tsize = execp->a_text;
epp->ep_daddr = LINUX_N_DATADDR(*execp, NMAGIC);
epp->ep_dsize = execp->a_data + execp->a_bss;
epp->ep_entry = execp->a_entry;
  354         /* set up command for text segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, execp->a_text,
epp->ep_taddr, epp->ep_vp, LINUX_N_TXTOFF(*execp, NMAGIC),
VM_PROT_READ|VM_PROT_EXECUTE);
  359         /* set up command for data segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, execp->a_data,
epp->ep_daddr, epp->ep_vp, LINUX_N_DATOFF(*execp, NMAGIC),
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  364         /* set up command for bss segment */
baddr = round_page(epp->ep_daddr + execp->a_data);
bsize = epp->ep_daddr + epp->ep_dsize - baddr;
  367         if (bsize > 0)
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, bsize, baddr,
NULLVP, 0, VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  371         return (exec_setup_stack(p, epp));
  372 }
  374 /*
  375  * exec_aout_prep_omagic(): Prepare Linux OMAGIC package.
  376  * Business as usual.
  377  */
  379 int
exec_linux_aout_prep_omagic(p, epp)
  381         struct proc *p;
  382         struct exec_package *epp;
  383 {
  384         struct exec *execp = epp->ep_hdr;
  385         long dsize, bsize, baddr;
epp->ep_taddr = LINUX_N_TXTADDR(*execp, OMAGIC);
epp->ep_tsize = execp->a_text;
epp->ep_daddr = LINUX_N_DATADDR(*execp, OMAGIC);
epp->ep_dsize = execp->a_data + execp->a_bss;
epp->ep_entry = execp->a_entry;
  393         /* set up command for text and data segments */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
execp->a_text + execp->a_data, epp->ep_taddr, epp->ep_vp,
LINUX_N_TXTOFF(*execp, OMAGIC), VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  398         /* set up command for bss segment */
baddr = round_page(epp->ep_daddr + execp->a_data);
bsize = epp->ep_daddr + epp->ep_dsize - baddr;
  401         if (bsize > 0)
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, bsize, baddr,
NULLVP, 0, VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  405         /*
  406          * Make sure (# of pages) mapped above equals (vm_tsize + vm_dsize);
  407          * obreak(2) relies on this fact. Both `vm_tsize' and `vm_dsize' are
  408          * computed (in execve(2)) by rounding *up* `ep_tsize' and `ep_dsize'
  409          * respectively to page boundaries.
  410          * Compensate `ep_dsize' for the amount of data covered by the last
  411          * text page. 
  412          */
dsize = epp->ep_dsize + execp->a_text - round_page(execp->a_text);
epp->ep_dsize = (dsize > 0) ? dsize : 0;
  415         return (exec_setup_stack(p, epp));
  416 }
  418 int
exec_linux_aout_prep_qmagic(p, epp)
  420         struct proc *p;
  421         struct exec_package *epp;
  422 {
  423         struct exec *execp = epp->ep_hdr;
epp->ep_taddr = LINUX_N_TXTADDR(*execp, QMAGIC);
epp->ep_tsize = execp->a_text;
epp->ep_daddr = LINUX_N_DATADDR(*execp, QMAGIC);
epp->ep_dsize = execp->a_data + execp->a_bss;
epp->ep_entry = execp->a_entry;
  431         /*
  432          * check if vnode is in open for writing, because we want to
  433          * demand-page out of it.  if it is, don't do it, for various
  434          * reasons
  435          */
  436         if ((execp->a_text != 0 || execp->a_data != 0) &&
epp->ep_vp->v_writecount != 0) {
  438 #ifdef DIAGNOSTIC
  439                 if (epp->ep_vp->v_flag & VTEXT)
panic("exec: a VTEXT vnode has writecount != 0");
  441 #endif
  442                 return (ETXTBSY);
  443         }
vn_marktext(epp->ep_vp);
  446         /* set up command for text segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_pagedvn, execp->a_text,
epp->ep_taddr, epp->ep_vp, LINUX_N_TXTOFF(*execp, QMAGIC),
VM_PROT_READ|VM_PROT_EXECUTE);
  451         /* set up command for data segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_pagedvn, execp->a_data,
epp->ep_daddr, epp->ep_vp, LINUX_N_DATOFF(*execp, QMAGIC),
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  456         /* set up command for bss segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, execp->a_bss,
epp->ep_daddr + execp->a_data, NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  461         return (exec_setup_stack(p, epp));
  462 }
  464 int
exec_linux_elf32_makecmds(struct proc *p, struct exec_package *epp)
  466 {
  467         if (!(emul_linux_elf.e_flags & EMUL_ENABLED))
  468                 return (ENOEXEC);
  469         return exec_elf32_makecmds(p, epp);
  470 }
  472 int
linux_elf_probe(p, epp, itp, pos, os)
  474         struct proc *p;
  475         struct exec_package *epp;
  476         char *itp;
u_long *pos;
u_int8_t *os;
  479 {
Elf32_Ehdr *eh = epp->ep_hdr;
  481         char *bp, *brand;
  482         int error;
size_t len;
brand = elf32_check_brand(eh);
  486         if (brand && strcmp(brand, "Linux"))
  487                 return (EINVAL);
  488         if (itp) {
  489                 if ((error = emul_find(p, NULL, linux_emul_path, itp, &bp, 0)))
  490                         return (error);
  491                 if ((error = copystr(bp, itp, MAXPATHLEN, &len)))
  492                         return (error);
free(bp, M_TEMP);
  494         }
epp->ep_emul = &emul_linux_elf;
  496         *pos = ELF32_NO_ADDR;
  497         if (*os == OOS_NULL)
  498                 *os = OOS_LINUX;
  499         return (0);
  500 }
  502 /*
  503  * The Linux system call to load shared libraries, a.out version. The
  504  * a.out shared libs are just files that are mapped onto a fixed
  505  * address in the process' address space. The address is given in
  506  * a_entry. Read in the header, set up some VM commands and run them.
  507  *
  508  * Yes, both text and data are mapped at once, so we're left with
  509  * writeable text for the shared libs. The Linux crt0 seemed to break
  510  * sometimes when data was mapped separately. It munmapped a uselib()
  511  * of ld.so by hand, which failed with shared text and data for ld.so
  512  * Yuck.
  513  *
  514  * Because of the problem with ZMAGIC executables (text starts
  515  * at 0x400 in the file, but needs to be mapped at 0), ZMAGIC
  516  * shared libs are not handled very efficiently :-(
  517  */
  519 int
linux_sys_uselib(p, v, retval)
  521         struct proc *p;
  522         void *v;
register_t *retval;
  524 {
  525         struct linux_sys_uselib_args /* {
  526                 syscallarg(char *) path;
  527         } */ *uap = v;
caddr_t sg;
  529         long bsize, dsize, tsize, taddr, baddr, daddr;
  530         struct nameidata ni;
  531         struct vnode *vp;
  532         struct exec hdr;
  533         struct exec_vmcmd_set vcset;
  534         int i, magic, error;
size_t rem;
sg = stackgap_init(p->p_emul);
LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
NDINIT(&ni, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
  542         if ((error = namei(&ni)))
  543                 return (error);
vp = ni.ni_vp;
  547         if ((error = vn_rdwr(UIO_READ, vp, (caddr_t) &hdr, LINUX_AOUT_HDR_SIZE,
  548                              0, UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred,
  549                              &rem, p))) {
vrele(vp);
  551                 return (error);
  552         }
  554         if (rem != 0) {
vrele(vp);
  556                 return (ENOEXEC);
  557         }
  559         if (LINUX_N_MACHTYPE(&hdr) != LINUX_MID_MACHINE)
  560                 return (ENOEXEC);
magic = LINUX_N_MAGIC(&hdr);
taddr = trunc_page(hdr.a_entry);
tsize = hdr.a_text;
daddr = taddr + tsize;
dsize = hdr.a_data + hdr.a_bss;
  568         if ((hdr.a_text != 0 || hdr.a_data != 0) && vp->v_writecount != 0) {
vrele(vp);
  570                 return (ETXTBSY);
  571         }
vn_marktext(vp);
VMCMDSET_INIT(&vcset);
NEW_VMCMD(
  577             &vcset, magic == ZMAGIC ? vmcmd_map_readvn : vmcmd_map_pagedvn,
hdr.a_text + hdr.a_data, taddr, vp, LINUX_N_TXTOFF(hdr, magic),
VM_PROT_READ|VM_PROT_EXECUTE|VM_PROT_WRITE);
baddr = round_page(daddr + hdr.a_data);
bsize = daddr + dsize - baddr;
  583         if (bsize > 0) {
NEW_VMCMD(&vcset, vmcmd_map_zero, bsize, baddr,
NULLVP, 0, VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  586         }
  588         for (i = 0; i < vcset.evs_used && !error; i++) {
  589                 struct exec_vmcmd *vcp;
vcp = &vcset.evs_cmds[i];
error = (*vcp->ev_proc)(p, vcp);
  593         }
kill_vmcmds(&vcset);
vrele(vp);
  599         return (error);
  600 }
  602 /*
  603  * Execve(2). Just check the alternate emulation path, and pass it on
  604  * to the regular execve().
  605  */
  606 int
linux_sys_execve(p, v, retval)
  608         struct proc *p;
  609         void *v;
register_t *retval;
  611 {
  612         struct linux_sys_execve_args /* {
  613                 syscallarg(char *) path;
  614                 syscallarg(char **) argv;
  615                 syscallarg(char **) envp;
  616         } */ *uap = v;
  617         struct sys_execve_args ap;
caddr_t sg;
sg = stackgap_init(p->p_emul);
LINUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
SCARG(&ap, path) = SCARG(uap, path);
SCARG(&ap, argp) = SCARG(uap, argp);
SCARG(&ap, envp) = SCARG(uap, envp);
  627         return (sys_execve(p, &ap, retval));
  628 }