root/compat/ibcs2/ibcs2_exec.c

DEFINITIONS

1. exec_ibcs2_coff_makecmds
2. exec_ibcs2_coff_setup_stack
3. exec_ibcs2_coff_prep_omagic
4. exec_ibcs2_coff_prep_nmagic
5. coff_find_section
6. exec_ibcs2_coff_prep_zmagic
7. coff_load_shlib
8. exec_ibcs2_xout_makecmds
9. exec_ibcs2_xout_prep_nmagic
10. exec_ibcs2_xout_setup_stack

    1 /*      $OpenBSD: ibcs2_exec.c,v 1.18 2006/12/29 13:04:37 pedro Exp $   */
    2 /*      $NetBSD: ibcs2_exec.c,v 1.12 1996/10/12 02:13:52 thorpej Exp $  */
    4 /*
    5  * Copyright (c) 1994, 1995 Scott Bartram
    6  * Copyright (c) 1994 Adam Glass
    7  * Copyright (c) 1993, 1994 Christopher G. Demetriou
    8  * All rights reserved.
    9  *
   10  * originally from kern/exec_ecoff.c
   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 Scott Bartram.
   23  * 4. The name of the author may not be used to endorse or promote products
   24  *    derived from this software without specific prior written permission
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   27  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   29  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   30  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   31  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   35  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   36  */
   38 #include <sys/param.h>
   39 #include <sys/systm.h>
   40 #include <sys/proc.h>
   41 #include <sys/exec.h>
   42 #include <sys/malloc.h>
   43 #include <sys/vnode.h>
   44 #include <sys/resourcevar.h>
   45 #include <sys/namei.h>
   46 #include <uvm/uvm_extern.h>
   48 #include <compat/ibcs2/ibcs2_types.h>
   49 #include <compat/ibcs2/ibcs2_exec.h>
   50 #include <compat/ibcs2/ibcs2_util.h>
   51 #include <compat/ibcs2/ibcs2_syscall.h>
   53 int exec_ibcs2_coff_prep_omagic(struct proc *, struct exec_package *,
   54                                      struct coff_filehdr *, 
   55                                      struct coff_aouthdr *);
   56 int exec_ibcs2_coff_prep_nmagic(struct proc *, struct exec_package *,
   57                                      struct coff_filehdr *, 
   58                                      struct coff_aouthdr *);
   59 int exec_ibcs2_coff_prep_zmagic(struct proc *, struct exec_package *,
   60                                      struct coff_filehdr *, 
   61                                      struct coff_aouthdr *);
   62 int exec_ibcs2_coff_setup_stack(struct proc *, struct exec_package *);
   63 void cpu_exec_ibcs2_coff_setup(int, struct proc *, struct exec_package *,
   64                                     void *);
   66 int exec_ibcs2_xout_prep_nmagic(struct proc *, struct exec_package *,
   67                                      struct xexec *, struct xext *);
   68 int exec_ibcs2_xout_prep_zmagic(struct proc *, struct exec_package *,
   69                                      struct xexec *, struct xext *);
   70 int exec_ibcs2_xout_setup_stack(struct proc *, struct exec_package *);
   71 int coff_load_shlib(struct proc *, char *, struct exec_package *);
   72 static int coff_find_section(struct proc *, struct vnode *, 
   73                                   struct coff_filehdr *, struct coff_scnhdr *,
   74                                   int);
   77 extern int bsd2ibcs_errno[];
   78 extern struct sysent ibcs2_sysent[];
   79 #ifdef SYSCALL_DEBUG
   80 extern char *ibcs2_syscallnames[];
   81 #endif
   82 extern void ibcs2_sendsig(sig_t, int, int, u_long, int, union sigval);
   83 extern char sigcode[], esigcode[];
   85 const char ibcs2_emul_path[] = "/emul/ibcs2";
   87 struct emul emul_ibcs2 = {
   88         "ibcs2",
bsd2ibcs_errno,
ibcs2_sendsig,
   91         0,
IBCS2_SYS_MAXSYSCALL,
ibcs2_sysent,
   94 #ifdef SYSCALL_DEBUG
ibcs2_syscallnames,
   96 #else
NULL,
   98 #endif
   99         0,
copyargs,
setregs,
NULL,
sigcode,
esigcode,
  105 };
  107 /*
  108  * exec_ibcs2_coff_makecmds(): Check if it's an coff-format executable.
  109  *
  110  * Given a proc pointer and an exec package pointer, see if the referent
  111  * of the epp is in coff format.  Check 'standard' magic numbers for
  112  * this architecture.  If that fails, return failure.
  113  *
  114  * This function is  responsible for creating a set of vmcmds which can be
  115  * used to build the process's vm space and inserting them into the exec
  116  * package.
  117  */
  119 int
exec_ibcs2_coff_makecmds(p, epp)
  121         struct proc *p;
  122         struct exec_package *epp;
  123 {
  124         int error;
  125         struct coff_filehdr *fp = epp->ep_hdr;
  126         struct coff_aouthdr *ap;
  128         if (epp->ep_hdrvalid < COFF_HDR_SIZE)
  129                 return ENOEXEC;
  131         if (COFF_BADMAG(fp))
  132                 return ENOEXEC;
ap = (struct coff_aouthdr *)((char *)epp->ep_hdr +
  135             sizeof(struct coff_filehdr));
  136         switch (ap->a_magic) {
  137         case COFF_OMAGIC:
error = exec_ibcs2_coff_prep_omagic(p, epp, fp, ap);
  139                 break;
  140         case COFF_NMAGIC:
error = exec_ibcs2_coff_prep_nmagic(p, epp, fp, ap);
  142                 break;
  143         case COFF_ZMAGIC:
error = exec_ibcs2_coff_prep_zmagic(p, epp, fp, ap);
  145                 break;
  146         default:
  147                 return ENOEXEC;
  148         }
  150         if (error == 0)
epp->ep_emul = &emul_ibcs2;
  153         if (error)
kill_vmcmds(&epp->ep_vmcmds);
  156         return error;
  157 }
  159 /*
  160  * exec_ibcs2_coff_setup_stack(): Set up the stack segment for a coff
  161  * executable.
  162  *
  163  * Note that the ep_ssize parameter must be set to be the current stack
  164  * limit; this is adjusted in the body of execve() to yield the
  165  * appropriate stack segment usage once the argument length is
  166  * calculated.
  167  *
  168  * This function returns an int for uniformity with other (future) formats'
  169  * stack setup functions.  They might have errors to return.
  170  */
  172 int
exec_ibcs2_coff_setup_stack(p, epp)
  174         struct proc *p;
  175         struct exec_package *epp;
  176 {
  177         /* DPRINTF(("enter exec_ibcs2_coff_setup_stack\n")); */
epp->ep_maxsaddr = USRSTACK - MAXSSIZ;
epp->ep_minsaddr = USRSTACK;
epp->ep_ssize = p->p_rlimit[RLIMIT_STACK].rlim_cur;
  183         /*
  184          * set up commands for stack.  note that this takes *two*, one to
  185          * map the part of the stack which we can access, and one to map
  186          * the part which we can't.
  187          *
  188          * arguably, it could be made into one, but that would require the
  189          * addition of another mapping proc, which is unnecessary
  190          *
  191          * note that in memory, things assumed to be: 0 ....... ep_maxsaddr
  192          * <stack> ep_minsaddr
  193          */
  194         /* DPRINTF(("VMCMD: addr %x size %d\n", epp->ep_maxsaddr,
  195                  (epp->ep_minsaddr - epp->ep_ssize) - epp->ep_maxsaddr)); */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero,
  197                   ((epp->ep_minsaddr - epp->ep_ssize) - epp->ep_maxsaddr),
epp->ep_maxsaddr, NULLVP, 0, VM_PROT_NONE);
  199         /* DPRINTF(("VMCMD: addr %x size %d\n",
  200                  epp->ep_minsaddr - epp->ep_ssize,
  201                  epp->ep_ssize)); */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, epp->ep_ssize,
  203                   (epp->ep_minsaddr - epp->ep_ssize), NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  206         return 0;
  207 }
  210 /*
  211  * exec_ibcs2_coff_prep_omagic(): Prepare a COFF OMAGIC binary's exec package
  212  */
  214 int
exec_ibcs2_coff_prep_omagic(p, epp, fp, ap)
  216         struct proc *p;
  217         struct exec_package *epp;
  218         struct coff_filehdr *fp;
  219         struct coff_aouthdr *ap;
  220 {
epp->ep_taddr = COFF_SEGMENT_ALIGN(ap, ap->a_tstart);
epp->ep_tsize = ap->a_tsize;
epp->ep_daddr = COFF_SEGMENT_ALIGN(ap, ap->a_dstart);
epp->ep_dsize = ap->a_dsize;
epp->ep_entry = ap->a_entry;
  227         /* set up command for text and data segments */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
ap->a_tsize + ap->a_dsize, epp->ep_taddr, epp->ep_vp,
COFF_TXTOFF(fp, ap),
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  233         /* set up command for bss segment */
  234         if (ap->a_bsize > 0)
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, ap->a_bsize,
COFF_SEGMENT_ALIGN(ap, ap->a_dstart + ap->a_dsize),
NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  240         return exec_ibcs2_coff_setup_stack(p, epp);
  241 }
  243 /*
  244  * exec_ibcs2_coff_prep_nmagic(): Prepare a 'native' NMAGIC COFF binary's exec
  245  *                          package.
  246  */
  248 int
exec_ibcs2_coff_prep_nmagic(p, epp, fp, ap)
  250         struct proc *p;
  251         struct exec_package *epp;
  252         struct coff_filehdr *fp;
  253         struct coff_aouthdr *ap;
  254 {
epp->ep_taddr = COFF_SEGMENT_ALIGN(ap, ap->a_tstart);
epp->ep_tsize = ap->a_tsize;
epp->ep_daddr = COFF_ROUND(ap->a_dstart, COFF_LDPGSZ);
epp->ep_dsize = ap->a_dsize;
epp->ep_entry = ap->a_entry;
  261         /* set up command for text segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, epp->ep_tsize,
epp->ep_taddr, epp->ep_vp, COFF_TXTOFF(fp, ap),
VM_PROT_READ|VM_PROT_EXECUTE);
  266         /* set up command for data segment */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, epp->ep_dsize,
epp->ep_daddr, epp->ep_vp, COFF_DATOFF(fp, ap),
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  271         /* set up command for bss segment */
  272         if (ap->a_bsize > 0)
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, ap->a_bsize,
COFF_SEGMENT_ALIGN(ap, ap->a_dstart + ap->a_dsize),
NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  278         return exec_ibcs2_coff_setup_stack(p, epp);
  279 }
  281 /*
  282  * coff_find_section - load specified section header
  283  *
  284  * TODO - optimize by reading all section headers in at once
  285  */
  287 static int
coff_find_section(p, vp, fp, sh, s_type)
  289         struct proc *p;
  290         struct vnode *vp;
  291         struct coff_filehdr *fp;
  292         struct coff_scnhdr *sh;
  293         int s_type;
  294 {
  295         int i, pos, error;
size_t siz, resid;
pos = COFF_HDR_SIZE;
  299         for (i = 0; i < fp->f_nscns; i++, pos += sizeof(struct coff_scnhdr)) {
siz = sizeof(struct coff_scnhdr);
error = vn_rdwr(UIO_READ, vp, (caddr_t) sh,
siz, pos, UIO_SYSSPACE, 0, p->p_ucred,
  303                     &resid, p);
  304                 if (error) {
DPRINTF(("section hdr %d read error %d\n", i, error));
  306                         return error;
  307                 }
siz -= resid;
  309                 if (siz != sizeof(struct coff_scnhdr)) {
DPRINTF(("incomplete read: hdr %d ask=%d, rem=%u got %u\n",
s_type, sizeof(struct coff_scnhdr),
resid, siz));
  313                         return ENOEXEC;
  314                 }
  315                 /* DPRINTF(("found section: %x\n", sh->s_flags)); */
  316                 if (sh->s_flags == s_type)
  317                         return 0;
  318         }
  319         return ENOEXEC;
  320 }
  322 /*
  323  * exec_ibcs2_coff_prep_zmagic(): Prepare a COFF ZMAGIC binary's exec package
  324  *
  325  * First, set the various offsets/lengths in the exec package.
  326  *
  327  * Then, mark the text image busy (so it can be demand paged) or error
  328  * out if this is not possible.  Finally, set up vmcmds for the
  329  * text, data, bss, and stack segments.
  330  */
  332 int
exec_ibcs2_coff_prep_zmagic(p, epp, fp, ap)
  334         struct proc *p;
  335         struct exec_package *epp;
  336         struct coff_filehdr *fp;
  337         struct coff_aouthdr *ap;
  338 {
  339         int error;
u_long offset;
  341         long dsize, baddr, bsize;
  342         struct coff_scnhdr sh;
  344         /* DPRINTF(("enter exec_ibcs2_coff_prep_zmagic\n")); */
  346         /* set up command for text segment */
error = coff_find_section(p, epp->ep_vp, fp, &sh, COFF_STYP_TEXT);
  348         if (error) {            
DPRINTF(("can't find text section: %d\n", error));
  350                 return error;
  351         }
  352         /* DPRINTF(("COFF text addr %x size %d offset %d\n", sh.s_vaddr,
  353                  sh.s_size, sh.s_scnptr)); */
epp->ep_taddr = COFF_ALIGN(sh.s_vaddr);
offset = sh.s_scnptr - (sh.s_vaddr - epp->ep_taddr);
epp->ep_tsize = sh.s_size + (sh.s_vaddr - epp->ep_taddr);
  358 #ifdef notyet
  359         /*
  360          * check if vnode is in open for writing, because we want to
  361          * demand-page out of it.  if it is, don't do it, for various
  362          * reasons
  363 n        */
  364         if ((ap->a_tsize != 0 || ap->a_dsize != 0) &&
epp->ep_vp->v_writecount != 0) {
  366 #ifdef DIAGNOSTIC
  367                 if (epp->ep_vp->v_flag & VTEXT)
panic("exec: a VTEXT vnode has writecount != 0");
  369 #endif
  370                 return ETXTBSY;
  371         }
vn_marktext(epp->ep_vp);
  373 #endif
  375         /* DPRINTF(("VMCMD: addr %x size %d offset %d\n", epp->ep_taddr,
  376                  epp->ep_tsize, offset)); */
  377 #ifdef notyet
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_pagedvn, epp->ep_tsize,
epp->ep_taddr, epp->ep_vp, offset,
VM_PROT_READ|VM_PROT_EXECUTE);
  381 #else
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, epp->ep_tsize,
epp->ep_taddr, epp->ep_vp, offset,
VM_PROT_READ|VM_PROT_EXECUTE);
  385 #endif
  387         /* set up command for data segment */
error = coff_find_section(p, epp->ep_vp, fp, &sh, COFF_STYP_DATA);
  389         if (error) {
DPRINTF(("can't find data section: %d\n", error));
  391                 return error;
  392         }
  393         /* DPRINTF(("COFF data addr %x size %d offset %d\n", sh.s_vaddr,
  394                  sh.s_size, sh.s_scnptr)); */
epp->ep_daddr = COFF_ALIGN(sh.s_vaddr);
offset = sh.s_scnptr - (sh.s_vaddr - epp->ep_daddr);
dsize = sh.s_size + (sh.s_vaddr - epp->ep_daddr);
epp->ep_dsize = dsize + ap->a_bsize;
  400         /* DPRINTF(("VMCMD: addr %x size %d offset %d\n", epp->ep_daddr,
  401                  dsize, offset)); */
  402 #ifdef notyet
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_pagedvn, dsize,
epp->ep_daddr, epp->ep_vp, offset,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  406 #else
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
dsize, epp->ep_daddr, epp->ep_vp, offset,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  410 #endif
  412         /* set up command for bss segment */
baddr = round_page(epp->ep_daddr + dsize);
bsize = epp->ep_daddr + epp->ep_dsize - baddr;
  415         if (bsize > 0) {
  416                 /* DPRINTF(("VMCMD: addr %x size %d offset %d\n",
  417                          baddr, bsize, 0)); */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero,
bsize, baddr, NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  421         }
  423         /* load any shared libraries */
error = coff_find_section(p, epp->ep_vp, fp, &sh, COFF_STYP_SHLIB);
  425         if (!error) {
size_t resid;
  427                 struct coff_slhdr *slhdr;
  428                 char buf[128], *bufp;   /* FIXME */
  429                 unsigned int len = sh.s_size, entry_len;
  431                 /* DPRINTF(("COFF shlib size %d offset %d\n",
  432                          sh.s_size, sh.s_scnptr)); */
  434                 if (len > sizeof(buf))
  435                         return (ENOEXEC);
error = vn_rdwr(UIO_READ, epp->ep_vp, (caddr_t) buf,
len, sh.s_scnptr,
UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred,
  440                                 &resid, p);
  441                 if (error) {
DPRINTF(("shlib section read error %d\n", error));
  443                         return ENOEXEC;
  444                 }
bufp = buf;
  446                 while (len) {
slhdr = (struct coff_slhdr *)bufp;
  448 #ifdef notyet
path_index = slhdr->path_index * sizeof(long);
  450 #endif
entry_len = slhdr->entry_len * sizeof(long);
  453                         /* DPRINTF(("path_index: %d entry_len: %d name: %s\n",
  454                                  path_index, entry_len, slhdr->sl_name)); */
  456                         if (entry_len > len)
  457                                 return (ENOEXEC);
error = coff_load_shlib(p, slhdr->sl_name, epp);
  460                         if (error)
  461                                 return ENOEXEC;
bufp += entry_len;
len -= entry_len;
  464                 }
  465         }
  467         /* set up entry point */
epp->ep_entry = ap->a_entry;
  470 #if 0
DPRINTF(("text addr: %x size: %d data addr: %x size: %d entry: %x\n",
epp->ep_taddr, epp->ep_tsize,
epp->ep_daddr, epp->ep_dsize,
epp->ep_entry));
  475 #endif
  477         return exec_ibcs2_coff_setup_stack(p, epp);
  478 }
  480 int
coff_load_shlib(p, path, epp)
  482         struct proc *p;
  483         char *path;
  484         struct exec_package *epp;
  485 {
  486         int error, taddr, tsize, daddr, dsize, offset;
size_t siz, resid;
  488         struct nameidata nd;
  489         struct coff_filehdr fh, *fhp = &fh;
  490         struct coff_scnhdr sh, *shp = &sh;
caddr_t sg = stackgap_init(p->p_emul);
  493         /*
  494          * 1. open shlib file
  495          * 2. read filehdr
  496          * 3. map text, data, and bss out of it using VM_*
  497          */
IBCS2_CHECK_ALT_EXIST(p, &sg, path);
NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path, p);
  500         /* first get the vnode */
  501         if ((error = namei(&nd)) != 0) {
DPRINTF(("coff_load_shlib: can't find library %s\n", path));
  503                 return error;
  504         }
siz = sizeof(struct coff_filehdr);
error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t) fhp, siz, 0,
UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p);
  509         if (error) {
DPRINTF(("filehdr read error %d\n", error));
vrele(nd.ni_vp);
  512             return error;
  513         }
siz -= resid;
  515         if (siz != sizeof(struct coff_filehdr)) {
DPRINTF(("coff_load_shlib: incomplete read: ask=%d, rem=%u got %u\n",
  517                      sizeof(struct coff_filehdr), resid, siz));
vrele(nd.ni_vp);
  519             return ENOEXEC;
  520         }
  522         /* load text */
error = coff_find_section(p, nd.ni_vp, fhp, shp, COFF_STYP_TEXT);
  524         if (error) {
DPRINTF(("can't find shlib text section\n"));
vrele(nd.ni_vp);
  527             return error;
  528         }
  529         /* DPRINTF(("COFF text addr %x size %d offset %d\n", sh.s_vaddr,
  530                  sh.s_size, sh.s_scnptr)); */
taddr = COFF_ALIGN(shp->s_vaddr);
offset = shp->s_scnptr - (shp->s_vaddr - taddr);
tsize = shp->s_size + (shp->s_vaddr - taddr);
  534         /* DPRINTF(("VMCMD: addr %x size %d offset %d\n", taddr, tsize, offset)); */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, tsize, taddr,
nd.ni_vp, offset,
VM_PROT_READ|VM_PROT_EXECUTE);
  539         /* load data */
error = coff_find_section(p, nd.ni_vp, fhp, shp, COFF_STYP_DATA);
  541         if (error) {
DPRINTF(("can't find shlib data section\n"));
vrele(nd.ni_vp);
  544             return error;
  545         }
  546         /* DPRINTF(("COFF data addr %x size %d offset %d\n", shp->s_vaddr,
  547                  shp->s_size, shp->s_scnptr)); */
daddr = COFF_ALIGN(shp->s_vaddr);
offset = shp->s_scnptr - (shp->s_vaddr - daddr);
dsize = shp->s_size + (shp->s_vaddr - daddr);
  551         /* epp->ep_dsize = dsize + ap->a_bsize; */
  553         /* DPRINTF(("VMCMD: addr %x size %d offset %d\n", daddr, dsize, offset)); */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
dsize, daddr, nd.ni_vp, offset,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  558         /* load bss */
error = coff_find_section(p, nd.ni_vp, fhp, shp, COFF_STYP_BSS);
  560         if (!error) {
  561                 int baddr = round_page(daddr + dsize);
  562                 int bsize = daddr + dsize + shp->s_size - baddr;
  563                 if (bsize > 0) {
  564                         /* DPRINTF(("VMCMD: addr %x size %d offset %d\n",
  565                            baddr, bsize, 0)); */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero,
bsize, baddr, NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  569             }
  570         }
vrele(nd.ni_vp);
  573         return 0;
  574 }
  576 int
exec_ibcs2_xout_makecmds(p, epp)
  578         struct proc *p;
  579         struct exec_package *epp;
  580 {
  581         int error;
  582         struct xexec *xp = epp->ep_hdr;
  583         struct xext *xep;
  585         if (epp->ep_hdrvalid < XOUT_HDR_SIZE)
  586                 return ENOEXEC;
  588         if ((xp->x_magic != XOUT_MAGIC) || (xp->x_cpu != XC_386))
  589                 return ENOEXEC;
  590         if ((xp->x_renv & (XE_ABS | XE_VMOD)) || !(xp->x_renv & XE_EXEC))
  591                 return ENOEXEC;
xep = (struct xext *)((char *)epp->ep_hdr + sizeof(struct xexec));
  594 #ifdef notyet
  595         if (xp->x_renv & XE_PURE)
error = exec_ibcs2_xout_prep_zmagic(p, epp, xp, xep);
  597         else
  598 #endif
error = exec_ibcs2_xout_prep_nmagic(p, epp, xp, xep);
  601         if (error == 0)
epp->ep_emul = &emul_ibcs2;
  604         if (error)
kill_vmcmds(&epp->ep_vmcmds);
  607         return error;
  608 }
  610 /*
  611  * exec_ibcs2_xout_prep_nmagic(): Prepare a pure x.out binary's exec package
  612  *
  613  */
  615 int
exec_ibcs2_xout_prep_nmagic(p, epp, xp, xep)
  617         struct proc *p;
  618         struct exec_package *epp;
  619         struct xexec *xp;
  620         struct xext *xep;
  621 {
  622         int error, nseg, i;
size_t resid;
  624         long baddr, bsize;
  625         struct xseg *xs;
  627         /* read in segment table */
  628         if (xep->xe_segsize > 16 * sizeof(*xs))
  629                 return (ENOEXEC);
xs = (struct xseg *)malloc(xep->xe_segsize, M_TEMP, M_WAITOK);
error = vn_rdwr(UIO_READ, epp->ep_vp, (caddr_t)xs,
xep->xe_segsize, xep->xe_segpos,
UIO_SYSSPACE, 0, p->p_ucred,
  634                         &resid, p);
  635         if (error) {
DPRINTF(("segment table read error %d\n", error));
free(xs, M_TEMP);
  638                 return ENOEXEC;
  639         }
  641         for (nseg = xep->xe_segsize / sizeof(*xs), i = 0; i < nseg; i++) {
  642                 switch (xs[i].xs_type) {
  643                 case XS_TTEXT:  /* text segment */
DPRINTF(("text addr %x psize %d vsize %d off %d\n",
xs[i].xs_rbase, xs[i].xs_psize,
xs[i].xs_vsize, xs[i].xs_filpos));
epp->ep_taddr = xs[i].xs_rbase; /* XXX - align ??? */
epp->ep_tsize = xs[i].xs_vsize;
DPRINTF(("VMCMD: addr %x size %d offset %d\n",
epp->ep_taddr, epp->ep_tsize,
xs[i].xs_filpos));
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
epp->ep_tsize, epp->ep_taddr,
epp->ep_vp, xs[i].xs_filpos,
VM_PROT_READ|VM_PROT_EXECUTE);
  659                         break;
  661                 case XS_TDATA:  /* data segment */
DPRINTF(("data addr %x psize %d vsize %d off %d\n",
xs[i].xs_rbase, xs[i].xs_psize,
xs[i].xs_vsize, xs[i].xs_filpos));
epp->ep_daddr = xs[i].xs_rbase; /* XXX - align ??? */
epp->ep_dsize = xs[i].xs_vsize;
DPRINTF(("VMCMD: addr %x size %d offset %d\n",
epp->ep_daddr, xs[i].xs_psize,
xs[i].xs_filpos));
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
xs[i].xs_psize, epp->ep_daddr,
epp->ep_vp, xs[i].xs_filpos,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  678                         /* set up command for bss segment */
baddr = round_page(epp->ep_daddr + xs[i].xs_psize);
bsize = epp->ep_daddr + epp->ep_dsize - baddr;
  681                         if (bsize > 0) {
DPRINTF(("VMCMD: bss addr %x size %d off %d\n",
baddr, bsize, 0));
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero,
bsize, baddr, NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|
VM_PROT_EXECUTE);
  688                         }
  689                         break;
  691                 default:
  692                         break;
  693                 }
  694         }
  696         /* set up entry point */
epp->ep_entry = xp->x_entry;
DPRINTF(("text addr: %x size: %d data addr: %x size: %d entry: %x\n",
epp->ep_taddr, epp->ep_tsize,
epp->ep_daddr, epp->ep_dsize,
epp->ep_entry));
free(xs, M_TEMP);
  705         return exec_ibcs2_xout_setup_stack(p, epp);
  706 }
  708 /*
  709  * exec_ibcs2_xout_setup_stack(): Set up the stack segment for a x.out
  710  * executable.
  711  *
  712  * Note that the ep_ssize parameter must be set to be the current stack
  713  * limit; this is adjusted in the body of execve() to yield the
  714  * appropriate stack segment usage once the argument length is
  715  * calculated.
  716  *
  717  * This function returns an int for uniformity with other (future) formats'
  718  * stack setup functions.  They might have errors to return.
  719  */
  721 int
exec_ibcs2_xout_setup_stack(p, epp)
  723         struct proc *p;
  724         struct exec_package *epp;
  725 {
epp->ep_maxsaddr = USRSTACK - MAXSSIZ;
epp->ep_minsaddr = USRSTACK;
epp->ep_ssize = p->p_rlimit[RLIMIT_STACK].rlim_cur;
  730         /*
  731          * set up commands for stack.  note that this takes *two*, one to
  732          * map the part of the stack which we can access, and one to map
  733          * the part which we can't.
  734          *
  735          * arguably, it could be made into one, but that would require the
  736          * addition of another mapping proc, which is unnecessary
  737          *
  738          * note that in memory, things assumed to be: 0 ....... ep_maxsaddr
  739          * <stack> ep_minsaddr
  740          */
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero,
  742                   ((epp->ep_minsaddr - epp->ep_ssize) - epp->ep_maxsaddr),
epp->ep_maxsaddr, NULLVP, 0, VM_PROT_NONE);
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_zero, epp->ep_ssize,
  745                   (epp->ep_minsaddr - epp->ep_ssize), NULLVP, 0,
VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE);
  748         return 0;
  749 }