 @@ -1,470 +1,438 @@
-/*	$NetBSD: cpu_exec.c,v 1.58 2009/12/14 00:46:05 matt Exp $	*/
+/*	$NetBSD: cpu_exec.c,v 1.59 2009/12/14 04:09:38 mrg Exp $	*/
 /*
  * Copyright (c) 1992, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by Ralph
  * Campbell.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)machdep.c	8.3 (Berkeley) 1/12/94
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: cpu_exec.c,v 1.58 2009/12/14 00:46:05 matt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: cpu_exec.c,v 1.59 2009/12/14 04:09:38 mrg Exp $");
 #include "opt_compat_netbsd.h"
 #include "opt_compat_ultrix.h"
 #include "opt_execfmt.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/malloc.h>
 #include <sys/vnode.h>
 #include <sys/exec.h>
 #include <sys/namei.h>
 #include <sys/resourcevar.h>
 #include <uvm/uvm_extern.h>
 #include <compat/common/compat_util.h>
 #ifdef EXEC_ECOFF
 #include <sys/exec_ecoff.h>
 #endif
 #include <sys/exec_elf.h>			/* mandatory */
 #include <machine/reg.h>
 #include <mips/regnum.h>			/* symbolic register indices */
 int	mips_elf_makecmds(struct lwp *, struct exec_package *);
 #ifdef EXEC_ECOFF
 void
 cpu_exec_ecoff_setregs(struct lwp *l, struct exec_package *epp, vaddr_t stack)
+{
 	struct ecoff_exechdr *execp = (struct ecoff_exechdr *)epp->ep_hdr;
 	struct frame *f = l->l_md.md_regs;
 	f->f_regs[_R_GP] = (register_t)execp->a.gp_value;
+}
 /*
  * cpu_exec_ecoff_probe()
  *	cpu-dependent ECOFF format hook for execve().
+ *
  * Do any machine-dependent diddling of the exec package when doing ECOFF.
  */
 int
 cpu_exec_ecoff_probe(struct lwp *l, struct exec_package *epp)
+{
 	/* NetBSD/mips does not have native ECOFF binaries. */
 	return ENOEXEC;
+}
 #endif /* EXEC_ECOFF */
 /*
  * mips_elf_makecmds (l, epp)
+ *
  * Test if an executable is a MIPS ELF executable.   If it is,
  * try to load it.
  */
 int
 mips_elf_makecmds (struct lwp *l, struct exec_package *epp)
+{
 	Elf32_Ehdr *ex = (Elf32_Ehdr *)epp->ep_hdr;
 	Elf32_Phdr ph;
 	int i, error;
 	size_t resid;
 	/* Make sure we got enough data to check magic numbers... */
 	if (epp->ep_hdrvalid < sizeof (Elf32_Ehdr)) {
 #ifdef DIAGNOSTIC
 		if (epp->ep_hdrlen < sizeof (Elf32_Ehdr))
 			printf ("mips_elf_makecmds: execsw hdrsize too short!\n");
 #endif
 	    return ENOEXEC;
+	}
 	/* See if it's got the basic elf magic number leadin... */
 	if (memcmp(ex->e_ident, ELFMAG, SELFMAG) != 0) {
 		return ENOEXEC;
+	}
 	/* XXX: Check other magic numbers here. */
 	if (ex->e_ident[EI_CLASS] != ELFCLASS32) {
 		return ENOEXEC;
+	}
 	/* See if we got any program header information... */
 	if (!ex->e_phoff || !ex->e_phnum) {
 		return ENOEXEC;
+	}
 	error = vn_marktext(epp->ep_vp);
 	if (error)
 		return (error);
 	/* Set the entry point... */
 	epp->ep_entry = ex->e_entry;
 	epp->ep_taddr = 0;
 	epp->ep_tsize = 0;
 	epp->ep_daddr = 0;
 	epp->ep_dsize = 0;
 	for (i = 0; i < ex->e_phnum; i++) {
 #ifdef DEBUG
 		/*printf("obsolete elf: mapping %x %x %x\n", resid);*/
 #endif
 		if ((error = vn_rdwr(UIO_READ, epp->ep_vp, (void *)&ph,
 				    sizeof ph, ex->e_phoff + i * sizeof ph,
 				    UIO_SYSSPACE, IO_NODELOCKED,
 				    l->l_cred, &resid, NULL))
 		    != 0)
 			return error;
 		if (resid != 0) {
 			return ENOEXEC;
+		}
 		/* We only care about loadable sections... */
 		if (ph.p_type == PT_LOAD) {
 			int prot = VM_PROT_READ | VM_PROT_EXECUTE;
 			int residue;
 			unsigned vaddr, offset, length;
 			vaddr = ph.p_vaddr;
 			offset = ph.p_offset;
 			length = ph.p_filesz;
 			residue = ph.p_memsz - ph.p_filesz;
 			if (ph.p_flags & PF_W) {
 				prot |= VM_PROT_WRITE;
 				if (!epp->ep_daddr || vaddr < epp->ep_daddr)
 					epp->ep_daddr = vaddr;
 				epp->ep_dsize += ph.p_memsz;
 				/* Read the data from the file... */
 				NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_readvn,
 					  length, vaddr,
 					  epp->ep_vp, offset, prot);
 #ifdef OLD_ELF_DEBUG
 /*XXX*/		printf(
 	"obsolete elf: NEW_VMCMD len %x va %x off %x prot %x residue %x\n",
 			length, vaddr, offset, prot, residue);
 #endif /*ELF_DEBUG*/
 				if (residue) {
 					vaddr &= ~(PAGE_SIZE - 1);
 					offset &= ~(PAGE_SIZE - 1);
 					length = roundup (length + ph.p_vaddr
 							  - vaddr, PAGE_SIZE);
 					residue = (ph.p_vaddr + ph.p_memsz)
 						  - (vaddr + length);
+				}
 			} else {
 				vaddr &= ~(PAGE_SIZE - 1);
 				offset &= ~(PAGE_SIZE - 1);
 				length = roundup (length + ph.p_vaddr - vaddr,
 						  PAGE_SIZE);
 				residue = (ph.p_vaddr + ph.p_memsz)
 					  - (vaddr + length);
 				if (!epp->ep_taddr || vaddr < epp->ep_taddr)
 					epp->ep_taddr = vaddr;
 				epp->ep_tsize += ph.p_memsz;
 				/* Map the data from the file... */
 				NEW_VMCMD(&epp->ep_vmcmds, vmcmd_map_pagedvn,
 					  length, vaddr,
 					  epp->ep_vp, offset, prot);
+			}
 			/* If part of the segment is just zeros (e.g., bss),
 			   map that. */
 			if (residue > 0) {
 #ifdef OLD_ELF_DEBUG
 /*XXX*/			printf(
 	"old elf:resid NEW_VMCMD len %x va %x off %x prot %x residue %x\n",
 				length, vaddr + length, offset, prot, residue);
 #endif /*ELF_DEBUG*/
 				NEW_VMCMD (&epp->ep_vmcmds, vmcmd_map_zero,
 					   residue, vaddr + length,
 					   NULLVP, 0, prot);
+			}
+		}
+	}
 	epp->ep_maxsaddr = USRSTACK - MAXSSIZ;
 	epp->ep_minsaddr = USRSTACK;
 	epp->ep_ssize = l->l_proc->p_rlimit[RLIMIT_STACK].rlim_cur;
 	/*
 	 * set up commands for stack.  note that this takes *two*, one to
 	 * map the part of the stack which we can access, and one to map
 	 * the part which we can't.
+	 *
 	 * arguably, it could be made into one, but that would require the
 	 * addition of another mapping proc, which is unnecessary
+	 *
 	 * note that in memory, things assumed to be: 0 ....... ep_maxsaddr
 	 * <stack> ep_minsaddr
 	 */
 	NEW_VMCMD2(&epp->ep_vmcmds, vmcmd_map_zero,
 	    ((epp->ep_minsaddr - epp->ep_ssize) - epp->ep_maxsaddr),
 	    epp->ep_maxsaddr, NULLVP, 0, VM_PROT_NONE, VMCMD_STACK);
 	NEW_VMCMD2(&epp->ep_vmcmds, vmcmd_map_zero, epp->ep_ssize,
 	    (epp->ep_minsaddr - epp->ep_ssize), NULLVP, 0,
 	    VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE, VMCMD_STACK);
 	return 0;
+}
 static int
 elf_check_itp(struct exec_package *epp, const char *itp,
 	const char *itp_suffix)
 	if (itp) {
 		/*
 		 * If the path is exactly "/usr/libexec/ld.elf_so", first
 		 * try to see if "/usr/libexec/ld.elf_so-<abi>" exists
 		 * and if so, use that instead.
 		 * XXX maybe move this into compat/common
 		 */
 		if (strcmp(itp, "/usr/libexec/ld.elf_so") == 0 ||
 		    strcmp(itp, "/libexec/ld.elf_so") == 0) {
 			struct nameidata nd;
 			char *path;
 			int error;
 			path = PNBUF_GET();
 			snprintf(path, MAXPATHLEN, "%s-%s", itp, itp_suffix);
 			NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, path);
 			error = namei(&nd);
 			/*
 			 * If that worked, replace interpreter in case we
 			 * actually need to load it
 			 */
 			if (error == 0) {
 				if (epp->ep_interp != NULL)
 					vrele(epp->ep_interp);
 				epp->ep_interp = nd.ni_vp;
 			PNBUF_PUT(path);
 	return 0;
 #if EXEC_ELF32
 int
 mips_netbsd_elf32_probe(struct lwp *l, struct exec_package *epp, void *eh0,
 	char *itp, vaddr_t *start_p)
+{
 	struct proc * const p = l->l_proc;
 	const Elf32_Ehdr * const eh = eh0;
 	int old_abi = p->p_md.md_abi;
 	const char *itp_suffix = NULL;
 	/*
 	 * Verify we can support the architecture.
 	 */
 	switch (eh->e_flags & EF_MIPS_ARCH) {
 	case EF_MIPS_ARCH_1:
 		break;
 	case EF_MIPS_ARCH_2:
 		if (cpu_arch < CPU_ARCH_MIPS2)
 			return ENOEXEC;
 		break;
 	case EF_MIPS_ARCH_3:
 		if (cpu_arch < CPU_ARCH_MIPS3)
 			return ENOEXEC;
 		break;
 	case EF_MIPS_ARCH_4:
 		if (cpu_arch < CPU_ARCH_MIPS4)
 			return ENOEXEC;
 		break;
 	case EF_MIPS_ARCH_5:
 		if (cpu_arch < CPU_ARCH_MIPS5)
 			return ENOEXEC;
 		break;
 	case EF_MIPS_ARCH_32:
 	case EF_MIPS_ARCH_64:
 		if (!CPUISMIPSNN)
 			return ENOEXEC;
 		break;
+	}
 	switch (eh->e_flags & (EF_MIPS_ABI|EF_MIPS_ABI2)) {
 #if !defined(__mips_o32)
 	case EF_MIPS_ABI2:
 		itp_suffix = "n32";
 		p->p_md.md_abi = _MIPS_BSD_API_N32;
 		if (old_abi != p->p_md.md_abi)
 			printf("pid %d(%s): ABI set to N32 (e_flags=%#x)\n", p->p_pid, p->p_comm, eh->e_flags);
 		break;
 #endif
 	case EF_MIPS_ABI_O32:
 		itp_suffix = "o32";
 		p->p_md.md_abi = _MIPS_BSD_API_O32;
 #ifdef COMPAT_16
 		*start_p = ELF32_LINK_ADDR;
 #endif
 		if (old_abi != p->p_md.md_abi)
 			printf("pid %d(%s): ABI set to O32 (e_flags=%#x)\n", p->p_pid, p->p_comm, eh->e_flags);
 		break;
 	default:
 		return ENOEXEC;
+	}
-	return elf_check_itp(epp, itp, itp_suffix);
+	(void)compat_elf_check_interp(epp, itp, itp_suffix);
 	return 0;
+}
 void
 coredump_elf32_setup(struct lwp *l, void *eh0)
+{
 	struct proc * const p = l->l_proc;
 	Elf32_Ehdr * const eh = eh0;
 	/*
 	 * Mark the type of CPU that the dump happened on.
 	 */
 	if (cpu_arch & CPU_ARCH_MIPS64) {
 		eh->e_flags |= EF_MIPS_ARCH_64;
 	} else if (cpu_arch & CPU_ARCH_MIPS32) {
 		eh->e_flags |= EF_MIPS_ARCH_32;
 	} else if (cpu_arch & CPU_ARCH_MIPS5) {
 		eh->e_flags |= EF_MIPS_ARCH_5;
 	} else if (cpu_arch & CPU_ARCH_MIPS4) {
 		eh->e_flags |= EF_MIPS_ARCH_4;
 	} else if (cpu_arch & CPU_ARCH_MIPS3) {
 		eh->e_flags |= EF_MIPS_ARCH_3;
 	} else if (cpu_arch & CPU_ARCH_MIPS2) {
 		eh->e_flags |= EF_MIPS_ARCH_2;
 	} else {
 		eh->e_flags |= EF_MIPS_ARCH_1;
+	}
 	switch (p->p_md.md_abi) {
 	case _MIPS_BSD_API_N32:
 		eh->e_flags |= EF_MIPS_ABI2;
 		break;
 	case _MIPS_BSD_API_O32:
 		eh->e_flags |=EF_MIPS_ABI_O32;
 		break;
+	}
+}
 #endif
 #if EXEC_ELF64
 int
 mips_netbsd_elf64_probe(struct lwp *l, struct exec_package *epp, void *eh0,
 	char *itp, vaddr_t *start_p)
+{
 	struct proc * const p = l->l_proc;
 	const Elf64_Ehdr * const eh = eh0;
 	int old_abi = p->p_md.md_abi;
 	const char *itp_suffix = NULL;
 	switch (eh->e_flags & EF_MIPS_ARCH) {
 	case EF_MIPS_ARCH_1:
 		return ENOEXEC;
 	case EF_MIPS_ARCH_2:
 		if (cpu_arch < CPU_ARCH_MIPS2)
 			return ENOEXEC;
 		break;
 	case EF_MIPS_ARCH_3:
 		if (cpu_arch < CPU_ARCH_MIPS3)
 			return ENOEXEC;
 		break;
 	case EF_MIPS_ARCH_4:
 		if (cpu_arch < CPU_ARCH_MIPS4)
 			return ENOEXEC;
 		break;
 	case EF_MIPS_ARCH_5:
 		if (cpu_arch < CPU_ARCH_MIPS5)
 			return ENOEXEC;
 		break;
 	case EF_MIPS_ARCH_32:
 		return ENOEXEC;
 	case EF_MIPS_ARCH_64:
 		if (!CPUISMIPS64)
 			return ENOEXEC;
 		break;
+	}
 	switch (eh->e_flags & (EF_MIPS_ABI|EF_MIPS_ABI2)) {
 	case 0:
 		itp_suffix = "64";
 		p->p_md.md_abi = _MIPS_BSD_API_N64;
 		if (old_abi != p->p_md.md_abi)
 			printf("pid %d(%s): ABI set to N64 (e_flags=%#x)\n", p->p_pid, p->p_comm, eh->e_flags);
 		break;
 	case EF_MIPS_ABI_O64:
 		itp_suffix = "o64";
 		p->p_md.md_abi = _MIPS_BSD_API_O64;
 		if (old_abi != p->p_md.md_abi)
 			printf("pid %d(%s): ABI set to O64 (e_flags=%#x)\n", p->p_pid, p->p_comm, eh->e_flags);
 		break;
 	default:
 		return ENOEXEC;
+	}
-	return elf_check_itp(epp, itp, itp_suffix);
+	(void)compat_elf_check_interp(epp, itp, itp_suffix);
 	return 0;
+}
 void
 coredump_elf64_setup(struct lwp *l, void *eh0)
+{
 	struct proc * const p = l->l_proc;
 	Elf64_Ehdr * const eh = eh0;
 	/*
 	 * Mark the type of CPU that the dump happened on.
 	 */
 	if (cpu_arch & CPU_ARCH_MIPS64) {
 		eh->e_flags |= EF_MIPS_ARCH_64;
 	} else if (cpu_arch & CPU_ARCH_MIPS32) {
 		eh->e_flags |= EF_MIPS_ARCH_32;
 	} else if (cpu_arch & CPU_ARCH_MIPS5) {
 		eh->e_flags |= EF_MIPS_ARCH_5;
 	} else if (cpu_arch & CPU_ARCH_MIPS4) {
 		eh->e_flags |= EF_MIPS_ARCH_4;
 	} else if (cpu_arch & CPU_ARCH_MIPS3) {
 		eh->e_flags |= EF_MIPS_ARCH_3;
 	} else if (cpu_arch & CPU_ARCH_MIPS2) {
 		eh->e_flags |= EF_MIPS_ARCH_2;
 	} else {
 		eh->e_flags |= EF_MIPS_ARCH_1;
+	}
 	switch (p->p_md.md_abi) {
 	case _MIPS_BSD_API_N64:
 		eh->e_flags |= EF_MIPS_ABI2;
 		break;
 	case _MIPS_BSD_API_O64:
 		eh->e_flags |= EF_MIPS_ABI_O64;
 		break;
+	}
+}
 #endif

 @@ -1,149 +1,223 @@
-/* 	$NetBSD: compat_util.c,v 1.42 2009/06/29 05:08:15 dholland Exp $	*/
+/* 	$NetBSD: compat_util.c,v 1.43 2009/12/14 04:09:38 mrg Exp $	*/
 /*-
  * Copyright (c) 1994 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Christos Zoulas and Frank van der Linden.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 2008, 2009 Matthew R. Green
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: compat_util.c,v 1.42 2009/06/29 05:08:15 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: compat_util.c,v 1.43 2009/12/14 04:09:38 mrg Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/proc.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/filedesc.h>
 #include <sys/exec.h>
 #include <sys/ioctl.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/vnode.h>
 #include <sys/syslog.h>
 #include <sys/mount.h>
 #include <compat/common/compat_util.h>
 void
 emul_find_root(struct lwp *l, struct exec_package *epp)
+{
 	struct vnode *vp;
 	const char *emul_path;
 	if (epp->ep_emul_root != NULL)
 		/* We've already found it */
 		return;
 	emul_path = epp->ep_esch->es_emul->e_path;
 	if (emul_path == NULL)
 		/* Emulation doesn't have a root */
 		return;
 	if (namei_simple_kernel(emul_path, NSM_FOLLOW_NOEMULROOT, &vp) != 0)
 		/* emulation root doesn't exist */
 		return;
 	epp->ep_emul_root = vp;
+}
 /*
  * Search the alternate path for dynamic binary interpreter. If not found
  * there, check if the interpreter exists in within 'proper' tree.
  */
 int
 emul_find_interp(struct lwp *l, struct exec_package *epp, const char *itp)
+{
 	int error;
 	struct nameidata nd;
 	unsigned int flags;
 	/* If we haven't found the emulation root already, do so now */
 	/* Maybe we should remember failures somehow ? */
 	if (epp->ep_esch->es_emul->e_path != 0 && epp->ep_emul_root == NULL)
 		emul_find_root(l, epp);
 	if (epp->ep_interp != NULL)
 		vrele(epp->ep_interp);
 	/* We need to use the emulation root for the new program,
 	 * not the one for the current process. */
 	if (epp->ep_emul_root == NULL)
 		flags = FOLLOW;
 	else {
 		nd.ni_erootdir = epp->ep_emul_root;
 		/* hack: Pass in the emulation path for ktrace calls */
 		nd.ni_next = epp->ep_esch->es_emul->e_path;
 		flags = FOLLOW | TRYEMULROOT | EMULROOTSET;
+	}
 	NDINIT(&nd, LOOKUP, flags, UIO_SYSSPACE, itp);
 	error = namei(&nd);
 	if (error != 0) {
 		epp->ep_interp = NULL;
 		return error;
+	}
 	/* Save interpreter in case we actually need to load it */
 	epp->ep_interp = nd.ni_vp;
 	return 0;
+}
 /*
  * Translate one set of flags to another, based on the entries in
  * the given table.  If 'leftover' is specified, it is filled in
  * with any flags which could not be translated.
  */
 unsigned long
 emul_flags_translate(const struct emul_flags_xtab *tab,
 		     unsigned long in, unsigned long *leftover)
+{
 	unsigned long out;
 	for (out = 0; tab->omask != 0; tab++) {
 		if ((in & tab->omask) == tab->oval) {
 			in &= ~tab->omask;
 			out |= tab->nval;
+		}
+	}
 	if (leftover != NULL)
 		*leftover = in;
 	return (out);
+}
 void
 compat_offseterr(struct vnode *vp, const char *msg)
+{
 	struct mount *mp;
 	mp = vp->v_mount;
 	log(LOG_ERR, "%s: dir offset too large on fs %s (mounted from %s)\n",
 	    msg, mp->mnt_stat.f_mntonname, mp->mnt_stat.f_mntfromname);
 	uprintf("%s: dir offset too large for emulated program\n", msg);
+}
 /*
  * Look for native NetBSD compatibility libraries, usually interp-ABI.
  * It returns 0 if it changed the interpreter, otherwise it returns
  * the error from namei().  Callers should not try any more processing
  * if this returns 0, and probably should just ignore the return value.
  */
 int
 compat_elf_check_interp(struct exec_package *epp,
 			char *interp,
 			const char *interp_suffix)
+{
 	int error = 0;
 	/*
 	 * Don't look for something else, if someone has already found and
 	 * setup the ep_interp already.
 	 */
 	if (interp && epp->ep_interp == NULL) {
 		/*
 		 * If the path is exactly "/usr/libexec/ld.elf_so", first
 		 * try to see if "/usr/libexec/ld.elf_so-<abi>" exists
 		 * and if so, use that instead.
 		 */
 		if (strcmp(interp, "/usr/libexec/ld.elf_so") == 0 ||
 		    strcmp(interp, "/libexec/ld.elf_so") == 0) {
 			struct vnode *vp;
 			char *path;
 			path = PNBUF_GET();
 			snprintf(path, MAXPATHLEN, "%s-%s", interp, interp_suffix);
 			error = namei_simple_kernel(path,
 					NSM_FOLLOW_NOEMULROOT, &vp);
 			/*
 			 * If that worked, replace interpreter in case we
 			 * actually need to load it.
 			 */
 			if (error == 0) {
 				epp->ep_interp = vp;
 				snprintf(interp, MAXPATHLEN, "%s", path);
+			}
 			PNBUF_PUT(path);
+		}
+	}
 	return error;
+}

 @@ -1,85 +1,88 @@
-/*	$NetBSD: compat_util.h,v 1.21 2008/11/19 18:36:02 ad Exp $	*/
+/*	$NetBSD: compat_util.h,v 1.22 2009/12/14 04:09:38 mrg Exp $	*/
 /*-
  * Copyright (c) 1994 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Christos Zoulas.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1995 Frank van der Linden
  * Copyright (c) 2009 Matthew R. Green
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  */
 #ifndef	_COMPAT_UTIL_H_
 #define	_COMPAT_UTIL_H_
 struct emul;
 struct proc;
 struct exec_package;
 struct emul_flags_xtab {
 	unsigned long omask;
 	unsigned long oval;
 	unsigned long nval;
 };
 void emul_find_root(struct lwp *, struct exec_package *);
 int emul_find_interp(struct lwp *, struct exec_package *, const char *);
 unsigned long emul_flags_translate(const struct emul_flags_xtab *tab,
 				   unsigned long in, unsigned long *leftover);
 void compat_offseterr(struct vnode *, const char *);
 int compat_elf_check_interp(struct exec_package *, char *, const char *);
 void compat_sysctl_init(void);
 void compat_sysctl_fini(void);
 #endif /* !_COMPAT_UTIL_H_ */

 @@ -1,245 +1,213 @@
-/*	$NetBSD: netbsd32_exec_elf32.c,v 1.31 2009/12/14 00:47:11 matt Exp $	*/
+/*	$NetBSD: netbsd32_exec_elf32.c,v 1.32 2009/12/14 04:09:38 mrg Exp $	*/
 /*	from: NetBSD: exec_aout.c,v 1.15 1996/09/26 23:34:46 cgd Exp */
 /*
  * Copyright (c) 1998, 2001 Matthew R. Green.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1993, 1994 Christopher G. Demetriou
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by Christopher G. Demetriou.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: netbsd32_exec_elf32.c,v 1.31 2009/12/14 00:47:11 matt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: netbsd32_exec_elf32.c,v 1.32 2009/12/14 04:09:38 mrg Exp $");
 #define	ELFSIZE		32
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/malloc.h>
 #include <sys/vnode.h>
 #include <sys/exec.h>
 #include <sys/exec_elf.h>
 #include <sys/resourcevar.h>
 #include <sys/signal.h>
 #include <sys/signalvar.h>
 #include <sys/kauth.h>
 #include <sys/namei.h>
 #include <compat/common/compat_util.h>
 #include <compat/netbsd32/netbsd32.h>
 #include <compat/netbsd32/netbsd32_exec.h>
 #include <machine/netbsd32_machdep.h>
 int netbsd32_copyinargs(struct exec_package *, struct ps_strings *,
 			void *, size_t, const void *, const void *);
 int ELFNAME2(netbsd32,probe_noteless)(struct lwp *, struct exec_package *epp,
 				      void *eh, char *itp, vaddr_t *pos);
 extern int ELFNAME2(netbsd,signature)(struct lwp *, struct exec_package *,
 				      Elf_Ehdr *);
 int
 ELFNAME2(netbsd32,probe)(struct lwp *l, struct exec_package *epp,
 			 void *eh, char *itp, vaddr_t *pos)
+{
 	int error;
 	if ((error = ELFNAME2(netbsd,signature)(l, epp, eh)) != 0)
 		return error;
 #ifdef ELF_MD_PROBE_FUNC
 	if ((error = ELF_MD_PROBE_FUNC(l, epp, eh, itp, pos)) != 0)
 		return error;
 #elif defined(ELF_INTERP_NON_RELOCATABLE)
 	*pos = ELF_LINK_ADDR;
 #endif
 	return ELFNAME2(netbsd32,probe_noteless)(l, epp, eh, itp, pos);
+}
 int
 ELFNAME2(netbsd32,probe_noteless)(struct lwp *l, struct exec_package *epp,
 				  void *eh, char *itp, vaddr_t *pos)
+{
-	int error;
+ 	if (itp && epp->ep_interp == NULL) {
 		extern const char machine32[];
-	if (itp) {
+		(void)compat_elf_check_interp(epp, itp, machine32);
 		/*
 		 * If the path is exactly "/usr/libexec/ld.elf_so", first
 		 * try to see if "/usr/libexec/ld.elf_so-<arch>" exists
 		 * and if so, use that instead.
 		 * XXX maybe move this into compat/common
 		 */
 		error = 0;
 		if (strcmp(itp, "/usr/libexec/ld.elf_so") == 0 ||
 		    strcmp(itp, "/libexec/ld.elf_so") == 0) {
 			extern const char machine32[];
 			struct vnode *vp;
 			char *path;
 			if (epp->ep_interp != NULL)
 				vrele(epp->ep_interp);
 			path = PNBUF_GET();
 			snprintf(path, MAXPATHLEN, "%s-%s", itp, machine32);
 			error = namei_simple_kernel(path,
 					NSM_FOLLOW_NOEMULROOT, &vp);
 			/*
 			 * If that worked, save interpreter in case we
 			 * actually need to load it
 			 */
 			if (error != 0)
 				epp->ep_interp = NULL;
 			else
 				epp->ep_interp = vp;
 			PNBUF_PUT(path);
 		/* Translate interpreter name if needed */
 		if (error && (error = emul_find_interp(l, epp, itp)) != 0)
 			return error;
+	}
 	epp->ep_flags |= EXEC_32;
 	epp->ep_vm_minaddr = VM_MIN_ADDRESS;
 	epp->ep_vm_maxaddr = USRSTACK32;
 #ifdef ELF_INTERP_NON_RELOCATABLE
 	*pos = ELF_LINK_ADDR;
 #endif
 	return 0;
+}
 /* round up and down to page boundaries. */
 #define	ELF_ROUND(a, b)		(((a) + (b) - 1) & ~((b) - 1))
 #define	ELF_TRUNC(a, b)		((a) & ~((b) - 1))
 /*
  * Copy arguments onto the stack in the normal way, but add some
  * extra information in case of dynamic binding.
  */
 int
 netbsd32_elf32_copyargs(struct lwp *l, struct exec_package *pack,
     struct ps_strings *arginfo, char **stackp, void *argp)
+{
 	size_t len;
 	AuxInfo ai[ELF_AUX_ENTRIES], *a;
 	struct elf_args *ap;
 	int error;
 	if ((error = netbsd32_copyargs(l, pack, arginfo, stackp, argp)) != 0)
 		return error;
 	a = ai;
 	/*
 	 * Push extra arguments on the stack needed by dynamically
 	 * linked binaries
 	 */
 	if ((ap = (struct elf_args *)pack->ep_emul_arg)) {
 		a->a_type = AT_PHDR;
 		a->a_v = ap->arg_phaddr;
 		a++;
 		a->a_type = AT_PHENT;
 		a->a_v = ap->arg_phentsize;
 		a++;
 		a->a_type = AT_PHNUM;
 		a->a_v = ap->arg_phnum;
 		a++;
 		a->a_type = AT_PAGESZ;
 		a->a_v = PAGE_SIZE;
 		a++;
 		a->a_type = AT_BASE;
 		a->a_v = ap->arg_interp;
 		a++;
 		a->a_type = AT_FLAGS;
 		a->a_v = 0;
 		a++;
 		a->a_type = AT_ENTRY;
 		a->a_v = ap->arg_entry;
 		a++;
 		a->a_type = AT_EUID;
 		a->a_v = kauth_cred_geteuid(l->l_cred);
 		a++;
 		a->a_type = AT_RUID;
 		a->a_v = kauth_cred_getuid(l->l_cred);
 		a++;
 		a->a_type = AT_EGID;
 		a->a_v = kauth_cred_getegid(l->l_cred);
 		a++;
 		a->a_type = AT_RGID;
 		a->a_v = kauth_cred_getgid(l->l_cred);
 		a++;
 		free((char *)ap, M_TEMP);
 		pack->ep_emul_arg = NULL;
+	}
 	a->a_type = AT_NULL;
 	a->a_v = 0;
 	a++;
 	len = (a - ai) * sizeof(AuxInfo);
 	if ((error = copyout(ai, *stackp, len)) != 0)
 		return error;
 	*stackp += len;
 	return 0;
+}