Home | History | Annotate | Line # | Download | only in kern
exec_elf.c revision 1.85.2.2
      1  1.85.2.2  pgoyette /*	$NetBSD: exec_elf.c,v 1.85.2.2 2017/03/20 06:57:47 pgoyette Exp $	*/
      2      1.10        ad 
      3      1.10        ad /*-
      4      1.78      maxv  * Copyright (c) 1994, 2000, 2005, 2015 The NetBSD Foundation, Inc.
      5      1.10        ad  * All rights reserved.
      6      1.10        ad  *
      7      1.10        ad  * This code is derived from software contributed to The NetBSD Foundation
      8      1.78      maxv  * by Christos Zoulas and Maxime Villard.
      9      1.10        ad  *
     10      1.10        ad  * Redistribution and use in source and binary forms, with or without
     11      1.10        ad  * modification, are permitted provided that the following conditions
     12      1.10        ad  * are met:
     13      1.10        ad  * 1. Redistributions of source code must retain the above copyright
     14      1.10        ad  *    notice, this list of conditions and the following disclaimer.
     15      1.10        ad  * 2. Redistributions in binary form must reproduce the above copyright
     16      1.10        ad  *    notice, this list of conditions and the following disclaimer in the
     17      1.10        ad  *    documentation and/or other materials provided with the distribution.
     18      1.10        ad  *
     19      1.10        ad  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20      1.10        ad  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21      1.10        ad  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22      1.10        ad  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23      1.10        ad  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24      1.10        ad  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25      1.10        ad  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26      1.10        ad  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27      1.10        ad  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28      1.10        ad  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29      1.10        ad  * POSSIBILITY OF SUCH DAMAGE.
     30      1.10        ad  */
     31       1.1      fvdl 
     32       1.1      fvdl /*
     33      1.10        ad  * Copyright (c) 1996 Christopher G. Demetriou
     34       1.1      fvdl  * All rights reserved.
     35       1.1      fvdl  *
     36       1.1      fvdl  * Redistribution and use in source and binary forms, with or without
     37       1.1      fvdl  * modification, are permitted provided that the following conditions
     38       1.1      fvdl  * are met:
     39       1.1      fvdl  * 1. Redistributions of source code must retain the above copyright
     40       1.1      fvdl  *    notice, this list of conditions and the following disclaimer.
     41       1.1      fvdl  * 2. Redistributions in binary form must reproduce the above copyright
     42       1.1      fvdl  *    notice, this list of conditions and the following disclaimer in the
     43       1.1      fvdl  *    documentation and/or other materials provided with the distribution.
     44       1.1      fvdl  * 3. The name of the author may not be used to endorse or promote products
     45       1.1      fvdl  *    derived from this software without specific prior written permission
     46       1.1      fvdl  *
     47       1.1      fvdl  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     48       1.1      fvdl  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     49       1.1      fvdl  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     50       1.1      fvdl  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     51       1.1      fvdl  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     52       1.1      fvdl  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     53       1.1      fvdl  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     54       1.1      fvdl  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     55       1.1      fvdl  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     56       1.1      fvdl  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     57       1.1      fvdl  */
     58       1.1      fvdl 
     59      1.10        ad #include <sys/cdefs.h>
     60  1.85.2.2  pgoyette __KERNEL_RCSID(1, "$NetBSD: exec_elf.c,v 1.85.2.2 2017/03/20 06:57:47 pgoyette Exp $");
     61      1.10        ad 
     62      1.10        ad #ifdef _KERNEL_OPT
     63      1.10        ad #include "opt_pax.h"
     64      1.10        ad #endif /* _KERNEL_OPT */
     65      1.10        ad 
     66       1.1      fvdl #include <sys/param.h>
     67       1.1      fvdl #include <sys/proc.h>
     68      1.10        ad #include <sys/kmem.h>
     69       1.1      fvdl #include <sys/namei.h>
     70       1.1      fvdl #include <sys/vnode.h>
     71       1.1      fvdl #include <sys/exec.h>
     72       1.1      fvdl #include <sys/exec_elf.h>
     73       1.8  christos #include <sys/syscall.h>
     74       1.8  christos #include <sys/signalvar.h>
     75      1.10        ad #include <sys/mount.h>
     76      1.10        ad #include <sys/stat.h>
     77      1.10        ad #include <sys/kauth.h>
     78      1.10        ad #include <sys/bitops.h>
     79      1.10        ad 
     80      1.10        ad #include <sys/cpu.h>
     81      1.10        ad #include <machine/reg.h>
     82       1.1      fvdl 
     83      1.10        ad #include <compat/common/compat_util.h>
     84       1.1      fvdl 
     85      1.10        ad #include <sys/pax.h>
     86      1.37    martin #include <uvm/uvm_param.h>
     87       1.1      fvdl 
     88      1.10        ad extern struct emul emul_netbsd;
     89       1.1      fvdl 
     90      1.10        ad #define elf_check_header	ELFNAME(check_header)
     91      1.10        ad #define elf_copyargs		ELFNAME(copyargs)
     92      1.65      maxv #define elf_load_interp		ELFNAME(load_interp)
     93      1.10        ad #define elf_load_psection	ELFNAME(load_psection)
     94      1.10        ad #define exec_elf_makecmds	ELFNAME2(exec,makecmds)
     95      1.10        ad #define netbsd_elf_signature	ELFNAME2(netbsd,signature)
     96  1.85.2.2  pgoyette #define netbsd_elf_note       	ELFNAME2(netbsd,note)
     97      1.10        ad #define netbsd_elf_probe	ELFNAME2(netbsd,probe)
     98      1.10        ad #define	coredump		ELFNAMEEND(coredump)
     99      1.35      matt #define	elf_free_emul_arg	ELFNAME(free_emul_arg)
    100       1.1      fvdl 
    101      1.58      maxv static int
    102      1.65      maxv elf_load_interp(struct lwp *, struct exec_package *, char *,
    103      1.58      maxv     struct exec_vmcmd_set *, u_long *, Elf_Addr *);
    104      1.58      maxv static void
    105      1.58      maxv elf_load_psection(struct exec_vmcmd_set *, struct vnode *, const Elf_Phdr *,
    106      1.64      maxv     Elf_Addr *, u_long *, int);
    107       1.6  christos 
    108      1.10        ad int	netbsd_elf_signature(struct lwp *, struct exec_package *, Elf_Ehdr *);
    109  1.85.2.2  pgoyette int	netbsd_elf_note(struct exec_package *, const Elf_Nhdr *, const char *,
    110  1.85.2.2  pgoyette 	    const char *);
    111      1.10        ad int	netbsd_elf_probe(struct lwp *, struct exec_package *, void *, char *,
    112      1.10        ad 	    vaddr_t *);
    113       1.1      fvdl 
    114      1.35      matt static void	elf_free_emul_arg(void *);
    115      1.35      matt 
    116  1.85.2.1  pgoyette #ifdef DEBUG_ELF
    117  1.85.2.1  pgoyette #define DPRINTF(a, ...)	printf("%s: " a "\n", __func__, ##__VA_ARGS__)
    118  1.85.2.1  pgoyette #else
    119  1.85.2.1  pgoyette #define DPRINTF(a, ...)
    120  1.85.2.1  pgoyette #endif
    121  1.85.2.1  pgoyette 
    122      1.10        ad /* round up and down to page boundaries. */
    123      1.10        ad #define	ELF_ROUND(a, b)		(((a) + (b) - 1) & ~((b) - 1))
    124      1.10        ad #define	ELF_TRUNC(a, b)		((a) & ~((b) - 1))
    125       1.1      fvdl 
    126      1.10        ad static void
    127      1.77      maxv elf_placedynexec(struct exec_package *epp, Elf_Ehdr *eh, Elf_Phdr *ph)
    128      1.10        ad {
    129      1.19  drochner 	Elf_Addr align, offset;
    130      1.19  drochner 	int i;
    131      1.19  drochner 
    132      1.19  drochner 	for (align = i = 0; i < eh->e_phnum; i++)
    133      1.19  drochner 		if (ph[i].p_type == PT_LOAD && ph[i].p_align > align)
    134      1.19  drochner 			align = ph[i].p_align;
    135      1.10        ad 
    136      1.83  christos 	offset = (Elf_Addr)pax_aslr_exec_offset(epp, align);
    137  1.85.2.2  pgoyette 	if (offset < epp->ep_vm_minaddr)
    138  1.85.2.2  pgoyette 		offset = roundup(epp->ep_vm_minaddr, align);
    139  1.85.2.2  pgoyette 	KASSERT((offset & (align - 1)) == 0);
    140      1.32   reinoud 
    141      1.10        ad 	for (i = 0; i < eh->e_phnum; i++)
    142      1.18  christos 		ph[i].p_vaddr += offset;
    143      1.63      matt 	epp->ep_entryoffset = offset;
    144      1.16  christos 	eh->e_entry += offset;
    145      1.10        ad }
    146       1.8  christos 
    147       1.8  christos /*
    148       1.1      fvdl  * Copy arguments onto the stack in the normal way, but add some
    149       1.1      fvdl  * extra information in case of dynamic binding.
    150       1.1      fvdl  */
    151      1.10        ad int
    152      1.10        ad elf_copyargs(struct lwp *l, struct exec_package *pack,
    153      1.10        ad     struct ps_strings *arginfo, char **stackp, void *argp)
    154       1.1      fvdl {
    155      1.10        ad 	size_t len, vlen;
    156      1.10        ad 	AuxInfo ai[ELF_AUX_ENTRIES], *a, *execname;
    157       1.1      fvdl 	struct elf_args *ap;
    158      1.10        ad 	int error;
    159       1.1      fvdl 
    160      1.10        ad 	if ((error = copyargs(l, pack, arginfo, stackp, argp)) != 0)
    161      1.10        ad 		return error;
    162      1.10        ad 
    163      1.10        ad 	a = ai;
    164      1.10        ad 	execname = NULL;
    165       1.1      fvdl 
    166      1.71      maxv 	memset(ai, 0, sizeof(ai));
    167      1.71      maxv 
    168       1.1      fvdl 	/*
    169       1.1      fvdl 	 * Push extra arguments on the stack needed by dynamically
    170       1.1      fvdl 	 * linked binaries
    171       1.1      fvdl 	 */
    172      1.10        ad 	if ((ap = (struct elf_args *)pack->ep_emul_arg)) {
    173      1.10        ad 		struct vattr *vap = pack->ep_vap;
    174      1.10        ad 
    175      1.10        ad 		a->a_type = AT_PHDR;
    176      1.10        ad 		a->a_v = ap->arg_phaddr;
    177      1.10        ad 		a++;
    178      1.10        ad 
    179      1.10        ad 		a->a_type = AT_PHENT;
    180      1.10        ad 		a->a_v = ap->arg_phentsize;
    181      1.10        ad 		a++;
    182      1.10        ad 
    183      1.10        ad 		a->a_type = AT_PHNUM;
    184      1.10        ad 		a->a_v = ap->arg_phnum;
    185      1.10        ad 		a++;
    186       1.1      fvdl 
    187      1.10        ad 		a->a_type = AT_PAGESZ;
    188      1.10        ad 		a->a_v = PAGE_SIZE;
    189       1.1      fvdl 		a++;
    190       1.1      fvdl 
    191      1.10        ad 		a->a_type = AT_BASE;
    192      1.10        ad 		a->a_v = ap->arg_interp;
    193       1.1      fvdl 		a++;
    194       1.1      fvdl 
    195      1.10        ad 		a->a_type = AT_FLAGS;
    196      1.10        ad 		a->a_v = 0;
    197       1.1      fvdl 		a++;
    198       1.1      fvdl 
    199      1.10        ad 		a->a_type = AT_ENTRY;
    200      1.10        ad 		a->a_v = ap->arg_entry;
    201       1.1      fvdl 		a++;
    202       1.1      fvdl 
    203      1.10        ad 		a->a_type = AT_EUID;
    204      1.10        ad 		if (vap->va_mode & S_ISUID)
    205      1.10        ad 			a->a_v = vap->va_uid;
    206      1.10        ad 		else
    207      1.10        ad 			a->a_v = kauth_cred_geteuid(l->l_cred);
    208       1.1      fvdl 		a++;
    209       1.1      fvdl 
    210      1.10        ad 		a->a_type = AT_RUID;
    211      1.10        ad 		a->a_v = kauth_cred_getuid(l->l_cred);
    212       1.1      fvdl 		a++;
    213       1.1      fvdl 
    214      1.10        ad 		a->a_type = AT_EGID;
    215      1.10        ad 		if (vap->va_mode & S_ISGID)
    216      1.10        ad 			a->a_v = vap->va_gid;
    217      1.10        ad 		else
    218      1.10        ad 			a->a_v = kauth_cred_getegid(l->l_cred);
    219       1.1      fvdl 		a++;
    220       1.1      fvdl 
    221      1.10        ad 		a->a_type = AT_RGID;
    222      1.10        ad 		a->a_v = kauth_cred_getgid(l->l_cred);
    223       1.1      fvdl 		a++;
    224       1.1      fvdl 
    225      1.36     joerg 		a->a_type = AT_STACKBASE;
    226      1.36     joerg 		a->a_v = l->l_proc->p_stackbase;
    227      1.36     joerg 		a++;
    228      1.36     joerg 
    229      1.10        ad 		if (pack->ep_path) {
    230      1.10        ad 			execname = a;
    231      1.10        ad 			a->a_type = AT_SUN_EXECNAME;
    232      1.10        ad 			a++;
    233      1.10        ad 		}
    234      1.10        ad 
    235      1.35      matt 		exec_free_emul_arg(pack);
    236       1.1      fvdl 	}
    237      1.10        ad 
    238      1.10        ad 	a->a_type = AT_NULL;
    239      1.10        ad 	a->a_v = 0;
    240      1.10        ad 	a++;
    241      1.10        ad 
    242      1.36     joerg 	vlen = (a - ai) * sizeof(ai[0]);
    243      1.36     joerg 
    244      1.36     joerg 	KASSERT(vlen <= sizeof(ai));
    245      1.10        ad 
    246      1.10        ad 	if (execname) {
    247      1.10        ad 		char *path = pack->ep_path;
    248      1.10        ad 		execname->a_v = (uintptr_t)(*stackp + vlen);
    249      1.10        ad 		len = strlen(path) + 1;
    250      1.10        ad 		if ((error = copyout(path, (*stackp + vlen), len)) != 0)
    251      1.10        ad 			return error;
    252      1.10        ad 		len = ALIGN(len);
    253      1.10        ad 	} else
    254      1.10        ad 		len = 0;
    255      1.10        ad 
    256      1.10        ad 	if ((error = copyout(ai, *stackp, vlen)) != 0)
    257      1.10        ad 		return error;
    258      1.10        ad 	*stackp += vlen + len;
    259      1.10        ad 
    260      1.10        ad 	return 0;
    261       1.1      fvdl }
    262       1.1      fvdl 
    263       1.1      fvdl /*
    264       1.1      fvdl  * elf_check_header():
    265       1.1      fvdl  *
    266      1.46    martin  * Check header for validity; return 0 if ok, ENOEXEC if error
    267       1.1      fvdl  */
    268       1.1      fvdl int
    269      1.56      maxv elf_check_header(Elf_Ehdr *eh)
    270       1.1      fvdl {
    271       1.3   thorpej 
    272      1.10        ad 	if (memcmp(eh->e_ident, ELFMAG, SELFMAG) != 0 ||
    273  1.85.2.1  pgoyette 	    eh->e_ident[EI_CLASS] != ELFCLASS) {
    274  1.85.2.1  pgoyette 		DPRINTF("bad magic %#x%x%x", eh->e_ident[0], eh->e_ident[1],
    275  1.85.2.1  pgoyette 		    eh->e_ident[2]);
    276       1.1      fvdl 		return ENOEXEC;
    277  1.85.2.1  pgoyette 	}
    278       1.1      fvdl 
    279       1.1      fvdl 	switch (eh->e_machine) {
    280      1.10        ad 
    281      1.10        ad 	ELFDEFNNAME(MACHDEP_ID_CASES)
    282       1.1      fvdl 
    283       1.1      fvdl 	default:
    284  1.85.2.1  pgoyette 		DPRINTF("bad machine %#x", eh->e_machine);
    285       1.1      fvdl 		return ENOEXEC;
    286       1.1      fvdl 	}
    287       1.1      fvdl 
    288  1.85.2.1  pgoyette 	if (ELF_EHDR_FLAGS_OK(eh) == 0) {
    289  1.85.2.1  pgoyette 		DPRINTF("bad flags %#x", eh->e_flags);
    290      1.10        ad 		return ENOEXEC;
    291  1.85.2.1  pgoyette 	}
    292      1.10        ad 
    293  1.85.2.1  pgoyette 	if (eh->e_shnum > ELF_MAXSHNUM || eh->e_phnum > ELF_MAXPHNUM) {
    294  1.85.2.1  pgoyette 		DPRINTF("bad shnum/phnum %#x/%#x", eh->e_shnum, eh->e_phnum);
    295      1.10        ad 		return ENOEXEC;
    296  1.85.2.1  pgoyette 	}
    297      1.10        ad 
    298       1.1      fvdl 	return 0;
    299       1.1      fvdl }
    300       1.1      fvdl 
    301       1.1      fvdl /*
    302       1.1      fvdl  * elf_load_psection():
    303      1.10        ad  *
    304       1.1      fvdl  * Load a psection at the appropriate address
    305       1.1      fvdl  */
    306      1.58      maxv static void
    307      1.10        ad elf_load_psection(struct exec_vmcmd_set *vcset, struct vnode *vp,
    308      1.64      maxv     const Elf_Phdr *ph, Elf_Addr *addr, u_long *size, int flags)
    309       1.1      fvdl {
    310      1.10        ad 	u_long msize, psize, rm, rf;
    311       1.1      fvdl 	long diff, offset;
    312      1.64      maxv 	int vmprot = 0;
    313       1.1      fvdl 
    314       1.1      fvdl 	/*
    315      1.10        ad 	 * If the user specified an address, then we load there.
    316      1.10        ad 	 */
    317      1.10        ad 	if (*addr == ELFDEFNNAME(NO_ADDR))
    318      1.10        ad 		*addr = ph->p_vaddr;
    319      1.10        ad 
    320      1.10        ad 	if (ph->p_align > 1) {
    321      1.10        ad 		/*
    322      1.10        ad 		 * Make sure we are virtually aligned as we are supposed to be.
    323      1.10        ad 		 */
    324      1.10        ad 		diff = ph->p_vaddr - ELF_TRUNC(ph->p_vaddr, ph->p_align);
    325      1.10        ad 		KASSERT(*addr - diff == ELF_TRUNC(*addr, ph->p_align));
    326      1.10        ad 		/*
    327      1.10        ad 		 * But make sure to not map any pages before the start of the
    328      1.10        ad 		 * psection by limiting the difference to within a page.
    329      1.10        ad 		 */
    330      1.10        ad 		diff &= PAGE_MASK;
    331      1.10        ad 	} else
    332      1.10        ad 		diff = 0;
    333       1.1      fvdl 
    334      1.64      maxv 	vmprot |= (ph->p_flags & PF_R) ? VM_PROT_READ : 0;
    335      1.64      maxv 	vmprot |= (ph->p_flags & PF_W) ? VM_PROT_WRITE : 0;
    336      1.64      maxv 	vmprot |= (ph->p_flags & PF_X) ? VM_PROT_EXECUTE : 0;
    337       1.1      fvdl 
    338      1.10        ad 	/*
    339      1.10        ad 	 * Adjust everything so it all starts on a page boundary.
    340      1.10        ad 	 */
    341      1.10        ad 	*addr -= diff;
    342       1.1      fvdl 	offset = ph->p_offset - diff;
    343       1.1      fvdl 	*size = ph->p_filesz + diff;
    344       1.1      fvdl 	msize = ph->p_memsz + diff;
    345       1.1      fvdl 
    346      1.10        ad 	if (ph->p_align >= PAGE_SIZE) {
    347      1.10        ad 		if ((ph->p_flags & PF_W) != 0) {
    348      1.10        ad 			/*
    349      1.10        ad 			 * Because the pagedvn pager can't handle zero fill
    350      1.10        ad 			 * of the last data page if it's not page aligned we
    351      1.10        ad 			 * map the last page readvn.
    352      1.10        ad 			 */
    353      1.10        ad 			psize = trunc_page(*size);
    354      1.10        ad 		} else {
    355      1.10        ad 			psize = round_page(*size);
    356      1.10        ad 		}
    357      1.10        ad 	} else {
    358      1.10        ad 		psize = *size;
    359      1.10        ad 	}
    360      1.10        ad 
    361      1.10        ad 	if (psize > 0) {
    362      1.10        ad 		NEW_VMCMD2(vcset, ph->p_align < PAGE_SIZE ?
    363      1.10        ad 		    vmcmd_map_readvn : vmcmd_map_pagedvn, psize, *addr, vp,
    364      1.64      maxv 		    offset, vmprot, flags);
    365      1.10        ad 		flags &= VMCMD_RELATIVE;
    366      1.10        ad 	}
    367      1.10        ad 	if (psize < *size) {
    368      1.10        ad 		NEW_VMCMD2(vcset, vmcmd_map_readvn, *size - psize,
    369      1.64      maxv 		    *addr + psize, vp, offset + psize, vmprot, flags);
    370      1.10        ad 	}
    371       1.1      fvdl 
    372       1.1      fvdl 	/*
    373      1.10        ad 	 * Check if we need to extend the size of the segment (does
    374      1.10        ad 	 * bss extend page the next page boundary)?
    375      1.10        ad 	 */
    376       1.1      fvdl 	rm = round_page(*addr + msize);
    377       1.1      fvdl 	rf = round_page(*addr + *size);
    378       1.1      fvdl 
    379       1.1      fvdl 	if (rm != rf) {
    380      1.10        ad 		NEW_VMCMD2(vcset, vmcmd_map_zero, rm - rf, rf, NULLVP,
    381      1.64      maxv 		    0, vmprot, flags & VMCMD_RELATIVE);
    382       1.1      fvdl 		*size = msize;
    383       1.1      fvdl 	}
    384       1.1      fvdl }
    385       1.1      fvdl 
    386       1.1      fvdl /*
    387      1.65      maxv  * elf_load_interp():
    388       1.1      fvdl  *
    389      1.65      maxv  * Load an interpreter pointed to by path.
    390       1.1      fvdl  */
    391      1.58      maxv static int
    392      1.65      maxv elf_load_interp(struct lwp *l, struct exec_package *epp, char *path,
    393      1.58      maxv     struct exec_vmcmd_set *vcset, u_long *entryoff, Elf_Addr *last)
    394       1.1      fvdl {
    395       1.1      fvdl 	int error, i;
    396      1.10        ad 	struct vnode *vp;
    397      1.10        ad 	struct vattr attr;
    398      1.10        ad 	Elf_Ehdr eh;
    399      1.10        ad 	Elf_Phdr *ph = NULL;
    400      1.10        ad 	const Elf_Phdr *base_ph;
    401      1.10        ad 	const Elf_Phdr *last_ph;
    402       1.1      fvdl 	u_long phsize;
    403      1.10        ad 	Elf_Addr addr = *last;
    404      1.10        ad 	struct proc *p;
    405      1.37    martin 	bool use_topdown;
    406      1.10        ad 
    407      1.10        ad 	p = l->l_proc;
    408      1.10        ad 
    409      1.38    martin 	KASSERT(p->p_vmspace);
    410      1.81    martin 	KASSERT(p->p_vmspace != proc0.p_vmspace);
    411      1.81    martin 
    412      1.54  christos #ifdef __USE_TOPDOWN_VM
    413      1.81    martin 	use_topdown = epp->ep_flags & EXEC_TOPDOWN_VM;
    414      1.37    martin #else
    415      1.81    martin 	use_topdown = false;
    416      1.37    martin #endif
    417      1.37    martin 
    418      1.10        ad 	/*
    419      1.10        ad 	 * 1. open file
    420      1.10        ad 	 * 2. read filehdr
    421      1.10        ad 	 * 3. map text, data, and bss out of it using VM_*
    422      1.10        ad 	 */
    423      1.10        ad 	vp = epp->ep_interp;
    424      1.10        ad 	if (vp == NULL) {
    425      1.10        ad 		error = emul_find_interp(l, epp, path);
    426      1.10        ad 		if (error != 0)
    427      1.10        ad 			return error;
    428      1.10        ad 		vp = epp->ep_interp;
    429      1.10        ad 	}
    430      1.10        ad 	/* We'll tidy this ourselves - otherwise we have locking issues */
    431      1.10        ad 	epp->ep_interp = NULL;
    432      1.10        ad 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
    433       1.1      fvdl 
    434       1.1      fvdl 	/*
    435      1.10        ad 	 * Similarly, if it's not marked as executable, or it's not a regular
    436      1.10        ad 	 * file, we don't allow it to be used.
    437      1.10        ad 	 */
    438      1.10        ad 	if (vp->v_type != VREG) {
    439      1.10        ad 		error = EACCES;
    440      1.10        ad 		goto badunlock;
    441      1.10        ad 	}
    442      1.10        ad 	if ((error = VOP_ACCESS(vp, VEXEC, l->l_cred)) != 0)
    443      1.10        ad 		goto badunlock;
    444      1.10        ad 
    445      1.10        ad 	/* get attributes */
    446      1.10        ad 	if ((error = VOP_GETATTR(vp, &attr, l->l_cred)) != 0)
    447      1.10        ad 		goto badunlock;
    448      1.10        ad 
    449      1.10        ad 	/*
    450      1.10        ad 	 * Check mount point.  Though we're not trying to exec this binary,
    451      1.10        ad 	 * we will be executing code from it, so if the mount point
    452      1.10        ad 	 * disallows execution or set-id-ness, we punt or kill the set-id.
    453      1.10        ad 	 */
    454      1.10        ad 	if (vp->v_mount->mnt_flag & MNT_NOEXEC) {
    455      1.10        ad 		error = EACCES;
    456      1.10        ad 		goto badunlock;
    457       1.1      fvdl 	}
    458      1.10        ad 	if (vp->v_mount->mnt_flag & MNT_NOSUID)
    459      1.10        ad 		epp->ep_vap->va_mode &= ~(S_ISUID | S_ISGID);
    460      1.10        ad 
    461      1.10        ad 	error = vn_marktext(vp);
    462      1.10        ad 	if (error)
    463      1.10        ad 		goto badunlock;
    464      1.10        ad 
    465      1.23   hannken 	VOP_UNLOCK(vp);
    466      1.10        ad 
    467      1.10        ad 	if ((error = exec_read_from(l, vp, 0, &eh, sizeof(eh))) != 0)
    468      1.10        ad 		goto bad;
    469      1.10        ad 
    470      1.56      maxv 	if ((error = elf_check_header(&eh)) != 0)
    471       1.1      fvdl 		goto bad;
    472      1.56      maxv 	if (eh.e_type != ET_DYN || eh.e_phnum == 0) {
    473  1.85.2.1  pgoyette 		DPRINTF("bad interpreter type %#x", eh.e_type);
    474      1.10        ad 		error = ENOEXEC;
    475       1.1      fvdl 		goto bad;
    476      1.10        ad 	}
    477       1.1      fvdl 
    478      1.10        ad 	phsize = eh.e_phnum * sizeof(Elf_Phdr);
    479      1.10        ad 	ph = kmem_alloc(phsize, KM_SLEEP);
    480       1.1      fvdl 
    481      1.10        ad 	if ((error = exec_read_from(l, vp, eh.e_phoff, ph, phsize)) != 0)
    482       1.1      fvdl 		goto bad;
    483       1.1      fvdl 
    484      1.10        ad #ifdef ELF_INTERP_NON_RELOCATABLE
    485      1.10        ad 	/*
    486      1.10        ad 	 * Evil hack:  Only MIPS should be non-relocatable, and the
    487      1.10        ad 	 * psections should have a high address (typically 0x5ffe0000).
    488      1.10        ad 	 * If it's now relocatable, it should be linked at 0 and the
    489      1.10        ad 	 * psections should have zeros in the upper part of the address.
    490      1.10        ad 	 * Otherwise, force the load at the linked address.
    491      1.10        ad 	 */
    492      1.10        ad 	if (*last == ELF_LINK_ADDR && (ph->p_vaddr & 0xffff0000) == 0)
    493      1.10        ad 		*last = ELFDEFNNAME(NO_ADDR);
    494      1.10        ad #endif
    495      1.10        ad 
    496      1.10        ad 	/*
    497      1.10        ad 	 * If no position to load the interpreter was set by a probe
    498      1.10        ad 	 * function, pick the same address that a non-fixed mmap(0, ..)
    499      1.10        ad 	 * would (i.e. something safely out of the way).
    500      1.10        ad 	 */
    501      1.10        ad 	if (*last == ELFDEFNNAME(NO_ADDR)) {
    502      1.10        ad 		u_long limit = 0;
    503      1.10        ad 		/*
    504      1.10        ad 		 * Find the start and ending addresses of the psections to
    505      1.10        ad 		 * be loaded.  This will give us the size.
    506      1.10        ad 		 */
    507      1.58      maxv 		for (i = 0, base_ph = NULL; i < eh.e_phnum; i++) {
    508      1.58      maxv 			if (ph[i].p_type == PT_LOAD) {
    509      1.58      maxv 				u_long psize = ph[i].p_vaddr + ph[i].p_memsz;
    510      1.10        ad 				if (base_ph == NULL)
    511      1.58      maxv 					base_ph = &ph[i];
    512      1.10        ad 				if (psize > limit)
    513      1.10        ad 					limit = psize;
    514      1.10        ad 			}
    515      1.10        ad 		}
    516      1.10        ad 
    517      1.10        ad 		if (base_ph == NULL) {
    518  1.85.2.1  pgoyette 			DPRINTF("no interpreter loadable sections");
    519      1.10        ad 			error = ENOEXEC;
    520      1.10        ad 			goto bad;
    521      1.10        ad 		}
    522      1.10        ad 
    523      1.10        ad 		/*
    524      1.10        ad 		 * Now compute the size and load address.
    525      1.10        ad 		 */
    526      1.10        ad 		addr = (*epp->ep_esch->es_emul->e_vm_default_addr)(p,
    527      1.10        ad 		    epp->ep_daddr,
    528      1.81    martin 		    round_page(limit) - trunc_page(base_ph->p_vaddr),
    529      1.81    martin 		    use_topdown);
    530      1.85  christos 		addr += (Elf_Addr)pax_aslr_rtld_offset(epp, base_ph->p_align,
    531      1.85  christos 		    use_topdown);
    532      1.81    martin 	} else {
    533      1.10        ad 		addr = *last; /* may be ELF_LINK_ADDR */
    534      1.81    martin 	}
    535      1.10        ad 
    536       1.1      fvdl 	/*
    537      1.10        ad 	 * Load all the necessary sections
    538      1.10        ad 	 */
    539      1.58      maxv 	for (i = 0, base_ph = NULL, last_ph = NULL; i < eh.e_phnum; i++) {
    540      1.58      maxv 		switch (ph[i].p_type) {
    541      1.10        ad 		case PT_LOAD: {
    542      1.10        ad 			u_long size;
    543      1.10        ad 			int flags;
    544      1.10        ad 
    545      1.10        ad 			if (base_ph == NULL) {
    546      1.10        ad 				/*
    547      1.10        ad 				 * First encountered psection is always the
    548      1.10        ad 				 * base psection.  Make sure it's aligned
    549      1.10        ad 				 * properly (align down for topdown and align
    550      1.10        ad 				 * upwards for not topdown).
    551      1.10        ad 				 */
    552      1.58      maxv 				base_ph = &ph[i];
    553      1.10        ad 				flags = VMCMD_BASE;
    554      1.10        ad 				if (addr == ELF_LINK_ADDR)
    555      1.58      maxv 					addr = ph[i].p_vaddr;
    556      1.37    martin 				if (use_topdown)
    557      1.58      maxv 					addr = ELF_TRUNC(addr, ph[i].p_align);
    558      1.10        ad 				else
    559      1.58      maxv 					addr = ELF_ROUND(addr, ph[i].p_align);
    560      1.10        ad 			} else {
    561      1.10        ad 				u_long limit = round_page(last_ph->p_vaddr
    562      1.10        ad 				    + last_ph->p_memsz);
    563      1.58      maxv 				u_long base = trunc_page(ph[i].p_vaddr);
    564      1.10        ad 
    565      1.10        ad 				/*
    566      1.10        ad 				 * If there is a gap in between the psections,
    567      1.10        ad 				 * map it as inaccessible so nothing else
    568      1.10        ad 				 * mmap'ed will be placed there.
    569      1.10        ad 				 */
    570      1.10        ad 				if (limit != base) {
    571      1.10        ad 					NEW_VMCMD2(vcset, vmcmd_map_zero,
    572      1.10        ad 					    base - limit,
    573      1.10        ad 					    limit - base_ph->p_vaddr, NULLVP,
    574      1.10        ad 					    0, VM_PROT_NONE, VMCMD_RELATIVE);
    575      1.10        ad 				}
    576       1.1      fvdl 
    577      1.58      maxv 				addr = ph[i].p_vaddr - base_ph->p_vaddr;
    578      1.10        ad 				flags = VMCMD_RELATIVE;
    579      1.10        ad 			}
    580      1.58      maxv 			last_ph = &ph[i];
    581      1.10        ad 			elf_load_psection(vcset, vp, &ph[i], &addr,
    582      1.64      maxv 			    &size, flags);
    583      1.10        ad 			/*
    584      1.10        ad 			 * If entry is within this psection then this
    585      1.10        ad 			 * must contain the .text section.  *entryoff is
    586      1.10        ad 			 * relative to the base psection.
    587      1.10        ad 			 */
    588      1.58      maxv 			if (eh.e_entry >= ph[i].p_vaddr &&
    589      1.58      maxv 			    eh.e_entry < (ph[i].p_vaddr + size)) {
    590      1.10        ad 				*entryoff = eh.e_entry - base_ph->p_vaddr;
    591       1.1      fvdl 			}
    592       1.1      fvdl 			addr += size;
    593       1.1      fvdl 			break;
    594      1.10        ad 		}
    595       1.1      fvdl 
    596       1.1      fvdl 		default:
    597       1.1      fvdl 			break;
    598       1.1      fvdl 		}
    599       1.1      fvdl 	}
    600       1.1      fvdl 
    601      1.10        ad 	kmem_free(ph, phsize);
    602      1.10        ad 	/*
    603      1.10        ad 	 * This value is ignored if TOPDOWN.
    604      1.10        ad 	 */
    605      1.10        ad 	*last = addr;
    606      1.10        ad 	vrele(vp);
    607      1.10        ad 	return 0;
    608      1.10        ad 
    609      1.10        ad badunlock:
    610      1.23   hannken 	VOP_UNLOCK(vp);
    611      1.10        ad 
    612       1.1      fvdl bad:
    613       1.1      fvdl 	if (ph != NULL)
    614      1.10        ad 		kmem_free(ph, phsize);
    615      1.10        ad 	vrele(vp);
    616       1.1      fvdl 	return error;
    617       1.1      fvdl }
    618       1.1      fvdl 
    619       1.1      fvdl /*
    620       1.1      fvdl  * exec_elf_makecmds(): Prepare an Elf binary's exec package
    621       1.1      fvdl  *
    622       1.1      fvdl  * First, set of the various offsets/lengths in the exec package.
    623       1.1      fvdl  *
    624       1.1      fvdl  * Then, mark the text image busy (so it can be demand paged) or error
    625       1.1      fvdl  * out if this is not possible.  Finally, set up vmcmds for the
    626       1.1      fvdl  * text, data, bss, and stack segments.
    627       1.1      fvdl  */
    628       1.1      fvdl int
    629      1.10        ad exec_elf_makecmds(struct lwp *l, struct exec_package *epp)
    630      1.10        ad {
    631      1.10        ad 	Elf_Ehdr *eh = epp->ep_hdr;
    632      1.10        ad 	Elf_Phdr *ph, *pp;
    633      1.26       chs 	Elf_Addr phdr = 0, computed_phdr = 0, pos = 0, end_text = 0;
    634      1.58      maxv 	int error, i;
    635      1.10        ad 	char *interp = NULL;
    636      1.10        ad 	u_long phsize;
    637      1.65      maxv 	struct elf_args *ap;
    638      1.56      maxv 	bool is_dyn = false;
    639       1.1      fvdl 
    640  1.85.2.1  pgoyette 	if (epp->ep_hdrvalid < sizeof(Elf_Ehdr)) {
    641  1.85.2.1  pgoyette 		DPRINTF("small header %#x", epp->ep_hdrvalid);
    642       1.1      fvdl 		return ENOEXEC;
    643  1.85.2.1  pgoyette 	}
    644      1.56      maxv 	if ((error = elf_check_header(eh)) != 0)
    645      1.56      maxv 		return error;
    646       1.1      fvdl 
    647      1.56      maxv 	if (eh->e_type == ET_DYN)
    648      1.76      maxv 		/* PIE, and some libs have an entry point */
    649      1.56      maxv 		is_dyn = true;
    650  1.85.2.1  pgoyette 	else if (eh->e_type != ET_EXEC) {
    651  1.85.2.1  pgoyette 		DPRINTF("bad type %#x", eh->e_type);
    652       1.1      fvdl 		return ENOEXEC;
    653  1.85.2.1  pgoyette 	}
    654       1.1      fvdl 
    655  1.85.2.1  pgoyette 	if (eh->e_phnum == 0) {
    656  1.85.2.1  pgoyette 		DPRINTF("no program headers");
    657      1.10        ad 		return ENOEXEC;
    658  1.85.2.1  pgoyette 	}
    659      1.10        ad 
    660      1.10        ad 	error = vn_marktext(epp->ep_vp);
    661      1.10        ad 	if (error)
    662      1.10        ad 		return error;
    663      1.10        ad 
    664       1.1      fvdl 	/*
    665      1.10        ad 	 * Allocate space to hold all the program headers, and read them
    666      1.10        ad 	 * from the file
    667      1.10        ad 	 */
    668      1.10        ad 	phsize = eh->e_phnum * sizeof(Elf_Phdr);
    669      1.10        ad 	ph = kmem_alloc(phsize, KM_SLEEP);
    670       1.1      fvdl 
    671      1.10        ad 	if ((error = exec_read_from(l, epp->ep_vp, eh->e_phoff, ph, phsize)) !=
    672      1.10        ad 	    0)
    673       1.1      fvdl 		goto bad;
    674       1.1      fvdl 
    675      1.10        ad 	epp->ep_taddr = epp->ep_tsize = ELFDEFNNAME(NO_ADDR);
    676      1.10        ad 	epp->ep_daddr = epp->ep_dsize = ELFDEFNNAME(NO_ADDR);
    677       1.1      fvdl 
    678       1.1      fvdl 	for (i = 0; i < eh->e_phnum; i++) {
    679       1.1      fvdl 		pp = &ph[i];
    680      1.10        ad 		if (pp->p_type == PT_INTERP) {
    681      1.52  christos 			if (pp->p_filesz < 2 || pp->p_filesz > MAXPATHLEN) {
    682  1.85.2.1  pgoyette 				DPRINTF("bad interpreter namelen %#jx",
    683  1.85.2.1  pgoyette 				    (uintmax_t)pp->p_filesz);
    684      1.10        ad 				error = ENOEXEC;
    685       1.1      fvdl 				goto bad;
    686      1.10        ad 			}
    687      1.10        ad 			interp = PNBUF_GET();
    688      1.53     skrll 			if ((error = exec_read_from(l, epp->ep_vp,
    689      1.53     skrll 			    pp->p_offset, interp, pp->p_filesz)) != 0)
    690      1.53     skrll 				goto bad;
    691      1.52  christos 			/* Ensure interp is NUL-terminated and of the expected length */
    692      1.52  christos 			if (strnlen(interp, pp->p_filesz) != pp->p_filesz - 1) {
    693  1.85.2.1  pgoyette 				DPRINTF("bad interpreter name");
    694      1.52  christos 				error = ENOEXEC;
    695      1.52  christos 				goto bad;
    696      1.52  christos 			}
    697       1.1      fvdl 			break;
    698       1.1      fvdl 		}
    699       1.1      fvdl 	}
    700       1.1      fvdl 
    701       1.1      fvdl 	/*
    702       1.1      fvdl 	 * On the same architecture, we may be emulating different systems.
    703      1.10        ad 	 * See which one will accept this executable.
    704       1.1      fvdl 	 *
    705       1.1      fvdl 	 * Probe functions would normally see if the interpreter (if any)
    706       1.1      fvdl 	 * exists. Emulation packages may possibly replace the interpreter in
    707      1.74      maxv 	 * interp with a changed path (/emul/xxx/<path>).
    708       1.1      fvdl 	 */
    709      1.10        ad 	pos = ELFDEFNNAME(NO_ADDR);
    710      1.10        ad 	if (epp->ep_esch->u.elf_probe_func) {
    711      1.10        ad 		vaddr_t startp = (vaddr_t)pos;
    712       1.1      fvdl 
    713      1.10        ad 		error = (*epp->ep_esch->u.elf_probe_func)(l, epp, eh, interp,
    714      1.10        ad 							  &startp);
    715       1.1      fvdl 		if (error)
    716       1.1      fvdl 			goto bad;
    717      1.10        ad 		pos = (Elf_Addr)startp;
    718       1.1      fvdl 	}
    719       1.1      fvdl 
    720      1.13  drochner 	if (is_dyn)
    721      1.77      maxv 		elf_placedynexec(epp, eh, ph);
    722      1.10        ad 
    723       1.1      fvdl 	/*
    724      1.10        ad 	 * Load all the necessary sections
    725      1.10        ad 	 */
    726      1.58      maxv 	for (i = 0; i < eh->e_phnum; i++) {
    727      1.58      maxv 		Elf_Addr addr = ELFDEFNNAME(NO_ADDR);
    728      1.10        ad 		u_long size = 0;
    729       1.1      fvdl 
    730       1.1      fvdl 		switch (ph[i].p_type) {
    731      1.10        ad 		case PT_LOAD:
    732       1.1      fvdl 			elf_load_psection(&epp->ep_vmcmds, epp->ep_vp,
    733      1.64      maxv 			    &ph[i], &addr, &size, VMCMD_FIXED);
    734      1.10        ad 
    735       1.4      fvdl 			/*
    736      1.24     joerg 			 * Consider this as text segment, if it is executable.
    737      1.24     joerg 			 * If there is more than one text segment, pick the
    738      1.24     joerg 			 * largest.
    739       1.4      fvdl 			 */
    740      1.24     joerg 			if (ph[i].p_flags & PF_X) {
    741      1.24     joerg 				if (epp->ep_taddr == ELFDEFNNAME(NO_ADDR) ||
    742      1.24     joerg 				    size > epp->ep_tsize) {
    743      1.24     joerg 					epp->ep_taddr = addr;
    744      1.24     joerg 					epp->ep_tsize = size;
    745      1.10        ad 				}
    746      1.25     joerg 				end_text = addr + size;
    747       1.4      fvdl 			} else {
    748       1.4      fvdl 				epp->ep_daddr = addr;
    749       1.4      fvdl 				epp->ep_dsize = size;
    750       1.4      fvdl 			}
    751      1.26       chs 			if (ph[i].p_offset == 0) {
    752      1.26       chs 				computed_phdr = ph[i].p_vaddr + eh->e_phoff;
    753      1.26       chs 			}
    754       1.1      fvdl 			break;
    755       1.1      fvdl 
    756      1.10        ad 		case PT_SHLIB:
    757      1.10        ad 			/* SCO has these sections. */
    758      1.10        ad 		case PT_INTERP:
    759      1.10        ad 			/* Already did this one. */
    760      1.10        ad 		case PT_DYNAMIC:
    761      1.10        ad 		case PT_NOTE:
    762       1.1      fvdl 			break;
    763      1.10        ad 		case PT_PHDR:
    764       1.4      fvdl 			/* Note address of program headers (in text segment) */
    765      1.58      maxv 			phdr = ph[i].p_vaddr;
    766       1.7  christos 			break;
    767       1.4      fvdl 
    768       1.1      fvdl 		default:
    769       1.1      fvdl 			/*
    770      1.10        ad 			 * Not fatal; we don't need to understand everything.
    771       1.1      fvdl 			 */
    772       1.1      fvdl 			break;
    773       1.1      fvdl 		}
    774       1.1      fvdl 	}
    775      1.59      maxv 
    776      1.68      maxv 	if (epp->ep_vmcmds.evs_used == 0) {
    777      1.59      maxv 		/* No VMCMD; there was no PT_LOAD section, or those
    778      1.59      maxv 		 * sections were empty */
    779  1.85.2.1  pgoyette 		DPRINTF("no vmcommands");
    780      1.59      maxv 		error = ENOEXEC;
    781      1.59      maxv 		goto bad;
    782      1.59      maxv 	}
    783      1.59      maxv 
    784      1.24     joerg 	if (epp->ep_daddr == ELFDEFNNAME(NO_ADDR)) {
    785      1.27       chs 		epp->ep_daddr = round_page(end_text);
    786      1.25     joerg 		epp->ep_dsize = 0;
    787      1.24     joerg 	}
    788      1.24     joerg 
    789       1.5      fvdl 	/*
    790      1.10        ad 	 * Check if we found a dynamically linked binary and arrange to load
    791      1.10        ad 	 * its interpreter
    792       1.5      fvdl 	 */
    793      1.10        ad 	if (interp) {
    794      1.65      maxv 		u_int nused = epp->ep_vmcmds.evs_used;
    795      1.57  christos 		u_long interp_offset = 0;
    796       1.1      fvdl 
    797      1.65      maxv 		if ((error = elf_load_interp(l, epp, interp,
    798      1.58      maxv 		    &epp->ep_vmcmds, &interp_offset, &pos)) != 0) {
    799       1.1      fvdl 			goto bad;
    800       1.1      fvdl 		}
    801      1.59      maxv 		if (epp->ep_vmcmds.evs_used == nused) {
    802      1.65      maxv 			/* elf_load_interp() has not set up any new VMCMD */
    803  1.85.2.1  pgoyette 			DPRINTF("no vmcommands for interpreter");
    804      1.59      maxv 			error = ENOEXEC;
    805      1.59      maxv 			goto bad;
    806      1.59      maxv 		}
    807      1.59      maxv 
    808      1.65      maxv 		ap = kmem_alloc(sizeof(*ap), KM_SLEEP);
    809      1.59      maxv 		ap->arg_interp = epp->ep_vmcmds.evs_cmds[nused].ev_addr;
    810      1.63      matt 		epp->ep_entryoffset = interp_offset;
    811      1.10        ad 		epp->ep_entry = ap->arg_interp + interp_offset;
    812      1.26       chs 		PNBUF_PUT(interp);
    813      1.78      maxv 		interp = NULL;
    814      1.65      maxv 	} else {
    815      1.26       chs 		epp->ep_entry = eh->e_entry;
    816      1.65      maxv 		if (epp->ep_flags & EXEC_FORCEAUX) {
    817      1.65      maxv 			ap = kmem_alloc(sizeof(*ap), KM_SLEEP);
    818      1.65      maxv 			ap->arg_interp = (vaddr_t)NULL;
    819      1.65      maxv 		} else
    820      1.65      maxv 			ap = NULL;
    821      1.65      maxv 	}
    822       1.1      fvdl 
    823      1.26       chs 	if (ap) {
    824      1.26       chs 		ap->arg_phaddr = phdr ? phdr : computed_phdr;
    825       1.1      fvdl 		ap->arg_phentsize = eh->e_phentsize;
    826       1.1      fvdl 		ap->arg_phnum = eh->e_phnum;
    827       1.1      fvdl 		ap->arg_entry = eh->e_entry;
    828       1.1      fvdl 		epp->ep_emul_arg = ap;
    829      1.35      matt 		epp->ep_emul_arg_free = elf_free_emul_arg;
    830      1.26       chs 	}
    831       1.1      fvdl 
    832       1.8  christos #ifdef ELF_MAP_PAGE_ZERO
    833       1.8  christos 	/* Dell SVR4 maps page zero, yeuch! */
    834      1.10        ad 	NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn, PAGE_SIZE, 0,
    835      1.10        ad 	    epp->ep_vp, 0, VM_PROT_READ);
    836       1.8  christos #endif
    837      1.78      maxv 
    838      1.78      maxv 	error = (*epp->ep_esch->es_setup_stack)(l, epp);
    839      1.78      maxv 	if (error)
    840      1.78      maxv 		goto bad;
    841      1.78      maxv 
    842      1.10        ad 	kmem_free(ph, phsize);
    843      1.78      maxv 	return 0;
    844       1.1      fvdl 
    845       1.1      fvdl bad:
    846      1.10        ad 	if (interp)
    847      1.10        ad 		PNBUF_PUT(interp);
    848      1.35      matt 	exec_free_emul_arg(epp);
    849      1.10        ad 	kmem_free(ph, phsize);
    850       1.1      fvdl 	kill_vmcmds(&epp->ep_vmcmds);
    851      1.10        ad 	return error;
    852      1.10        ad }
    853      1.10        ad 
    854      1.10        ad int
    855      1.10        ad netbsd_elf_signature(struct lwp *l, struct exec_package *epp,
    856      1.10        ad     Elf_Ehdr *eh)
    857      1.10        ad {
    858      1.10        ad 	size_t i;
    859  1.85.2.2  pgoyette 	Elf_Phdr *ph;
    860  1.85.2.2  pgoyette 	size_t phsize;
    861  1.85.2.2  pgoyette 	char *nbuf;
    862      1.10        ad 	int error;
    863      1.10        ad 	int isnetbsd = 0;
    864      1.10        ad 
    865      1.10        ad 	epp->ep_pax_flags = 0;
    866  1.85.2.2  pgoyette 
    867  1.85.2.2  pgoyette 	if (eh->e_phnum > ELF_MAXPHNUM || eh->e_phnum == 0) {
    868  1.85.2.2  pgoyette 		DPRINTF("no signature %#x", eh->e_phnum);
    869      1.10        ad 		return ENOEXEC;
    870  1.85.2.1  pgoyette 	}
    871      1.10        ad 
    872  1.85.2.2  pgoyette 	phsize = eh->e_phnum * sizeof(Elf_Phdr);
    873  1.85.2.2  pgoyette 	ph = kmem_alloc(phsize, KM_SLEEP);
    874  1.85.2.2  pgoyette 	error = exec_read_from(l, epp->ep_vp, eh->e_phoff, ph, phsize);
    875      1.10        ad 	if (error)
    876      1.10        ad 		goto out;
    877      1.10        ad 
    878  1.85.2.2  pgoyette 	nbuf = kmem_alloc(ELF_MAXNOTESIZE, KM_SLEEP);
    879  1.85.2.2  pgoyette 	for (i = 0; i < eh->e_phnum; i++) {
    880  1.85.2.2  pgoyette 		const char *nptr;
    881  1.85.2.2  pgoyette 		size_t nlen;
    882  1.85.2.2  pgoyette 
    883  1.85.2.2  pgoyette 		if (ph[i].p_type != PT_NOTE ||
    884  1.85.2.2  pgoyette 		    ph[i].p_filesz > ELF_MAXNOTESIZE)
    885      1.10        ad 			continue;
    886      1.10        ad 
    887  1.85.2.2  pgoyette 		nlen = ph[i].p_filesz;
    888  1.85.2.2  pgoyette 		error = exec_read_from(l, epp->ep_vp, ph[i].p_offset,
    889  1.85.2.2  pgoyette 				       nbuf, nlen);
    890      1.10        ad 		if (error)
    891      1.15  christos 			continue;
    892      1.10        ad 
    893  1.85.2.2  pgoyette 		nptr = nbuf;
    894  1.85.2.2  pgoyette 		while (nlen > 0) {
    895  1.85.2.2  pgoyette 			const Elf_Nhdr *np;
    896  1.85.2.2  pgoyette 			const char *ndata, *ndesc;
    897  1.85.2.2  pgoyette 
    898  1.85.2.2  pgoyette 			/* note header */
    899  1.85.2.2  pgoyette 			np = (const Elf_Nhdr *)nptr;
    900  1.85.2.2  pgoyette 			if (nlen < sizeof(*np)) {
    901      1.39  christos 				break;
    902      1.39  christos 			}
    903  1.85.2.2  pgoyette 			nptr += sizeof(*np);
    904  1.85.2.2  pgoyette 			nlen -= sizeof(*np);
    905      1.61      maxv 
    906  1.85.2.2  pgoyette 			/* note name */
    907  1.85.2.2  pgoyette 			ndata = nptr;
    908  1.85.2.2  pgoyette 			if (nlen < roundup(np->n_namesz, 4)) {
    909      1.61      maxv 				break;
    910      1.39  christos 			}
    911  1.85.2.2  pgoyette 			nptr += roundup(np->n_namesz, 4);
    912  1.85.2.2  pgoyette 			nlen -= roundup(np->n_namesz, 4);
    913      1.10        ad 
    914  1.85.2.2  pgoyette 			/* note description */
    915  1.85.2.2  pgoyette 			ndesc = nptr;
    916  1.85.2.2  pgoyette 			if (nlen < roundup(np->n_descsz, 4)) {
    917      1.47      matt 				break;
    918      1.47      matt 			}
    919  1.85.2.2  pgoyette 			nptr += roundup(np->n_descsz, 4);
    920  1.85.2.2  pgoyette 			nlen -= roundup(np->n_descsz, 4);
    921      1.61      maxv 
    922  1.85.2.2  pgoyette 			isnetbsd |= netbsd_elf_note(epp, np, ndata, ndesc);
    923  1.85.2.2  pgoyette 		}
    924  1.85.2.2  pgoyette 	}
    925  1.85.2.2  pgoyette 	kmem_free(nbuf, ELF_MAXNOTESIZE);
    926  1.85.2.2  pgoyette 
    927  1.85.2.2  pgoyette 	error = isnetbsd ? 0 : ENOEXEC;
    928  1.85.2.2  pgoyette #ifdef DEBUG_ELF
    929  1.85.2.2  pgoyette 	if (error)
    930  1.85.2.2  pgoyette 		DPRINTF("not netbsd");
    931  1.85.2.2  pgoyette #endif
    932  1.85.2.2  pgoyette out:
    933  1.85.2.2  pgoyette 	kmem_free(ph, phsize);
    934  1.85.2.2  pgoyette 	return error;
    935  1.85.2.2  pgoyette }
    936  1.85.2.2  pgoyette 
    937  1.85.2.2  pgoyette int
    938  1.85.2.2  pgoyette netbsd_elf_note(struct exec_package *epp,
    939  1.85.2.2  pgoyette 		const Elf_Nhdr *np, const char *ndata, const char *ndesc)
    940  1.85.2.2  pgoyette {
    941  1.85.2.2  pgoyette 	int isnetbsd = 0;
    942  1.85.2.2  pgoyette 
    943  1.85.2.2  pgoyette #ifdef DIAGNOSTIC
    944  1.85.2.2  pgoyette 	const char *badnote;
    945  1.85.2.2  pgoyette #define BADNOTE(n) badnote = (n)
    946  1.85.2.2  pgoyette #else
    947  1.85.2.2  pgoyette #define BADNOTE(n)
    948      1.49    martin #endif
    949  1.85.2.2  pgoyette 
    950  1.85.2.2  pgoyette 	switch (np->n_type) {
    951  1.85.2.2  pgoyette 	case ELF_NOTE_TYPE_NETBSD_TAG:
    952  1.85.2.2  pgoyette 		/* It is us */
    953  1.85.2.2  pgoyette 		if (np->n_namesz == ELF_NOTE_NETBSD_NAMESZ &&
    954  1.85.2.2  pgoyette 		    np->n_descsz == ELF_NOTE_NETBSD_DESCSZ &&
    955  1.85.2.2  pgoyette 		    memcmp(ndata, ELF_NOTE_NETBSD_NAME,
    956  1.85.2.2  pgoyette 		    ELF_NOTE_NETBSD_NAMESZ) == 0) {
    957  1.85.2.2  pgoyette 			memcpy(&epp->ep_osversion, ndesc,
    958  1.85.2.2  pgoyette 			    ELF_NOTE_NETBSD_DESCSZ);
    959  1.85.2.2  pgoyette 			isnetbsd = 1;
    960      1.49    martin 			break;
    961  1.85.2.2  pgoyette 		}
    962      1.47      matt 
    963  1.85.2.2  pgoyette 		/*
    964  1.85.2.2  pgoyette 		 * Ignore SuSE tags; SuSE's n_type is the same the
    965  1.85.2.2  pgoyette 		 * NetBSD one.
    966  1.85.2.2  pgoyette 		 */
    967  1.85.2.2  pgoyette 		if (np->n_namesz == ELF_NOTE_SUSE_NAMESZ &&
    968  1.85.2.2  pgoyette 		    memcmp(ndata, ELF_NOTE_SUSE_NAME,
    969  1.85.2.2  pgoyette 		    ELF_NOTE_SUSE_NAMESZ) == 0)
    970  1.85.2.2  pgoyette 			break;
    971  1.85.2.2  pgoyette 		/*
    972  1.85.2.2  pgoyette 		 * Ignore old GCC
    973  1.85.2.2  pgoyette 		 */
    974  1.85.2.2  pgoyette 		if (np->n_namesz == ELF_NOTE_OGCC_NAMESZ &&
    975  1.85.2.2  pgoyette 		    memcmp(ndata, ELF_NOTE_OGCC_NAME,
    976  1.85.2.2  pgoyette 		    ELF_NOTE_OGCC_NAMESZ) == 0)
    977      1.31  christos 			break;
    978  1.85.2.2  pgoyette 		BADNOTE("NetBSD tag");
    979  1.85.2.2  pgoyette 		goto bad;
    980      1.31  christos 
    981  1.85.2.2  pgoyette 	case ELF_NOTE_TYPE_PAX_TAG:
    982  1.85.2.2  pgoyette 		if (np->n_namesz == ELF_NOTE_PAX_NAMESZ &&
    983  1.85.2.2  pgoyette 		    np->n_descsz == ELF_NOTE_PAX_DESCSZ &&
    984  1.85.2.2  pgoyette 		    memcmp(ndata, ELF_NOTE_PAX_NAME,
    985  1.85.2.2  pgoyette 		    ELF_NOTE_PAX_NAMESZ) == 0) {
    986  1.85.2.2  pgoyette 			uint32_t flags;
    987  1.85.2.2  pgoyette 			memcpy(&flags, ndesc, sizeof(flags));
    988  1.85.2.2  pgoyette 			/* Convert the flags and insert them into
    989  1.85.2.2  pgoyette 			 * the exec package. */
    990  1.85.2.2  pgoyette 			pax_setup_elf_flags(epp, flags);
    991      1.79  christos 			break;
    992  1.85.2.2  pgoyette 		}
    993  1.85.2.2  pgoyette 		BADNOTE("PaX tag");
    994  1.85.2.2  pgoyette 		goto bad;
    995      1.79  christos 
    996  1.85.2.2  pgoyette 	case ELF_NOTE_TYPE_MARCH_TAG:
    997  1.85.2.2  pgoyette 		/* Copy the machine arch into the package. */
    998  1.85.2.2  pgoyette 		if (np->n_namesz == ELF_NOTE_MARCH_NAMESZ
    999  1.85.2.2  pgoyette 		    && memcmp(ndata, ELF_NOTE_MARCH_NAME,
   1000  1.85.2.2  pgoyette 			    ELF_NOTE_MARCH_NAMESZ) == 0) {
   1001  1.85.2.2  pgoyette 			/* Do not truncate the buffer */
   1002  1.85.2.2  pgoyette 			if (np->n_descsz > sizeof(epp->ep_machine_arch)) {
   1003  1.85.2.2  pgoyette 				BADNOTE("description size limit");
   1004  1.85.2.2  pgoyette 				goto bad;
   1005  1.85.2.2  pgoyette 			}
   1006  1.85.2.2  pgoyette 			/*
   1007  1.85.2.2  pgoyette 			 * Ensure ndesc is NUL-terminated and of the
   1008  1.85.2.2  pgoyette 			 * expected length.
   1009  1.85.2.2  pgoyette 			 */
   1010  1.85.2.2  pgoyette 			if (strnlen(ndesc, np->n_descsz) + 1 !=
   1011  1.85.2.2  pgoyette 			    np->n_descsz) {
   1012  1.85.2.2  pgoyette 				BADNOTE("description size");
   1013  1.85.2.2  pgoyette 				goto bad;
   1014  1.85.2.2  pgoyette 			}
   1015  1.85.2.2  pgoyette 			strlcpy(epp->ep_machine_arch, ndesc,
   1016  1.85.2.2  pgoyette 			    sizeof(epp->ep_machine_arch));
   1017  1.85.2.2  pgoyette 			break;
   1018  1.85.2.2  pgoyette 		}
   1019  1.85.2.2  pgoyette 		BADNOTE("march tag");
   1020  1.85.2.2  pgoyette 		goto bad;
   1021  1.85.2.2  pgoyette 
   1022  1.85.2.2  pgoyette 	case ELF_NOTE_TYPE_MCMODEL_TAG:
   1023  1.85.2.2  pgoyette 		/* arch specific check for code model */
   1024  1.85.2.2  pgoyette #ifdef ELF_MD_MCMODEL_CHECK
   1025  1.85.2.2  pgoyette 		if (np->n_namesz == ELF_NOTE_MCMODEL_NAMESZ
   1026  1.85.2.2  pgoyette 		    && memcmp(ndata, ELF_NOTE_MCMODEL_NAME,
   1027  1.85.2.2  pgoyette 			    ELF_NOTE_MCMODEL_NAMESZ) == 0) {
   1028  1.85.2.2  pgoyette 			ELF_MD_MCMODEL_CHECK(epp, ndesc, np->n_descsz);
   1029  1.85.2.2  pgoyette 			break;
   1030  1.85.2.2  pgoyette 		}
   1031  1.85.2.2  pgoyette 		BADNOTE("mcmodel tag");
   1032  1.85.2.2  pgoyette 		goto bad;
   1033  1.85.2.2  pgoyette #endif
   1034  1.85.2.2  pgoyette 		break;
   1035  1.85.2.2  pgoyette 
   1036  1.85.2.2  pgoyette 	case ELF_NOTE_TYPE_SUSE_VERSION_TAG:
   1037  1.85.2.2  pgoyette 		break;
   1038  1.85.2.2  pgoyette 
   1039  1.85.2.2  pgoyette 	case ELF_NOTE_TYPE_GO_BUILDID_TAG:
   1040  1.85.2.2  pgoyette 		break;
   1041  1.85.2.2  pgoyette 
   1042  1.85.2.2  pgoyette 	default:
   1043  1.85.2.2  pgoyette 		BADNOTE("unknown tag");
   1044      1.61      maxv bad:
   1045      1.15  christos #ifdef DIAGNOSTIC
   1046  1.85.2.2  pgoyette 		/* Ignore GNU tags */
   1047  1.85.2.2  pgoyette 		if (np->n_namesz == ELF_NOTE_GNU_NAMESZ &&
   1048  1.85.2.2  pgoyette 		    memcmp(ndata, ELF_NOTE_GNU_NAME,
   1049  1.85.2.2  pgoyette 		    ELF_NOTE_GNU_NAMESZ) == 0)
   1050  1.85.2.2  pgoyette 		    break;
   1051  1.85.2.2  pgoyette 
   1052  1.85.2.2  pgoyette 		int ns = (int)np->n_namesz;
   1053  1.85.2.2  pgoyette 		printf("%s: Unknown elf note type %d (%s): "
   1054  1.85.2.2  pgoyette 		    "[namesz=%d, descsz=%d name=%-*.*s]\n",
   1055  1.85.2.2  pgoyette 		    epp->ep_kname, np->n_type, badnote, np->n_namesz,
   1056  1.85.2.2  pgoyette 		    np->n_descsz, ns, ns, ndata);
   1057      1.15  christos #endif
   1058  1.85.2.2  pgoyette 		break;
   1059      1.10        ad 	}
   1060      1.10        ad 
   1061  1.85.2.2  pgoyette 	return isnetbsd;
   1062      1.10        ad }
   1063      1.10        ad 
   1064      1.10        ad int
   1065      1.10        ad netbsd_elf_probe(struct lwp *l, struct exec_package *epp, void *eh, char *itp,
   1066      1.10        ad     vaddr_t *pos)
   1067      1.10        ad {
   1068      1.10        ad 	int error;
   1069      1.10        ad 
   1070      1.10        ad 	if ((error = netbsd_elf_signature(l, epp, eh)) != 0)
   1071      1.10        ad 		return error;
   1072      1.12      matt #ifdef ELF_MD_PROBE_FUNC
   1073      1.12      matt 	if ((error = ELF_MD_PROBE_FUNC(l, epp, eh, itp, pos)) != 0)
   1074      1.12      matt 		return error;
   1075      1.12      matt #elif defined(ELF_INTERP_NON_RELOCATABLE)
   1076      1.10        ad 	*pos = ELF_LINK_ADDR;
   1077      1.10        ad #endif
   1078      1.29     joerg 	epp->ep_flags |= EXEC_FORCEAUX;
   1079      1.10        ad 	return 0;
   1080       1.1      fvdl }
   1081      1.35      matt 
   1082      1.35      matt void
   1083      1.35      matt elf_free_emul_arg(void *arg)
   1084      1.35      matt {
   1085      1.35      matt 	struct elf_args *ap = arg;
   1086      1.35      matt 	KASSERT(ap != NULL);
   1087      1.35      matt 	kmem_free(ap, sizeof(*ap));
   1088      1.35      matt }
   1089