 @@ -1,505 +1,500 @@
-/*	$NetBSD: linux32_machdep.c,v 1.20 2008/10/19 09:44:31 njoly Exp $ */
+/*	$NetBSD: linux32_machdep.c,v 1.21 2009/03/15 15:56:50 cegger Exp $ */
 /*-
  * Copyright (c) 2006 Emmanuel Dreyfus, 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 Emmanuel Dreyfus
  * 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 THE AUTHOR 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 AUTHOR 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: linux32_machdep.c,v 1.20 2008/10/19 09:44:31 njoly Exp $");
+__KERNEL_RCSID(0, "$NetBSD: linux32_machdep.c,v 1.21 2009/03/15 15:56:50 cegger Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/signalvar.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/user.h>
 #include <sys/buf.h>
 #include <sys/reboot.h>
 #include <sys/conf.h>
 #include <sys/exec.h>
 #include <sys/file.h>
 #include <sys/callout.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 #include <sys/msgbuf.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/device.h>
 #include <sys/syscallargs.h>
 #include <sys/filedesc.h>
 #include <sys/exec_elf.h>
 #include <sys/disklabel.h>
 #include <sys/ioctl.h>
 #include <sys/wait.h>
 #include <miscfs/specfs/specdev.h>
 #include <machine/netbsd32_machdep.h>
 #include <compat/netbsd32/netbsd32.h>
 #include <compat/netbsd32/netbsd32_syscallargs.h>
 #include <compat/linux/common/linux_signal.h>
 #include <compat/linux/common/linux_errno.h>
 #include <compat/linux32/common/linux32_types.h>
 #include <compat/linux32/common/linux32_errno.h>
 #include <compat/linux32/common/linux32_machdep.h>
 #include <compat/linux32/common/linux32_signal.h>
 #include <compat/linux32/common/linux32_exec.h>
 #include <compat/linux32/linux32_syscallargs.h>
 #include <sys/cpu.h>
 #include <machine/cpufunc.h>
 #include <machine/psl.h>
 #include <machine/reg.h>
 #include <machine/segments.h>
 #include <machine/specialreg.h>
 #include <machine/sysarch.h>
 #include <machine/vmparam.h>
 extern char linux32_sigcode[1];
 extern char linux32_rt_sigcode[1];
 extern char linux32_esigcode[1];
 extern void (osyscall_return)(void);
 static void linux32_save_ucontext(struct lwp *, struct trapframe *,
     const sigset_t *, struct sigaltstack *, struct linux32_ucontext *);
 static void linux32_save_sigcontext(struct lwp *, struct trapframe *,
     const sigset_t *, struct linux32_sigcontext *);
 static void linux32_rt_sendsig(const ksiginfo_t *, const sigset_t *);
 static void linux32_old_sendsig(const ksiginfo_t *, const sigset_t *);
 static int linux32_restore_sigcontext(struct lwp *,
     struct linux32_sigcontext *, register_t *);
 void
 linux32_sendsig(const ksiginfo_t *ksi, const sigset_t *mask)
+{
 	if (SIGACTION(curproc, ksi->ksi_signo).sa_flags & SA_SIGINFO)
 		linux32_rt_sendsig(ksi, mask);
 	else
 		linux32_old_sendsig(ksi, mask);
 	return;
+}
 void
 linux32_old_sendsig(const ksiginfo_t *ksi, const sigset_t *mask)
+{
 	struct lwp *l = curlwp;
 	struct proc *p = l->l_proc;
 	struct trapframe *tf;
 	struct linux32_sigframe *fp, frame;
 	int onstack, error;
 	int sig = ksi->ksi_signo;
 	sig_t catcher = SIGACTION(p, sig).sa_handler;
 	struct sigaltstack *sas = &l->l_sigstk;
 	tf = l->l_md.md_regs;
 	/* Do we need to jump onto the signal stack? */
 	onstack = (sas->ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 &&
 	    (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0;
 	/* Allocate space for the signal handler context. */
 	if (onstack)
 		fp = (struct linux32_sigframe *)((char *)sas->ss_sp +
 		    sas->ss_size);
 	else
 		fp = (struct linux32_sigframe *)tf->tf_rsp;
 	fp--;
 	/* Build stack frame for signal trampoline. */
 	NETBSD32PTR32(frame.sf_handler, catcher);
 	frame.sf_sig = native_to_linux32_signo[sig];
 	linux32_save_sigcontext(l, tf, mask, &frame.sf_sc);
 	sendsig_reset(l, sig);
 	mutex_exit(p->p_lock);
 	error = copyout(&frame, fp, sizeof(frame));
 	mutex_enter(p->p_lock);
 	if (error != 0) {
 		/*
 		 * Process has trashed its stack; give it an illegal
 		 * instruction to halt it in its tracks.
 		 */
 		sigexit(l, SIGILL);
 		/* NOTREACHED */
+	}
 	/*
 	 * Build context to run handler in.
 	 */
 	tf->tf_gs = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_fs = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_es = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_ds = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_rip = ((long)p->p_sigctx.ps_sigcode) & 0xffffffff;
 	tf->tf_cs = GSEL(GUCODE32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_rflags &= ~PSL_CLEARSIG & 0xffffffff;
 	tf->tf_rsp = (long)fp & 0xffffffff;
 	tf->tf_ss = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	/* Remember that we're now on the signal stack. */
 	if (onstack)
 		sas->ss_flags |= SS_ONSTACK;
 	return;
+}
 void
 linux32_rt_sendsig(const ksiginfo_t *ksi, const sigset_t *mask)
+{
 	struct lwp *l = curlwp;
 	struct proc *p = l->l_proc;
 	struct trapframe *tf;
 	struct linux32_rt_sigframe *fp, frame;
 	int onstack, error;
 	linux32_siginfo_t *lsi;
 	int sig = ksi->ksi_signo;
 	sig_t catcher = SIGACTION(p, sig).sa_handler;
 	struct sigaltstack *sas = &l->l_sigstk;
 	tf = l->l_md.md_regs;
 	/* Do we need to jump onto the signal stack? */
 	onstack = (sas->ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 &&
 	    (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0;
 	/* Allocate space for the signal handler context. */
 	if (onstack)
 		fp = (struct linux32_rt_sigframe *)((char *)sas->ss_sp +
 		    sas->ss_size);
 	else
 		fp = (struct linux32_rt_sigframe *)tf->tf_rsp;
 	fp--;
 	/* Build stack frame for signal trampoline. */
 	NETBSD32PTR32(frame.sf_handler, catcher);
 	frame.sf_sig = native_to_linux32_signo[sig];
 	NETBSD32PTR32(frame.sf_sip, &fp->sf_si);
 	NETBSD32PTR32(frame.sf_ucp, &fp->sf_uc);
 	lsi = &frame.sf_si;
 	(void)memset(lsi, 0, sizeof(frame.sf_si));
 	lsi->lsi_errno = native_to_linux32_errno[ksi->ksi_errno];
 	lsi->lsi_code = native_to_linux_si_code(ksi->ksi_code);
 	lsi->lsi_signo = frame.sf_sig;
 	switch (lsi->lsi_signo) {
 	case LINUX32_SIGILL:
 	case LINUX32_SIGFPE:
 	case LINUX32_SIGSEGV:
 	case LINUX32_SIGBUS:
 	case LINUX32_SIGTRAP:
 		NETBSD32PTR32(lsi->lsi_addr, ksi->ksi_addr);
 		break;
 	case LINUX32_SIGCHLD:
 		lsi->lsi_uid = ksi->ksi_uid;
 		lsi->lsi_pid = ksi->ksi_pid;
 		lsi->lsi_utime = ksi->ksi_utime;
 		lsi->lsi_stime = ksi->ksi_stime;
 		/* We use the same codes */
 		lsi->lsi_code = ksi->ksi_code;
 		/* XXX is that right? */
 		lsi->lsi_status = WEXITSTATUS(ksi->ksi_status);
 		break;
 	case LINUX32_SIGIO:
 		lsi->lsi_band = ksi->ksi_band;
 		lsi->lsi_fd = ksi->ksi_fd;
 		break;
 	default:
 		lsi->lsi_uid = ksi->ksi_uid;
 		lsi->lsi_pid = ksi->ksi_pid;
 		if (lsi->lsi_signo == LINUX32_SIGALRM ||
 		    lsi->lsi_signo >= LINUX32_SIGRTMIN)
 			NETBSD32PTR32(lsi->lsi_value.sival_ptr,
 			     ksi->ksi_value.sival_ptr);
 		break;
+	}
 	/* Save register context. */
 	linux32_save_ucontext(l, tf, mask, sas, &frame.sf_uc);
 	sendsig_reset(l, sig);
 	mutex_exit(p->p_lock);
 	error = copyout(&frame, fp, sizeof(frame));
 	mutex_enter(p->p_lock);
 	if (error != 0) {
 		/*
 		 * Process has trashed its stack; give it an illegal
 		 * instruction to halt it in its tracks.
 		 */
 		sigexit(l, SIGILL);
 		/* NOTREACHED */
+	}
 	/*
 	 * Build context to run handler in.
 	 */
 	tf->tf_gs = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_fs = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_es = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_ds = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_rip = (((long)p->p_sigctx.ps_sigcode) +
 	    (linux32_rt_sigcode - linux32_sigcode)) & 0xffffffff;
 	tf->tf_cs = GSEL(GUCODE32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_rflags &= ~PSL_CLEARSIG & 0xffffffff;
 	tf->tf_rsp = (long)fp & 0xffffffff;
 	tf->tf_ss = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	/* Remember that we're now on the signal stack. */
 	if (onstack)
 		sas->ss_flags |= SS_ONSTACK;
 	return;
+}
 void
 linux32_setregs(struct lwp *l, struct exec_package *pack, u_long stack)
+{
 	struct pcb *pcb = &l->l_addr->u_pcb;
 	struct trapframe *tf;
 	struct proc *p = l->l_proc;
 	void **retaddr;
 	/* If we were using the FPU, forget about it. */
 	if (l->l_addr->u_pcb.pcb_fpcpu != NULL)
 		fpusave_lwp(l, 0);
 #if defined(USER_LDT) && 0
 	pmap_ldt_cleanup(p);
 #endif
 	netbsd32_adjust_limits(p);
 	l->l_md.md_flags &= ~MDP_USEDFPU;
 	pcb->pcb_flags = 0;
 	pcb->pcb_savefpu.fp_fxsave.fx_fcw = __Linux_NPXCW__;
 	pcb->pcb_savefpu.fp_fxsave.fx_mxcsr = __INITIAL_MXCSR__;
 	pcb->pcb_savefpu.fp_fxsave.fx_mxcsr_mask = __INITIAL_MXCSR_MASK__;
 	pcb->pcb_fs = 0;
 	pcb->pcb_gs = 0;
 	p->p_flag |= PK_32;
 	tf = l->l_md.md_regs;
 	tf->tf_rax = 0;
 	tf->tf_rbx = (u_int64_t)p->p_psstr & 0xffffffff;
 	tf->tf_rcx = pack->ep_entry & 0xffffffff;
 	tf->tf_rdx = 0;
 	tf->tf_rsi = 0;
 	tf->tf_rdi = 0;
 	tf->tf_rbp = 0;
 	tf->tf_rsp = stack & 0xffffffff;
 	tf->tf_r8 = 0;
 	tf->tf_r9 = 0;
 	tf->tf_r10 = 0;
 	tf->tf_r11 = 0;
 	tf->tf_r12 = 0;
 	tf->tf_r13 = 0;
 	tf->tf_r14 = 0;
 	tf->tf_r15 = 0;
 	tf->tf_rip = pack->ep_entry & 0xffffffff;
 	tf->tf_rflags = PSL_USERSET;
 	tf->tf_cs = GSEL(GUCODE32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_ss = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_ds = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_es = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_fs = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	tf->tf_gs = GSEL(GUDATA32_SEL, SEL_UPL) & 0xffffffff;
 	/* XXX frob return address to return via old iret method, not sysret */
 	retaddr = (void **)tf - 1;
 	*retaddr = (void *)osyscall_return;
 	return;
+}
 static void
 linux32_save_ucontext(struct lwp *l, struct trapframe *tf, const sigset_t *mask, struct sigaltstack *sas, struct linux32_ucontext *uc)
+{
 	uc->uc_flags = 0;
 	NETBSD32PTR32(uc->uc_link, NULL);
 	native_to_linux32_sigaltstack(&uc->uc_stack, sas);
 	linux32_save_sigcontext(l, tf, mask, &uc->uc_mcontext);
 	native_to_linux32_sigset(&uc->uc_sigmask, mask);
 	(void)memset(&uc->uc_fpregs_mem, 0, sizeof(uc->uc_fpregs_mem));
+}
 static void
-linux32_save_sigcontext(l, tf, mask, sc)
+linux32_save_sigcontext(struct lwp *l, struct trapframe *tf,
-	struct lwp *l;
+			const sigset_t *mask, struct linux32_sigcontext *sc)
 	struct trapframe *tf;
 	const sigset_t *mask;
 	struct linux32_sigcontext *sc;
+{
 	/* Save register context. */
 	sc->sc_gs = tf->tf_gs;
 	sc->sc_fs = tf->tf_fs;
 	sc->sc_es = tf->tf_es;
 	sc->sc_ds = tf->tf_ds;
 	sc->sc_eflags = tf->tf_rflags;
 	sc->sc_edi = tf->tf_rdi;
 	sc->sc_esi = tf->tf_rsi;
 	sc->sc_esp = tf->tf_rsp;
 	sc->sc_ebp = tf->tf_rbp;
 	sc->sc_ebx = tf->tf_rbx;
 	sc->sc_edx = tf->tf_rdx;
 	sc->sc_ecx = tf->tf_rcx;
 	sc->sc_eax = tf->tf_rax;
 	sc->sc_eip = tf->tf_rip;
 	sc->sc_cs = tf->tf_cs;
 	sc->sc_esp_at_signal = tf->tf_rsp;
 	sc->sc_ss = tf->tf_ss;
 	sc->sc_err = tf->tf_err;
 	sc->sc_trapno = tf->tf_trapno;
 	sc->sc_cr2 = l->l_addr->u_pcb.pcb_cr2;
 	NETBSD32PTR32(sc->sc_387, NULL);
 	/* Save signal stack. */
 	/* Linux doesn't save the onstack flag in sigframe */
 	/* Save signal mask. */
 	native_to_linux32_old_sigset(&sc->sc_mask, mask);
+}
 int
 linux32_sys_sigreturn(struct lwp *l, const struct linux32_sys_sigreturn_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux32_sigcontextp_t) scp;
 	} */
 	struct linux32_sigcontext ctx;
 	int error;
 	if ((error = copyin(SCARG_P32(uap, scp), &ctx, sizeof(ctx))) != 0)
 		return error;
 	return linux32_restore_sigcontext(l, &ctx, retval);
+}
 int
 linux32_sys_rt_sigreturn(struct lwp *l, const struct linux32_sys_rt_sigreturn_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux32_ucontextp_t) ucp;
 	} */
 	struct linux32_ucontext ctx;
 	int error;
 	if ((error = copyin(SCARG_P32(uap, ucp), &ctx, sizeof(ctx))) != 0)
 		return error;
 	return linux32_restore_sigcontext(l, &ctx.uc_mcontext, retval);
+}
 static int
-linux32_restore_sigcontext(l, scp, retval)
+linux32_restore_sigcontext(struct lwp *l, struct linux32_sigcontext *scp,
-	struct lwp *l;
+			register_t *retval)
 	struct linux32_sigcontext *scp;
 	register_t *retval;
+{
 	struct trapframe *tf;
 	struct proc *p = l->l_proc;
 	struct sigaltstack *sas = &l->l_sigstk;
 	sigset_t mask;
 	ssize_t ss_gap;
 	/* Restore register context. */
 	tf = l->l_md.md_regs;
 	/*
 	 * Check for security violations.  If we're returning to
 	 * protected mode, the CPU will validate the segment registers
 	 * automatically and generate a trap on violations.  We handle
 	 * the trap, rather than doing all of the checking here.
 	 */
 	if (((scp->sc_eflags ^ tf->tf_rflags) & PSL_USERSTATIC) != 0 ||
 	    !USERMODE(scp->sc_cs, scp->sc_eflags))
 		return EINVAL;
 	if (scp->sc_fs != 0 && !VALID_USER_DSEL32(scp->sc_fs))
 		return EINVAL;
 	if (scp->sc_gs != 0 && !VALID_USER_DSEL32(scp->sc_gs))
 		return EINVAL;
 	if (scp->sc_es != 0 && !VALID_USER_DSEL32(scp->sc_es))
 		return EINVAL;
 	if (!VALID_USER_DSEL32(scp->sc_ds) ||
 	    !VALID_USER_DSEL32(scp->sc_ss))
 		return EINVAL;
 	if (scp->sc_eip >= VM_MAXUSER_ADDRESS32)
 		return EINVAL;
 	tf->tf_gs = (register_t)scp->sc_gs & 0xffffffff;
 	tf->tf_fs = (register_t)scp->sc_fs & 0xffffffff;
 	tf->tf_es = (register_t)scp->sc_es & 0xffffffff;
 	tf->tf_ds = (register_t)scp->sc_ds & 0xffffffff;
 	tf->tf_rflags &= ~PSL_USER;
 	tf->tf_rflags |= ((register_t)scp->sc_eflags & PSL_USER);
 	tf->tf_rdi = (register_t)scp->sc_edi & 0xffffffff;
 	tf->tf_rsi = (register_t)scp->sc_esi & 0xffffffff;
 	tf->tf_rbp = (register_t)scp->sc_ebp & 0xffffffff;
 	tf->tf_rbx = (register_t)scp->sc_ebx & 0xffffffff;
 	tf->tf_rdx = (register_t)scp->sc_edx & 0xffffffff;
 	tf->tf_rcx = (register_t)scp->sc_ecx & 0xffffffff;
 	tf->tf_rax = (register_t)scp->sc_eax & 0xffffffff;
 	tf->tf_rip = (register_t)scp->sc_eip & 0xffffffff;
 	tf->tf_cs = (register_t)scp->sc_cs & 0xffffffff;
 	tf->tf_rsp = (register_t)scp->sc_esp_at_signal & 0xffffffff;
 	tf->tf_ss = (register_t)scp->sc_ss & 0xffffffff;
 	mutex_enter(p->p_lock);
 	/* Restore signal stack. */
 	ss_gap = (ssize_t)
 	    ((char *)NETBSD32IPTR64(scp->sc_esp_at_signal)
 	     - (char *)sas->ss_sp);
 	if (ss_gap >= 0 && ss_gap < sas->ss_size)
 		sas->ss_flags |= SS_ONSTACK;
 	else
 		sas->ss_flags &= ~SS_ONSTACK;
 	/* Restore signal mask. */
 	linux32_old_to_native_sigset(&mask, &scp->sc_mask);
 	(void) sigprocmask1(l, SIG_SETMASK, &mask, 0);
 	mutex_exit(p->p_lock);
 #ifdef DEBUG_LINUX
 	printf("linux32_sigreturn: rip = 0x%lx, rsp = 0x%lx, flags = 0x%lx\n",
 	    tf->tf_rip, tf->tf_rsp, tf->tf_rflags);
 #endif
 	return EJUSTRETURN;
+}

 @@ -1,251 +1,247 @@
-/*	$NetBSD: linux32_exec_elf32.c,v 1.8 2008/04/28 20:23:44 martin Exp $ */
+/*	$NetBSD: linux32_exec_elf32.c,v 1.9 2009/03/15 15:56:50 cegger Exp $ */
 /*-
  * Copyright (c) 1995, 1998, 2000, 2001,2006 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Christos Zoulas, Frank van der Linden, Eric Haszlakiewicz and
  * Emmanuel Dreyfus.
+ *
  * 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: linux32_exec_elf32.c,v 1.8 2008/04/28 20:23:44 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: linux32_exec_elf32.c,v 1.9 2009/03/15 15:56:50 cegger 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/kauth.h>
 #include <sys/kernel.h>
 #include <sys/resourcevar.h>
 #include <sys/signal.h>
 #include <sys/signalvar.h>
 #include <compat/linux/common/linux_exec.h>
 #include <compat/netbsd32/netbsd32.h>
 #include <compat/netbsd32/netbsd32_exec.h>
 #include <compat/linux32/common/linux32_exec.h>
 #include <machine/frame.h>
 #ifdef DEBUG_LINUX
 #define DPRINTF(a)      uprintf a
 #else
 #define DPRINTF(a)
 #endif
 int linux32_copyinargs(struct exec_package *, struct ps_strings *,
 			void *, size_t, const void *, const void *);
 int
-ELFNAME2(linux32,probe)(l, epp, eh, itp, pos)
+ELFNAME2(linux32,probe)(struct lwp *l, struct exec_package *epp,
-	struct lwp *l;
+			void *eh, char *itp, vaddr_t *pos)
 	struct exec_package *epp;
 	void *eh;
 	char *itp;
 	vaddr_t *pos;
+{
 	int error;
 	if (((error = ELFNAME2(linux,signature)(l, epp, eh, itp)) != 0) &&
 #ifdef LINUX32_GCC_SIGNATURE
 	    ((error = ELFNAME2(linux,gcc_signature)(l, epp, eh)) != 0) &&
 #endif
 #ifdef LINUX32_ATEXIT_SIGNATURE
 	    ((error = ELFNAME2(linux,atexit_signature)(l, epp, eh)) != 0) &&
 #endif
 #ifdef LINUX32_DEBUGLINK_SIGNATURE
 	    ((error = ELFNAME2(linux,debuglink_signature)(l, epp, eh)) != 0) &&
 #endif
 )
 			return error;
 	if (itp) {
 		if ((error = emul_find_interp(l, epp, itp)))
 			return (error);
+	}
 #if 0
 	DPRINTF(("linux32_probe: returning 0\n"));
 #endif
 	epp->ep_flags |= EXEC_32;
 	epp->ep_vm_minaddr = VM_MIN_ADDRESS;
 	epp->ep_vm_maxaddr = USRSTACK32;
 	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
 linux32_elf32_copyargs(struct lwp *l, struct exec_package *pack,
     struct ps_strings *arginfo, char **stackp, void *argp)
+{
 	struct linux32_extra_stack_data *esdp, esd;
 	struct elf_args *ap;
 	struct vattr *vap;
 	Elf_Ehdr *eh;
 	Elf_Phdr *ph;
 	Elf_Addr phdr = 0;
 	u_long phsize;
 	int error;
 	int i;
 	if ((error = netbsd32_copyargs(l, pack, arginfo, stackp, argp)) != 0)
 		return error;
 	/*
 	 * Push extra arguments on the stack needed by dynamically
 	 * linked binaries and static binaries as well.
 	 */
 	memset(&esd, 0, sizeof(esd));
 	esdp = (struct linux32_extra_stack_data *)(*stackp);
 	ap = (struct elf_args *)pack->ep_emul_arg;
 	vap = pack->ep_vap;
 	eh = (Elf_Ehdr *)pack->ep_hdr;
 	/*
 	 * We forgot this, so we ned to reload it now. XXX keep track of it?
 	 */
 	if (ap == NULL) {
 		phsize = eh->e_phnum * sizeof(Elf_Phdr);
 		ph = (Elf_Phdr *)malloc(phsize, M_TEMP, M_WAITOK);
 		error = exec_read_from(l, pack->ep_vp, eh->e_phoff, ph, phsize);
 		if (error != 0) {
 			for (i = 0; i < eh->e_phnum; i++) {
 				if (ph[i].p_type == PT_PHDR) {
 					phdr = ph[i].p_vaddr;
 					break;
+				}
+			}
+		}
 		free(ph, M_TEMP);
+	}
 	/*
 	 * The exec_package doesn't have a proc pointer and it's not
 	 * exactly trivial to add one since the credentials are
 	 * changing. XXX Linux uses curlwp's credentials.
 	 * Why can't we use them too? XXXad we do now; what's different
 	 * about Linux's LWP creds?
 	 */
 	i = 0;
 	esd.ai[i].a_type = LINUX_AT_SYSINFO;
 	esd.ai[i++].a_v = NETBSD32PTR32I(&esdp->kernel_vsyscall[0]);
 	esd.ai[i].a_type = LINUX_AT_SYSINFO_EHDR;
 	esd.ai[i++].a_v = NETBSD32PTR32I(&esdp->elfhdr);
 	esd.ai[i].a_type = LINUX_AT_HWCAP;
 	esd.ai[i++].a_v = LINUX32_CPUCAP;
 	esd.ai[i].a_type = AT_PAGESZ;
 	esd.ai[i++].a_v = PAGE_SIZE;
 	esd.ai[i].a_type = LINUX_AT_CLKTCK;
 	esd.ai[i++].a_v = hz;
 	esd.ai[i].a_type = AT_PHDR;
 	esd.ai[i++].a_v = (ap ? ap->arg_phaddr: phdr);
 	esd.ai[i].a_type = AT_PHENT;
 	esd.ai[i++].a_v = (ap ? ap->arg_phentsize : eh->e_phentsize);
 	esd.ai[i].a_type = AT_PHNUM;
 	esd.ai[i++].a_v = (ap ? ap->arg_phnum : eh->e_phnum);
 	esd.ai[i].a_type = AT_BASE;
 	esd.ai[i++].a_v = (ap ? ap->arg_interp : 0);
 	esd.ai[i].a_type = AT_FLAGS;
 	esd.ai[i++].a_v = 0;
 	esd.ai[i].a_type = AT_ENTRY;
 	esd.ai[i++].a_v = (ap ? ap->arg_entry : eh->e_entry);
 	esd.ai[i].a_type = LINUX_AT_EGID;
 	esd.ai[i++].a_v = ((vap->va_mode & S_ISGID) ?
 	    vap->va_gid : kauth_cred_getegid(l->l_cred));
 	esd.ai[i].a_type = LINUX_AT_GID;
 	esd.ai[i++].a_v = kauth_cred_getgid(l->l_cred);
 	esd.ai[i].a_type = LINUX_AT_EUID;
 	esd.ai[i++].a_v = ((vap->va_mode & S_ISUID) ?
 	    vap->va_uid : kauth_cred_geteuid(l->l_cred));
 	esd.ai[i].a_type = LINUX_AT_UID;
 	esd.ai[i++].a_v = kauth_cred_getuid(l->l_cred);
 	esd.ai[i].a_type = LINUX_AT_SECURE;
 	esd.ai[i++].a_v = 0;
 	esd.ai[i].a_type = LINUX_AT_PLATFORM;
 	esd.ai[i++].a_v = NETBSD32PTR32I(&esdp->hw_platform[0]);
 	esd.ai[i].a_type = AT_NULL;
 	esd.ai[i++].a_v = 0;
 #ifdef DEBUG_LINUX
 	if (i != LINUX32_ELF_AUX_ENTRIES) {
 		printf("linux32_elf32_copyargs: %d Aux entries\n", i);
 		return EINVAL;
+	}
 #endif
 	memcpy(esd.kernel_vsyscall, linux32_kernel_vsyscall,
 	    sizeof(linux32_kernel_vsyscall));
 	memcpy(&esd.elfhdr, eh, sizeof(*eh));
 	strcpy(esd.hw_platform, LINUX32_PLATFORM);
 	if (ap) {
 		free((char *)ap, M_TEMP);
 		pack->ep_emul_arg = NULL;
+	}
 	/*
 	 * Copy out the ELF auxiliary table and hw platform name
 	 */
 	if ((error = copyout(&esd, esdp, sizeof(esd))) != 0)
 		return error;
 	*stackp += sizeof(esd);
 	return 0;
+}

 @@ -1,552 +1,549 @@
-/*	$NetBSD: linux32_unistd.c,v 1.30 2009/01/16 13:10:47 njoly Exp $ */
+/*	$NetBSD: linux32_unistd.c,v 1.31 2009/03/15 15:56:50 cegger Exp $ */
 /*-
  * Copyright (c) 2006 Emmanuel Dreyfus, 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 Emmanuel Dreyfus
  * 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 THE AUTHOR 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 AUTHOR 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: linux32_unistd.c,v 1.30 2009/01/16 13:10:47 njoly Exp $");
+__KERNEL_RCSID(0, "$NetBSD: linux32_unistd.c,v 1.31 2009/03/15 15:56:50 cegger Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/fstypes.h>
 #include <sys/signal.h>
 #include <sys/dirent.h>
 #include <sys/kernel.h>
 #include <sys/fcntl.h>
 #include <sys/select.h>
 #include <sys/proc.h>
 #include <sys/ucred.h>
 #include <sys/swap.h>
 #include <sys/kauth.h>
 #include <machine/types.h>
 #include <sys/syscallargs.h>
 #include <compat/netbsd32/netbsd32.h>
 #include <compat/netbsd32/netbsd32_conv.h>
 #include <compat/linux/common/linux_types.h>
 #include <compat/linux/common/linux_signal.h>
 #include <compat/linux/common/linux_machdep.h>
 #include <compat/linux/common/linux_misc.h>
 #include <compat/linux/common/linux_oldolduname.h>
 #include <compat/linux/common/linux_ipc.h>
 #include <compat/linux/common/linux_sem.h>
 #include <compat/linux/linux_syscallargs.h>
 #include <compat/linux32/common/linux32_types.h>
 #include <compat/linux32/common/linux32_signal.h>
 #include <compat/linux32/common/linux32_machdep.h>
 #include <compat/linux32/common/linux32_sysctl.h>
 #include <compat/linux32/common/linux32_socketcall.h>
 #include <compat/linux32/linux32_syscallargs.h>
 static int linux32_select1(struct lwp *, register_t *,
     int, fd_set *, fd_set *, fd_set *, struct timeval *);
 int
 linux32_sys_brk(struct lwp *l, const struct linux32_sys_brk_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_charp) nsize;
 	} */
 	struct linux_sys_brk_args ua;
 	NETBSD32TOP_UAP(nsize, char);
 	return linux_sys_brk(l, &ua, retval);
+}
 int
 linux32_sys_llseek(struct lwp *l, const struct linux32_sys_llseek_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
                 syscallarg(u_int32_t) ohigh;
                 syscallarg(u_int32_t) olow;
 		syscallarg(netbsd32_voidp) res;
 		syscallarg(int) whence;
 	} */
 	struct linux_sys_llseek_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(ohigh);
 	NETBSD32TO64_UAP(olow);
 	NETBSD32TOP_UAP(res, void);
 	NETBSD32TO64_UAP(whence);
 	return linux_sys_llseek(l, &ua, retval);
+}
 int
 linux32_sys_select(struct lwp *l, const struct linux32_sys_select_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) nfds;
 		syscallarg(netbsd32_fd_setp_t) readfds;
 		syscallarg(netbsd32_fd_setp_t) writefds;
 		syscallarg(netbsd32_fd_setp_t) exceptfds;
 		syscallarg(netbsd32_timeval50p_t) timeout;
 	} */
 	return linux32_select1(l, retval, SCARG(uap, nfds),
 	    SCARG_P32(uap, readfds),
 	    SCARG_P32(uap, writefds),
 	    SCARG_P32(uap, exceptfds),
 	    SCARG_P32(uap, timeout));
+}
 int
 linux32_sys_oldselect(struct lwp *l, const struct linux32_sys_oldselect_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux32_oldselectp_t) lsp;
 	} */
 	struct linux32_oldselect lsp32;
 	int error;
 	if ((error = copyin(SCARG_P32(uap, lsp), &lsp32, sizeof(lsp32))) != 0)
 		return error;
 	return linux32_select1(l, retval, lsp32.nfds,
 	     NETBSD32PTR64(lsp32.readfds), NETBSD32PTR64(lsp32.writefds),
 	     NETBSD32PTR64(lsp32.exceptfds), NETBSD32PTR64(lsp32.timeout));
+}
 static int
-linux32_select1(l, retval, nfds, readfds, writefds, exceptfds, timeout)
+linux32_select1(struct lwp *l, register_t *retval, int nfds,
-        struct lwp *l;
+		fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
-        register_t *retval;
+		struct timeval *timeout)
         int nfds;
         fd_set *readfds, *writefds, *exceptfds;
         struct timeval *timeout;
+{
 	struct timeval tv0, tv1, utv, *tv = NULL;
 	struct netbsd32_timeval50 utv32;
 	int error;
 	timerclear(&utv); /* XXX GCC4 */
 	/*
 	 * Store current time for computation of the amount of
 	 * time left.
 	 */
 	if (timeout) {
 		if ((error = copyin(timeout, &utv32, sizeof(utv32))))
 			return error;
 		netbsd32_to_timeval50(&utv32, &utv);
 		if (itimerfix(&utv)) {
 			/*
 			 * The timeval was invalid.  Convert it to something
 			 * valid that will act as it does under Linux.
 			 */
 			utv.tv_sec += utv.tv_usec / 1000000;
 			utv.tv_usec %= 1000000;
 			if (utv.tv_usec < 0) {
 				utv.tv_sec -= 1;
 				utv.tv_usec += 1000000;
+			}
 			if (utv.tv_sec < 0)
 				timerclear(&utv);
+		}
 		microtime(&tv0);
 		tv = &utv;
+	}
 	error = selcommon(l, retval, nfds,
 	    readfds, writefds, exceptfds, tv, NULL);
 	if (error) {
 		/*
 		 * See fs/select.c in the Linux kernel.  Without this,
 		 * Maelstrom doesn't work.
 		 */
 		if (error == ERESTART)
 			error = EINTR;
 		return error;
+	}
 	if (timeout) {
 		if (*retval) {
 			/*
 			 * Compute how much time was left of the timeout,
 			 * by subtracting the current time and the time
 			 * before we started the call, and subtracting
 			 * that result from the user-supplied value.
 			 */
 			microtime(&tv1);
 			timersub(&tv1, &tv0, &tv1);
 			timersub(&utv, &tv1, &utv);
 			if (utv.tv_sec < 0)
 				timerclear(&utv);
 		} else {
 			timerclear(&utv);
+		}
 		netbsd32_from_timeval50(&utv, &utv32);
 		if ((error = copyout(&utv32, timeout, sizeof(utv32))))
 			return error;
+	}
 	return 0;
+}
 int
 linux32_sys_pipe(struct lwp *l, const struct linux32_sys_pipe_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(netbsd32_intp) fd;
 	} */
 	int error;
 	int pfds[2];
 	if ((error = sys_pipe(l, 0, retval)))
 		return error;
 	pfds[0] = (int)retval[0];
 	pfds[1] = (int)retval[1];
 	if ((error = copyout(pfds, SCARG_P32(uap, fd), 2 * sizeof (int))) != 0)
 		return error;
 	retval[0] = 0;
 	retval[1] = 0;
 	return 0;
+}
 int
 linux32_sys_unlink(struct lwp *l, const struct linux32_sys_unlink_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 	} */
 	struct linux_sys_unlink_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	return linux_sys_unlink(l, &ua, retval);
+}
 int
 linux32_sys_creat(struct lwp *l, const struct linux32_sys_creat_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) mode;
 	} */
 	struct sys_open_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	SCARG(&ua, flags) = O_CREAT | O_TRUNC | O_WRONLY;
 	NETBSD32TO64_UAP(mode);
 	return sys_open(l, &ua, retval);
+}
 int
 linux32_sys_mknod(struct lwp *l, const struct linux32_sys_mknod_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 		syscallarg(int) mode;
 		syscallarg(int) dev;
 	} */
 	struct linux_sys_mknod_args ua;
 	NETBSD32TOP_UAP(path, const char);
 	NETBSD32TO64_UAP(mode);
 	NETBSD32TO64_UAP(dev);
 	return linux_sys_mknod(l, &ua, retval);
+}
 int
 linux32_sys_break(struct lwp *l, const struct linux32_sys_break_args *uap, register_t *retval)
+{
 #if 0
 	/* {
 		syscallarg(const netbsd32_charp) nsize;
 	} */
 #endif
 	return ENOSYS;
+}
 int
 linux32_sys_swapon(struct lwp *l, const struct linux32_sys_swapon_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) name;
 	} */
 	struct sys_swapctl_args ua;
         SCARG(&ua, cmd) = SWAP_ON;
         SCARG(&ua, arg) = SCARG_P32(uap, name);
         SCARG(&ua, misc) = 0;   /* priority */
         return (sys_swapctl(l, &ua, retval));
+}
 int
 linux32_sys_swapoff(struct lwp *l, const struct linux32_sys_swapoff_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const netbsd32_charp) path;
 	} */
 	struct sys_swapctl_args ua;
         SCARG(&ua, cmd) = SWAP_OFF;
         SCARG(&ua, arg) = SCARG_P32(uap, path);
         SCARG(&ua, misc) = 0;   /* priority */
         return (sys_swapctl(l, &ua, retval));
+}
 int
 linux32_sys_reboot(struct lwp *l, const struct linux32_sys_reboot_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) magic1;
 		syscallarg(int) magic2;
 		syscallarg(int) cmd;
 		syscallarg(netbsd32_voidp) arg;
 	} */
 	struct linux_sys_reboot_args ua;
 	NETBSD32TO64_UAP(magic1);
 	NETBSD32TO64_UAP(magic2);
 	NETBSD32TO64_UAP(cmd);
 	NETBSD32TOP_UAP(arg, void);
 	return linux_sys_reboot(l, &ua, retval);
+}
 int
 linux32_sys_setresuid(struct lwp *l, const struct linux32_sys_setresuid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(uid_t) ruid;
 		syscallarg(uid_t) euid;
 		syscallarg(uid_t) suid;
 	} */
 	struct linux_sys_setresuid_args ua;
 	NETBSD32TO64_UAP(ruid);
 	NETBSD32TO64_UAP(euid);
 	NETBSD32TO64_UAP(suid);
 	return linux_sys_setresuid(l, &ua, retval);
+}
 int
 linux32_sys_getresuid(struct lwp *l, const struct linux32_sys_getresuid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux32_uidp_t) ruid;
 		syscallarg(linux32_uidp_t) euid;
 		syscallarg(linux32_uidp_t) suid;
 	} */
 	kauth_cred_t pc = l->l_cred;
 	int error;
 	uid_t uid;
 	uid = kauth_cred_getuid(pc);
 	if ((error = copyout(&uid, SCARG_P32(uap, ruid), sizeof(uid_t))) != 0)
 		return error;
 	uid = kauth_cred_geteuid(pc);
 	if ((error = copyout(&uid, SCARG_P32(uap, euid), sizeof(uid_t))) != 0)
 		return error;
 	uid = kauth_cred_getsvuid(pc);
 	return copyout(&uid, SCARG_P32(uap, suid), sizeof(uid_t));
+}
 int
 linux32_sys_setresgid(struct lwp *l, const struct linux32_sys_setresgid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(gid_t) rgid;
 		syscallarg(gid_t) egid;
 		syscallarg(gid_t) sgid;
 	} */
 	struct linux_sys_setresgid_args ua;
 	NETBSD32TO64_UAP(rgid);
 	NETBSD32TO64_UAP(egid);
 	NETBSD32TO64_UAP(sgid);
 	return linux_sys_setresgid(l, &ua, retval);
+}
 int
 linux32_sys_getresgid(struct lwp *l, const struct linux32_sys_getresgid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux32_gidp_t) rgid;
 		syscallarg(linux32_gidp_t) egid;
 		syscallarg(linux32_gidp_t) sgid;
 	} */
 	kauth_cred_t pc = l->l_cred;
 	int error;
 	gid_t gid;
 	gid = kauth_cred_getgid(pc);
 	if ((error = copyout(&gid, SCARG_P32(uap, rgid), sizeof(gid_t))) != 0)
 		return error;
 	gid = kauth_cred_getegid(pc);
 	if ((error = copyout(&gid, SCARG_P32(uap, egid), sizeof(gid_t))) != 0)
 		return error;
 	gid = kauth_cred_getsvgid(pc);
 	return copyout(&gid, SCARG_P32(uap, sgid), sizeof(gid_t));
+}
 int
 linux32_sys_nice(struct lwp *l, const struct linux32_sys_nice_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) incr;
 	} */
 	struct proc *p = l->l_proc;
 	struct sys_setpriority_args bsa;
 	SCARG(&bsa, which) = PRIO_PROCESS;
 	SCARG(&bsa, who) = 0;
 	SCARG(&bsa, prio) = p->p_nice - NZERO + SCARG(uap, incr);
 	return sys_setpriority(l, &bsa, retval);
+}
 int
 linux32_sys_alarm(struct lwp *l, const struct linux32_sys_alarm_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(unsigned int) secs;
 	} */
 	struct linux_sys_alarm_args ua;
 	NETBSD32TO64_UAP(secs);
 	return linux_sys_alarm(l, &ua, retval);
+}
 int
 linux32_sys_fdatasync(struct lwp *l, const struct linux32_sys_fdatasync_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 	} */
 	struct linux_sys_fdatasync_args ua;
 	NETBSD32TO64_UAP(fd);
 	return linux_sys_fdatasync(l, &ua, retval);
+}
 int
 linux32_sys_setfsuid(struct lwp *l, const struct linux32_sys_setfsuid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(uid_t) uid;
 	} */
 	struct linux_sys_setfsuid_args ua;
 	NETBSD32TO64_UAP(uid);
 	return linux_sys_setfsuid(l, &ua, retval);
+}
 int
 linux32_sys_setfsgid(struct lwp *l, const struct linux32_sys_setfsgid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(gid_t) gid;
 	} */
 	struct linux_sys_setfsgid_args ua;
 	NETBSD32TO64_UAP(gid);
 	return linux_sys_setfsgid(l, &ua, retval);
+}
 /*
  * pread(2).
  */
 int
 linux32_sys_pread(struct lwp *l,
     const struct linux32_sys_pread_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(netbsd32_voidp) buf;
 		syscallarg(netbsd32_size_t) nbyte;
 		syscallarg(linux32_off_t) offset;
 	} */
 	struct sys_pread_args pra;
 	SCARG(&pra, fd) = SCARG(uap, fd);
 	SCARG(&pra, buf) = SCARG_P32(uap, buf);
 	SCARG(&pra, nbyte) = SCARG(uap, nbyte);
 	SCARG(&pra, offset) = SCARG(uap, offset);
 	return sys_pread(l, &pra, retval);
+}
 /*
  * pwrite(2).
  */
 int
 linux32_sys_pwrite(struct lwp *l,
     const struct linux32_sys_pwrite_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(const netbsd32_voidp) buf;
 		syscallarg(netbsd32_size_t) nbyte;
 		syscallarg(linux32_off_t) offset;
 	} */
 	struct sys_pwrite_args pra;
 	SCARG(&pra, fd) = SCARG(uap, fd);
 	SCARG(&pra, buf) = SCARG_P32(uap, buf);
 	SCARG(&pra, nbyte) = SCARG(uap, nbyte);
 	SCARG(&pra, offset) = SCARG(uap, offset);
 	return sys_pwrite(l, &pra, retval);
+}