 @@ -1,497 +1,499 @@
-/*	$NetBSD: linux_misc_notalpha.c,v 1.103 2008/07/15 16:18:08 christos Exp $	*/
+/*	$NetBSD: linux_misc_notalpha.c,v 1.104 2008/10/03 22:39:36 njoly Exp $	*/
 /*-
  * Copyright (c) 1995, 1998, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Frank van der Linden and Eric Haszlakiewicz; by Jason R. Thorpe
  * of the Numerical Aerospace Simulation Facility, NASA Ames Research Center.
+ *
  * 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: linux_misc_notalpha.c,v 1.103 2008/07/15 16:18:08 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: linux_misc_notalpha.c,v 1.104 2008/10/03 22:39:36 njoly Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/mman.h>
 #include <sys/mount.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 #include <sys/namei.h>
 #include <sys/proc.h>
 #include <sys/prot.h>
 #include <sys/ptrace.h>
 #include <sys/resource.h>
 #include <sys/resourcevar.h>
 #include <sys/time.h>
 #include <sys/vfs_syscalls.h>
 #include <sys/wait.h>
 #include <sys/kauth.h>
 #include <sys/syscallargs.h>
 #include <compat/linux/common/linux_types.h>
 #include <compat/linux/common/linux_fcntl.h>
 #include <compat/linux/common/linux_misc.h>
 #include <compat/linux/common/linux_mmap.h>
 #include <compat/linux/common/linux_signal.h>
 #include <compat/linux/common/linux_util.h>
 #include <compat/linux/common/linux_ipc.h>
 #include <compat/linux/common/linux_sem.h>
 #include <compat/linux/linux_syscallargs.h>
 /*
  * This file contains routines which are used
  * on every linux architechture except the Alpha.
  */
 /* Used on: arm, i386, m68k, mips, ppc, sparc, sparc64 */
 /* Not used on: alpha */
 #ifdef DEBUG_LINUX
 #define DPRINTF(a)	uprintf a
 #else
 #define DPRINTF(a)
 #endif
 #ifndef COMPAT_LINUX32
 #if !defined(__m68k__) && !defined(__amd64__)
 static void bsd_to_linux_statfs64(const struct statvfs *,
 	struct linux_statfs64  *);
 #endif
 /*
  * Alarm. This is a libc call which uses setitimer(2) in NetBSD.
  * Fiddle with the timers to make it work.
+ *
  * XXX This shouldn't be dicking about with the ptimer stuff directly.
  */
 int
 linux_sys_alarm(struct lwp *l, const struct linux_sys_alarm_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(unsigned int) secs;
 	} */
 	struct proc *p = l->l_proc;
 	struct timespec now;
 	struct itimerspec *itp, it;
 	struct ptimer *ptp, *spare;
 	extern kmutex_t timer_lock;
 	struct ptimers *pts;
 	if ((pts = p->p_timers) == NULL)
 		pts = timers_alloc(p);
 	spare = NULL;
  retry:
 	mutex_spin_enter(&timer_lock);
 	if (pts && pts->pts_timers[ITIMER_REAL])
 		itp = &pts->pts_timers[ITIMER_REAL]->pt_time;
 	else
 		itp = NULL;
 	/*
 	 * Clear any pending timer alarms.
 	 */
 	if (itp) {
 		callout_stop(&pts->pts_timers[ITIMER_REAL]->pt_ch);
 		timespecclear(&itp->it_interval);
 		getnanotime(&now);
 		if (timespecisset(&itp->it_value) &&
 		    timespeccmp(&itp->it_value, &now, >))
 			timespecsub(&itp->it_value, &now, &itp->it_value);
 		/*
 		 * Return how many seconds were left (rounded up)
 		 */
 		retval[0] = itp->it_value.tv_sec;
 		if (itp->it_value.tv_nsec)
 			retval[0]++;
 	} else {
 		retval[0] = 0;
+	}
 	/*
 	 * alarm(0) just resets the timer.
 	 */
 	if (SCARG(uap, secs) == 0) {
 		if (itp)
 			timespecclear(&itp->it_value);
 		mutex_spin_exit(&timer_lock);
 		return 0;
+	}
 	/*
 	 * Check the new alarm time for sanity, and set it.
 	 */
 	timespecclear(&it.it_interval);
 	it.it_value.tv_sec = SCARG(uap, secs);
 	it.it_value.tv_nsec = 0;
 	if (itimespecfix(&it.it_value) || itimespecfix(&it.it_interval)) {
 		mutex_spin_exit(&timer_lock);
 		return (EINVAL);
+	}
 	ptp = pts->pts_timers[ITIMER_REAL];
 	if (ptp == NULL) {
 		if (spare == NULL) {
 			mutex_spin_exit(&timer_lock);
 			spare = pool_get(&ptimer_pool, PR_WAITOK);
 			goto retry;
+		}
 		ptp = spare;
 		spare = NULL;
 		ptp->pt_ev.sigev_notify = SIGEV_SIGNAL;
 		ptp->pt_ev.sigev_signo = SIGALRM;
 		ptp->pt_overruns = 0;
 		ptp->pt_proc = p;
 		ptp->pt_type = CLOCK_REALTIME;
 		ptp->pt_entry = CLOCK_REALTIME;
 		ptp->pt_active = 0;
 		ptp->pt_queued = 0;
 		callout_init(&ptp->pt_ch, CALLOUT_MPSAFE);
 		pts->pts_timers[ITIMER_REAL] = ptp;
+	}
 	if (timespecisset(&it.it_value)) {
 		/*
 		 * Don't need to check tvhzto() return value, here.
 		 * callout_reset() does it for us.
 		 */
 		getnanotime(&now);
 		timespecadd(&it.it_value, &now, &it.it_value);
 		callout_reset(&ptp->pt_ch, tshzto(&it.it_value),
 		    realtimerexpire, ptp);
+	}
 	ptp->pt_time = it;
 	mutex_spin_exit(&timer_lock);
 	return 0;
+}
 #endif /* !COMPAT_LINUX32 */
 #if !defined(__amd64__)
 int
 linux_sys_nice(struct lwp *l, const struct linux_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) = SCARG(uap, incr);
+	SCARG(&bsa, prio) = p->p_nice - NZERO + SCARG(uap, incr);
         return sys_setpriority(l, &bsa, retval);
+}
 #endif /* !__amd64__ */
 #ifndef COMPAT_LINUX32
 #ifndef __amd64__
 /*
  * The old Linux readdir was only able to read one entry at a time,
  * even though it had a 'count' argument. In fact, the emulation
  * of the old call was better than the original, because it did handle
  * the count arg properly. Don't bother with it anymore now, and use
  * it to distinguish between old and new. The difference is that the
  * newer one actually does multiple entries, and the reclen field
  * really is the reclen, not the namelength.
  */
 int
 linux_sys_readdir(struct lwp *l, const struct linux_sys_readdir_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(struct linux_dirent *) dent;
 		syscallarg(unsigned int) count;
 	} */
 	int error;
 	struct linux_sys_getdents_args da;
 	SCARG(&da, fd) = SCARG(uap, fd);
 	SCARG(&da, dent) = SCARG(uap, dent);
 	SCARG(&da, count) = 1;
 	error = linux_sys_getdents(l, &da, retval);
 	if (error == 0 && *retval > 1)
 		*retval = 1;
 	return error;
+}
 #endif /* !amd64 */
 /*
  * I wonder why Linux has gettimeofday() _and_ time().. Still, we
  * need to deal with it.
  */
 int
 linux_sys_time(struct lwp *l, const struct linux_sys_time_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux_time_t) *t;
 	} */
 	struct timeval atv;
 	linux_time_t tt;
 	int error;
 	microtime(&atv);
 	tt = atv.tv_sec;
 	if (SCARG(uap, t) && (error = copyout(&tt, SCARG(uap, t), sizeof tt)))
 		return error;
 	retval[0] = tt;
 	return 0;
+}
 /*
  * utime(). Do conversion to things that utimes() understands,
  * and pass it on.
  */
 int
 linux_sys_utime(struct lwp *l, const struct linux_sys_utime_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const char *) path;
 		syscallarg(struct linux_utimbuf *)times;
 	} */
 	int error;
 	struct timeval tv[2], *tvp;
 	struct linux_utimbuf lut;
 	if (SCARG(uap, times) != NULL) {
 		if ((error = copyin(SCARG(uap, times), &lut, sizeof lut)))
 			return error;
 		tv[0].tv_usec = tv[1].tv_usec = 0;
 		tv[0].tv_sec = lut.l_actime;
 		tv[1].tv_sec = lut.l_modtime;
 		tvp = tv;
 	} else
 		tvp = NULL;
 	return do_sys_utimes(l, NULL, SCARG(uap, path), FOLLOW,
 			   tvp,  UIO_SYSSPACE);
+}
 #ifndef __amd64__
 /*
  * waitpid(2).  Just forward on to linux_sys_wait4 with a NULL rusage.
  */
 int
 linux_sys_waitpid(struct lwp *l, const struct linux_sys_waitpid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) pid;
 		syscallarg(int *) status;
 		syscallarg(int) options;
 	} */
 	struct linux_sys_wait4_args linux_w4a;
 	SCARG(&linux_w4a, pid) = SCARG(uap, pid);
 	SCARG(&linux_w4a, status) = SCARG(uap, status);
 	SCARG(&linux_w4a, options) = SCARG(uap, options);
 	SCARG(&linux_w4a, rusage) = NULL;
 	return linux_sys_wait4(l, &linux_w4a, retval);
+}
 #endif /* !amd64 */
 int
 linux_sys_setresgid(struct lwp *l, const struct linux_sys_setresgid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(gid_t) rgid;
 		syscallarg(gid_t) egid;
 		syscallarg(gid_t) sgid;
 	} */
 	/*
 	 * Note: These checks are a little different than the NetBSD
 	 * setregid(2) call performs.  This precisely follows the
 	 * behavior of the Linux kernel.
 	 */
 	return do_setresgid(l, SCARG(uap,rgid), SCARG(uap, egid),
 			    SCARG(uap, sgid),
 			    ID_R_EQ_R | ID_R_EQ_E | ID_R_EQ_S |
 			    ID_E_EQ_R | ID_E_EQ_E | ID_E_EQ_S |
 			    ID_S_EQ_R | ID_S_EQ_E | ID_S_EQ_S );
+}
 int
 linux_sys_getresgid(struct lwp *l, const struct linux_sys_getresgid_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(gid_t *) rgid;
 		syscallarg(gid_t *) egid;
 		syscallarg(gid_t *) sgid;
 	} */
 	kauth_cred_t pc = l->l_cred;
 	int error;
 	gid_t gid;
 	/*
 	 * Linux copies these values out to userspace like so:
+	 *
 	 *	1. Copy out rgid.
 	 *	2. If that succeeds, copy out egid.
 	 *	3. If both of those succeed, copy out sgid.
 	 */
 	gid = kauth_cred_getgid(pc);
 	if ((error = copyout(&gid, SCARG(uap, rgid), sizeof(gid_t))) != 0)
 		return (error);
 	gid = kauth_cred_getegid(pc);
 	if ((error = copyout(&gid, SCARG(uap, egid), sizeof(gid_t))) != 0)
 		return (error);
 	gid = kauth_cred_getsvgid(pc);
 	return (copyout(&gid, SCARG(uap, sgid), sizeof(gid_t)));
+}
 #ifndef __amd64__
 /*
  * I wonder why Linux has settimeofday() _and_ stime().. Still, we
  * need to deal with it.
  */
 int
 linux_sys_stime(struct lwp *l, const struct linux_sys_stime_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(linux_time_t) *t;
 	} */
 	struct timespec ats;
 	linux_time_t tt;
 	int error;
 	if ((error = copyin(&tt, SCARG(uap, t), sizeof tt)) != 0)
 		return error;
 	ats.tv_sec = tt;
 	ats.tv_nsec = 0;
 	if ((error = settime(l->l_proc, &ats)))
 		return (error);
 	return 0;
+}
 #endif /* !amd64 */
 #if !defined(__m68k__) && !defined(__amd64__)
 /*
  * Convert NetBSD statvfs structure to Linux statfs64 structure.
  * See comments in bsd_to_linux_statfs() for further background.
  * We can safely pass correct bsize and frsize here, since Linux glibc
  * statvfs() doesn't use statfs64().
  */
 static void
 bsd_to_linux_statfs64(const struct statvfs *bsp, struct linux_statfs64 *lsp)
+{
 	int i, div;
 	for (i = 0; i < linux_fstypes_cnt; i++) {
 		if (strcmp(bsp->f_fstypename, linux_fstypes[i].bsd) == 0) {
 			lsp->l_ftype = linux_fstypes[i].linux;
 			break;
+		}
+	}
 	if (i == linux_fstypes_cnt) {
 		DPRINTF(("unhandled fstype in linux emulation: %s\n",
 		    bsp->f_fstypename));
 		lsp->l_ftype = LINUX_DEFAULT_SUPER_MAGIC;
+	}
 	div = bsp->f_frsize ? (bsp->f_bsize / bsp->f_frsize) : 1;
 	if (div == 0)
 		div = 1;
 	lsp->l_fbsize = bsp->f_bsize;
 	lsp->l_ffrsize = bsp->f_frsize;
 	lsp->l_fblocks = bsp->f_blocks / div;
 	lsp->l_fbfree = bsp->f_bfree / div;
 	lsp->l_fbavail = bsp->f_bavail / div;
 	lsp->l_ffiles = bsp->f_files;
 	lsp->l_fffree = bsp->f_ffree / div;
 	/* Linux sets the fsid to 0..., we don't */
 	lsp->l_ffsid.val[0] = bsp->f_fsidx.__fsid_val[0];
 	lsp->l_ffsid.val[1] = bsp->f_fsidx.__fsid_val[1];
 	lsp->l_fnamelen = bsp->f_namemax;
 	(void)memset(lsp->l_fspare, 0, sizeof(lsp->l_fspare));
+}
 /*
  * Implement the fs stat functions. Straightforward.
  */
 int
 linux_sys_statfs64(struct lwp *l, const struct linux_sys_statfs64_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(const char *) path;
 		syscallarg(size_t) sz;
 		syscallarg(struct linux_statfs64 *) sp;
 	} */
 	struct statvfs *sb;
 	struct linux_statfs64 ltmp;
 	int error;
 	if (SCARG(uap, sz) != sizeof ltmp)
 		return (EINVAL);
 	sb = STATVFSBUF_GET();
 	error = do_sys_pstatvfs(l, SCARG(uap, path), ST_WAIT, sb);
 	if (error == 0) {
 		bsd_to_linux_statfs64(sb, &ltmp);
 		error = copyout(&ltmp, SCARG(uap, sp), sizeof ltmp);
+	}
 	STATVFSBUF_PUT(sb);
 	return error;
+}
 int
 linux_sys_fstatfs64(struct lwp *l, const struct linux_sys_fstatfs64_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int) fd;
 		syscallarg(size_t) sz;
 		syscallarg(struct linux_statfs64 *) sp;
 	} */
 	struct statvfs *sb;
 	struct linux_statfs64 ltmp;
 	int error;
 	if (SCARG(uap, sz) != sizeof ltmp)
 		return (EINVAL);
 	sb = STATVFSBUF_GET();
 	error = do_sys_fstatvfs(l, SCARG(uap, fd), ST_WAIT, sb);
 	if (error == 0) {
 		bsd_to_linux_statfs64(sb, &ltmp);
 		error = copyout(&ltmp, SCARG(uap, sp), sizeof ltmp);
+	}
 	STATVFSBUF_PUT(sb);
 	return error;
+}
 #endif /* !__m68k__ && !__amd64__ */
 #endif /* !COMPAT_LINUX32 */

 @@ -1,500 +1,501 @@
-/*	$NetBSD: linux32_unistd.c,v 1.23 2008/09/22 13:07:46 njoly Exp $ */
+/*	$NetBSD: linux32_unistd.c,v 1.24 2008/10/03 22:39:36 njoly 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.23 2008/09/22 13:07:46 njoly Exp $");
+__KERNEL_RCSID(0, "$NetBSD: linux32_unistd.c,v 1.24 2008/10/03 22:39:36 njoly 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 <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/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)
+{
 	/* {
 		syscallcarg(int) fd;
                 syscallarg(u_int32_t) ohigh;
                 syscallarg(u_int32_t) olow;
 		syscallarg(netbsd32_caddr_t) res;
 		syscallcarg(int) whence;
 	} */
 	struct linux_sys_llseek_args ua;
 	NETBSD32TO64_UAP(fd);
 	NETBSD32TO64_UAP(ohigh);
 	NETBSD32TO64_UAP(olow);
 	NETBSD32TOP_UAP(res, char);
 	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_timevalp_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)
         struct lwp *l;
         register_t *retval;
         int nfds;
         fd_set *readfds, *writefds, *exceptfds;
         struct timeval *timeout;
+{
 	struct timeval tv0, tv1, utv, *tv = NULL;
 	struct netbsd32_timeval 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_timeval(&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_timeval(&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;
 	SCARG(&ua, ruid) = (SCARG(uap, ruid) == -1) ? -1 : SCARG(uap, ruid);
 	SCARG(&ua, euid) = (SCARG(uap, euid) == -1) ? -1 : SCARG(uap, euid);
 	SCARG(&ua, suid) = (SCARG(uap, suid) == -1) ? -1 : SCARG(uap, suid);
 	return linux_sys_setresuid(l, &ua, retval);
+}
 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;
 	SCARG(&ua, rgid) = (SCARG(uap, rgid) == -1) ? -1 : SCARG(uap, rgid);
 	SCARG(&ua, egid) = (SCARG(uap, egid) == -1) ? -1 : SCARG(uap, egid);
 	SCARG(&ua, sgid) = (SCARG(uap, sgid) == -1) ? -1 : SCARG(uap, sgid);
 	return linux_sys_setresgid(l, &ua, retval);
+}
 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) = SCARG(uap, incr);
+	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);
+}