root/kern/exec_elf.c

DEFINITIONS

1. ELFNAME

    1 /*      $OpenBSD: exec_elf.c,v 1.61 2007/05/28 23:10:10 beck Exp $      */
    3 /*
    4  * Copyright (c) 1996 Per Fogelstrom
    5  * All rights reserved.
    6  *
    7  * Copyright (c) 1994 Christos Zoulas
    8  * All rights reserved.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 3. The name of the author may not be used to endorse or promote products
   19  *    derived from this software without specific prior written permission
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   31  *
   32  */
   34 #include <sys/param.h>
   35 #include <sys/systm.h>
   36 #include <sys/kernel.h>
   37 #include <sys/proc.h>
   38 #include <sys/malloc.h>
   39 #include <sys/pool.h>
   40 #include <sys/mount.h>
   41 #include <sys/namei.h>
   42 #include <sys/vnode.h>
   43 #include <sys/exec.h>
   44 #include <sys/exec_elf.h>
   45 #include <sys/exec_olf.h>
   46 #include <sys/file.h>
   47 #include <sys/syscall.h>
   48 #include <sys/signalvar.h>
   49 #include <sys/stat.h>
   51 #include <sys/mman.h>
   52 #include <uvm/uvm_extern.h>
   54 #include <machine/cpu.h>
   55 #include <machine/reg.h>
   56 #include <machine/exec.h>
   58 #ifdef COMPAT_LINUX
   59 #include <compat/linux/linux_exec.h>
   60 #endif
   62 #ifdef COMPAT_SVR4
   63 #include <compat/svr4/svr4_exec.h>
   64 #endif
   66 #ifdef COMPAT_FREEBSD
   67 #include <compat/freebsd/freebsd_exec.h>
   68 #endif
   70 struct ELFNAME(probe_entry) {
   71         int (*func)(struct proc *, struct exec_package *, char *,
u_long *, u_int8_t *);
   73         int os_mask;
   74 } ELFNAME(probes)[] = {
   75         /* XXX - bogus, shouldn't be size independent.. */
   76 #ifdef COMPAT_FREEBSD
   77         { freebsd_elf_probe, 1 << OOS_FREEBSD },
   78 #endif
   79 #ifdef COMPAT_SVR4
   80         { svr4_elf_probe,
   81             1 << OOS_SVR4 | 1 << OOS_ESIX | 1 << OOS_SOLARIS | 1 << OOS_SCO |
   82             1 << OOS_DELL | 1 << OOS_NCR },
   83 #endif
   84 #ifdef COMPAT_LINUX
   85         { linux_elf_probe, 1 << OOS_LINUX },
   86 #endif
   87         { 0, 1 << OOS_OPENBSD }
   88 };
   90 int ELFNAME(load_file)(struct proc *, char *, struct exec_package *,
   91         struct elf_args *, Elf_Addr *);
   92 int ELFNAME(check_header)(Elf_Ehdr *, int);
   93 int ELFNAME(olf_check_header)(Elf_Ehdr *, int, u_int8_t *);
   94 int ELFNAME(read_from)(struct proc *, struct vnode *, u_long, caddr_t, int);
   95 void ELFNAME(load_psection)(struct exec_vmcmd_set *, struct vnode *,
Elf_Phdr *, Elf_Addr *, Elf_Addr *, int *, int);
   98 extern char sigcode[], esigcode[];
   99 #ifdef SYSCALL_DEBUG
  100 extern char *syscallnames[];
  101 #endif
  103 /* round up and down to page boundaries. */
  104 #define ELF_ROUND(a, b)         (((a) + (b) - 1) & ~((b) - 1))
  105 #define ELF_TRUNC(a, b)         ((a) & ~((b) - 1))
  107 /*
  108  * We limit the number of program headers to 32, this should
  109  * be a reasonable limit for ELF, the most we have seen so far is 12
  110  */
  111 #define ELF_MAX_VALID_PHDR 32
  113 /*
  114  * This is the basic elf emul. elf_probe_funcs may change to other emuls.
  115  */
  116 struct emul ELFNAMEEND(emul) = {
  117         "native",
NULL,
sendsig,
SYS_syscall,
SYS_MAXSYSCALL,
sysent,
  123 #ifdef SYSCALL_DEBUG
syscallnames,
  125 #else
NULL,
  127 #endif
  128         sizeof (AuxInfo) * ELF_AUX_ENTRIES,
ELFNAME(copyargs),
setregs,
ELFNAME2(exec,fixup),
sigcode,
esigcode,
EMUL_ENABLED | EMUL_NATIVE,
  135 };
  137 /*
  138  * Copy arguments onto the stack in the normal way, but add some
  139  * space for extra information in case of dynamic binding.
  140  */
  141 void *
ELFNAME(copyargs)(struct exec_package *pack, struct ps_strings *arginfo,
  143                 void *stack, void *argp)
  144 {
stack = copyargs(pack, arginfo, stack, argp);
  146         if (!stack)
  147                 return (NULL);
  149         /*
  150          * Push space for extra arguments on the stack needed by
  151          * dynamically linked binaries.
  152          */
  153         if (pack->ep_interp != NULL) {
pack->ep_emul_argp = stack;
stack = (char *)stack + ELF_AUX_ENTRIES * sizeof (AuxInfo);
  156         }
  157         return (stack);
  158 }
  160 /*
  161  * Check header for validity; return 0 for ok, ENOEXEC if error
  162  */
  163 int
ELFNAME(check_header)(Elf_Ehdr *ehdr, int type)
  165 {
  166         /*
  167          * We need to check magic, class size, endianess, and version before
  168          * we look at the rest of the Elf_Ehdr structure. These few elements
  169          * are represented in a machine independant fashion.
  170          */
  171         if (!IS_ELF(*ehdr) ||
ehdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
ehdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
ehdr->e_ident[EI_VERSION] != ELF_TARG_VER)
  175                 return (ENOEXEC);
  177         /* Now check the machine dependant header */
  178         if (ehdr->e_machine != ELF_TARG_MACH ||
ehdr->e_version != ELF_TARG_VER)
  180                 return (ENOEXEC);
  182         /* Check the type */
  183         if (ehdr->e_type != type)
  184                 return (ENOEXEC);
  186         /* Don't allow an insane amount of sections. */
  187         if (ehdr->e_phnum > ELF_MAX_VALID_PHDR)
  188                 return (ENOEXEC);
  190         return (0);
  191 }
  193 #ifndef SMALL_KERNEL
  194 /*
  195  * Check header for validity; return 0 for ok, ENOEXEC if error.
  196  * Remember OS tag for callers sake.
  197  */
  198 int
ELFNAME(olf_check_header)(Elf_Ehdr *ehdr, int type, u_int8_t *os)
  200 {
  201         int i;
  203         /*
  204          * We need to check magic, class size, endianess, version, and OS
  205          * before we look at the rest of the Elf_Ehdr structure. These few
  206          * elements are represented in a machine independant fashion.
  207          */
  208         if (!IS_OLF(*ehdr) ||
ehdr->e_ident[OI_CLASS] != ELF_TARG_CLASS ||
ehdr->e_ident[OI_DATA] != ELF_TARG_DATA ||
ehdr->e_ident[OI_VERSION] != ELF_TARG_VER)
  212                 return (ENOEXEC);
  214         for (i = 0;
i < sizeof(ELFNAME(probes)) / sizeof(ELFNAME(probes)[0]);
i++) {
  217                 if ((1 << ehdr->e_ident[OI_OS]) & ELFNAME(probes)[i].os_mask)
  218                         goto os_ok;
  219         }
  220         return (ENOEXEC);
os_ok:
  223         /* Now check the machine dependant header */
  224         if (ehdr->e_machine != ELF_TARG_MACH ||
ehdr->e_version != ELF_TARG_VER)
  226                 return (ENOEXEC);
  228         /* Check the type */
  229         if (ehdr->e_type != type)
  230                 return (ENOEXEC);
  232         /* Don't allow an insane amount of sections. */
  233         if (ehdr->e_phnum > ELF_MAX_VALID_PHDR)
  234                 return (ENOEXEC);
  236         *os = ehdr->e_ident[OI_OS];
  237         return (0);
  238 }
  239 #endif  /* !SMALL_KERNEL */
  241 /*
  242  * Load a psection at the appropriate address
  243  */
  244 void
ELFNAME(load_psection)(struct exec_vmcmd_set *vcset, struct vnode *vp,
Elf_Phdr *ph, Elf_Addr *addr, Elf_Addr *size, int *prot, int flags)
  247 {
u_long uaddr, msize, lsize, psize, rm, rf;
  249         long diff, offset, bdiff;
Elf_Addr base;
  252         /*
  253          * If the user specified an address, then we load there.
  254          */
  255         if (*addr != ELFDEFNNAME(NO_ADDR)) {
  256                 if (ph->p_align > 1) {
  257                         *addr = ELF_TRUNC(*addr, ph->p_align);
diff = ph->p_vaddr - ELF_TRUNC(ph->p_vaddr, ph->p_align);
  259                         /* page align vaddr */
base = *addr + trunc_page(ph->p_vaddr) 
  261                             - ELF_TRUNC(ph->p_vaddr, ph->p_align);
bdiff = ph->p_vaddr - trunc_page(ph->p_vaddr);
  265                 } else
diff = 0;
  267         } else {
  268                 *addr = uaddr = ph->p_vaddr;
  269                 if (ph->p_align > 1)
  270                         *addr = ELF_TRUNC(uaddr, ph->p_align);
base = trunc_page(uaddr);
bdiff = uaddr - base;
diff = uaddr - *addr;
  274         }
  276         *prot |= (ph->p_flags & PF_R) ? VM_PROT_READ : 0;
  277         *prot |= (ph->p_flags & PF_W) ? VM_PROT_WRITE : 0;
  278         *prot |= (ph->p_flags & PF_X) ? VM_PROT_EXECUTE : 0;
msize = ph->p_memsz + diff;
offset = ph->p_offset - bdiff;
lsize = ph->p_filesz + bdiff;
psize = round_page(lsize);
  285         /*
  286          * Because the pagedvn pager can't handle zero fill of the last
  287          * data page if it's not page aligned we map the last page readvn.
  288          */
  289         if (ph->p_flags & PF_W) {
psize = trunc_page(lsize);
  291                 if (psize > 0)
NEW_VMCMD2(vcset, vmcmd_map_pagedvn, psize, base, vp,
offset, *prot, flags);
  294                 if (psize != lsize) {
NEW_VMCMD2(vcset, vmcmd_map_readvn, lsize - psize,
base + psize, vp, offset + psize, *prot, flags);
  297                 }
  298         } else {
NEW_VMCMD2(vcset, vmcmd_map_pagedvn, psize, base, vp, offset,
  300                     *prot, flags);
  301         }
  303         /*
  304          * Check if we need to extend the size of the segment
  305          */
rm = round_page(*addr + ph->p_memsz + diff);
rf = round_page(*addr + ph->p_filesz + diff);
  309         if (rm != rf) {
NEW_VMCMD2(vcset, vmcmd_map_zero, rm - rf, rf, NULLVP, 0,
  311                     *prot, flags);
  312         }
  313         *size = msize;
  314 }
  316 /*
  317  * Read from vnode into buffer at offset.
  318  */
  319 int
ELFNAME(read_from)(struct proc *p, struct vnode *vp, u_long off, caddr_t buf,
  321         int size)
  322 {
  323         int error;
size_t resid;
  326         if ((error = vn_rdwr(UIO_READ, vp, buf, size, off, UIO_SYSSPACE,
  327             0, p->p_ucred, &resid, p)) != 0)
  328                 return error;
  329         /*
  330          * See if we got all of it
  331          */
  332         if (resid != 0)
  333                 return (ENOEXEC);
  334         return (0);
  335 }
  337 /*
  338  * Load a file (interpreter/library) pointed to by path [stolen from
  339  * coff_load_shlib()]. Made slightly generic so it might be used externally.
  340  */
  341 int
ELFNAME(load_file)(struct proc *p, char *path, struct exec_package *epp,
  343         struct elf_args *ap, Elf_Addr *last)
  344 {
  345         int error, i;
  346         struct nameidata nd;
Elf_Ehdr eh;
Elf_Phdr *ph = NULL;
u_long phsize;
Elf_Addr addr;
  351         struct vnode *vp;
  352 #ifndef SMALL_KERNEL
u_int8_t os;                    /* Just a dummy in this routine */
  354 #endif
Elf_Phdr *base_ph = NULL;
  356         struct interp_ld_sec {
Elf_Addr vaddr;
u_long memsz;
  359         } loadmap[ELF_MAX_VALID_PHDR];
  360         int nload, idx = 0;
Elf_Addr pos = *last;
  362         int file_align;
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, path, p);
  365         if ((error = namei(&nd)) != 0) {
  366                 return (error);
  367         }
vp = nd.ni_vp;
  369         if (vp->v_type != VREG) {
error = EACCES;
  371                 goto bad;
  372         }
  373         if ((error = VOP_GETATTR(vp, epp->ep_vap, p->p_ucred, p)) != 0)
  374                 goto bad;
  375         if (vp->v_mount->mnt_flag & MNT_NOEXEC) {
error = EACCES;
  377                 goto bad;
  378         }
  379         if ((error = VOP_ACCESS(vp, VREAD, p->p_ucred, p)) != 0)
  380                 goto bad1;
  381         if ((error = ELFNAME(read_from)(p, nd.ni_vp, 0,
  382                                     (caddr_t)&eh, sizeof(eh))) != 0)
  383                 goto bad1;
  385         if (ELFNAME(check_header)(&eh, ET_DYN)
  386 #ifndef SMALL_KERNEL
  387             && ELFNAME(olf_check_header)(&eh, ET_DYN, &os)
  388 #endif
  389             ) {
error = ENOEXEC;
  391                 goto bad1;
  392         }
phsize = eh.e_phnum * sizeof(Elf_Phdr);
ph = malloc(phsize, M_TEMP, M_WAITOK);
  397         if ((error = ELFNAME(read_from)(p, nd.ni_vp, eh.e_phoff, (caddr_t)ph,
phsize)) != 0)
  399                 goto bad1;
  401         for (i = 0; i < eh.e_phnum; i++) {
  402                 if (ph[i].p_type == PT_LOAD) {
loadmap[idx].vaddr = trunc_page(ph[i].p_vaddr);
loadmap[idx].memsz = round_page (ph[i].p_vaddr +
ph[i].p_memsz - loadmap[idx].vaddr);
file_align = ph[i].p_align;
idx++;
  408                 }
  409         }
nload = idx;
  412         /*
  413          * If no position to load the interpreter was set by a probe
  414          * function, pick the same address that a non-fixed mmap(0, ..)
  415          * would (i.e. something safely out of the way).
  416          */
  417         if (pos == ELFDEFNNAME(NO_ADDR)) {
pos = uvm_map_hint(p, VM_PROT_EXECUTE);
  419         }
pos = ELF_ROUND(pos, file_align);
  422         *last = epp->ep_interp_pos = pos;
  423         for (i = 0; i < nload;/**/) {
vaddr_t addr;
  425                 struct  uvm_object *uobj;
off_t   uoff;
size_t  size;
  429 #ifdef this_needs_fixing
  430                 if (i == 0) {
uobj = &vp->v_uvm.u_obj;
  432                         /* need to fix uoff */
  433                 } else {
  434 #endif
uobj = NULL;
uoff = 0;
  437 #ifdef this_needs_fixing
  438                 }
  439 #endif
addr = trunc_page(pos + loadmap[i].vaddr);
size =  round_page(addr + loadmap[i].memsz) - addr;
  444                 /* CRAP - map_findspace does not avoid daddr+MAXDSIZ */
  445                 if ((addr + size > (vaddr_t)p->p_vmspace->vm_daddr) &&
  446                     (addr < (vaddr_t)p->p_vmspace->vm_daddr + MAXDSIZ))
addr = round_page((vaddr_t)p->p_vmspace->vm_daddr +
MAXDSIZ);
  450                 if (uvm_map_findspace(&p->p_vmspace->vm_map, addr, size,
  451                     &addr, uobj, uoff, 0, UVM_FLAG_FIXED) == NULL) {
  452                         if (uvm_map_findspace(&p->p_vmspace->vm_map, addr, size,
  453                             &addr, uobj, uoff, 0, 0) == NULL) {
error = ENOMEM; /* XXX */
  455                                 goto bad1;
  456                         }
  457                 } 
  458                 if (addr != pos + loadmap[i].vaddr) {
  459                         /* base changed. */
pos = addr - trunc_page(loadmap[i].vaddr);
pos = ELF_ROUND(pos,file_align);
epp->ep_interp_pos = *last = pos;
i = 0;
  464                         continue;
  465                 }
i++;
  468         }
  470         /*
  471          * Load all the necessary sections
  472          */
  473         for (i = 0; i < eh.e_phnum; i++) {
Elf_Addr size = 0;
  475                 int prot = 0;
  476                 int flags;
  478                 switch (ph[i].p_type) {
  479                 case PT_LOAD:
  480                         if (base_ph == NULL) {
flags = VMCMD_BASE;
addr = *last;
base_ph = &ph[i];
  484                         } else {
flags = VMCMD_RELATIVE;
addr = ph[i].p_vaddr - base_ph->p_vaddr;
  487                         }
ELFNAME(load_psection)(&epp->ep_vmcmds, nd.ni_vp,
  489                             &ph[i], &addr, &size, &prot, flags);
  490                         /* If entry is within this section it must be text */
  491                         if (eh.e_entry >= ph[i].p_vaddr &&
eh.e_entry < (ph[i].p_vaddr + size)) {
epp->ep_entry = addr + eh.e_entry -
ELF_TRUNC(ph[i].p_vaddr,ph[i].p_align);
ap->arg_interp = addr;
  496                         }
addr += size;
  498                         break;
  500                 case PT_DYNAMIC:
  501                 case PT_PHDR:
  502                 case PT_NOTE:
  503                         break;
  505                 default:
  506                         break;
  507                 }
  508         }
vn_marktext(nd.ni_vp);
bad1:
VOP_CLOSE(nd.ni_vp, FREAD, p->p_ucred, p);
bad:
  515         if (ph != NULL)
free(ph, M_TEMP);
  518         *last = addr;
vput(nd.ni_vp);
  520         return (error);
  521 }
  523 /*
  524  * Prepare an Elf binary's exec package
  525  *
  526  * First, set of the various offsets/lengths in the exec package.
  527  *
  528  * Then, mark the text image busy (so it can be demand paged) or error out if
  529  * this is not possible.  Finally, set up vmcmds for the text, data, bss, and
  530  * stack segments.
  531  */
  532 int
ELFNAME2(exec,makecmds)(struct proc *p, struct exec_package *epp)
  534 {
Elf_Ehdr *eh = epp->ep_hdr;
Elf_Phdr *ph, *pp;
Elf_Addr phdr = 0;
  538         int error, i;
  539         char *interp = NULL;
u_long pos = 0, phsize;
u_int8_t os = OOS_NULL;
  543         if (epp->ep_hdrvalid < sizeof(Elf_Ehdr))
  544                 return (ENOEXEC);
  546         if (ELFNAME(check_header)(eh, ET_EXEC)
  547 #ifndef SMALL_KERNEL
  548             && ELFNAME(olf_check_header)(eh, ET_EXEC, &os)
  549 #endif
  550             )
  551                 return (ENOEXEC);
  553         /*
  554          * check if vnode is in open for writing, because we want to demand-
  555          * page out of it.  if it is, don't do it, for various reasons.
  556          */
  557         if (epp->ep_vp->v_writecount != 0) {
  558 #ifdef DIAGNOSTIC
  559                 if (epp->ep_vp->v_flag & VTEXT)
panic("exec: a VTEXT vnode has writecount != 0");
  561 #endif
  562                 return (ETXTBSY);
  563         }
  564         /*
  565          * Allocate space to hold all the program headers, and read them
  566          * from the file
  567          */
phsize = eh->e_phnum * sizeof(Elf_Phdr);
ph = malloc(phsize, M_TEMP, M_WAITOK);
  571         if ((error = ELFNAME(read_from)(p, epp->ep_vp, eh->e_phoff, (caddr_t)ph,
phsize)) != 0)
  573                 goto bad;
epp->ep_tsize = ELFDEFNNAME(NO_ADDR);
epp->ep_dsize = ELFDEFNNAME(NO_ADDR);
  578         for (i = 0; i < eh->e_phnum; i++) {
pp = &ph[i];
  580                 if (pp->p_type == PT_INTERP) {
  581                         if (pp->p_filesz >= MAXPATHLEN)
  582                                 goto bad;
interp = pool_get(&namei_pool, PR_WAITOK);
  584                         if ((error = ELFNAME(read_from)(p, epp->ep_vp,
pp->p_offset, interp, pp->p_filesz)) != 0) {
  586                                 goto bad;
  587                         }
  588                         break;
  589                 }
  590         }
  592         /*
  593          * OK, we want a slightly different twist of the
  594          * standard emulation package for "real" elf.
  595          */
epp->ep_emul = &ELFNAMEEND(emul);
pos = ELFDEFNNAME(NO_ADDR);
  599         /*
  600          * On the same architecture, we may be emulating different systems.
  601          * See which one will accept this executable.
  602          *
  603          * Probe functions would normally see if the interpreter (if any)
  604          * exists. Emulation packages may possibly replace the interpreter in
  605          * *interp with a changed path (/emul/xxx/<path>), and also
  606          * set the ep_emul field in the exec package structure.
  607          */
error = ENOEXEC;
p->p_os = OOS_OPENBSD;
  610 #ifdef NATIVE_EXEC_ELF
  611         if (ELFNAME(os_pt_note)(p, epp, epp->ep_hdr, "OpenBSD", 8, 4) == 0) {
  612                 goto native;
  613         }
  614 #endif
  615         for (i = 0;
i < sizeof(ELFNAME(probes)) / sizeof(ELFNAME(probes)[0]) && error;
i++) {
  618                 if (os == OOS_NULL || ((1 << os) & ELFNAME(probes)[i].os_mask))
error = ELFNAME(probes)[i].func ?
  620                             (*ELFNAME(probes)[i].func)(p, epp, interp, &pos, &os) :
  621                             0;
  622         }
  623         if (!error)
p->p_os = os;
  625 #ifndef NATIVE_EXEC_ELF
  626         else
  627                 goto bad;
  628 #else
native:
  630 #endif /* NATIVE_EXEC_ELF */
  631         /*
  632          * Load all the necessary sections
  633          */
  634         for (i = 0; i < eh->e_phnum; i++) {
Elf_Addr addr = ELFDEFNNAME(NO_ADDR), size = 0;
  636                 int prot = 0;
pp = &ph[i];
  640                 switch (ph[i].p_type) {
  641                 case PT_LOAD:
  642                         /*
  643                          * Calculates size of text and data segments
  644                          * by starting at first and going to end of last.
  645                          * 'rwx' sections are treated as data.
  646                          * this is correct for BSS_PLT, but may not be
  647                          * for DATA_PLT, is fine for TEXT_PLT.
  648                          */
ELFNAME(load_psection)(&epp->ep_vmcmds, epp->ep_vp,
  650                             &ph[i], &addr, &size, &prot, 0);
  651                         /*
  652                          * Decide whether it's text or data by looking
  653                          * at the protection of the section
  654                          */
  655                         if (prot & VM_PROT_WRITE) {
  656                                 /* data section */
  657                                 if (epp->ep_dsize == ELFDEFNNAME(NO_ADDR)) {
epp->ep_daddr = addr;
epp->ep_dsize = size;
  660                                 } else {
  661                                         if (addr < epp->ep_daddr) {
epp->ep_dsize =
epp->ep_dsize +
epp->ep_daddr -
addr;
epp->ep_daddr = addr;
  667                                         } else
epp->ep_dsize = addr+size -
epp->ep_daddr;
  670                                 }
  671                         } else if (prot & VM_PROT_EXECUTE) {
  672                                 /* text section */
  673                                 if (epp->ep_tsize == ELFDEFNNAME(NO_ADDR)) {
epp->ep_taddr = addr;
epp->ep_tsize = size;
  676                                 } else {
  677                                         if (addr < epp->ep_taddr) {
epp->ep_tsize =
epp->ep_tsize +
epp->ep_taddr -
addr;
epp->ep_taddr = addr;
  683                                         } else
epp->ep_tsize = addr+size -
epp->ep_taddr;
  686                                 }
  687                         }
  688                         break;
  690                 case PT_SHLIB:
error = ENOEXEC;
  692                         goto bad;
  694                 case PT_INTERP:
  695                         /* Already did this one */
  696                 case PT_DYNAMIC:
  697                 case PT_NOTE:
  698                         break;
  700                 case PT_PHDR:
  701                         /* Note address of program headers (in text segment) */
phdr = pp->p_vaddr;
  703                         break;
  705                 default:
  706                         /*
  707                          * Not fatal, we don't need to understand everything
  708                          * :-)
  709                          */
  710                         break;
  711                 }
  712         }
  714         /*
  715          * Strangely some linux programs may have all load sections marked
  716          * writeable, in this case, textsize is not -1, but rather 0;
  717          */
  718         if (epp->ep_tsize == ELFDEFNNAME(NO_ADDR))
epp->ep_tsize = 0;
  720         /*
  721          * Another possibility is that it has all load sections marked
  722          * read-only.  Fake a zero-sized data segment right after the
  723          * text segment.
  724          */
  725         if (epp->ep_dsize == ELFDEFNNAME(NO_ADDR)) {
epp->ep_daddr = round_page(epp->ep_taddr + epp->ep_tsize);
epp->ep_dsize = 0;
  728         }
epp->ep_interp = interp;
epp->ep_entry = eh->e_entry;
  733         /*
  734          * Check if we found a dynamically linked binary and arrange to load
  735          * its interpreter when the exec file is released.
  736          */
  737         if (interp) {
  738                 struct elf_args *ap;
ap = malloc(sizeof(struct elf_args), M_TEMP, M_WAITOK);
ap->arg_phaddr = phdr;
ap->arg_phentsize = eh->e_phentsize;
ap->arg_phnum = eh->e_phnum;
ap->arg_entry = eh->e_entry;
ap->arg_os = os;
epp->ep_emul_arg = ap;
epp->ep_interp_pos = pos;
  750         }
  752 #if defined(COMPAT_SVR4) && defined(i386)
  753 #ifndef ELF_MAP_PAGE_ZERO
  754         /* Dell SVR4 maps page zero, yeuch! */
  755         if (p->p_os == OOS_DELL)
  756 #endif
NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, PAGE_SIZE, 0,
epp->ep_vp, 0, VM_PROT_READ);
  759 #endif
free(ph, M_TEMP);
vn_marktext(epp->ep_vp);
  763         return (exec_setup_stack(p, epp));
bad:
  766         if (interp)
pool_put(&namei_pool, interp);
free(ph, M_TEMP);
kill_vmcmds(&epp->ep_vmcmds);
  770         return (ENOEXEC);
  771 }
  773 /*
  774  * Phase II of load. It is now safe to load the interpreter. Info collected
  775  * when loading the program is available for setup of the interpreter.
  776  */
  777 int
ELFNAME2(exec,fixup)(struct proc *p, struct exec_package *epp)
  779 {
  780         char    *interp;
  781         int     error;
  782         struct  elf_args *ap;
AuxInfo ai[ELF_AUX_ENTRIES], *a;
Elf_Addr        pos = epp->ep_interp_pos;
  786         if (epp->ep_interp == NULL) {
  787                 return (0);
  788         }
interp = epp->ep_interp;
ap = epp->ep_emul_arg;
  793         if ((error = ELFNAME(load_file)(p, interp, epp, ap, &pos)) != 0) {
free(ap, M_TEMP);
pool_put(&namei_pool, interp);
kill_vmcmds(&epp->ep_vmcmds);
  797                 return (error);
  798         }
  799         /*
  800          * We have to do this ourselves...
  801          */
error = exec_process_vmcmds(p, epp);
  804         /*
  805          * Push extra arguments on the stack needed by dynamically
  806          * linked binaries
  807          */
  808         if (error == 0) {
a = ai;
a->au_id = AUX_phdr;
a->au_v = ap->arg_phaddr;
a++;
a->au_id = AUX_phent;
a->au_v = ap->arg_phentsize;
a++;
a->au_id = AUX_phnum;
a->au_v = ap->arg_phnum;
a++;
a->au_id = AUX_pagesz;
a->au_v = PAGE_SIZE;
a++;
a->au_id = AUX_base;
a->au_v = ap->arg_interp;
a++;
a->au_id = AUX_flags;
a->au_v = 0;
a++;
a->au_id = AUX_entry;
a->au_v = ap->arg_entry;
a++;
a->au_id = AUX_null;
a->au_v = 0;
a++;
error = copyout(ai, epp->ep_emul_argp, sizeof ai);
  844         }
free(ap, M_TEMP);
pool_put(&namei_pool, interp);
  847         return (error);
  848 }
  850 /*
  851  * Older ELF binaries use EI_ABIVERSION (formerly EI_BRAND) to brand
  852  * executables.  Newer ELF binaries use EI_OSABI instead.
  853  */
  854 char *
ELFNAME(check_brand)(Elf_Ehdr *eh)
  856 {
  857         if (eh->e_ident[EI_ABIVERSION] == '\0')
  858                 return (NULL);
  859         return (&eh->e_ident[EI_ABIVERSION]);
  860 }
  862 int
ELFNAME(os_pt_note)(struct proc *p, struct exec_package *epp, Elf_Ehdr *eh,
  864         char *os_name, size_t name_size, size_t desc_size)
  865 {
Elf_Phdr *hph, *ph;
Elf_Note *np = NULL;
size_t phsize;
  869         int error;
phsize = eh->e_phnum * sizeof(Elf_Phdr);
hph = malloc(phsize, M_TEMP, M_WAITOK);
  873         if ((error = ELFNAME(read_from)(p, epp->ep_vp, eh->e_phoff,
  874             (caddr_t)hph, phsize)) != 0)
  875                 goto out1;
  877         for (ph = hph;  ph < &hph[eh->e_phnum]; ph++) {
  878                 if (ph->p_type != PT_NOTE ||
ph->p_filesz > 1024 ||
ph->p_filesz < sizeof(Elf_Note) + name_size)
  881                         continue;
np = malloc(ph->p_filesz, M_TEMP, M_WAITOK);
  884                 if ((error = ELFNAME(read_from)(p, epp->ep_vp, ph->p_offset,
  885                     (caddr_t)np, ph->p_filesz)) != 0)
  886                         goto out2;
  888 #if 0
  889                 if (np->type != ELF_NOTE_TYPE_OSVERSION) {
free(np, M_TEMP);
np = NULL;
  892                         continue;
  893                 }
  894 #endif
  896                 /* Check the name and description sizes. */
  897                 if (np->namesz != name_size ||
np->descsz != desc_size)
  899                         goto out3;
  901                 if (bcmp((np + 1), os_name, name_size))
  902                         goto out3;
  904                 /* XXX: We could check for the specific emulation here */
  905                 /* All checks succeeded. */
error = 0;
  907                 goto out2;
  908         }
out3:
error = ENOEXEC;
out2:
  913         if (np)
free(np, M_TEMP);
out1:
free(hph, M_TEMP);
  917         return error;
  918 }