 @@ -1,438 +1,436 @@
-/*	$NetBSD: kern_clock.c,v 1.127 2010/12/20 00:25:46 matt Exp $	*/
+/*	$NetBSD: kern_clock.c,v 1.128 2011/07/27 14:35:33 uebayasi Exp $	*/
 /*-
  * Copyright (c) 2000, 2004, 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center.
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum.
+ *
  * 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) 1982, 1986, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * 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.
+ *
  *	@(#)kern_clock.c	8.5 (Berkeley) 1/21/94
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_clock.c,v 1.127 2010/12/20 00:25:46 matt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_clock.c,v 1.128 2011/07/27 14:35:33 uebayasi Exp $");
 #include "opt_ntp.h"
 #include "opt_perfctrs.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
 #include <sys/signalvar.h>
 #include <sys/sysctl.h>
 #include <sys/timex.h>
 #include <sys/sched.h>
 #include <sys/time.h>
 #include <sys/timetc.h>
 #include <sys/cpu.h>
 #include <sys/atomic.h>
 #include <uvm/uvm_extern.h>
 #ifdef GPROF
 #include <sys/gmon.h>
 #endif
 /*
  * Clock handling routines.
+ *
  * This code is written to operate with two timers that run independently of
  * each other.  The main clock, running hz times per second, is used to keep
  * track of real time.  The second timer handles kernel and user profiling,
  * and does resource use estimation.  If the second timer is programmable,
  * it is randomized to avoid aliasing between the two clocks.  For example,
  * the randomization prevents an adversary from always giving up the CPU
  * just before its quantum expires.  Otherwise, it would never accumulate
  * CPU ticks.  The mean frequency of the second timer is stathz.
+ *
  * If no second timer exists, stathz will be zero; in this case we drive
  * profiling and statistics off the main clock.  This WILL NOT be accurate;
  * do not do it unless absolutely necessary.
+ *
  * The statistics clock may (or may not) be run at a higher rate while
  * profiling.  This profile clock runs at profhz.  We require that profhz
  * be an integral multiple of stathz.
+ *
  * If the statistics clock is running fast, it must be divided by the ratio
  * profhz/stathz for statistics.  (For profiling, every tick counts.)
  */
 int	stathz;
 int	profhz;
 int	profsrc;
 int	schedhz;
 int	profprocs;
 int	hardclock_ticks;
 static int hardscheddiv; /* hard => sched divider (used if schedhz == 0) */
 static int psdiv;			/* prof => stat divider */
 int	psratio;			/* ratio: prof / stat */
 static u_int get_intr_timecount(struct timecounter *);
 static struct timecounter intr_timecounter = {
 	get_intr_timecount,	/* get_timecount */
 ,			/* no poll_pps */
 	~0u,			/* counter_mask */
 ,		        /* frequency */
 	"clockinterrupt",	/* name */
 ,			/* quality - minimum implementation level for a clock */
 	NULL,			/* prev */
 	NULL,			/* next */
 };
 static u_int
 get_intr_timecount(struct timecounter *tc)
+{
 	return (u_int)hardclock_ticks;
+}
 /*
  * Initialize clock frequencies and start both clocks running.
  */
 void
 initclocks(void)
+{
 	int i;
 	/*
 	 * Set divisors to 1 (normal case) and let the machine-specific
 	 * code do its bit.
 	 */
 	psdiv = 1;
 	/*
 	 * provide minimum default time counter
 	 * will only run at interrupt resolution
 	 */
 	intr_timecounter.tc_frequency = hz;
 	tc_init(&intr_timecounter);
 	cpu_initclocks();
 	/*
 	 * Compute profhz and stathz, fix profhz if needed.
 	 */
 	i = stathz ? stathz : hz;
 	if (profhz == 0)
 		profhz = i;
 	psratio = profhz / i;
 	if (schedhz == 0) {
 		/* 16Hz is best */
 		hardscheddiv = hz / 16;
 		if (hardscheddiv <= 0)
 			panic("hardscheddiv");
+	}
+}
 /*
  * The real-time timer, interrupting hz times per second.
  */
 void
 hardclock(struct clockframe *frame)
+{
 	struct lwp *l;
 	struct cpu_info *ci;
 	ci = curcpu();
 	l = ci->ci_data.cpu_onproc;
 	timer_tick(l, CLKF_USERMODE(frame));
 	/*
 	 * If no separate statistics clock is available, run it from here.
 	 */
 	if (stathz == 0)
 		statclock(frame);
 	/*
 	 * If no separate schedclock is provided, call it here
 	 * at about 16 Hz.
 	 */
 	if (schedhz == 0) {
 		if ((int)(--ci->ci_schedstate.spc_schedticks) <= 0) {
 			schedclock(l);
 			ci->ci_schedstate.spc_schedticks = hardscheddiv;
+		}
+	}
 	if ((--ci->ci_schedstate.spc_ticks) <= 0)
 		sched_tick(ci);
 	if (CPU_IS_PRIMARY(ci)) {
 		hardclock_ticks++;
 		tc_ticktock();
+	}
 	/*
 	 * Update real-time timeout queue.
 	 */
 	callout_hardclock();
+}
 /*
  * Start profiling on a process.
+ *
  * Kernel profiling passes proc0 which never exits and hence
  * keeps the profile clock running constantly.
  */
 void
 startprofclock(struct proc *p)
+{
 	KASSERT(mutex_owned(&p->p_stmutex));
 	if ((p->p_stflag & PST_PROFIL) == 0) {
 		p->p_stflag |= PST_PROFIL;
 		/*
 		 * This is only necessary if using the clock as the
 		 * profiling source.
 		 */
 		if (++profprocs == 1 && stathz != 0)
 			psdiv = psratio;
+	}
+}
 /*
  * Stop profiling on a process.
  */
 void
 stopprofclock(struct proc *p)
+{
 	KASSERT(mutex_owned(&p->p_stmutex));
 	if (p->p_stflag & PST_PROFIL) {
 		p->p_stflag &= ~PST_PROFIL;
 		/*
 		 * This is only necessary if using the clock as the
 		 * profiling source.
 		 */
 		if (--profprocs == 0 && stathz != 0)
 			psdiv = 1;
+	}
+}
 #if defined(PERFCTRS)
 /*
  * Independent profiling "tick" in case we're using a separate
  * clock or profiling event source.  Currently, that's just
  * performance counters--hence the wrapper.
  */
 void
 proftick(struct clockframe *frame)
+{
 #ifdef GPROF
         struct gmonparam *g;
         intptr_t i;
 #endif
 	struct lwp *l;
 	struct proc *p;
 	l = curcpu()->ci_data.cpu_onproc;
 	p = (l ? l->l_proc : NULL);
 	if (CLKF_USERMODE(frame)) {
 		mutex_spin_enter(&p->p_stmutex);
 		if (p->p_stflag & PST_PROFIL)
 			addupc_intr(l, CLKF_PC(frame));
 		mutex_spin_exit(&p->p_stmutex);
 	} else {
 #ifdef GPROF
 		g = &_gmonparam;
 		if (g->state == GMON_PROF_ON) {
 			i = CLKF_PC(frame) - g->lowpc;
 			if (i < g->textsize) {
 				i /= HISTFRACTION * sizeof(*g->kcount);
 				g->kcount[i]++;
+			}
+		}
 #endif
 #ifdef LWP_PC
 		if (p != NULL && (p->p_stflag & PST_PROFIL) != 0)
 			addupc_intr(l, LWP_PC(l));
 #endif
+	}
+}
 #endif
 void
 schedclock(struct lwp *l)
+{
 	if ((l->l_flag & LW_IDLE) != 0)
 		return;
 	sched_schedclock(l);
+}
 /*
  * Statistics clock.  Grab profile sample, and if divider reaches 0,
  * do process and kernel statistics.
  */
 void
 statclock(struct clockframe *frame)
+{
 #ifdef GPROF
 	struct gmonparam *g;
 	intptr_t i;
 #endif
 	struct cpu_info *ci = curcpu();
 	struct schedstate_percpu *spc = &ci->ci_schedstate;
 	struct proc *p;
 	struct lwp *l;
 	/*
 	 * Notice changes in divisor frequency, and adjust clock
 	 * frequency accordingly.
 	 */
 	if (spc->spc_psdiv != psdiv) {
 		spc->spc_psdiv = psdiv;
 		spc->spc_pscnt = psdiv;
 		if (psdiv == 1) {
 			setstatclockrate(stathz);
 		} else {
 			setstatclockrate(profhz);
+		}
+	}
 	l = ci->ci_data.cpu_onproc;
 	if ((l->l_flag & LW_IDLE) != 0) {
 		/*
 		 * don't account idle lwps as swapper.
 		 */
 		p = NULL;
 	} else {
 		p = l->l_proc;
 		mutex_spin_enter(&p->p_stmutex);
+	}
 	if (CLKF_USERMODE(frame)) {
 		if ((p->p_stflag & PST_PROFIL) && profsrc == PROFSRC_CLOCK)
 			addupc_intr(l, CLKF_PC(frame));
 		if (--spc->spc_pscnt > 0) {
 			mutex_spin_exit(&p->p_stmutex);
 			return;
+		}
 		/*
 		 * Came from user mode; CPU was in user state.
 		 * If this process is being profiled record the tick.
 		 */
 		p->p_uticks++;
 		if (p->p_nice > NZERO)
 			spc->spc_cp_time[CP_NICE]++;
 		else
 			spc->spc_cp_time[CP_USER]++;
 	} else {
 #ifdef GPROF
 		/*
 		 * Kernel statistics are just like addupc_intr, only easier.
 		 */
 		g = &_gmonparam;
 		if (profsrc == PROFSRC_CLOCK && g->state == GMON_PROF_ON) {
 			i = CLKF_PC(frame) - g->lowpc;
 			if (i < g->textsize) {
 				i /= HISTFRACTION * sizeof(*g->kcount);
 				g->kcount[i]++;
+			}
+		}
 #endif
 #ifdef LWP_PC
 		if (p != NULL && profsrc == PROFSRC_CLOCK &&
 		    (p->p_stflag & PST_PROFIL)) {
 			addupc_intr(l, LWP_PC(l));
+		}
 #endif
 		if (--spc->spc_pscnt > 0) {
 			if (p != NULL)
 				mutex_spin_exit(&p->p_stmutex);
 			return;
+		}
 		/*
 		 * Came from kernel mode, so we were:
 		 * - handling an interrupt,
 		 * - doing syscall or trap work on behalf of the current
 		 *   user process, or
 		 * - spinning in the idle loop.
 		 * Whichever it is, charge the time as appropriate.
 		 * Note that we charge interrupts to the current process,
 		 * regardless of whether they are ``for'' that process,
 		 * so that we know how much of its real time was spent
 		 * in ``non-process'' (i.e., interrupt) work.
 		 */
 		if (CLKF_INTR(frame) || (curlwp->l_pflag & LP_INTR) != 0) {
 			if (p != NULL) {
 				p->p_iticks++;
+			}
 			spc->spc_cp_time[CP_INTR]++;
 		} else if (p != NULL) {
 			p->p_sticks++;
 			spc->spc_cp_time[CP_SYS]++;
 		} else {
 			spc->spc_cp_time[CP_IDLE]++;
+		}
+	}
 	spc->spc_pscnt = psdiv;
 	if (p != NULL) {
 		atomic_inc_uint(&l->l_cpticks);
 		mutex_spin_exit(&p->p_stmutex);
+	}
+}

 @@ -1,391 +1,389 @@
-/*	$NetBSD: kern_condvar.c,v 1.29 2011/04/14 20:19:35 jym Exp $	*/
+/*	$NetBSD: kern_condvar.c,v 1.30 2011/07/27 14:35:33 uebayasi Exp $	*/
 /*-
  * Copyright (c) 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
  */
 /*
  * Kernel condition variable implementation.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_condvar.c,v 1.29 2011/04/14 20:19:35 jym Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_condvar.c,v 1.30 2011/07/27 14:35:33 uebayasi Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/sched.h>
 #include <sys/systm.h>
 #include <sys/condvar.h>
 #include <sys/sleepq.h>
 #include <sys/lockdebug.h>
 #include <sys/cpu.h>
 #include <uvm/uvm_extern.h>
 /*
  * Accessors for the private contents of the kcondvar_t data type.
+ *
  *	cv_opaque[0]	sleepq...
  *	cv_opaque[1]	...pointers
  *	cv_opaque[2]	description for ps(1)
+ *
  * cv_opaque[0..1] is protected by the interlock passed to cv_wait() (enqueue
  * only), and the sleep queue lock acquired with sleeptab_lookup() (enqueue
  * and dequeue).
+ *
  * cv_opaque[2] (the wmesg) is static and does not change throughout the life
  * of the CV.
  */
 #define	CV_SLEEPQ(cv)		((sleepq_t *)(cv)->cv_opaque)
 #define	CV_WMESG(cv)		((const char *)(cv)->cv_opaque[2])
 #define	CV_SET_WMESG(cv, v) 	(cv)->cv_opaque[2] = __UNCONST(v)
 #define	CV_DEBUG_P(cv)	(CV_WMESG(cv) != nodebug)
 #define	CV_RA		((uintptr_t)__builtin_return_address(0))
 static void	cv_unsleep(lwp_t *, bool);
 static void	cv_wakeup_one(kcondvar_t *);
 static void	cv_wakeup_all(kcondvar_t *);
 static syncobj_t cv_syncobj = {
 	SOBJ_SLEEPQ_SORTED,
 	cv_unsleep,
 	sleepq_changepri,
 	sleepq_lendpri,
 	syncobj_noowner,
 };
 lockops_t cv_lockops = {
 	"Condition variable",
 	LOCKOPS_CV,
 	NULL
 };
 static const char deadcv[] = "deadcv";
 static const char nodebug[] = "nodebug";
 /*
  * cv_init:
+ *
  *	Initialize a condition variable for use.
  */
 void
 cv_init(kcondvar_t *cv, const char *wmesg)
+{
 #ifdef LOCKDEBUG
 	bool dodebug;
 	dodebug = LOCKDEBUG_ALLOC(cv, &cv_lockops,
 	    (uintptr_t)__builtin_return_address(0));
 	if (!dodebug) {
 		/* XXX This will break vfs_lockf. */
 		wmesg = nodebug;
+	}
 #endif
 	KASSERT(wmesg != NULL);
 	CV_SET_WMESG(cv, wmesg);
 	sleepq_init(CV_SLEEPQ(cv));
+}
 /*
  * cv_destroy:
+ *
  *	Tear down a condition variable.
  */
 void
 cv_destroy(kcondvar_t *cv)
+{
 	LOCKDEBUG_FREE(CV_DEBUG_P(cv), cv);
 #ifdef DIAGNOSTIC
 	KASSERT(cv_is_valid(cv));
 	CV_SET_WMESG(cv, deadcv);
 #endif
+}
 /*
  * cv_enter:
+ *
  *	Look up and lock the sleep queue corresponding to the given
  *	condition variable, and increment the number of waiters.
  */
 static inline void
 cv_enter(kcondvar_t *cv, kmutex_t *mtx, lwp_t *l)
+{
 	sleepq_t *sq;
 	kmutex_t *mp;
 	KASSERT(cv_is_valid(cv));
 	KASSERT(!cpu_intr_p());
 	KASSERT((l->l_pflag & LP_INTR) == 0 || panicstr != NULL);
 	LOCKDEBUG_LOCKED(CV_DEBUG_P(cv), cv, mtx, CV_RA, 0);
 	l->l_kpriority = true;
 	mp = sleepq_hashlock(cv);
 	sq = CV_SLEEPQ(cv);
 	sleepq_enter(sq, l, mp);
 	sleepq_enqueue(sq, cv, CV_WMESG(cv), &cv_syncobj);
 	mutex_exit(mtx);
 	KASSERT(cv_has_waiters(cv));
+}
 /*
  * cv_exit:
+ *
  *	After resuming execution, check to see if we have been restarted
  *	as a result of cv_signal().  If we have, but cannot take the
  *	wakeup (because of eg a pending Unix signal or timeout) then try
  *	to ensure that another LWP sees it.  This is necessary because
  *	there may be multiple waiters, and at least one should take the
  *	wakeup if possible.
  */
 static inline int
 cv_exit(kcondvar_t *cv, kmutex_t *mtx, lwp_t *l, const int error)
+{
 	mutex_enter(mtx);
 	if (__predict_false(error != 0))
 		cv_signal(cv);
 	LOCKDEBUG_UNLOCKED(CV_DEBUG_P(cv), cv, CV_RA, 0);
 	KASSERT(cv_is_valid(cv));
 	return error;
+}
 /*
  * cv_unsleep:
+ *
  *	Remove an LWP from the condition variable and sleep queue.  This
  *	is called when the LWP has not been awoken normally but instead
  *	interrupted: for example, when a signal is received.  Must be
  *	called with the LWP locked, and must return it unlocked.
  */
 static void
 cv_unsleep(lwp_t *l, bool cleanup)
+{
 	kcondvar_t *cv;
 	cv = (kcondvar_t *)(uintptr_t)l->l_wchan;
 	KASSERT(l->l_wchan == (wchan_t)cv);
 	KASSERT(l->l_sleepq == CV_SLEEPQ(cv));
 	KASSERT(cv_is_valid(cv));
 	KASSERT(cv_has_waiters(cv));
 	sleepq_unsleep(l, cleanup);
+}
 /*
  * cv_wait:
+ *
  *	Wait non-interruptably on a condition variable until awoken.
  */
 void
 cv_wait(kcondvar_t *cv, kmutex_t *mtx)
+{
 	lwp_t *l = curlwp;
 	KASSERT(mutex_owned(mtx));
 	cv_enter(cv, mtx, l);
 	(void)sleepq_block(0, false);
 	(void)cv_exit(cv, mtx, l, 0);
+}
 /*
  * cv_wait_sig:
+ *
  *	Wait on a condition variable until a awoken or a signal is received.
  *	Will also return early if the process is exiting.  Returns zero if
  *	awoken normally, ERESTART if a signal was received and the system
  *	call is restartable, or EINTR otherwise.
  */
 int
 cv_wait_sig(kcondvar_t *cv, kmutex_t *mtx)
+{
 	lwp_t *l = curlwp;
 	int error;
 	KASSERT(mutex_owned(mtx));
 	cv_enter(cv, mtx, l);
 	error = sleepq_block(0, true);
 	return cv_exit(cv, mtx, l, error);
+}
 /*
  * cv_timedwait:
+ *
  *	Wait on a condition variable until awoken or the specified timeout
  *	expires.  Returns zero if awoken normally or EWOULDBLOCK if the
  *	timeout expired.
  */
 int
 cv_timedwait(kcondvar_t *cv, kmutex_t *mtx, int timo)
+{
 	lwp_t *l = curlwp;
 	int error;
 	KASSERT(mutex_owned(mtx));
 	cv_enter(cv, mtx, l);
 	error = sleepq_block(timo, false);
 	return cv_exit(cv, mtx, l, error);
+}
 /*
  * cv_timedwait_sig:
+ *
  *	Wait on a condition variable until a timeout expires, awoken or a
  *	signal is received.  Will also return early if the process is
  *	exiting.  Returns zero if awoken normally, EWOULDBLOCK if the
  *	timeout expires, ERESTART if a signal was received and the system
  *	call is restartable, or EINTR otherwise.
  */
 int
 cv_timedwait_sig(kcondvar_t *cv, kmutex_t *mtx, int timo)
+{
 	lwp_t *l = curlwp;
 	int error;
 	KASSERT(mutex_owned(mtx));
 	cv_enter(cv, mtx, l);
 	error = sleepq_block(timo, true);
 	return cv_exit(cv, mtx, l, error);
+}
 /*
  * cv_signal:
+ *
  *	Wake the highest priority LWP waiting on a condition variable.
  *	Must be called with the interlocking mutex held.
  */
 void
 cv_signal(kcondvar_t *cv)
+{
 	/* LOCKDEBUG_WAKEUP(CV_DEBUG_P(cv), cv, CV_RA); */
 	KASSERT(cv_is_valid(cv));
 	if (__predict_false(!TAILQ_EMPTY(CV_SLEEPQ(cv))))
 		cv_wakeup_one(cv);
+}
 static void __noinline
 cv_wakeup_one(kcondvar_t *cv)
+{
 	sleepq_t *sq;
 	kmutex_t *mp;
 	lwp_t *l;
 	KASSERT(cv_is_valid(cv));
 	mp = sleepq_hashlock(cv);
 	sq = CV_SLEEPQ(cv);
 	l = TAILQ_FIRST(sq);
 	if (l == NULL) {
 		mutex_spin_exit(mp);
 		return;
+	}
 	KASSERT(l->l_sleepq == sq);
 	KASSERT(l->l_mutex == mp);
 	KASSERT(l->l_wchan == cv);
 	sleepq_remove(sq, l);
 	mutex_spin_exit(mp);
 	KASSERT(cv_is_valid(cv));
+}
 /*
  * cv_broadcast:
+ *
  *	Wake all LWPs waiting on a condition variable.  Must be called
  *	with the interlocking mutex held.
  */
 void
 cv_broadcast(kcondvar_t *cv)
+{
 	/* LOCKDEBUG_WAKEUP(CV_DEBUG_P(cv), cv, CV_RA); */
 	KASSERT(cv_is_valid(cv));
 	if (__predict_false(!TAILQ_EMPTY(CV_SLEEPQ(cv))))
 		cv_wakeup_all(cv);
+}
 static void __noinline
 cv_wakeup_all(kcondvar_t *cv)
+{
 	sleepq_t *sq;
 	kmutex_t *mp;
 	lwp_t *l, *next;
 	KASSERT(cv_is_valid(cv));
 	mp = sleepq_hashlock(cv);
 	sq = CV_SLEEPQ(cv);
 	for (l = TAILQ_FIRST(sq); l != NULL; l = next) {
 		KASSERT(l->l_sleepq == sq);
 		KASSERT(l->l_mutex == mp);
 		KASSERT(l->l_wchan == cv);
 		next = TAILQ_NEXT(l, l_sleepchain);
 		sleepq_remove(sq, l);
+	}
 	mutex_spin_exit(mp);
 	KASSERT(cv_is_valid(cv));
+}
 /*
  * cv_has_waiters:
+ *
  *	For diagnostic assertions: return non-zero if a condition
  *	variable has waiters.
  */
 bool
 cv_has_waiters(kcondvar_t *cv)
+{
 	return !TAILQ_EMPTY(CV_SLEEPQ(cv));
+}
 /*
  * cv_is_valid:
+ *
  *	For diagnostic assertions: return non-zero if a condition
  *	variable appears to be valid.  No locks need be held.
  */
 bool
 cv_is_valid(kcondvar_t *cv)
+{
 	return CV_WMESG(cv) != deadcv && CV_WMESG(cv) != NULL;
+}

 @@ -1,515 +1,513 @@
-/*	$NetBSD: kern_turnstile.c,v 1.29 2011/05/13 22:19:41 rmind Exp $	*/
+/*	$NetBSD: kern_turnstile.c,v 1.30 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c) 2002, 2006, 2007, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe and Andrew Doran.
+ *
  * 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.
  */
 /*
  * Turnstiles are described in detail in:
+ *
  *	Solaris Internals: Core Kernel Architecture, Jim Mauro and
  *	    Richard McDougall.
+ *
  * Turnstiles are kept in a hash table.  There are likely to be many more
  * synchronisation objects than there are threads.  Since a thread can block
  * on only one lock at a time, we only need one turnstile per thread, and
  * so they are allocated at thread creation time.
+ *
  * When a thread decides it needs to block on a lock, it looks up the
  * active turnstile for that lock.  If no active turnstile exists, then
  * the process lends its turnstile to the lock.  If there is already an
  * active turnstile for the lock, the thread places its turnstile on a
  * list of free turnstiles, and references the active one instead.
+ *
  * The act of looking up the turnstile acquires an interlock on the sleep
  * queue.  If a thread decides it doesn't need to block after all, then this
  * interlock must be released by explicitly aborting the turnstile
  * operation.
+ *
  * When a thread is awakened, it needs to get its turnstile back.  If there
  * are still other threads waiting in the active turnstile, the thread
  * grabs a free turnstile off the free list.  Otherwise, it can take back
  * the active turnstile from the lock (thus deactivating the turnstile).
+ *
  * Turnstiles are the place to do priority inheritence.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_turnstile.c,v 1.29 2011/05/13 22:19:41 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_turnstile.c,v 1.30 2011/07/27 14:35:34 uebayasi Exp $");
 #include <sys/param.h>
 #include <sys/lockdebug.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/sleepq.h>
 #include <sys/systm.h>
 #include <uvm/uvm_extern.h>
 #define	TS_HASH_SIZE	64
 #define	TS_HASH_MASK	(TS_HASH_SIZE - 1)
 #define	TS_HASH(obj)	(((uintptr_t)(obj) >> 3) & TS_HASH_MASK)
 static tschain_t	turnstile_tab[TS_HASH_SIZE]	__cacheline_aligned;
 pool_cache_t		turnstile_cache			__read_mostly;
 static int		turnstile_ctor(void *, void *, int);
 extern turnstile_t	turnstile0;
 /*
  * turnstile_init:
+ *
  *	Initialize the turnstile mechanism.
  */
 void
 turnstile_init(void)
+{
 	tschain_t *tc;
 	int i;
 	for (i = 0; i < TS_HASH_SIZE; i++) {
 		tc = &turnstile_tab[i];
 		LIST_INIT(&tc->tc_chain);
 		tc->tc_mutex = mutex_obj_alloc(MUTEX_DEFAULT, IPL_SCHED);
+	}
 	turnstile_cache = pool_cache_init(sizeof(turnstile_t), 0, 0, 0,
 	    "tstilepl", NULL, IPL_NONE, turnstile_ctor, NULL, NULL);
 	KASSERT(turnstile_cache != NULL);
 	(void)turnstile_ctor(NULL, &turnstile0, 0);
+}
 /*
  * turnstile_ctor:
+ *
  *	Constructor for turnstiles.
  */
 static int
 turnstile_ctor(void *arg, void *obj, int flags)
+{
 	turnstile_t *ts = obj;
 	memset(ts, 0, sizeof(*ts));
 	sleepq_init(&ts->ts_sleepq[TS_READER_Q]);
 	sleepq_init(&ts->ts_sleepq[TS_WRITER_Q]);
 	return (0);
+}
 /*
  * turnstile_remove:
+ *
  *	Remove an LWP from a turnstile sleep queue and wake it.
  */
 static inline void
 turnstile_remove(turnstile_t *ts, lwp_t *l, int q)
+{
 	turnstile_t *nts;
 	KASSERT(l->l_ts == ts);
 	/*
 	 * This process is no longer using the active turnstile.
 	 * Find an inactive one on the free list to give to it.
 	 */
 	if ((nts = ts->ts_free) != NULL) {
 		KASSERT(TS_ALL_WAITERS(ts) > 1);
 		l->l_ts = nts;
 		ts->ts_free = nts->ts_free;
 		nts->ts_free = NULL;
 	} else {
 		/*
 		 * If the free list is empty, this is the last
 		 * waiter.
 		 */
 		KASSERT(TS_ALL_WAITERS(ts) == 1);
 		LIST_REMOVE(ts, ts_chain);
+	}
 	ts->ts_waiters[q]--;
 	sleepq_remove(&ts->ts_sleepq[q], l);
+}
 /*
  * turnstile_lookup:
+ *
  *	Look up the turnstile for the specified lock.  This acquires and
  *	holds the turnstile chain lock (sleep queue interlock).
  */
 turnstile_t *
 turnstile_lookup(wchan_t obj)
+{
 	turnstile_t *ts;
 	tschain_t *tc;
 	tc = &turnstile_tab[TS_HASH(obj)];
 	mutex_spin_enter(tc->tc_mutex);
 	LIST_FOREACH(ts, &tc->tc_chain, ts_chain)
 		if (ts->ts_obj == obj)
 			return (ts);
 	/*
 	 * No turnstile yet for this lock.  No problem, turnstile_block()
 	 * handles this by fetching the turnstile from the blocking thread.
 	 */
 	return (NULL);
+}
 /*
  * turnstile_exit:
+ *
  *	Abort a turnstile operation.
  */
 void
 turnstile_exit(wchan_t obj)
+{
 	tschain_t *tc;
 	tc = &turnstile_tab[TS_HASH(obj)];
 	mutex_spin_exit(tc->tc_mutex);
+}
 /*
  * turnstile_block:
+ *
  *	 Enter an object into the turnstile chain and prepare the current
  *	 LWP for sleep.
  */
 void
 turnstile_block(turnstile_t *ts, int q, wchan_t obj, syncobj_t *sobj)
+{
 	lwp_t *l;
 	lwp_t *cur; /* cached curlwp */
 	lwp_t *owner;
 	turnstile_t *ots;
 	tschain_t *tc;
 	sleepq_t *sq;
 	pri_t prio, obase;
 	tc = &turnstile_tab[TS_HASH(obj)];
 	l = cur = curlwp;
 	KASSERT(q == TS_READER_Q || q == TS_WRITER_Q);
 	KASSERT(mutex_owned(tc->tc_mutex));
 	KASSERT(l != NULL && l->l_ts != NULL);
 	if (ts == NULL) {
 		/*
 		 * We are the first thread to wait for this object;
 		 * lend our turnstile to it.
 		 */
 		ts = l->l_ts;
 		KASSERT(TS_ALL_WAITERS(ts) == 0);
 		KASSERT(TAILQ_EMPTY(&ts->ts_sleepq[TS_READER_Q]) &&
 			TAILQ_EMPTY(&ts->ts_sleepq[TS_WRITER_Q]));
 		ts->ts_obj = obj;
 		ts->ts_inheritor = NULL;
 		LIST_INSERT_HEAD(&tc->tc_chain, ts, ts_chain);
 	} else {
 		/*
 		 * Object already has a turnstile.  Put our turnstile
 		 * onto the free list, and reference the existing
 		 * turnstile instead.
 		 */
 		ots = l->l_ts;
 		KASSERT(ots->ts_free == NULL);
 		ots->ts_free = ts->ts_free;
 		ts->ts_free = ots;
 		l->l_ts = ts;
 		KASSERT(ts->ts_obj == obj);
 		KASSERT(TS_ALL_WAITERS(ts) != 0);
 		KASSERT(!TAILQ_EMPTY(&ts->ts_sleepq[TS_READER_Q]) ||
 			!TAILQ_EMPTY(&ts->ts_sleepq[TS_WRITER_Q]));
+	}
 	sq = &ts->ts_sleepq[q];
 	ts->ts_waiters[q]++;
 	sleepq_enter(sq, l, tc->tc_mutex);
 	LOCKDEBUG_BARRIER(tc->tc_mutex, 1);
 	l->l_kpriority = true;
 	obase = l->l_kpribase;
 	if (obase < PRI_KTHREAD)
 		l->l_kpribase = PRI_KTHREAD;
 	sleepq_enqueue(sq, obj, "tstile", sobj);
 	/*
 	 * Disable preemption across this entire block, as we may drop
 	 * scheduler locks (allowing preemption), and would prefer not
 	 * to be interrupted while in a state of flux.
 	 */
 	KPREEMPT_DISABLE(l);
 	/*
 	 * Lend our priority to lwps on the blocking chain.
+	 *
 	 * NOTE: if you get a panic in this code block, it is likely that
 	 * a lock has been destroyed or corrupted while still in use.  Try
 	 * compiling a kernel with LOCKDEBUG to pinpoint the problem.
 	 */
 	prio = lwp_eprio(l);
 	KASSERT(cur == l);
 	KASSERT(tc->tc_mutex == cur->l_mutex);
 	for (;;) {
 		bool dolock;
 		if (l->l_wchan == NULL)
 			break;
 		owner = (*l->l_syncobj->sobj_owner)(l->l_wchan);
 		if (owner == NULL)
 			break;
 		/* The owner may have changed as we have dropped the tc lock */
 		if (cur == owner) {
 			/*
 			 * we own the lock: stop here, sleepq_block()
 			 * should wake up immediatly
 			 */
 			break;
+		}
 		if (l->l_mutex != owner->l_mutex)
 			dolock = true;
 		else
 			dolock = false;
 		if (l == owner || (dolock && !lwp_trylock(owner))) {
 			/*
 			 * restart from curlwp.
 			 * Note that there may be a livelock here:
 			 * the owner may try grabing cur's lock (which is
 			 * the tc lock) while we're trying to grab
 			 * the owner's lock.
 			 */
 			lwp_unlock(l);
 			l = cur;
 			lwp_lock(l);
 			prio = lwp_eprio(l);
 			continue;
+		}
 		if (prio <= lwp_eprio(owner)) {
 			if (dolock)
 				lwp_unlock(owner);
 			break;
+		}
 		ts = l->l_ts;
 		KASSERT(ts->ts_inheritor == owner || ts->ts_inheritor == NULL);
 		if (ts->ts_inheritor == NULL) {
 			ts->ts_inheritor = owner;
 			ts->ts_eprio = prio;
 			SLIST_INSERT_HEAD(&owner->l_pi_lenders, ts, ts_pichain);
 			lwp_lendpri(owner, prio);
 		} else if (prio > ts->ts_eprio) {
 			ts->ts_eprio = prio;
 			lwp_lendpri(owner, prio);
+		}
 		if (dolock)
 			lwp_unlock(l);
 		l = owner;
+	}
 	LOCKDEBUG_BARRIER(l->l_mutex, 1);
 	if (cur->l_mutex != l->l_mutex) {
 		lwp_unlock(l);
 		lwp_lock(cur);
+	}
 	LOCKDEBUG_BARRIER(cur->l_mutex, 1);
 	sleepq_block(0, false);
 	cur->l_kpribase = obase;
 	KPREEMPT_ENABLE(cur);
+}
 /*
  * turnstile_wakeup:
+ *
  *	Wake up the specified number of threads that are blocked
  *	in a turnstile.
  */
 void
 turnstile_wakeup(turnstile_t *ts, int q, int count, lwp_t *nl)
+{
 	sleepq_t *sq;
 	tschain_t *tc;
 	lwp_t *l;
 	tc = &turnstile_tab[TS_HASH(ts->ts_obj)];
 	sq = &ts->ts_sleepq[q];
 	KASSERT(q == TS_READER_Q || q == TS_WRITER_Q);
 	KASSERT(count > 0 && count <= TS_WAITERS(ts, q));
 	KASSERT(mutex_owned(tc->tc_mutex));
 	KASSERT(ts->ts_inheritor == curlwp || ts->ts_inheritor == NULL);
 	/*
 	 * restore inherited priority if necessary.
 	 */
 	if (ts->ts_inheritor != NULL) {
 		turnstile_t *iter;
 		turnstile_t *next;
 		turnstile_t *prev = NULL;
 		pri_t prio;
 		bool dolock;
 		ts->ts_inheritor = NULL;
 		l = curlwp;
 		dolock = l->l_mutex == l->l_cpu->ci_schedstate.spc_lwplock;
 		if (dolock) {
 			lwp_lock(l);
+		}
 		/*
 		 * the following loop does two things.
+		 *
 		 * - remove ts from the list.
+		 *
 		 * - from the rest of the list, find the highest priority.
 		 */
 		prio = -1;
 		KASSERT(!SLIST_EMPTY(&l->l_pi_lenders));
 		for (iter = SLIST_FIRST(&l->l_pi_lenders);
 		    iter != NULL; iter = next) {
 			KASSERT(lwp_eprio(l) >= ts->ts_eprio);
 			next = SLIST_NEXT(iter, ts_pichain);
 			if (iter == ts) {
 				if (prev == NULL) {
 					SLIST_REMOVE_HEAD(&l->l_pi_lenders,
 					    ts_pichain);
 				} else {
 					SLIST_REMOVE_AFTER(prev, ts_pichain);
+				}
 			} else if (prio < iter->ts_eprio) {
 				prio = iter->ts_eprio;
+			}
 			prev = iter;
+		}
 		lwp_lendpri(l, prio);
 		if (dolock) {
 			lwp_unlock(l);
+		}
+	}
 	if (nl != NULL) {
 #if defined(DEBUG) || defined(LOCKDEBUG)
 		TAILQ_FOREACH(l, sq, l_sleepchain) {
 			if (l == nl)
 				break;
+		}
 		if (l == NULL)
 			panic("turnstile_wakeup: nl not on sleepq");
 #endif
 		turnstile_remove(ts, nl, q);
 	} else {
 		while (count-- > 0) {
 			l = TAILQ_FIRST(sq);
 			KASSERT(l != NULL);
 			turnstile_remove(ts, l, q);
+		}
+	}
 	mutex_spin_exit(tc->tc_mutex);
+}
 /*
  * turnstile_unsleep:
+ *
  *	Remove an LWP from the turnstile.  This is called when the LWP has
  *	not been awoken normally but instead interrupted: for example, if it
  *	has received a signal.  It's not a valid action for turnstiles,
  *	since LWPs blocking on a turnstile are not interruptable.
  */
 void
 turnstile_unsleep(lwp_t *l, bool cleanup)
+{
 	lwp_unlock(l);
 	panic("turnstile_unsleep");
+}
 /*
  * turnstile_changepri:
+ *
  *	Adjust the priority of an LWP residing on a turnstile.
  */
 void
 turnstile_changepri(lwp_t *l, pri_t pri)
+{
 	/* XXX priority inheritance */
 	sleepq_changepri(l, pri);
+}
 #if defined(LOCKDEBUG)
 /*
  * turnstile_print:
+ *
  *	Given the address of a lock object, print the contents of a
  *	turnstile.
  */
 void
 turnstile_print(volatile void *obj, void (*pr)(const char *, ...))
+{
 	turnstile_t *ts;
 	tschain_t *tc;
 	sleepq_t *rsq, *wsq;
 	lwp_t *l;
 	tc = &turnstile_tab[TS_HASH(obj)];
 	LIST_FOREACH(ts, &tc->tc_chain, ts_chain)
 		if (ts->ts_obj == obj)
 			break;
 	(*pr)("Turnstile chain at %p.\n", tc);
 	if (ts == NULL) {
 		(*pr)("=> No active turnstile for this lock.\n");
 		return;
+	}
 	rsq = &ts->ts_sleepq[TS_READER_Q];
 	wsq = &ts->ts_sleepq[TS_WRITER_Q];
 	(*pr)("=> Turnstile at %p (wrq=%p, rdq=%p).\n", ts, rsq, wsq);
 	(*pr)("=> %d waiting readers:", TS_WAITERS(ts, TS_READER_Q));
 	TAILQ_FOREACH(l, rsq, l_sleepchain) {
 		(*pr)(" %p", l);
+	}
 	(*pr)("\n");
 	(*pr)("=> %d waiting writers:", TS_WAITERS(ts, TS_WRITER_Q));
 	TAILQ_FOREACH(l, wsq, l_sleepchain) {
 		(*pr)(" %p", l);
+	}
 	(*pr)("\n");
+}
 #endif	/* LOCKDEBUG */

 @@ -1,1094 +1,1092 @@
-/*	$NetBSD: kern_ksyms.c,v 1.63 2011/04/24 18:46:22 rmind Exp $	*/
+/*	$NetBSD: kern_ksyms.c,v 1.64 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software developed for The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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) 2001, 2003 Anders Magnusson (ragge@ludd.luth.se).
  * 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.
  */
 /*
  * Code to deal with in-kernel symbol table management + /dev/ksyms.
+ *
  * For each loaded module the symbol table info is kept track of by a
  * struct, placed in a circular list. The first entry is the kernel
  * symbol table.
  */
 /*
  * TODO:
+ *
  *	Add support for mmap, poll.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_ksyms.c,v 1.63 2011/04/24 18:46:22 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_ksyms.c,v 1.64 2011/07/27 14:35:34 uebayasi Exp $");
 #if defined(_KERNEL) && defined(_KERNEL_OPT)
 #include "opt_ddb.h"
 #include "opt_ddbparam.h"	/* for SYMTAB_SPACE */
 #include "opt_dtrace.h"
 #endif
 #define _KSYMS_PRIVATE
 #include <sys/param.h>
 #include <sys/queue.h>
 #include <sys/exec.h>
 #include <sys/systm.h>
 #include <sys/conf.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/atomic.h>
 #include <sys/ksyms.h>
 #include <uvm/uvm_extern.h>
 #ifdef DDB
 #include <ddb/db_output.h>
 #endif
 #include "ksyms.h"
 #define KSYMS_MAX_ID	65536
 #ifdef KDTRACE_HOOKS
 static uint32_t ksyms_nmap[KSYMS_MAX_ID];	/* sorted symbol table map */
 #else
 static uint32_t *ksyms_nmap = NULL;
 #endif
 static int ksyms_maxlen;
 static bool ksyms_isopen;
 static bool ksyms_initted;
 static struct ksyms_hdr ksyms_hdr;
 static kmutex_t ksyms_lock;
 void ksymsattach(int);
 static void ksyms_hdr_init(void *);
 static void ksyms_sizes_calc(void);
 #ifdef KSYMS_DEBUG
 #define	FOLLOW_CALLS		1
 #define	FOLLOW_MORE_CALLS	2
 #define	FOLLOW_DEVKSYMS		4
 static int ksyms_debug;
 #endif
 #ifdef SYMTAB_SPACE
 #define		SYMTAB_FILLER	"|This is the symbol table!"
 char		db_symtab[SYMTAB_SPACE] = SYMTAB_FILLER;
 int		db_symtabsize = SYMTAB_SPACE;
 #endif
 int ksyms_symsz;
 int ksyms_strsz;
 int ksyms_ctfsz;
 TAILQ_HEAD(, ksyms_symtab) ksyms_symtabs =
     TAILQ_HEAD_INITIALIZER(ksyms_symtabs);
 static struct ksyms_symtab kernel_symtab;
 static int
 ksyms_verify(void *symstart, void *strstart)
+{
 #if defined(DIAGNOSTIC) || defined(DEBUG)
 	if (symstart == NULL)
 		printf("ksyms: Symbol table not found\n");
 	if (strstart == NULL)
 		printf("ksyms: String table not found\n");
 	if (symstart == NULL || strstart == NULL)
 		printf("ksyms: Perhaps the kernel is stripped?\n");
 #endif
 	if (symstart == NULL || strstart == NULL)
 		return 0;
 	return 1;
+}
 /*
  * Finds a certain symbol name in a certain symbol table.
  */
 static Elf_Sym *
 findsym(const char *name, struct ksyms_symtab *table, int type)
+{
 	Elf_Sym *sym, *maxsym;
 	int low, mid, high, nglob;
 	char *str, *cmp;
 	sym = table->sd_symstart;
 	str = table->sd_strstart - table->sd_usroffset;
 	nglob = table->sd_nglob;
 	low = 0;
 	high = nglob;
 	/*
 	 * Start with a binary search of all global symbols in this table.
 	 * Global symbols must have unique names.
 	 */
 	while (low < high) {
 		mid = (low + high) >> 1;
 		cmp = sym[mid].st_name + str;
 		if (cmp[0] < name[0] || strcmp(cmp, name) < 0) {
 			low = mid + 1;
 		} else {
 			high = mid;
+		}
+	}
 	KASSERT(low == high);
 	if (__predict_true(low < nglob &&
 	    strcmp(sym[low].st_name + str, name) == 0)) {
 		KASSERT(ELF_ST_BIND(sym[low].st_info) == STB_GLOBAL);
 		return &sym[low];
+	}
 	/*
 	 * Perform a linear search of local symbols (rare).  Many local
 	 * symbols with the same name can exist so are not included in
 	 * the binary search.
 	 */
 	if (type != KSYMS_EXTERN) {
 		maxsym = sym + table->sd_symsize / sizeof(Elf_Sym);
 		for (sym += nglob; sym < maxsym; sym++) {
 			if (strcmp(name, sym->st_name + str) == 0) {
 				return sym;
+			}
+		}
+	}
 	return NULL;
+}
 /*
  * The "attach" is in reality done in ksyms_init().
  */
 void
 ksymsattach(int arg)
+{
+}
 void
 ksyms_init(void)
+{
 #ifdef SYMTAB_SPACE
 	if (!ksyms_initted &&
 	    strncmp(db_symtab, SYMTAB_FILLER, sizeof(SYMTAB_FILLER))) {
 		ksyms_addsyms_elf(db_symtabsize, db_symtab,
 		    db_symtab + db_symtabsize);
+	}
 #endif
 	mutex_init(&ksyms_lock, MUTEX_DEFAULT, IPL_NONE);
+}
 /*
  * Add a symbol table.
  * This is intended for use when the symbol table and its corresponding
  * string table are easily available.  If they are embedded in an ELF
  * image, use addsymtab_elf() instead.
+ *
  * name - Symbol's table name.
  * symstart, symsize - Address and size of the symbol table.
  * strstart, strsize - Address and size of the string table.
  * tab - Symbol table to be updated with this information.
  * newstart - Address to which the symbol table has to be copied during
  *            shrinking.  If NULL, it is not moved.
  */
 static const char *addsymtab_strstart;
 static int
 addsymtab_compar(const void *a, const void *b)
+{
 	const Elf_Sym *sa, *sb;
 	sa = a;
 	sb = b;
 	/*
 	 * Split the symbol table into two, with globals at the start
 	 * and locals at the end.
 	 */
 	if (ELF_ST_BIND(sa->st_info) != ELF_ST_BIND(sb->st_info)) {
 		if (ELF_ST_BIND(sa->st_info) == STB_GLOBAL) {
 			return -1;
+		}
 		if (ELF_ST_BIND(sb->st_info) == STB_GLOBAL) {
 			return 1;
+		}
+	}
 	/* Within each band, sort by name. */
 	return strcmp(sa->st_name + addsymtab_strstart,
 	    sb->st_name + addsymtab_strstart);
+}
 static void
 addsymtab(const char *name, void *symstart, size_t symsize,
 	  void *strstart, size_t strsize, struct ksyms_symtab *tab,
 	  void *newstart, void *ctfstart, size_t ctfsize, uint32_t *nmap)
+{
 	Elf_Sym *sym, *nsym, ts;
 	int i, j, n, nglob;
 	char *str;
 	int nsyms = symsize / sizeof(Elf_Sym);
 	/* Sanity check for pre-allocated map table used during startup. */
 	if ((nmap == ksyms_nmap) && (nsyms >= KSYMS_MAX_ID)) {
 		printf("kern_ksyms: ERROR %d > %d, increase KSYMS_MAX_ID\n",
 		    nsyms, KSYMS_MAX_ID);
 		/* truncate for now */
 		nsyms = KSYMS_MAX_ID - 1;
+	}
 	tab->sd_symstart = symstart;
 	tab->sd_symsize = symsize;
 	tab->sd_strstart = strstart;
 	tab->sd_strsize = strsize;
 	tab->sd_name = name;
 	tab->sd_minsym = UINTPTR_MAX;
 	tab->sd_maxsym = 0;
 	tab->sd_usroffset = 0;
 	tab->sd_gone = false;
 #ifdef KDTRACE_HOOKS
 	tab->sd_ctfstart = ctfstart;
 	tab->sd_ctfsize = ctfsize;
 	tab->sd_nmap = nmap;
 	tab->sd_nmapsize = nsyms;
 #endif
 #ifdef KSYMS_DEBUG
 	printf("newstart %p sym %p ksyms_symsz %zu str %p strsz %zu send %p\n",
 	    newstart, symstart, symsize, strstart, strsize,
 	    tab->sd_strstart + tab->sd_strsize);
 #endif
 	if (nmap) {
 		memset(nmap, 0, nsyms * sizeof(uint32_t));
+	}
 	/* Pack symbol table by removing all file name references. */
 	sym = tab->sd_symstart;
 	nsym = (Elf_Sym *)newstart;
 	str = tab->sd_strstart;
 	nglob = 0;
 	for (i = n = 0; i < nsyms; i++) {
 	    	/* This breaks CTF mapping, so don't do it when
 		 * DTrace is enabled
 		 */
 #ifndef KDTRACE_HOOKS
 		/*
 		 * Remove useless symbols.
 		 * Should actually remove all typeless symbols.
 		 */
 		if (sym[i].st_name == 0)
 			continue; /* Skip nameless entries */
 		if (sym[i].st_shndx == SHN_UNDEF)
 			continue; /* Skip external references */
 		if (ELF_ST_TYPE(sym[i].st_info) == STT_FILE)
 			continue; /* Skip filenames */
 		if (ELF_ST_TYPE(sym[i].st_info) == STT_NOTYPE &&
 		    sym[i].st_value == 0 &&
 		    strcmp(str + sym[i].st_name, "*ABS*") == 0)
 			continue; /* XXX */
 		if (ELF_ST_TYPE(sym[i].st_info) == STT_NOTYPE &&
 		    strcmp(str + sym[i].st_name, "gcc2_compiled.") == 0)
 			continue; /* XXX */
 #endif
 		/* Save symbol. Set it as an absolute offset */
 		nsym[n] = sym[i];
 #ifdef KDTRACE_HOOKS
 		if (nmap != NULL) {
 			/*
 			 * Save the size, replace it with the symbol id so
 			 * the mapping can be done after the cleanup and sort.
 			 */
 			nmap[i] = nsym[n].st_size;
 			nsym[n].st_size = i + 1;	/* zero is reserved */
+		}
 #endif
 		nsym[n].st_shndx = SHBSS;
 		j = strlen(nsym[n].st_name + str) + 1;
 		if (j > ksyms_maxlen)
 			ksyms_maxlen = j;
 		nglob += (ELF_ST_BIND(nsym[n].st_info) == STB_GLOBAL);
 		/* Compute min and max symbols. */
 		if (strcmp(str + sym[i].st_name, "*ABS*") != 0
 		    && ELF_ST_TYPE(nsym[n].st_info) != STT_NOTYPE) {
 			if (nsym[n].st_value < tab->sd_minsym) {
 				tab->sd_minsym = nsym[n].st_value;
+			}
 			if (nsym[n].st_value > tab->sd_maxsym) {
 				tab->sd_maxsym = nsym[n].st_value;
+			}
+		}
 		n++;
+	}
 	/* Fill the rest of the record, and sort the symbols. */
 	tab->sd_symstart = nsym;
 	tab->sd_symsize = n * sizeof(Elf_Sym);
 	tab->sd_nglob = nglob;
 	addsymtab_strstart = str;
 	if (kheapsort(nsym, n, sizeof(Elf_Sym), addsymtab_compar, &ts) != 0)
 		panic("addsymtab");
 #ifdef KDTRACE_HOOKS
 	/*
 	 * Build the mapping from original symbol id to new symbol table.
 	 * Deleted symbols will have a zero map, indices will be one based
 	 * instead of zero based.
 	 * Resulting map is sd_nmap[original_index] = new_index + 1
 	 */
 	if (nmap != NULL) {
 		int new;
 		for (new = 0; new < n; new++) {
 			uint32_t orig = nsym[new].st_size - 1;
 			uint32_t size = nmap[orig];
 			nmap[orig] = new + 1;
 			/* restore the size */
 			nsym[new].st_size = size;
+		}
+	}
 #endif
 	/* ksymsread() is unlocked, so membar. */
 	membar_producer();
 	TAILQ_INSERT_TAIL(&ksyms_symtabs, tab, sd_queue);
 	ksyms_sizes_calc();
 	ksyms_initted = true;
+}
 /*
  * Setup the kernel symbol table stuff.
  */
 void
 ksyms_addsyms_elf(int symsize, void *start, void *end)
+{
 	int i, j;
 	Elf_Shdr *shdr;
 	char *symstart = NULL, *strstart = NULL;
 	size_t strsize = 0;
 	Elf_Ehdr *ehdr;
 	char *ctfstart = NULL;
 	size_t ctfsize = 0;
 	if (symsize <= 0) {
 		printf("[ Kernel symbol table missing! ]\n");
 		return;
+	}
 	/* Sanity check */
 	if (ALIGNED_POINTER(start, long) == 0) {
 		printf("[ Kernel symbol table has bad start address %p ]\n",
 		    start);
 		return;
+	}
 	ehdr = (Elf_Ehdr *)start;
 	/* check if this is a valid ELF header */
 	/* No reason to verify arch type, the kernel is actually running! */
 	if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) ||
 	    ehdr->e_ident[EI_CLASS] != ELFCLASS ||
 	    ehdr->e_version > 1) {
 		printf("[ Kernel symbol table invalid! ]\n");
 		return; /* nothing to do */
+	}
 	/* Loaded header will be scratched in addsymtab */
 	ksyms_hdr_init(start);
 	/* Find the symbol table and the corresponding string table. */
 	shdr = (Elf_Shdr *)((uint8_t *)start + ehdr->e_shoff);
 	for (i = 1; i < ehdr->e_shnum; i++) {
 		if (shdr[i].sh_type != SHT_SYMTAB)
 			continue;
 		if (shdr[i].sh_offset == 0)
 			continue;
 		symstart = (uint8_t *)start + shdr[i].sh_offset;
 		symsize = shdr[i].sh_size;
 		j = shdr[i].sh_link;
 		if (shdr[j].sh_offset == 0)
 			continue; /* Can this happen? */
 		strstart = (uint8_t *)start + shdr[j].sh_offset;
 		strsize = shdr[j].sh_size;
 		break;
+	}
 #ifdef KDTRACE_HOOKS
 	/* Find the CTF section */
 	shdr = (Elf_Shdr *)((uint8_t *)start + ehdr->e_shoff);
 	if (ehdr->e_shstrndx != 0) {
 		char *shstr = (uint8_t *)start +
 		    shdr[ehdr->e_shstrndx].sh_offset;
 		for (i = 1; i < ehdr->e_shnum; i++) {
 #ifdef DEBUG
 		    	printf("ksyms: checking %s\n", &shstr[shdr[i].sh_name]);
 #endif
 			if (shdr[i].sh_type != SHT_PROGBITS)
 				continue;
 			if (strncmp(".SUNW_ctf", &shstr[shdr[i].sh_name], 10)
 			    != 0)
 				continue;
 			ctfstart = (uint8_t *)start + shdr[i].sh_offset;
 			ctfsize = shdr[i].sh_size;
 			ksyms_ctfsz = ctfsize;
 #ifdef DEBUG
 			aprint_normal("Found CTF at %p, size 0x%zx\n",
 			    ctfstart, ctfsize);
 #endif
 			break;
+		}
 #ifdef DEBUG
 	} else {
 	    	printf("ksyms: e_shstrndx == 0\n");
 #endif
+	}
 #endif
 	if (!ksyms_verify(symstart, strstart))
 		return;
 	addsymtab("netbsd", symstart, symsize, strstart, strsize,
 	    &kernel_symtab, start, ctfstart, ctfsize, ksyms_nmap);
 #ifdef DEBUG
 	aprint_normal("Loaded initial symtab at %p, strtab at %p, # entries %ld\n",
 	    kernel_symtab.sd_symstart, kernel_symtab.sd_strstart,
 	    (long)kernel_symtab.sd_symsize/sizeof(Elf_Sym));
 #endif
+}
 /*
  * Setup the kernel symbol table stuff.
  * Use this when the address of the symbol and string tables are known;
  * otherwise use ksyms_init with an ELF image.
  * We need to pass a minimal ELF header which will later be completed by
  * ksyms_hdr_init and handed off to userland through /dev/ksyms.  We use
  * a void *rather than a pointer to avoid exposing the Elf_Ehdr type.
  */
 void
 ksyms_addsyms_explicit(void *ehdr, void *symstart, size_t symsize,
 		    void *strstart, size_t strsize)
+{
 	if (!ksyms_verify(symstart, strstart))
 		return;
 	ksyms_hdr_init(ehdr);
 	addsymtab("netbsd", symstart, symsize, strstart, strsize,
 	    &kernel_symtab, symstart, NULL, 0, ksyms_nmap);
+}
 /*
  * Get the value associated with a symbol.
  * "mod" is the module name, or null if any module.
  * "sym" is the symbol name.
  * "val" is a pointer to the corresponding value, if call succeeded.
  * Returns 0 if success or ENOENT if no such entry.
+ *
  * Call with ksyms_lock, unless known that the symbol table can't change.
  */
 int
 ksyms_getval_unlocked(const char *mod, const char *sym, unsigned long *val,
 		      int type)
+{
 	struct ksyms_symtab *st;
 	Elf_Sym *es;
 #ifdef KSYMS_DEBUG
 	if (ksyms_debug & FOLLOW_CALLS)
 		printf("ksyms_getval_unlocked: mod %s sym %s valp %p\n",
 		    mod, sym, val);
 #endif
 	TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
 		if (__predict_false(st->sd_gone))
 			continue;
 		if (mod != NULL && strcmp(st->sd_name, mod))
 			continue;
 		if ((es = findsym(sym, st, type)) != NULL) {
 			*val = es->st_value;
 			return 0;
+		}
+	}
 	return ENOENT;
+}
 int
 ksyms_getval(const char *mod, const char *sym, unsigned long *val, int type)
+{
 	int rc;
 	if (!ksyms_initted)
 		return ENOENT;
 	mutex_enter(&ksyms_lock);
 	rc = ksyms_getval_unlocked(mod, sym, val, type);
 	mutex_exit(&ksyms_lock);
 	return rc;
+}
 struct ksyms_symtab *
 ksyms_get_mod(const char *mod)
+{
 	struct ksyms_symtab *st;
 	mutex_enter(&ksyms_lock);
 	TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
 		if (__predict_false(st->sd_gone))
 			continue;
 		if (mod != NULL && strcmp(st->sd_name, mod))
 			continue;
 		break;
+	}
 	mutex_exit(&ksyms_lock);
 	return st;
+}
 /*
  * ksyms_mod_foreach()
+ *
  * Iterate over the symbol table of the specified module, calling the callback
  * handler for each symbol. Stop iterating if the handler return is non-zero.
+ *
  */
 int
 ksyms_mod_foreach(const char *mod, ksyms_callback_t callback, void *opaque)
+{
 	struct ksyms_symtab *st;
 	Elf_Sym *sym, *maxsym;
 	char *str;
 	int symindx;
 	if (!ksyms_initted)
 		return ENOENT;
 	mutex_enter(&ksyms_lock);
 	/* find the module */
 	TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
 		if (__predict_false(st->sd_gone))
 			continue;
 		if (mod != NULL && strcmp(st->sd_name, mod))
 			continue;
 		sym = st->sd_symstart;
 		str = st->sd_strstart - st->sd_usroffset;
 		/* now iterate through the symbols */
 		maxsym = sym + st->sd_symsize / sizeof(Elf_Sym);
 		for (symindx = 0; sym < maxsym; sym++, symindx++) {
 			if (callback(str + sym->st_name, symindx,
 			    (void *)sym->st_value,
 			    sym->st_size,
 			    sym->st_info,
 			    opaque) != 0) {
 				break;
+			}
+		}
+	}
 	mutex_exit(&ksyms_lock);
 	return 0;
+}
 /*
  * Get "mod" and "symbol" associated with an address.
  * Returns 0 if success or ENOENT if no such entry.
+ *
  * Call with ksyms_lock, unless known that the symbol table can't change.
  */
 int
 ksyms_getname(const char **mod, const char **sym, vaddr_t v, int f)
+{
 	struct ksyms_symtab *st;
 	Elf_Sym *les, *es = NULL;
 	vaddr_t laddr = 0;
 	const char *lmod = NULL;
 	char *stable = NULL;
 	int type, i, sz;
 	if (!ksyms_initted)
 		return ENOENT;
 	TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
 		if (st->sd_gone)
 			continue;
 		if (v < st->sd_minsym || v > st->sd_maxsym)
 			continue;
 		sz = st->sd_symsize/sizeof(Elf_Sym);
 		for (i = 0; i < sz; i++) {
 			les = st->sd_symstart + i;
 			type = ELF_ST_TYPE(les->st_info);
 			if ((f & KSYMS_PROC) && (type != STT_FUNC))
 				continue;
 			if (type == STT_NOTYPE)
 				continue;
 			if (((f & KSYMS_ANY) == 0) &&
 			    (type != STT_FUNC) && (type != STT_OBJECT))
 				continue;
 			if ((les->st_value <= v) && (les->st_value > laddr)) {
 				laddr = les->st_value;
 				es = les;
 				lmod = st->sd_name;
 				stable = st->sd_strstart - st->sd_usroffset;
+			}
+		}
+	}
 	if (es == NULL)
 		return ENOENT;
 	if ((f & KSYMS_EXACT) && (v != es->st_value))
 		return ENOENT;
 	if (mod)
 		*mod = lmod;
 	if (sym)
 		*sym = stable + es->st_name;
 	return 0;
+}
 /*
  * Add a symbol table from a loadable module.
  */
 void
 ksyms_modload(const char *name, void *symstart, vsize_t symsize,
 	      char *strstart, vsize_t strsize)
+{
 	struct ksyms_symtab *st;
 	st = kmem_zalloc(sizeof(*st), KM_SLEEP);
 	mutex_enter(&ksyms_lock);
 	addsymtab(name, symstart, symsize, strstart, strsize, st, symstart,
 	    NULL, 0, NULL);
 	mutex_exit(&ksyms_lock);
+}
 /*
  * Remove a symbol table from a loadable module.
  */
 void
 ksyms_modunload(const char *name)
+{
 	struct ksyms_symtab *st;
 	mutex_enter(&ksyms_lock);
 	TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
 		if (st->sd_gone)
 			continue;
 		if (strcmp(name, st->sd_name) != 0)
 			continue;
 		st->sd_gone = true;
 		if (!ksyms_isopen) {
 			TAILQ_REMOVE(&ksyms_symtabs, st, sd_queue);
 			ksyms_sizes_calc();
 			kmem_free(st, sizeof(*st));
+		}
 		break;
+	}
 	mutex_exit(&ksyms_lock);
 	KASSERT(st != NULL);
+}
 #ifdef DDB
 /*
  * Keep sifting stuff here, to avoid export of ksyms internals.
+ *
  * Systems is expected to be quiescent, so no locking done.
  */
 int
 ksyms_sift(char *mod, char *sym, int mode)
+{
 	struct ksyms_symtab *st;
 	char *sb;
 	int i, sz;
 	if (!ksyms_initted)
 		return ENOENT;
 	TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
 		if (st->sd_gone)
 			continue;
 		if (mod && strcmp(mod, st->sd_name))
 			continue;
 		sb = st->sd_strstart - st->sd_usroffset;
 		sz = st->sd_symsize/sizeof(Elf_Sym);
 		for (i = 0; i < sz; i++) {
 			Elf_Sym *les = st->sd_symstart + i;
 			char c;
 			if (strstr(sb + les->st_name, sym) == NULL)
 				continue;
 			if (mode == 'F') {
 				switch (ELF_ST_TYPE(les->st_info)) {
 				case STT_OBJECT:
 					c = '+';
 					break;
 				case STT_FUNC:
 					c = '*';
 					break;
 				case STT_SECTION:
 					c = '&';
 					break;
 				case STT_FILE:
 					c = '/';
 					break;
 				default:
 					c = ' ';
 					break;
+				}
 				db_printf("%s%c ", sb + les->st_name, c);
 			} else
 				db_printf("%s ", sb + les->st_name);
+		}
+	}
 	return ENOENT;
+}
 #endif /* DDB */
 /*
  * In case we exposing the symbol table to the userland using the pseudo-
  * device /dev/ksyms, it is easier to provide all the tables as one.
  * However, it means we have to change all the st_name fields for the
  * symbols so they match the ELF image that the userland will read
  * through the device.
+ *
  * The actual (correct) value of st_name is preserved through a global
  * offset stored in the symbol table structure.
+ *
  * Call with ksyms_lock held.
  */
 static void
 ksyms_sizes_calc(void)
+{
         struct ksyms_symtab *st;
 	int i, delta;
         ksyms_symsz = ksyms_strsz = 0;
         TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
 		delta = ksyms_strsz - st->sd_usroffset;
 		if (delta != 0) {
 			for (i = 0; i < st->sd_symsize/sizeof(Elf_Sym); i++)
 				st->sd_symstart[i].st_name += delta;
 			st->sd_usroffset = ksyms_strsz;
+		}
                 ksyms_symsz += st->sd_symsize;
                 ksyms_strsz += st->sd_strsize;
+        }
+}
 static void
 ksyms_hdr_init(void *hdraddr)
+{
 	/* Copy the loaded elf exec header */
 	memcpy(&ksyms_hdr.kh_ehdr, hdraddr, sizeof(Elf_Ehdr));
 	/* Set correct program/section header sizes, offsets and numbers */
 	ksyms_hdr.kh_ehdr.e_phoff = offsetof(struct ksyms_hdr, kh_phdr[0]);
 	ksyms_hdr.kh_ehdr.e_phentsize = sizeof(Elf_Phdr);
 	ksyms_hdr.kh_ehdr.e_phnum = NPRGHDR;
 	ksyms_hdr.kh_ehdr.e_shoff = offsetof(struct ksyms_hdr, kh_shdr[0]);
 	ksyms_hdr.kh_ehdr.e_shentsize = sizeof(Elf_Shdr);
 	ksyms_hdr.kh_ehdr.e_shnum = NSECHDR;
 	ksyms_hdr.kh_ehdr.e_shstrndx = SHSTRTAB;
 	/* Text/data - fake */
 	ksyms_hdr.kh_phdr[0].p_type = PT_LOAD;
 	ksyms_hdr.kh_phdr[0].p_memsz = (unsigned long)-1L;
 	ksyms_hdr.kh_phdr[0].p_flags = PF_R | PF_X | PF_W;
 	/* First section is null */
 	/* Second section header; ".symtab" */
 	ksyms_hdr.kh_shdr[SYMTAB].sh_name = 1; /* Section 3 offset */
 	ksyms_hdr.kh_shdr[SYMTAB].sh_type = SHT_SYMTAB;
 	ksyms_hdr.kh_shdr[SYMTAB].sh_offset = sizeof(struct ksyms_hdr);
 /*	ksyms_hdr.kh_shdr[SYMTAB].sh_size = filled in at open */
 	ksyms_hdr.kh_shdr[SYMTAB].sh_link = 2; /* Corresponding strtab */
 	ksyms_hdr.kh_shdr[SYMTAB].sh_addralign = sizeof(long);
 	ksyms_hdr.kh_shdr[SYMTAB].sh_entsize = sizeof(Elf_Sym);
 	/* Third section header; ".strtab" */
 	ksyms_hdr.kh_shdr[STRTAB].sh_name = 9; /* Section 3 offset */
 	ksyms_hdr.kh_shdr[STRTAB].sh_type = SHT_STRTAB;
 /*	ksyms_hdr.kh_shdr[STRTAB].sh_offset = filled in at open */
 /*	ksyms_hdr.kh_shdr[STRTAB].sh_size = filled in at open */
 	ksyms_hdr.kh_shdr[STRTAB].sh_addralign = sizeof(char);
 	/* Fourth section, ".shstrtab" */
 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_name = 17; /* This section name offset */
 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_type = SHT_STRTAB;
 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_offset =
 	    offsetof(struct ksyms_hdr, kh_strtab);
 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_size = SHSTRSIZ;
 	ksyms_hdr.kh_shdr[SHSTRTAB].sh_addralign = sizeof(char);
 	/* Fifth section, ".bss". All symbols reside here. */
 	ksyms_hdr.kh_shdr[SHBSS].sh_name = 27; /* This section name offset */
 	ksyms_hdr.kh_shdr[SHBSS].sh_type = SHT_NOBITS;
 	ksyms_hdr.kh_shdr[SHBSS].sh_offset = 0;
 	ksyms_hdr.kh_shdr[SHBSS].sh_size = (unsigned long)-1L;
 	ksyms_hdr.kh_shdr[SHBSS].sh_addralign = PAGE_SIZE;
 	ksyms_hdr.kh_shdr[SHBSS].sh_flags = SHF_ALLOC | SHF_EXECINSTR;
 #ifdef KDTRACE_HOOKS
 	/* Sixth section header; ".SUNW_ctf" */
 	ksyms_hdr.kh_shdr[SHCTF].sh_name = 32; /* Section 6 offset */
 	ksyms_hdr.kh_shdr[SHCTF].sh_type = SHT_PROGBITS;
 /*	ksyms_hdr.kh_shdr[SHCTF].sh_offset = filled in at open */
 /*	ksyms_hdr.kh_shdr[SHCTF].sh_size = filled in at open */
 	ksyms_hdr.kh_shdr[SHCTF].sh_link = SYMTAB; /* Corresponding symtab */
 	ksyms_hdr.kh_shdr[SHCTF].sh_addralign = sizeof(char);
 #endif
 	/* Set section names */
 	strlcpy(&ksyms_hdr.kh_strtab[1], ".symtab",
 	    sizeof(ksyms_hdr.kh_strtab) - 1);
 	strlcpy(&ksyms_hdr.kh_strtab[9], ".strtab",
 	    sizeof(ksyms_hdr.kh_strtab) - 9);
 	strlcpy(&ksyms_hdr.kh_strtab[17], ".shstrtab",
 	    sizeof(ksyms_hdr.kh_strtab) - 17);
 	strlcpy(&ksyms_hdr.kh_strtab[27], ".bss",
 	    sizeof(ksyms_hdr.kh_strtab) - 27);
 #ifdef KDTRACE_HOOKS
 	strlcpy(&ksyms_hdr.kh_strtab[32], ".SUNW_ctf",
 	    sizeof(ksyms_hdr.kh_strtab) - 32);
 #endif
+}
 static int
 ksymsopen(dev_t dev, int oflags, int devtype, struct lwp *l)
+{
 	if (minor(dev) != 0 || !ksyms_initted)
 		return ENXIO;
 	/*
 	 * Create a "snapshot" of the kernel symbol table.  Setting
 	 * ksyms_isopen will prevent symbol tables from being freed.
 	 */
 	mutex_enter(&ksyms_lock);
 	ksyms_hdr.kh_shdr[SYMTAB].sh_size = ksyms_symsz;
 	ksyms_hdr.kh_shdr[SYMTAB].sh_info = ksyms_symsz / sizeof(Elf_Sym);
 	ksyms_hdr.kh_shdr[STRTAB].sh_offset = ksyms_symsz +
 	    ksyms_hdr.kh_shdr[SYMTAB].sh_offset;
 	ksyms_hdr.kh_shdr[STRTAB].sh_size = ksyms_strsz;
 #ifdef KDTRACE_HOOKS
 	ksyms_hdr.kh_shdr[SHCTF].sh_offset = ksyms_strsz +
 	    ksyms_hdr.kh_shdr[STRTAB].sh_offset;
 	ksyms_hdr.kh_shdr[SHCTF].sh_size = ksyms_ctfsz;
 #endif
 	ksyms_isopen = true;
 	mutex_exit(&ksyms_lock);
 	return 0;
+}
 static int
 ksymsclose(dev_t dev, int oflags, int devtype, struct lwp *l)
+{
 	struct ksyms_symtab *st, *next;
 	bool resize;
 	/* Discard refernces to symbol tables. */
 	mutex_enter(&ksyms_lock);
 	ksyms_isopen = false;
 	resize = false;
 	for (st = TAILQ_FIRST(&ksyms_symtabs); st != NULL; st = next) {
 		next = TAILQ_NEXT(st, sd_queue);
 		if (st->sd_gone) {
 			TAILQ_REMOVE(&ksyms_symtabs, st, sd_queue);
 			kmem_free(st, sizeof(*st));
 			resize = true;
+		}
+	}
 	if (resize)
 		ksyms_sizes_calc();
 	mutex_exit(&ksyms_lock);
 	return 0;
+}
 static int
 ksymsread(dev_t dev, struct uio *uio, int ioflag)
+{
 	struct ksyms_symtab *st;
 	size_t filepos, inpos, off;
 	int error;
 #ifdef KDTRACE_HOOKS
 	struct ksyms_symtab *cst;
 #endif
 	/*
 	 * First: Copy out the ELF header.   XXX Lose if ksymsopen()
 	 * occurs during read of the header.
 	 */
 	off = uio->uio_offset;
 	if (off < sizeof(struct ksyms_hdr)) {
 		error = uiomove((char *)&ksyms_hdr + off,
 		    sizeof(struct ksyms_hdr) - off, uio);
 		if (error != 0)
 			return error;
+	}
 	/*
 	 * Copy out the symbol table.
 	 */
 	filepos = sizeof(struct ksyms_hdr);
 	TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
 		if (uio->uio_resid == 0)
 			return 0;
 		if (uio->uio_offset <= st->sd_symsize + filepos) {
 			inpos = uio->uio_offset - filepos;
 			error = uiomove((char *)st->sd_symstart + inpos,
 			   st->sd_symsize - inpos, uio);
 			if (error != 0)
 				return error;
+		}
 		filepos += st->sd_symsize;
+	}
 	/*
 	 * Copy out the string table
 	 */
 	KASSERT(filepos == sizeof(struct ksyms_hdr) +
 	    ksyms_hdr.kh_shdr[SYMTAB].sh_size);
 	TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) {
 		if (uio->uio_resid == 0)
 			return 0;
 		if (uio->uio_offset <= st->sd_strsize + filepos) {
 			inpos = uio->uio_offset - filepos;
 			error = uiomove((char *)st->sd_strstart + inpos,
 			   st->sd_strsize - inpos, uio);
 			if (error != 0)
 				return error;
+		}
 		filepos += st->sd_strsize;
+	}
 #ifdef KDTRACE_HOOKS
 	/*
 	 * Copy out the CTF table.
 	 */
 	cst = TAILQ_FIRST(&ksyms_symtabs);
 	if (cst->sd_ctfstart != NULL) {
 		if (uio->uio_resid == 0)
 			return 0;
 		if (uio->uio_offset <= cst->sd_ctfsize + filepos) {
 			inpos = uio->uio_offset - filepos;
 			error = uiomove((char *)cst->sd_ctfstart + inpos,
 			   cst->sd_ctfsize - inpos, uio);
 			if (error != 0)
 				return error;
+		}
 		filepos += cst->sd_ctfsize;
+	}
 #endif
 	return 0;
+}
 static int
 ksymswrite(dev_t dev, struct uio *uio, int ioflag)
+{
 	return EROFS;
+}
 static int
 ksymsioctl(dev_t dev, u_long cmd, void *data, int fflag, struct lwp *l)
+{
 	struct ksyms_gsymbol *kg = (struct ksyms_gsymbol *)data;
 	struct ksyms_symtab *st;
 	Elf_Sym *sym = NULL, copy;
 	unsigned long val;
 	int error = 0;
 	char *str = NULL;
 	int len;
 	/* Read ksyms_maxlen only once while not holding the lock. */
 	len = ksyms_maxlen;
 	if (cmd == KIOCGVALUE || cmd == KIOCGSYMBOL) {
 		str = kmem_alloc(len, KM_SLEEP);
 		if ((error = copyinstr(kg->kg_name, str, len, NULL)) != 0) {
 			kmem_free(str, len);
 			return error;
+		}
+	}
 	switch (cmd) {
 	case KIOCGVALUE:
 		/*
 		 * Use the in-kernel symbol lookup code for fast
 		 * retreival of a value.
 		 */
 		error = ksyms_getval(NULL, str, &val, KSYMS_EXTERN);
 		if (error == 0)
 			error = copyout(&val, kg->kg_value, sizeof(long));
 		kmem_free(str, len);
 		break;

 @@ -1,491 +1,489 @@
-/*	$NetBSD: kern_sleepq.c,v 1.40 2011/07/26 13:04:51 yamt Exp $	*/
+/*	$NetBSD: kern_sleepq.c,v 1.41 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c) 2006, 2007, 2008, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
  */
 /*
  * Sleep queue implementation, used by turnstiles and general sleep/wakeup
  * interfaces.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.40 2011/07/26 13:04:51 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.41 2011/07/27 14:35:34 uebayasi Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/cpu.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
 #include <sys/sa.h>
 #include <sys/savar.h>
 #include <sys/sched.h>
 #include <sys/systm.h>
 #include <sys/sleepq.h>
 #include <sys/ktrace.h>
 #include <uvm/uvm_extern.h>
 #include "opt_sa.h"
 static int	sleepq_sigtoerror(lwp_t *, int);
 /* General purpose sleep table, used by ltsleep() and condition variables. */
 sleeptab_t	sleeptab	__cacheline_aligned;
 /*
  * sleeptab_init:
+ *
  *	Initialize a sleep table.
  */
 void
 sleeptab_init(sleeptab_t *st)
+{
 	sleepq_t *sq;
 	int i;
 	for (i = 0; i < SLEEPTAB_HASH_SIZE; i++) {
 		sq = &st->st_queues[i].st_queue;
 		st->st_queues[i].st_mutex =
 		    mutex_obj_alloc(MUTEX_DEFAULT, IPL_SCHED);
 		sleepq_init(sq);
+	}
+}
 /*
  * sleepq_init:
+ *
  *	Prepare a sleep queue for use.
  */
 void
 sleepq_init(sleepq_t *sq)
+{
 	TAILQ_INIT(sq);
+}
 /*
  * sleepq_remove:
+ *
  *	Remove an LWP from a sleep queue and wake it up.
  */
 void
 sleepq_remove(sleepq_t *sq, lwp_t *l)
+{
 	struct schedstate_percpu *spc;
 	struct cpu_info *ci;
 	KASSERT(lwp_locked(l, NULL));
 	TAILQ_REMOVE(sq, l, l_sleepchain);
 	l->l_syncobj = &sched_syncobj;
 	l->l_wchan = NULL;
 	l->l_sleepq = NULL;
 	l->l_flag &= ~LW_SINTR;
 	ci = l->l_cpu;
 	spc = &ci->ci_schedstate;
 	/*
 	 * If not sleeping, the LWP must have been suspended.  Let whoever
 	 * holds it stopped set it running again.
 	 */
 	if (l->l_stat != LSSLEEP) {
 		KASSERT(l->l_stat == LSSTOP || l->l_stat == LSSUSPENDED);
 		lwp_setlock(l, spc->spc_lwplock);
 		return;
+	}
 	/*
 	 * If the LWP is still on the CPU, mark it as LSONPROC.  It may be
 	 * about to call mi_switch(), in which case it will yield.
 	 */
 	if ((l->l_pflag & LP_RUNNING) != 0) {
 		l->l_stat = LSONPROC;
 		l->l_slptime = 0;
 		lwp_setlock(l, spc->spc_lwplock);
 		return;
+	}
 	/* Update sleep time delta, call the wake-up handler of scheduler */
 	l->l_slpticksum += (hardclock_ticks - l->l_slpticks);
 	sched_wakeup(l);
 	/* Look for a CPU to wake up */
 	l->l_cpu = sched_takecpu(l);
 	ci = l->l_cpu;
 	spc = &ci->ci_schedstate;
 	/*
 	 * Set it running.
 	 */
 	spc_lock(ci);
 	lwp_setlock(l, spc->spc_mutex);
 #ifdef KERN_SA
 	if (l->l_proc->p_sa != NULL)
 		sa_awaken(l);
 #endif /* KERN_SA */
 	sched_setrunnable(l);
 	l->l_stat = LSRUN;
 	l->l_slptime = 0;
 	sched_enqueue(l, false);
 	spc_unlock(ci);
+}
 /*
  * sleepq_insert:
+ *
  *	Insert an LWP into the sleep queue, optionally sorting by priority.
  */
 void
 sleepq_insert(sleepq_t *sq, lwp_t *l, syncobj_t *sobj)
+{
 	if ((sobj->sobj_flag & SOBJ_SLEEPQ_SORTED) != 0) {
 		lwp_t *l2;
 		const int pri = lwp_eprio(l);
 		TAILQ_FOREACH(l2, sq, l_sleepchain) {
 			if (lwp_eprio(l2) < pri) {
 				TAILQ_INSERT_BEFORE(l2, l, l_sleepchain);
 				return;
+			}
+		}
+	}
 	if ((sobj->sobj_flag & SOBJ_SLEEPQ_LIFO) != 0)
 		TAILQ_INSERT_HEAD(sq, l, l_sleepchain);
 	else
 		TAILQ_INSERT_TAIL(sq, l, l_sleepchain);
+}
 /*
  * sleepq_enqueue:
+ *
  *	Enter an LWP into the sleep queue and prepare for sleep.  The sleep
  *	queue must already be locked, and any interlock (such as the kernel
  *	lock) must have be released (see sleeptab_lookup(), sleepq_enter()).
  */
 void
 sleepq_enqueue(sleepq_t *sq, wchan_t wchan, const char *wmesg, syncobj_t *sobj)
+{
 	lwp_t *l = curlwp;
 	KASSERT(lwp_locked(l, NULL));
 	KASSERT(l->l_stat == LSONPROC);
 	KASSERT(l->l_wchan == NULL && l->l_sleepq == NULL);
 	l->l_syncobj = sobj;
 	l->l_wchan = wchan;
 	l->l_sleepq = sq;
 	l->l_wmesg = wmesg;
 	l->l_slptime = 0;
 	l->l_stat = LSSLEEP;
 	l->l_sleeperr = 0;
 	sleepq_insert(sq, l, sobj);
 	/* Save the time when thread has slept */
 	l->l_slpticks = hardclock_ticks;
 	sched_slept(l);
+}
 /*
  * sleepq_block:
+ *
  *	After any intermediate step such as releasing an interlock, switch.
  * 	sleepq_block() may return early under exceptional conditions, for
  * 	example if the LWP's containing process is exiting.
  */
 int
 sleepq_block(int timo, bool catch)
+{
 	int error = 0, sig;
 	struct proc *p;
 	lwp_t *l = curlwp;
 	bool early = false;
 	int biglocks = l->l_biglocks;
 	ktrcsw(1, 0);
 	/*
 	 * If sleeping interruptably, check for pending signals, exits or
 	 * core dump events.
 	 */
 	if (catch) {
 		l->l_flag |= LW_SINTR;
 		if ((l->l_flag & (LW_CANCELLED|LW_WEXIT|LW_WCORE)) != 0) {
 			l->l_flag &= ~LW_CANCELLED;
 			error = EINTR;
 			early = true;
 		} else if ((l->l_flag & LW_PENDSIG) != 0 && sigispending(l, 0))
 			early = true;
+	}
 	if (early) {
 		/* lwp_unsleep() will release the lock */
 		lwp_unsleep(l, true);
 	} else {
 		if (timo)
 			callout_schedule(&l->l_timeout_ch, timo);
 #ifdef KERN_SA
 		if (((l->l_flag & LW_SA) != 0) && (~l->l_pflag & LP_SA_NOBLOCK))
 			sa_switch(l);
 		else
 #endif
 			mi_switch(l);
 		/* The LWP and sleep queue are now unlocked. */
 		if (timo) {
 			/*
 			 * Even if the callout appears to have fired, we need to
 			 * stop it in order to synchronise with other CPUs.
 			 */
 			if (callout_halt(&l->l_timeout_ch, NULL))
 				error = EWOULDBLOCK;
+		}
+	}
 	if (catch && error == 0) {
 		p = l->l_proc;
 		if ((l->l_flag & (LW_CANCELLED | LW_WEXIT | LW_WCORE)) != 0)
 			error = EINTR;
 		else if ((l->l_flag & LW_PENDSIG) != 0) {
 			/*
 			 * Acquiring p_lock may cause us to recurse
 			 * through the sleep path and back into this
 			 * routine, but is safe because LWPs sleeping
 			 * on locks are non-interruptable.  We will
 			 * not recurse again.
 			 */
 			mutex_enter(p->p_lock);
 			if ((sig = issignal(l)) != 0)
 				error = sleepq_sigtoerror(l, sig);
 			mutex_exit(p->p_lock);
+		}
+	}
 	ktrcsw(0, 0);
 	if (__predict_false(biglocks != 0)) {
 		KERNEL_LOCK(biglocks, NULL);
+	}
 	return error;
+}
 /*
  * sleepq_wake:
+ *
  *	Wake zero or more LWPs blocked on a single wait channel.
  */
 lwp_t *
 sleepq_wake(sleepq_t *sq, wchan_t wchan, u_int expected, kmutex_t *mp)
+{
 	lwp_t *l, *next;
 	KASSERT(mutex_owned(mp));
 	for (l = TAILQ_FIRST(sq); l != NULL; l = next) {
 		KASSERT(l->l_sleepq == sq);
 		KASSERT(l->l_mutex == mp);
 		next = TAILQ_NEXT(l, l_sleepchain);
 		if (l->l_wchan != wchan)
 			continue;
 		sleepq_remove(sq, l);
 		if (--expected == 0)
 			break;
+	}
 	mutex_spin_exit(mp);
 	return l;
+}
 /*
  * sleepq_unsleep:
+ *
  *	Remove an LWP from its sleep queue and set it runnable again.
  *	sleepq_unsleep() is called with the LWP's mutex held, and will
  *	always release it.
  */
 void
 sleepq_unsleep(lwp_t *l, bool cleanup)
+{
 	sleepq_t *sq = l->l_sleepq;
 	kmutex_t *mp = l->l_mutex;
 	KASSERT(lwp_locked(l, mp));
 	KASSERT(l->l_wchan != NULL);
 	sleepq_remove(sq, l);
 	if (cleanup) {
 		mutex_spin_exit(mp);
+	}
+}
 /*
  * sleepq_timeout:
+ *
  *	Entered via the callout(9) subsystem to time out an LWP that is on a
  *	sleep queue.
  */
 void
 sleepq_timeout(void *arg)
+{
 	lwp_t *l = arg;
 	/*
 	 * Lock the LWP.  Assuming it's still on the sleep queue, its
 	 * current mutex will also be the sleep queue mutex.
 	 */
 	lwp_lock(l);
 	if (l->l_wchan == NULL) {
 		/* Somebody beat us to it. */
 		lwp_unlock(l);
 		return;
+	}
 	lwp_unsleep(l, true);
+}
 /*
  * sleepq_sigtoerror:
+ *
  *	Given a signal number, interpret and return an error code.
  */
 static int
 sleepq_sigtoerror(lwp_t *l, int sig)
+{
 	struct proc *p = l->l_proc;
 	int error;
 	KASSERT(mutex_owned(p->p_lock));
 	/*
 	 * If this sleep was canceled, don't let the syscall restart.
 	 */
 	if ((SIGACTION(p, sig).sa_flags & SA_RESTART) == 0)
 		error = EINTR;
 	else
 		error = ERESTART;
 	return error;
+}
 /*
  * sleepq_abort:
+ *
  *	After a panic or during autoconfiguration, lower the interrupt
  *	priority level to give pending interrupts a chance to run, and
  *	then return.  Called if sleepq_dontsleep() returns non-zero, and
  *	always returns zero.
  */
 int
 sleepq_abort(kmutex_t *mtx, int unlock)
+{
 	extern int safepri;
 	int s;
 	s = splhigh();
 	splx(safepri);
 	splx(s);
 	if (mtx != NULL && unlock != 0)
 		mutex_exit(mtx);
 	return 0;
+}
 /*
  * sleepq_changepri:
+ *
  *	Adjust the priority of an LWP residing on a sleepq.  This method
  *	will only alter the user priority; the effective priority is
  *	assumed to have been fixed at the time of insertion into the queue.
  */
 void
 sleepq_changepri(lwp_t *l, pri_t pri)
+{
 	sleepq_t *sq = l->l_sleepq;
 	pri_t opri;
 	KASSERT(lwp_locked(l, NULL));
 	opri = lwp_eprio(l);
 	l->l_priority = pri;
 	if (lwp_eprio(l) == opri) {
 		return;
+	}
 	if ((l->l_syncobj->sobj_flag & SOBJ_SLEEPQ_SORTED) == 0) {
 		return;
+	}
 	/*
 	 * Don't let the sleep queue become empty, even briefly.
 	 * cv_signal() and cv_broadcast() inspect it without the
 	 * sleep queue lock held and need to see a non-empty queue
 	 * head if there are waiters.
 	 */
 	if (TAILQ_FIRST(sq) == l && TAILQ_NEXT(l, l_sleepchain) == NULL) {
 		return;
+	}
 	TAILQ_REMOVE(sq, l, l_sleepchain);
 	sleepq_insert(sq, l, l->l_syncobj);
+}
 void
 sleepq_lendpri(lwp_t *l, pri_t pri)
+{
 	sleepq_t *sq = l->l_sleepq;
 	pri_t opri;
 	KASSERT(lwp_locked(l, NULL));
 	opri = lwp_eprio(l);
 	l->l_inheritedprio = pri;
 	if (lwp_eprio(l) == opri) {
 		return;
+	}
 	if ((l->l_syncobj->sobj_flag & SOBJ_SLEEPQ_SORTED) == 0) {
 		return;
+	}
 	/*
 	 * Don't let the sleep queue become empty, even briefly.
 	 * cv_signal() and cv_broadcast() inspect it without the
 	 * sleep queue lock held and need to see a non-empty queue
 	 * head if there are waiters.
 	 */
 	if (TAILQ_FIRST(sq) == l && TAILQ_NEXT(l, l_sleepchain) == NULL) {
 		return;
+	}
 	TAILQ_REMOVE(sq, l, l_sleepchain);
 	sleepq_insert(sq, l, l->l_syncobj);
+}

 @@ -1,726 +1,724 @@
-/*	$NetBSD: kern_subr.c,v 1.208 2010/11/11 11:07:07 hannken Exp $	*/
+/*	$NetBSD: kern_subr.c,v 1.209 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c) 1997, 1998, 1999, 2002, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, and by Luke Mewburn.
+ *
  * 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) 1982, 1986, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * Copyright (c) 1992, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This software was developed by the Computer Systems Engineering group
  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
  * contributed to Berkeley.
+ *
  * All advertising materials mentioning features or use of this software
  * must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Lawrence Berkeley Laboratory.
+ *
  * 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.
+ *
  *	@(#)kern_subr.c	8.4 (Berkeley) 2/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_subr.c,v 1.208 2010/11/11 11:07:07 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_subr.c,v 1.209 2011/07/27 14:35:34 uebayasi Exp $");
 #include "opt_ddb.h"
 #include "opt_md.h"
 #include "opt_syscall_debug.h"
 #include "opt_ktrace.h"
 #include "opt_ptrace.h"
 #include "opt_tftproot.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/mount.h>
 #include <sys/device.h>
 #include <sys/reboot.h>
 #include <sys/conf.h>
 #include <sys/disk.h>
 #include <sys/disklabel.h>
 #include <sys/queue.h>
 #include <sys/ktrace.h>
 #include <sys/ptrace.h>
 #include <sys/fcntl.h>
 #include <sys/kauth.h>
 #include <sys/stat.h>
 #include <sys/vnode.h>
 #include <sys/module.h>
 #include <uvm/uvm_extern.h>
 #include <dev/cons.h>
 #include <net/if.h>
 /* XXX these should eventually move to subr_autoconf.c */
 static device_t finddevice(const char *);
 static device_t getdisk(char *, int, int, dev_t *, int);
 static device_t parsedisk(char *, int, int, dev_t *);
 static const char *getwedgename(const char *, int);
 #ifdef TFTPROOT
 int tftproot_dhcpboot(device_t);
 #endif
 dev_t	dumpcdev;	/* for savecore */
 static int
 isswap(device_t dv)
+{
 	struct dkwedge_info wi;
 	struct vnode *vn;
 	int error;
 	if (device_class(dv) != DV_DISK || !device_is_a(dv, "dk"))
 		return 0;
 	if ((vn = opendisk(dv)) == NULL)
 		return 0;
 	error = VOP_IOCTL(vn, DIOCGWEDGEINFO, &wi, FREAD, NOCRED);
 	VOP_CLOSE(vn, FREAD, NOCRED);
 	vput(vn);
 	if (error) {
 #ifdef DEBUG_WEDGE
 		printf("%s: Get wedge info returned %d\n", device_xname(dv), error);
 #endif
 		return 0;
+	}
 	return strcmp(wi.dkw_ptype, DKW_PTYPE_SWAP) == 0;
+}
 /*
  * Determine the root device and, if instructed to, the root file system.
  */
 #ifdef MEMORY_DISK_IS_ROOT
 int md_is_root = 1;
 #else
 int md_is_root = 0;
 #endif
 /*
  * The device and wedge that we booted from.  If booted_wedge is NULL,
  * the we might consult booted_partition.
  */
 device_t booted_device;
 device_t booted_wedge;
 int booted_partition;
 /*
  * Use partition letters if it's a disk class but not a wedge.
  * XXX Check for wedge is kinda gross.
  */
 #define	DEV_USES_PARTITIONS(dv)						\
 	(device_class((dv)) == DV_DISK &&				\
 	 !device_is_a((dv), "dk"))
 void
 setroot(device_t bootdv, int bootpartition)
+{
 	device_t dv;
 	deviter_t di;
 	int len, majdev;
 	dev_t nrootdev;
 	dev_t ndumpdev = NODEV;
 	char buf[128];
 	const char *rootdevname;
 	const char *dumpdevname;
 	device_t rootdv = NULL;		/* XXX gcc -Wuninitialized */
 	device_t dumpdv = NULL;
 	struct ifnet *ifp;
 	const char *deffsname;
 	struct vfsops *vops;
 #ifdef TFTPROOT
 	if (tftproot_dhcpboot(bootdv) != 0)
 		boothowto |= RB_ASKNAME;
 #endif
 	/*
 	 * For root on md0 we have to force the attachment of md0.
 	 */
 	if (md_is_root) {
 		int md_major;
 		dev_t md_dev;
 		bootdv = NULL;
 		md_major = devsw_name2blk("md", NULL, 0);
 		if (md_major >= 0) {
 			md_dev = MAKEDISKDEV(md_major, 0, RAW_PART);
 			if (bdev_open(md_dev, FREAD, S_IFBLK, curlwp) == 0)
 				bootdv = device_find_by_xname("md0");
+		}
 		if (bootdv == NULL)
 			panic("Cannot open \"md0\" (root)");
+	}
 	/*
 	 * If NFS is specified as the file system, and we found
 	 * a DV_DISK boot device (or no boot device at all), then
 	 * find a reasonable network interface for "rootspec".
 	 */
 	vops = vfs_getopsbyname(MOUNT_NFS);
 	if (vops != NULL && strcmp(rootfstype, MOUNT_NFS) == 0 &&
 	    rootspec == NULL &&
 	    (bootdv == NULL || device_class(bootdv) != DV_IFNET)) {
 		IFNET_FOREACH(ifp) {
 			if ((ifp->if_flags &
 			     (IFF_LOOPBACK|IFF_POINTOPOINT)) == 0)
 				break;
+		}
 		if (ifp == NULL) {
 			/*
 			 * Can't find a suitable interface; ask the
 			 * user.
 			 */
 			boothowto |= RB_ASKNAME;
 		} else {
 			/*
 			 * Have a suitable interface; behave as if
 			 * the user specified this interface.
 			 */
 			rootspec = (const char *)ifp->if_xname;
+		}
+	}
 	if (vops != NULL)
 		vfs_delref(vops);
 	/*
 	 * If wildcarded root and we the boot device wasn't determined,
 	 * ask the user.
 	 */
 	if (rootspec == NULL && bootdv == NULL)
 		boothowto |= RB_ASKNAME;
  top:
 	if (boothowto & RB_ASKNAME) {
 		device_t defdumpdv;
 		for (;;) {
 			printf("root device");
 			if (bootdv != NULL) {
 				printf(" (default %s", device_xname(bootdv));
 				if (DEV_USES_PARTITIONS(bootdv))
 					printf("%c", bootpartition + 'a');
 				printf(")");
+			}
 			printf(": ");
 			len = cngetsn(buf, sizeof(buf));
 			if (len == 0 && bootdv != NULL) {
 				strlcpy(buf, device_xname(bootdv), sizeof(buf));
 				len = strlen(buf);
+			}
 			if (len > 0 && buf[len - 1] == '*') {
 				buf[--len] = '\0';
 				dv = getdisk(buf, len, 1, &nrootdev, 0);
 				if (dv != NULL) {
 					rootdv = dv;
 					break;
+				}
+			}
 			dv = getdisk(buf, len, bootpartition, &nrootdev, 0);
 			if (dv != NULL) {
 				rootdv = dv;
 				break;
+			}
+		}
 		/*
 		 * Set up the default dump device.  If root is on
 		 * a network device, there is no default dump
 		 * device, since we don't support dumps to the
 		 * network.
 		 */
 		if (DEV_USES_PARTITIONS(rootdv) == 0)
 			defdumpdv = NULL;
 		else
 			defdumpdv = rootdv;
 		for (;;) {
 			printf("dump device");
 			if (defdumpdv != NULL) {
 				/*
 				 * Note, we know it's a disk if we get here.
 				 */
 				printf(" (default %sb)", device_xname(defdumpdv));
+			}
 			printf(": ");
 			len = cngetsn(buf, sizeof(buf));
 			if (len == 0) {
 				if (defdumpdv != NULL) {
 					ndumpdev = MAKEDISKDEV(major(nrootdev),
 					    DISKUNIT(nrootdev), 1);
+				}
 				dumpdv = defdumpdv;
 				break;
+			}
 			if (len == 4 && strcmp(buf, "none") == 0) {
 				dumpdv = NULL;
 				break;
+			}
 			dv = getdisk(buf, len, 1, &ndumpdev, 1);
 			if (dv != NULL) {
 				dumpdv = dv;
 				break;
+			}
+		}
 		rootdev = nrootdev;
 		dumpdev = ndumpdev;
 		for (vops = LIST_FIRST(&vfs_list); vops != NULL;
 		     vops = LIST_NEXT(vops, vfs_list)) {
 			if (vops->vfs_mountroot != NULL &&
 			    strcmp(rootfstype, vops->vfs_name) == 0)
 			break;
+		}
 		if (vops == NULL) {
 			deffsname = "generic";
 		} else
 			deffsname = vops->vfs_name;
 		for (;;) {
 			printf("file system (default %s): ", deffsname);
 			len = cngetsn(buf, sizeof(buf));
 			if (len == 0) {
 				if (strcmp(deffsname, "generic") == 0)
 					rootfstype = ROOT_FSTYPE_ANY;
 				break;
+			}
 			if (len == 4 && strcmp(buf, "halt") == 0)
 				cpu_reboot(RB_HALT, NULL);
 			else if (len == 6 && strcmp(buf, "reboot") == 0)
 				cpu_reboot(0, NULL);
 #if defined(DDB)
 			else if (len == 3 && strcmp(buf, "ddb") == 0) {
 				console_debugger();
+			}
 #endif
 			else if (len == 7 && strcmp(buf, "generic") == 0) {
 				rootfstype = ROOT_FSTYPE_ANY;
 				break;
+			}
 			vops = vfs_getopsbyname(buf);
 			if (vops == NULL || vops->vfs_mountroot == NULL) {
 				printf("use one of: generic");
 				for (vops = LIST_FIRST(&vfs_list);
 				     vops != NULL;
 				     vops = LIST_NEXT(vops, vfs_list)) {
 					if (vops->vfs_mountroot != NULL)
 						printf(" %s", vops->vfs_name);
+				}
 				if (vops != NULL)
 					vfs_delref(vops);
 #if defined(DDB)
 				printf(" ddb");
 #endif
 				printf(" halt reboot\n");
 			} else {
 				/*
 				 * XXX If *vops gets freed between here and
 				 * the call to mountroot(), rootfstype will
 				 * point to something unexpected.  But in
 				 * this case the system will fail anyway.
 				 */
 				rootfstype = vops->vfs_name;
 				vfs_delref(vops);
 				break;
+			}
+		}
 	} else if (rootspec == NULL) {
 		/*
 		 * Wildcarded root; use the boot device.
 		 */
 		rootdv = bootdv;
 		if (bootdv)
 			majdev = devsw_name2blk(device_xname(bootdv), NULL, 0);
 		else
 			majdev = -1;
 		if (majdev >= 0) {
 			/*
 			 * Root is on a disk.  `bootpartition' is root,
 			 * unless the device does not use partitions.
 			 */
 			if (DEV_USES_PARTITIONS(bootdv))
 				rootdev = MAKEDISKDEV(majdev,
 						      device_unit(bootdv),
 						      bootpartition);
 			else
 				rootdev = makedev(majdev, device_unit(bootdv));
+		}
 	} else {
 		/*
 		 * `root on <dev> ...'
 		 */
 		/*
 		 * If it's a network interface, we can bail out
 		 * early.
 		 */
 		dv = finddevice(rootspec);
 		if (dv != NULL && device_class(dv) == DV_IFNET) {
 			rootdv = dv;
 			goto haveroot;
+		}
 		if (rootdev == NODEV &&
 		    device_class(dv) == DV_DISK && device_is_a(dv, "dk") &&
 		    (majdev = devsw_name2blk(device_xname(dv), NULL, 0)) >= 0)
 			rootdev = makedev(majdev, device_unit(dv));
 		rootdevname = devsw_blk2name(major(rootdev));
 		if (rootdevname == NULL) {
 			printf("unknown device major 0x%llx\n",
 			    (unsigned long long)rootdev);
 			boothowto |= RB_ASKNAME;
 			goto top;
+		}
 		memset(buf, 0, sizeof(buf));
 		snprintf(buf, sizeof(buf), "%s%llu", rootdevname,
 		    (unsigned long long)DISKUNIT(rootdev));
 		rootdv = finddevice(buf);
 		if (rootdv == NULL) {
 			printf("device %s (0x%llx) not configured\n",
 			    buf, (unsigned long long)rootdev);
 			boothowto |= RB_ASKNAME;
 			goto top;
+		}
+	}
  haveroot:
 	root_device = rootdv;
 	switch (device_class(rootdv)) {
 	case DV_IFNET:
 	case DV_DISK:
 		aprint_normal("root on %s", device_xname(rootdv));
 		if (DEV_USES_PARTITIONS(rootdv))
 			aprint_normal("%c", (int)DISKPART(rootdev) + 'a');
 		break;
 	default:
 		printf("can't determine root device\n");
 		boothowto |= RB_ASKNAME;
 		goto top;
+	}
 	/*
 	 * Now configure the dump device.
+	 *
 	 * If we haven't figured out the dump device, do so, with
 	 * the following rules:
+	 *
 	 *	(a) We already know dumpdv in the RB_ASKNAME case.
+	 *
 	 *	(b) If dumpspec is set, try to use it.  If the device
 	 *	    is not available, punt.
+	 *
 	 *	(c) If dumpspec is not set, the dump device is
 	 *	    wildcarded or unspecified.  If the root device
 	 *	    is DV_IFNET, punt.  Otherwise, use partition b
 	 *	    of the root device.
 	 */
 	if (boothowto & RB_ASKNAME) {		/* (a) */
 		if (dumpdv == NULL)
 			goto nodumpdev;
 	} else if (dumpspec != NULL) {		/* (b) */
 		if (strcmp(dumpspec, "none") == 0 || dumpdev == NODEV) {
 			/*
 			 * Operator doesn't want a dump device.
 			 * Or looks like they tried to pick a network
 			 * device.  Oops.
 			 */
 			goto nodumpdev;
+		}
 		dumpdevname = devsw_blk2name(major(dumpdev));
 		if (dumpdevname == NULL)
 			goto nodumpdev;
 		memset(buf, 0, sizeof(buf));
 		snprintf(buf, sizeof(buf), "%s%llu", dumpdevname,
 		    (unsigned long long)DISKUNIT(dumpdev));
 		dumpdv = finddevice(buf);
 		if (dumpdv == NULL) {
 			/*
 			 * Device not configured.
 			 */
 			goto nodumpdev;
+		}
 	} else {				/* (c) */
 		if (DEV_USES_PARTITIONS(rootdv) == 0) {
 			for (dv = deviter_first(&di, DEVITER_F_ROOT_FIRST);
 			     dv != NULL;
 			     dv = deviter_next(&di))
 				if (isswap(dv))
 					break;
 			deviter_release(&di);
 			if (dv == NULL)
 				goto nodumpdev;
 			majdev = devsw_name2blk(device_xname(dv), NULL, 0);
 			if (majdev < 0)
 				goto nodumpdev;
 			dumpdv = dv;
 			dumpdev = makedev(majdev, device_unit(dumpdv));
 		} else {
 			dumpdv = rootdv;
 			dumpdev = MAKEDISKDEV(major(rootdev),
 			    device_unit(dumpdv), 1);
+		}
+	}
 	dumpcdev = devsw_blk2chr(dumpdev);
 	aprint_normal(" dumps on %s", device_xname(dumpdv));
 	if (DEV_USES_PARTITIONS(dumpdv))
 		aprint_normal("%c", (int)DISKPART(dumpdev) + 'a');
 	aprint_normal("\n");
 	return;
  nodumpdev:
 	dumpdev = NODEV;
 	dumpcdev = NODEV;
 	aprint_normal("\n");
+}
 static device_t
 finddevice(const char *name)
+{
 	const char *wname;
 	if ((wname = getwedgename(name, strlen(name))) != NULL)
 		return dkwedge_find_by_wname(wname);
 	return device_find_by_xname(name);
+}
 static device_t
 getdisk(char *str, int len, int defpart, dev_t *devp, int isdump)
+{
 	device_t dv;
 	deviter_t di;
 	if ((dv = parsedisk(str, len, defpart, devp)) == NULL) {
 		printf("use one of:");
 		for (dv = deviter_first(&di, DEVITER_F_ROOT_FIRST); dv != NULL;
 		     dv = deviter_next(&di)) {
 			if (DEV_USES_PARTITIONS(dv))
 				printf(" %s[a-%c]", device_xname(dv),
 				    'a' + MAXPARTITIONS - 1);
 			else if (device_class(dv) == DV_DISK)
 				printf(" %s", device_xname(dv));
 			if (isdump == 0 && device_class(dv) == DV_IFNET)
 				printf(" %s", device_xname(dv));
+		}
 		deviter_release(&di);
 		dkwedge_print_wnames();
 		if (isdump)
 			printf(" none");
 #if defined(DDB)
 		printf(" ddb");
 #endif
 		printf(" halt reboot\n");
+	}
 	return dv;
+}
 static const char *
 getwedgename(const char *name, int namelen)
+{
 	const char *wpfx = "wedge:";
 	const int wpfxlen = strlen(wpfx);
 	if (namelen < wpfxlen || strncmp(name, wpfx, wpfxlen) != 0)
 		return NULL;
 	return name + wpfxlen;
+}
 static device_t
 parsedisk(char *str, int len, int defpart, dev_t *devp)
+{
 	device_t dv;
 	const char *wname;
 	char *cp, c;
 	int majdev, part;
 	if (len == 0)
 		return (NULL);
 	if (len == 4 && strcmp(str, "halt") == 0)
 		cpu_reboot(RB_HALT, NULL);
 	else if (len == 6 && strcmp(str, "reboot") == 0)
 		cpu_reboot(0, NULL);
 #if defined(DDB)
 	else if (len == 3 && strcmp(str, "ddb") == 0)
 		console_debugger();
 #endif
 	cp = str + len - 1;
 	c = *cp;
 	if ((wname = getwedgename(str, len)) != NULL) {
 		if ((dv = dkwedge_find_by_wname(wname)) == NULL)
 			return NULL;
 		part = defpart;
 		goto gotdisk;
 	} else if (c >= 'a' && c <= ('a' + MAXPARTITIONS - 1)) {
 		part = c - 'a';
 		*cp = '\0';
 	} else
 		part = defpart;
 	dv = finddevice(str);
 	if (dv != NULL) {
 		if (device_class(dv) == DV_DISK) {
  gotdisk:
 			majdev = devsw_name2blk(device_xname(dv), NULL, 0);
 			if (majdev < 0)
 				panic("parsedisk");
 			if (DEV_USES_PARTITIONS(dv))
 				*devp = MAKEDISKDEV(majdev, device_unit(dv),
 						    part);
 			else
 				*devp = makedev(majdev, device_unit(dv));
+		}
 		if (device_class(dv) == DV_IFNET)
 			*devp = NODEV;
+	}
 	*cp = c;
 	return (dv);
+}
 /*
  * Return true if system call tracing is enabled for the specified process.
  */
 bool
 trace_is_enabled(struct proc *p)
+{
 #ifdef SYSCALL_DEBUG
 	return (true);
 #endif
 #ifdef KTRACE
 	if (ISSET(p->p_traceflag, (KTRFAC_SYSCALL | KTRFAC_SYSRET)))
 		return (true);
 #endif
 #ifdef PTRACE
 	if (ISSET(p->p_slflag, PSL_SYSCALL))
 		return (true);
 #endif
 	return (false);
+}
 /*
  * Start trace of particular system call. If process is being traced,
  * this routine is called by MD syscall dispatch code just before
  * a system call is actually executed.
  */
 int
 trace_enter(register_t code, const register_t *args, int narg)
+{
 #ifdef SYSCALL_DEBUG
 	scdebug_call(code, args);
 #endif /* SYSCALL_DEBUG */
 	ktrsyscall(code, args, narg);
 #ifdef PTRACE
 	if ((curlwp->l_proc->p_slflag & (PSL_SYSCALL|PSL_TRACED)) ==
 	    (PSL_SYSCALL|PSL_TRACED))
 		process_stoptrace();
 #endif
 	return 0;
+}
 /*
  * End trace of particular system call. If process is being traced,
  * this routine is called by MD syscall dispatch code just after
  * a system call finishes.
  * MD caller guarantees the passed 'code' is within the supported
  * system call number range for emulation the process runs under.
  */
 void
 trace_exit(register_t code, register_t rval[], int error)
+{
 #ifdef SYSCALL_DEBUG
 	scdebug_ret(code, error, rval);
 #endif /* SYSCALL_DEBUG */
 	ktrsysret(code, error, rval);
 #ifdef PTRACE
 	if ((curlwp->l_proc->p_slflag & (PSL_SYSCALL|PSL_TRACED)) ==
 	    (PSL_SYSCALL|PSL_TRACED))
 		process_stoptrace();
 #endif
+}

 @@ -1,1083 +1,1081 @@
-/*	$NetBSD: kern_time.c,v 1.168 2011/04/08 10:35:37 yamt Exp $	*/
+/*	$NetBSD: kern_time.c,v 1.169 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c) 2000, 2004, 2005, 2007, 2008, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Christopher G. Demetriou, and by Andrew Doran.
+ *
  * 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) 1982, 1986, 1989, 1993
  *	The Regents of the University of California.  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. 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.
+ *
  *	@(#)kern_time.c	8.4 (Berkeley) 5/26/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_time.c,v 1.168 2011/04/08 10:35:37 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_time.c,v 1.169 2011/07/27 14:35:34 uebayasi Exp $");
 #include <sys/param.h>
 #include <sys/resourcevar.h>
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/signalvar.h>
 #include <sys/syslog.h>
 #include <sys/timetc.h>
 #include <sys/timex.h>
 #include <sys/kauth.h>
 #include <sys/mount.h>
 #include <sys/sa.h>
 #include <sys/savar.h>
 #include <sys/syscallargs.h>
 #include <sys/cpu.h>
 #include <uvm/uvm_extern.h>
 #include "opt_sa.h"
 static void	timer_intr(void *);
 static void	itimerfire(struct ptimer *);
 static void	itimerfree(struct ptimers *, int);
 kmutex_t	timer_lock;
 static void	*timer_sih;
 static TAILQ_HEAD(, ptimer) timer_queue;
 struct pool ptimer_pool, ptimers_pool;
 #define	CLOCK_VIRTUAL_P(clockid)	\
 	((clockid) == CLOCK_VIRTUAL || (clockid) == CLOCK_PROF)
 CTASSERT(ITIMER_REAL == CLOCK_REALTIME);
 CTASSERT(ITIMER_VIRTUAL == CLOCK_VIRTUAL);
 CTASSERT(ITIMER_PROF == CLOCK_PROF);
 /*
  * Initialize timekeeping.
  */
 void
 time_init(void)
+{
 	pool_init(&ptimer_pool, sizeof(struct ptimer), 0, 0, 0, "ptimerpl",
 	    &pool_allocator_nointr, IPL_NONE);
 	pool_init(&ptimers_pool, sizeof(struct ptimers), 0, 0, 0, "ptimerspl",
 	    &pool_allocator_nointr, IPL_NONE);
+}
 void
 time_init2(void)
+{
 	TAILQ_INIT(&timer_queue);
 	mutex_init(&timer_lock, MUTEX_DEFAULT, IPL_SCHED);
 	timer_sih = softint_establish(SOFTINT_CLOCK | SOFTINT_MPSAFE,
 	    timer_intr, NULL);
+}
 /* Time of day and interval timer support.
+ *
  * These routines provide the kernel entry points to get and set
  * the time-of-day and per-process interval timers.  Subroutines
  * here provide support for adding and subtracting timeval structures
  * and decrementing interval timers, optionally reloading the interval
  * timers when they expire.
  */
 /* This function is used by clock_settime and settimeofday */
 static int
 settime1(struct proc *p, const struct timespec *ts, bool check_kauth)
+{
 	struct timespec delta, now;
 	int s;
 	/* WHAT DO WE DO ABOUT PENDING REAL-TIME TIMEOUTS??? */
 	s = splclock();
 	nanotime(&now);
 	timespecsub(ts, &now, &delta);
 	if (check_kauth && kauth_authorize_system(kauth_cred_get(),
 	    KAUTH_SYSTEM_TIME, KAUTH_REQ_SYSTEM_TIME_SYSTEM, __UNCONST(ts),
 	    &delta, KAUTH_ARG(check_kauth ? false : true)) != 0) {
 		splx(s);
 		return (EPERM);
+	}
 #ifdef notyet
 	if ((delta.tv_sec < 86400) && securelevel > 0) { /* XXX elad - notyet */
 		splx(s);
 		return (EPERM);
+	}
 #endif
 	tc_setclock(ts);
 	timespecadd(&boottime, &delta, &boottime);
 	resettodr();
 	splx(s);
 	return (0);
+}
 int
 settime(struct proc *p, struct timespec *ts)
+{
 	return (settime1(p, ts, true));
+}
 /* ARGSUSED */
 int
 sys___clock_gettime50(struct lwp *l,
     const struct sys___clock_gettime50_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(clockid_t) clock_id;
 		syscallarg(struct timespec *) tp;
 	} */
 	int error;
 	struct timespec ats;
 	error = clock_gettime1(SCARG(uap, clock_id), &ats);
 	if (error != 0)
 		return error;
 	return copyout(&ats, SCARG(uap, tp), sizeof(ats));
+}
 int
 clock_gettime1(clockid_t clock_id, struct timespec *ts)
+{
 	switch (clock_id) {
 	case CLOCK_REALTIME:
 		nanotime(ts);
 		break;
 	case CLOCK_MONOTONIC:
 		nanouptime(ts);
 		break;
 	default:
 		return EINVAL;
+	}
 	return 0;
+}
 /* ARGSUSED */
 int
 sys___clock_settime50(struct lwp *l,
     const struct sys___clock_settime50_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(clockid_t) clock_id;
 		syscallarg(const struct timespec *) tp;
 	} */
 	int error;
 	struct timespec ats;
 	if ((error = copyin(SCARG(uap, tp), &ats, sizeof(ats))) != 0)
 		return error;
 	return clock_settime1(l->l_proc, SCARG(uap, clock_id), &ats, true);
+}
 int
 clock_settime1(struct proc *p, clockid_t clock_id, const struct timespec *tp,
     bool check_kauth)
+{
 	int error;
 	switch (clock_id) {
 	case CLOCK_REALTIME:
 		if ((error = settime1(p, tp, check_kauth)) != 0)
 			return (error);
 		break;
 	case CLOCK_MONOTONIC:
 		return (EINVAL);	/* read-only clock */
 	default:
 		return (EINVAL);
+	}
 	return 0;
+}
 int
 sys___clock_getres50(struct lwp *l, const struct sys___clock_getres50_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(clockid_t) clock_id;
 		syscallarg(struct timespec *) tp;
 	} */
 	struct timespec ts;
 	int error = 0;
 	if ((error = clock_getres1(SCARG(uap, clock_id), &ts)) != 0)
 		return error;
 	if (SCARG(uap, tp))
 		error = copyout(&ts, SCARG(uap, tp), sizeof(ts));
 	return error;
+}
 int
 clock_getres1(clockid_t clock_id, struct timespec *ts)
+{
 	switch (clock_id) {
 	case CLOCK_REALTIME:
 	case CLOCK_MONOTONIC:
 		ts->tv_sec = 0;
 		if (tc_getfrequency() > 1000000000)
 			ts->tv_nsec = 1;
 		else
 			ts->tv_nsec = 1000000000 / tc_getfrequency();
 		break;
 	default:
 		return EINVAL;
+	}
 	return 0;
+}
 /* ARGSUSED */
 int
 sys___nanosleep50(struct lwp *l, const struct sys___nanosleep50_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(struct timespec *) rqtp;
 		syscallarg(struct timespec *) rmtp;
 	} */
 	struct timespec rmt, rqt;
 	int error, error1;
 	error = copyin(SCARG(uap, rqtp), &rqt, sizeof(struct timespec));
 	if (error)
 		return (error);
 	error = nanosleep1(l, &rqt, SCARG(uap, rmtp) ? &rmt : NULL);
 	if (SCARG(uap, rmtp) == NULL || (error != 0 && error != EINTR))
 		return error;
 	error1 = copyout(&rmt, SCARG(uap, rmtp), sizeof(rmt));
 	return error1 ? error1 : error;
+}
 int
 nanosleep1(struct lwp *l, struct timespec *rqt, struct timespec *rmt)
+{
 	struct timespec rmtstart;
 	int error, timo;
 	if ((error = itimespecfix(rqt)) != 0)
 		return error;
 	timo = tstohz(rqt);
 	/*
 	 * Avoid inadvertantly sleeping forever
 	 */
 	if (timo == 0)
 		timo = 1;
 	getnanouptime(&rmtstart);
 again:
 	error = kpause("nanoslp", true, timo, NULL);
 	if (rmt != NULL || error == 0) {
 		struct timespec rmtend;
 		struct timespec t0;
 		struct timespec *t;
 		getnanouptime(&rmtend);
 		t = (rmt != NULL) ? rmt : &t0;
 		timespecsub(&rmtend, &rmtstart, t);
 		timespecsub(rqt, t, t);
 		if (t->tv_sec < 0)
 			timespecclear(t);
 		if (error == 0) {
 			timo = tstohz(t);
 			if (timo > 0)
 				goto again;
+		}
+	}
 	if (error == ERESTART)
 		error = EINTR;
 	if (error == EWOULDBLOCK)
 		error = 0;
 	return error;
+}
 /* ARGSUSED */
 int
 sys___gettimeofday50(struct lwp *l, const struct sys___gettimeofday50_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(struct timeval *) tp;
 		syscallarg(void *) tzp;		really "struct timezone *";
 	} */
 	struct timeval atv;
 	int error = 0;
 	struct timezone tzfake;
 	if (SCARG(uap, tp)) {
 		microtime(&atv);
 		error = copyout(&atv, SCARG(uap, tp), sizeof(atv));
 		if (error)
 			return (error);
+	}
 	if (SCARG(uap, tzp)) {
 		/*
 		 * NetBSD has no kernel notion of time zone, so we just
 		 * fake up a timezone struct and return it if demanded.
 		 */
 		tzfake.tz_minuteswest = 0;
 		tzfake.tz_dsttime = 0;
 		error = copyout(&tzfake, SCARG(uap, tzp), sizeof(tzfake));
+	}
 	return (error);
+}
 /* ARGSUSED */
 int
 sys___settimeofday50(struct lwp *l, const struct sys___settimeofday50_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(const struct timeval *) tv;
 		syscallarg(const void *) tzp; really "const struct timezone *";
 	} */
 	return settimeofday1(SCARG(uap, tv), true, SCARG(uap, tzp), l, true);
+}
 int
 settimeofday1(const struct timeval *utv, bool userspace,
     const void *utzp, struct lwp *l, bool check_kauth)
+{
 	struct timeval atv;
 	struct timespec ts;
 	int error;
 	/* Verify all parameters before changing time. */
 	/*
 	 * NetBSD has no kernel notion of time zone, and only an
 	 * obsolete program would try to set it, so we log a warning.
 	 */
 	if (utzp)
 		log(LOG_WARNING, "pid %d attempted to set the "
 		    "(obsolete) kernel time zone\n", l->l_proc->p_pid);
 	if (utv == NULL)
 		return 0;
 	if (userspace) {
 		if ((error = copyin(utv, &atv, sizeof(atv))) != 0)
 			return error;
 		utv = &atv;
+	}
 	TIMEVAL_TO_TIMESPEC(utv, &ts);
 	return settime1(l->l_proc, &ts, check_kauth);
+}
 int	time_adjusted;			/* set if an adjustment is made */
 /* ARGSUSED */
 int
 sys___adjtime50(struct lwp *l, const struct sys___adjtime50_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(const struct timeval *) delta;
 		syscallarg(struct timeval *) olddelta;
 	} */
 	int error = 0;
 	struct timeval atv, oldatv;
 	if ((error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_TIME,
 	    KAUTH_REQ_SYSTEM_TIME_ADJTIME, NULL, NULL, NULL)) != 0)
 		return error;
 	if (SCARG(uap, delta)) {
 		error = copyin(SCARG(uap, delta), &atv,
 		    sizeof(*SCARG(uap, delta)));
 		if (error)
 			return (error);
+	}
 	adjtime1(SCARG(uap, delta) ? &atv : NULL,
 	    SCARG(uap, olddelta) ? &oldatv : NULL, l->l_proc);
 	if (SCARG(uap, olddelta))
 		error = copyout(&oldatv, SCARG(uap, olddelta),
 		    sizeof(*SCARG(uap, olddelta)));
 	return error;
+}
 void
 adjtime1(const struct timeval *delta, struct timeval *olddelta, struct proc *p)
+{
 	extern int64_t time_adjtime;  /* in kern_ntptime.c */
 	if (olddelta) {
 		mutex_spin_enter(&timecounter_lock);
 		olddelta->tv_sec = time_adjtime / 1000000;
 		olddelta->tv_usec = time_adjtime % 1000000;
 		if (olddelta->tv_usec < 0) {
 			olddelta->tv_usec += 1000000;
 			olddelta->tv_sec--;
+		}
 		mutex_spin_exit(&timecounter_lock);
+	}
 	if (delta) {
 		mutex_spin_enter(&timecounter_lock);
 		time_adjtime = delta->tv_sec * 1000000 + delta->tv_usec;
 		if (time_adjtime) {
 			/* We need to save the system time during shutdown */
 			time_adjusted |= 1;
+		}
 		mutex_spin_exit(&timecounter_lock);
+	}
+}
 /*
  * Interval timer support. Both the BSD getitimer() family and the POSIX
  * timer_*() family of routines are supported.
+ *
  * All timers are kept in an array pointed to by p_timers, which is
  * allocated on demand - many processes don't use timers at all. The
  * first three elements in this array are reserved for the BSD timers:
  * element 0 is ITIMER_REAL, element 1 is ITIMER_VIRTUAL, and element
  * 2 is ITIMER_PROF. The rest may be allocated by the timer_create()
  * syscall.
+ *
  * Realtime timers are kept in the ptimer structure as an absolute
  * time; virtual time timers are kept as a linked list of deltas.
  * Virtual time timers are processed in the hardclock() routine of
  * kern_clock.c.  The real time timer is processed by a callout
  * routine, called from the softclock() routine.  Since a callout may
  * be delayed in real time due to interrupt processing in the system,
  * it is possible for the real time timeout routine (realtimeexpire,
  * given below), to be delayed in real time past when it is supposed
  * to occur.  It does not suffice, therefore, to reload the real timer
  * .it_value from the real time timers .it_interval.  Rather, we
  * compute the next time in absolute time the timer should go off.  */
 /* Allocate a POSIX realtime timer. */
 int
 sys_timer_create(struct lwp *l, const struct sys_timer_create_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(clockid_t) clock_id;
 		syscallarg(struct sigevent *) evp;
 		syscallarg(timer_t *) timerid;
 	} */
 	return timer_create1(SCARG(uap, timerid), SCARG(uap, clock_id),
 	    SCARG(uap, evp), copyin, l);
+}
 int
 timer_create1(timer_t *tid, clockid_t id, struct sigevent *evp,
     copyin_t fetch_event, struct lwp *l)
+{
 	int error;
 	timer_t timerid;
 	struct ptimers *pts;
 	struct ptimer *pt;
 	struct proc *p;
 	p = l->l_proc;
 	if (id != CLOCK_REALTIME && id != CLOCK_VIRTUAL &&
 	    id != CLOCK_PROF && id != CLOCK_MONOTONIC)
 		return (EINVAL);
 	if ((pts = p->p_timers) == NULL)
 		pts = timers_alloc(p);
 	pt = pool_get(&ptimer_pool, PR_WAITOK);
 	if (evp != NULL) {
 		if (((error =
 		    (*fetch_event)(evp, &pt->pt_ev, sizeof(pt->pt_ev))) != 0) ||
 		    ((pt->pt_ev.sigev_notify < SIGEV_NONE) ||
 			(pt->pt_ev.sigev_notify > SIGEV_SA)) ||
 			(pt->pt_ev.sigev_notify == SIGEV_SIGNAL &&
 			 (pt->pt_ev.sigev_signo <= 0 ||
 			  pt->pt_ev.sigev_signo >= NSIG))) {
 			pool_put(&ptimer_pool, pt);
 			return (error ? error : EINVAL);
+		}
+	}
 	/* Find a free timer slot, skipping those reserved for setitimer(). */
 	mutex_spin_enter(&timer_lock);
 	for (timerid = 3; timerid < TIMER_MAX; timerid++)
 		if (pts->pts_timers[timerid] == NULL)
 			break;
 	if (timerid == TIMER_MAX) {
 		mutex_spin_exit(&timer_lock);
 		pool_put(&ptimer_pool, pt);
 		return EAGAIN;
+	}
 	if (evp == NULL) {
 		pt->pt_ev.sigev_notify = SIGEV_SIGNAL;
 		switch (id) {
 		case CLOCK_REALTIME:
 		case CLOCK_MONOTONIC:
 			pt->pt_ev.sigev_signo = SIGALRM;
 			break;
 		case CLOCK_VIRTUAL:
 			pt->pt_ev.sigev_signo = SIGVTALRM;
 			break;
 		case CLOCK_PROF:
 			pt->pt_ev.sigev_signo = SIGPROF;
 			break;
+		}
 		pt->pt_ev.sigev_value.sival_int = timerid;
+	}
 	pt->pt_info.ksi_signo = pt->pt_ev.sigev_signo;
 	pt->pt_info.ksi_errno = 0;
 	pt->pt_info.ksi_code = 0;
 	pt->pt_info.ksi_pid = p->p_pid;
 	pt->pt_info.ksi_uid = kauth_cred_getuid(l->l_cred);
 	pt->pt_info.ksi_value = pt->pt_ev.sigev_value;
 	pt->pt_type = id;
 	pt->pt_proc = p;
 	pt->pt_overruns = 0;
 	pt->pt_poverruns = 0;
 	pt->pt_entry = timerid;
 	pt->pt_queued = false;
 	timespecclear(&pt->pt_time.it_value);
 	if (!CLOCK_VIRTUAL_P(id))
 		callout_init(&pt->pt_ch, CALLOUT_MPSAFE);
 	else
 		pt->pt_active = 0;
 	pts->pts_timers[timerid] = pt;
 	mutex_spin_exit(&timer_lock);
 	return copyout(&timerid, tid, sizeof(timerid));
+}
 /* Delete a POSIX realtime timer */
 int
 sys_timer_delete(struct lwp *l, const struct sys_timer_delete_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(timer_t) timerid;
 	} */
 	struct proc *p = l->l_proc;
 	timer_t timerid;
 	struct ptimers *pts;
 	struct ptimer *pt, *ptn;
 	timerid = SCARG(uap, timerid);
 	pts = p->p_timers;
 	if (pts == NULL || timerid < 2 || timerid >= TIMER_MAX)
 		return (EINVAL);
 	mutex_spin_enter(&timer_lock);
 	if ((pt = pts->pts_timers[timerid]) == NULL) {
 		mutex_spin_exit(&timer_lock);
 		return (EINVAL);
+	}
 	if (CLOCK_VIRTUAL_P(pt->pt_type)) {
 		if (pt->pt_active) {
 			ptn = LIST_NEXT(pt, pt_list);
 			LIST_REMOVE(pt, pt_list);
 			for ( ; ptn; ptn = LIST_NEXT(ptn, pt_list))
 				timespecadd(&pt->pt_time.it_value,
 				    &ptn->pt_time.it_value,
 				    &ptn->pt_time.it_value);
 			pt->pt_active = 0;
+		}
+	}
 	itimerfree(pts, timerid);
 	return (0);
+}
 /*
  * Set up the given timer. The value in pt->pt_time.it_value is taken
  * to be an absolute time for CLOCK_REALTIME/CLOCK_MONOTONIC timers and
  * a relative time for CLOCK_VIRTUAL/CLOCK_PROF timers.
  */
 void
 timer_settime(struct ptimer *pt)
+{
 	struct ptimer *ptn, *pptn;
 	struct ptlist *ptl;
 	KASSERT(mutex_owned(&timer_lock));
 	if (!CLOCK_VIRTUAL_P(pt->pt_type)) {
 		callout_halt(&pt->pt_ch, &timer_lock);
 		if (timespecisset(&pt->pt_time.it_value)) {
 			/*
 			 * Don't need to check tshzto() return value, here.
 			 * callout_reset() does it for us.
 			 */
 			callout_reset(&pt->pt_ch, tshzto(&pt->pt_time.it_value),
 			    realtimerexpire, pt);
+		}
 	} else {
 		if (pt->pt_active) {
 			ptn = LIST_NEXT(pt, pt_list);
 			LIST_REMOVE(pt, pt_list);
 			for ( ; ptn; ptn = LIST_NEXT(ptn, pt_list))
 				timespecadd(&pt->pt_time.it_value,
 				    &ptn->pt_time.it_value,
 				    &ptn->pt_time.it_value);
+		}
 		if (timespecisset(&pt->pt_time.it_value)) {
 			if (pt->pt_type == CLOCK_VIRTUAL)
 				ptl = &pt->pt_proc->p_timers->pts_virtual;
 			else
 				ptl = &pt->pt_proc->p_timers->pts_prof;
 			for (ptn = LIST_FIRST(ptl), pptn = NULL;
 			     ptn && timespeccmp(&pt->pt_time.it_value,
 				 &ptn->pt_time.it_value, >);
 			     pptn = ptn, ptn = LIST_NEXT(ptn, pt_list))
 				timespecsub(&pt->pt_time.it_value,
 				    &ptn->pt_time.it_value,
 				    &pt->pt_time.it_value);
 			if (pptn)
 				LIST_INSERT_AFTER(pptn, pt, pt_list);
 			else
 				LIST_INSERT_HEAD(ptl, pt, pt_list);
 			for ( ; ptn ; ptn = LIST_NEXT(ptn, pt_list))
 				timespecsub(&ptn->pt_time.it_value,
 				    &pt->pt_time.it_value,
 				    &ptn->pt_time.it_value);
 			pt->pt_active = 1;
 		} else
 			pt->pt_active = 0;
+	}
+}
 void
 timer_gettime(struct ptimer *pt, struct itimerspec *aits)
+{
 	struct timespec now;
 	struct ptimer *ptn;
 	KASSERT(mutex_owned(&timer_lock));
 	*aits = pt->pt_time;
 	if (!CLOCK_VIRTUAL_P(pt->pt_type)) {
 		/*
 		 * Convert from absolute to relative time in .it_value
 		 * part of real time timer.  If time for real time
 		 * timer has passed return 0, else return difference
 		 * between current time and time for the timer to go
 		 * off.
 		 */
 		if (timespecisset(&aits->it_value)) {
 			if (pt->pt_type == CLOCK_REALTIME) {
 				getnanotime(&now);
 			} else { /* CLOCK_MONOTONIC */
 				getnanouptime(&now);
+			}
 			if (timespeccmp(&aits->it_value, &now, <))
 				timespecclear(&aits->it_value);
 			else
 				timespecsub(&aits->it_value, &now,
 				    &aits->it_value);
+		}
 	} else if (pt->pt_active) {
 		if (pt->pt_type == CLOCK_VIRTUAL)
 			ptn = LIST_FIRST(&pt->pt_proc->p_timers->pts_virtual);
 		else
 			ptn = LIST_FIRST(&pt->pt_proc->p_timers->pts_prof);
 		for ( ; ptn && ptn != pt; ptn = LIST_NEXT(ptn, pt_list))
 			timespecadd(&aits->it_value,
 			    &ptn->pt_time.it_value, &aits->it_value);
 		KASSERT(ptn != NULL); /* pt should be findable on the list */
 	} else
 		timespecclear(&aits->it_value);
+}
 /* Set and arm a POSIX realtime timer */
 int
 sys___timer_settime50(struct lwp *l,
     const struct sys___timer_settime50_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(timer_t) timerid;
 		syscallarg(int) flags;
 		syscallarg(const struct itimerspec *) value;
 		syscallarg(struct itimerspec *) ovalue;
 	} */
 	int error;
 	struct itimerspec value, ovalue, *ovp = NULL;
 	if ((error = copyin(SCARG(uap, value), &value,
 	    sizeof(struct itimerspec))) != 0)
 		return (error);
 	if (SCARG(uap, ovalue))
 		ovp = &ovalue;
 	if ((error = dotimer_settime(SCARG(uap, timerid), &value, ovp,
 	    SCARG(uap, flags), l->l_proc)) != 0)
 		return error;
 	if (ovp)
 		return copyout(&ovalue, SCARG(uap, ovalue),
 		    sizeof(struct itimerspec));
 	return 0;
+}
 int
 dotimer_settime(int timerid, struct itimerspec *value,
     struct itimerspec *ovalue, int flags, struct proc *p)
+{
 	struct timespec now;
 	struct itimerspec val, oval;
 	struct ptimers *pts;
 	struct ptimer *pt;
 	int error;
 	pts = p->p_timers;
 	if (pts == NULL || timerid < 2 || timerid >= TIMER_MAX)
 		return EINVAL;
 	val = *value;
 	if ((error = itimespecfix(&val.it_value)) != 0 ||
 	    (error = itimespecfix(&val.it_interval)) != 0)
 		return error;
 	mutex_spin_enter(&timer_lock);
 	if ((pt = pts->pts_timers[timerid]) == NULL) {
 		mutex_spin_exit(&timer_lock);
 		return EINVAL;
+	}
 	oval = pt->pt_time;
 	pt->pt_time = val;
 	/*
 	 * If we've been passed a relative time for a realtime timer,
 	 * convert it to absolute; if an absolute time for a virtual
 	 * timer, convert it to relative and make sure we don't set it
 	 * to zero, which would cancel the timer, or let it go
 	 * negative, which would confuse the comparison tests.
 	 */
 	if (timespecisset(&pt->pt_time.it_value)) {
 		if (!CLOCK_VIRTUAL_P(pt->pt_type)) {
 			if ((flags & TIMER_ABSTIME) == 0) {
 				if (pt->pt_type == CLOCK_REALTIME) {
 					getnanotime(&now);
 				} else { /* CLOCK_MONOTONIC */
 					getnanouptime(&now);
+				}
 				timespecadd(&pt->pt_time.it_value, &now,
 				    &pt->pt_time.it_value);
+			}
 		} else {
 			if ((flags & TIMER_ABSTIME) != 0) {
 				getnanotime(&now);
 				timespecsub(&pt->pt_time.it_value, &now,
 				    &pt->pt_time.it_value);
 				if (!timespecisset(&pt->pt_time.it_value) ||
 				    pt->pt_time.it_value.tv_sec < 0) {
 					pt->pt_time.it_value.tv_sec = 0;
 					pt->pt_time.it_value.tv_nsec = 1;
+				}
+			}
+		}
+	}
 	timer_settime(pt);
 	mutex_spin_exit(&timer_lock);
 	if (ovalue)
 		*ovalue = oval;
 	return (0);
+}
 /* Return the time remaining until a POSIX timer fires. */
 int
 sys___timer_gettime50(struct lwp *l,
     const struct sys___timer_gettime50_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(timer_t) timerid;
 		syscallarg(struct itimerspec *) value;
 	} */
 	struct itimerspec its;
 	int error;
 	if ((error = dotimer_gettime(SCARG(uap, timerid), l->l_proc,
 	    &its)) != 0)
 		return error;
 	return copyout(&its, SCARG(uap, value), sizeof(its));
+}
 int
 dotimer_gettime(int timerid, struct proc *p, struct itimerspec *its)
+{
 	struct ptimer *pt;
 	struct ptimers *pts;
 	pts = p->p_timers;
 	if (pts == NULL || timerid < 2 || timerid >= TIMER_MAX)
 		return (EINVAL);
 	mutex_spin_enter(&timer_lock);
 	if ((pt = pts->pts_timers[timerid]) == NULL) {
 		mutex_spin_exit(&timer_lock);
 		return (EINVAL);
+	}
 	timer_gettime(pt, its);
 	mutex_spin_exit(&timer_lock);
 	return 0;
+}
 /*
  * Return the count of the number of times a periodic timer expired
  * while a notification was already pending. The counter is reset when
  * a timer expires and a notification can be posted.
  */
 int
 sys_timer_getoverrun(struct lwp *l, const struct sys_timer_getoverrun_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(timer_t) timerid;
 	} */
 	struct proc *p = l->l_proc;
 	struct ptimers *pts;
 	int timerid;
 	struct ptimer *pt;
 	timerid = SCARG(uap, timerid);
 	pts = p->p_timers;
 	if (pts == NULL || timerid < 2 || timerid >= TIMER_MAX)
 		return (EINVAL);
 	mutex_spin_enter(&timer_lock);
 	if ((pt = pts->pts_timers[timerid]) == NULL) {
 		mutex_spin_exit(&timer_lock);
 		return (EINVAL);
+	}
 	*retval = pt->pt_poverruns;
 	mutex_spin_exit(&timer_lock);
 	return (0);
+}
 #ifdef KERN_SA
 /* Glue function that triggers an upcall; called from userret(). */
 void
 timerupcall(struct lwp *l)
+{
 	struct ptimers *pt = l->l_proc->p_timers;
 	struct proc *p = l->l_proc;
 	unsigned int i, fired, done;
 	KDASSERT(l->l_proc->p_sa);
 	/* Bail out if we do not own the virtual processor */
 	if (l->l_savp->savp_lwp != l)
 		return ;
 	mutex_enter(p->p_lock);
 	fired = pt->pts_fired;
 	done = 0;
 	while ((i = ffs(fired)) != 0) {
 		siginfo_t *si;
 		int mask = 1 << --i;
 		int f;
 		f = ~l->l_pflag & LP_SA_NOBLOCK;
 		l->l_pflag |= LP_SA_NOBLOCK;
 		si = siginfo_alloc(PR_WAITOK);
 		si->_info = pt->pts_timers[i]->pt_info.ksi_info;
 		if (sa_upcall(l, SA_UPCALL_SIGEV | SA_UPCALL_DEFER, NULL, l,
 		    sizeof(*si), si, siginfo_free) != 0) {
 			siginfo_free(si);
 			/* XXX What do we do here?? */
 		} else
 			done |= mask;
 		fired &= ~mask;
 		l->l_pflag ^= f;
+	}
 	pt->pts_fired &= ~done;
 	if (pt->pts_fired == 0)
 		l->l_proc->p_timerpend = 0;
 	mutex_exit(p->p_lock);
+}
 #endif /* KERN_SA */
 /*
  * Real interval timer expired:
  * send process whose timer expired an alarm signal.
  * If time is not set up to reload, then just return.
  * Else compute next time timer should go off which is > current time.
  * This is where delay in processing this timeout causes multiple
  * SIGALRM calls to be compressed into one.
  */
 void
 realtimerexpire(void *arg)
+{
 	uint64_t last_val, next_val, interval, now_ns;
 	struct timespec now, next;
 	struct ptimer *pt;
 	int backwards;
 	pt = arg;
 	mutex_spin_enter(&timer_lock);
 	itimerfire(pt);
 	if (!timespecisset(&pt->pt_time.it_interval)) {
 		timespecclear(&pt->pt_time.it_value);
 		mutex_spin_exit(&timer_lock);
 		return;
+	}
 	getnanotime(&now);
 	backwards = (timespeccmp(&pt->pt_time.it_value, &now, >));
 	timespecadd(&pt->pt_time.it_value, &pt->pt_time.it_interval, &next);
 	/* Handle the easy case of non-overflown timers first. */
 	if (!backwards && timespeccmp(&next, &now, >)) {
 		pt->pt_time.it_value = next;
 	} else {
 		now_ns = timespec2ns(&now);
 		last_val = timespec2ns(&pt->pt_time.it_value);
 		interval = timespec2ns(&pt->pt_time.it_interval);
 		next_val = now_ns +
 		    (now_ns - last_val + interval - 1) % interval;
 		if (backwards)
 			next_val += interval;
 		else
 			pt->pt_overruns += (now_ns - last_val) / interval;
 		pt->pt_time.it_value.tv_sec = next_val / 1000000000;
 		pt->pt_time.it_value.tv_nsec = next_val % 1000000000;
+	}
 	/*
 	 * Don't need to check tshzto() return value, here.
 	 * callout_reset() does it for us.
 	 */
 	callout_reset(&pt->pt_ch, tshzto(&pt->pt_time.it_value),
 	    realtimerexpire, pt);
 	mutex_spin_exit(&timer_lock);
+}
 /* BSD routine to get the value of an interval timer. */
 /* ARGSUSED */
 int
 sys___getitimer50(struct lwp *l, const struct sys___getitimer50_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(int) which;
 		syscallarg(struct itimerval *) itv;
 	} */
 	struct proc *p = l->l_proc;
 	struct itimerval aitv;
 	int error;
 	error = dogetitimer(p, SCARG(uap, which), &aitv);
 	if (error)
 		return error;
 	return (copyout(&aitv, SCARG(uap, itv), sizeof(struct itimerval)));
+}
 int
 dogetitimer(struct proc *p, int which, struct itimerval *itvp)
+{
 	struct ptimers *pts;
 	struct ptimer *pt;
 	struct itimerspec its;
 	if ((u_int)which > ITIMER_PROF)
 		return (EINVAL);
 	mutex_spin_enter(&timer_lock);
 	pts = p->p_timers;
 	if (pts == NULL || (pt = pts->pts_timers[which]) == NULL) {
 		timerclear(&itvp->it_value);
 		timerclear(&itvp->it_interval);
 	} else {
 		timer_gettime(pt, &its);
 		TIMESPEC_TO_TIMEVAL(&itvp->it_value, &its.it_value);
 		TIMESPEC_TO_TIMEVAL(&itvp->it_interval, &its.it_interval);
+	}
 	mutex_spin_exit(&timer_lock);
 	return 0;

 @@ -1,541 +1,539 @@
-/*	$NetBSD: sched_4bsd.c,v 1.26 2011/04/14 16:19:35 yamt Exp $	*/
+/*	$NetBSD: sched_4bsd.c,v 1.27 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2004, 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, by Charles M. Hannum, Andrew Doran, and
  * Daniel Sieger.
+ *
  * 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) 1982, 1986, 1990, 1991, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * 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.
+ *
  *	@(#)kern_synch.c	8.9 (Berkeley) 5/19/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sched_4bsd.c,v 1.26 2011/04/14 16:19:35 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sched_4bsd.c,v 1.27 2011/07/27 14:35:34 uebayasi Exp $");
 #include "opt_ddb.h"
 #include "opt_lockdebug.h"
 #include "opt_perfctrs.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/cpu.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/signalvar.h>
 #include <sys/resourcevar.h>
 #include <sys/sched.h>
 #include <sys/sysctl.h>
 #include <sys/kauth.h>
 #include <sys/lockdebug.h>
 #include <sys/kmem.h>
 #include <sys/intr.h>
 #include <uvm/uvm_extern.h>
 static void updatepri(struct lwp *);
 static void resetpriority(struct lwp *);
 extern unsigned int sched_pstats_ticks; /* defined in kern_synch.c */
 /* Number of hardclock ticks per sched_tick() */
 static int rrticks;
 /*
  * Force switch among equal priority processes every 100ms.
  * Called from hardclock every hz/10 == rrticks hardclock ticks.
+ *
  * There's no need to lock anywhere in this routine, as it's
  * CPU-local and runs at IPL_SCHED (called from clock interrupt).
  */
 /* ARGSUSED */
 void
 sched_tick(struct cpu_info *ci)
+{
 	struct schedstate_percpu *spc = &ci->ci_schedstate;
 	lwp_t *l;
 	spc->spc_ticks = rrticks;
 	if (CURCPU_IDLE_P()) {
 		cpu_need_resched(ci, 0);
 		return;
+	}
 	l = ci->ci_data.cpu_onproc;
 	if (l == NULL) {
 		return;
+	}
 	switch (l->l_class) {
 	case SCHED_FIFO:
 		/* No timeslicing for FIFO jobs. */
 		break;
 	case SCHED_RR:
 		/* Force it into mi_switch() to look for other jobs to run. */
 		cpu_need_resched(ci, RESCHED_KPREEMPT);
 		break;
 	default:
 		if (spc->spc_flags & SPCF_SHOULDYIELD) {
 			/*
 			 * Process is stuck in kernel somewhere, probably
 			 * due to buggy or inefficient code.  Force a
 			 * kernel preemption.
 			 */
 			cpu_need_resched(ci, RESCHED_KPREEMPT);
 		} else if (spc->spc_flags & SPCF_SEENRR) {
 			/*
 			 * The process has already been through a roundrobin
 			 * without switching and may be hogging the CPU.
 			 * Indicate that the process should yield.
 			 */
 			spc->spc_flags |= SPCF_SHOULDYIELD;
 			cpu_need_resched(ci, 0);
 		} else {
 			spc->spc_flags |= SPCF_SEENRR;
+		}
 		break;
+	}
+}
 /*
  * Why PRIO_MAX - 2? From setpriority(2):
+ *
  *	prio is a value in the range -20 to 20.  The default priority is
  *	0; lower priorities cause more favorable scheduling.  A value of
  *	19 or 20 will schedule a process only when nothing at priority <=
  *	0 is runnable.
+ *
  * This gives estcpu influence over 18 priority levels, and leaves nice
  * with 40 levels.  One way to think about it is that nice has 20 levels
  * either side of estcpu's 18.
  */
 #define	ESTCPU_SHIFT	11
 #define	ESTCPU_MAX	((PRIO_MAX - 2) << ESTCPU_SHIFT)
 #define	ESTCPU_ACCUM	(1 << (ESTCPU_SHIFT - 1))
 #define	ESTCPULIM(e)	min((e), ESTCPU_MAX)
 /*
  * Constants for digital decay and forget:
  *	90% of (l_estcpu) usage in 5 * loadav time
  *	95% of (l_pctcpu) usage in 60 seconds (load insensitive)
  *          Note that, as ps(1) mentions, this can let percentages
  *          total over 100% (I've seen 137.9% for 3 processes).
+ *
  * Note that hardclock updates l_estcpu and l_cpticks independently.
+ *
  * We wish to decay away 90% of l_estcpu in (5 * loadavg) seconds.
  * That is, the system wants to compute a value of decay such
  * that the following for loop:
  * 	for (i = 0; i < (5 * loadavg); i++)
  * 		l_estcpu *= decay;
  * will compute
  * 	l_estcpu *= 0.1;
  * for all values of loadavg:
+ *
  * Mathematically this loop can be expressed by saying:
  * 	decay ** (5 * loadavg) ~= .1
+ *
  * The system computes decay as:
  * 	decay = (2 * loadavg) / (2 * loadavg + 1)
+ *
  * We wish to prove that the system's computation of decay
  * will always fulfill the equation:
  * 	decay ** (5 * loadavg) ~= .1
+ *
  * If we compute b as:
  * 	b = 2 * loadavg
  * then
  * 	decay = b / (b + 1)
+ *
  * We now need to prove two things:
  *	1) Given factor ** (5 * loadavg) ~= .1, prove factor == b/(b+1)
  *	2) Given b/(b+1) ** power ~= .1, prove power == (5 * loadavg)
+ *
  * Facts:
  *         For x close to zero, exp(x) =~ 1 + x, since
  *              exp(x) = 0! + x**1/1! + x**2/2! + ... .
  *              therefore exp(-1/b) =~ 1 - (1/b) = (b-1)/b.
  *         For x close to zero, ln(1+x) =~ x, since
  *              ln(1+x) = x - x**2/2 + x**3/3 - ...     -1 < x < 1
  *              therefore ln(b/(b+1)) = ln(1 - 1/(b+1)) =~ -1/(b+1).
  *         ln(.1) =~ -2.30
+ *
  * Proof of (1):
  *    Solve (factor)**(power) =~ .1 given power (5*loadav):
  *	solving for factor,
  *      ln(factor) =~ (-2.30/5*loadav), or
  *      factor =~ exp(-1/((5/2.30)*loadav)) =~ exp(-1/(2*loadav)) =
  *          exp(-1/b) =~ (b-1)/b =~ b/(b+1).                    QED
+ *
  * Proof of (2):
  *    Solve (factor)**(power) =~ .1 given factor == (b/(b+1)):
  *	solving for power,
  *      power*ln(b/(b+1)) =~ -2.30, or
  *      power =~ 2.3 * (b + 1) = 4.6*loadav + 2.3 =~ 5*loadav.  QED
+ *
  * Actual power values for the implemented algorithm are as follows:
  *      loadav: 1       2       3       4
  *      power:  5.68    10.32   14.94   19.55
  */
 /* calculations for digital decay to forget 90% of usage in 5*loadav sec */
 #define	loadfactor(loadav)	(2 * (loadav) / ncpu)
 static fixpt_t
 decay_cpu(fixpt_t loadfac, fixpt_t estcpu)
+{
 	if (estcpu == 0) {
 		return 0;
+	}
 #if !defined(_LP64)
 	/* avoid 64bit arithmetics. */
 #define	FIXPT_MAX ((fixpt_t)((UINTMAX_C(1) << sizeof(fixpt_t) * CHAR_BIT) - 1))
 	if (__predict_true(loadfac <= FIXPT_MAX / ESTCPU_MAX)) {
 		return estcpu * loadfac / (loadfac + FSCALE);
+	}
 #endif /* !defined(_LP64) */
 	return (uint64_t)estcpu * loadfac / (loadfac + FSCALE);
+}
 /*
  * For all load averages >= 1 and max l_estcpu of (255 << ESTCPU_SHIFT),
  * sleeping for at least seven times the loadfactor will decay l_estcpu to
  * less than (1 << ESTCPU_SHIFT).
+ *
  * note that our ESTCPU_MAX is actually much smaller than (255 << ESTCPU_SHIFT).
  */
 static fixpt_t
 decay_cpu_batch(fixpt_t loadfac, fixpt_t estcpu, unsigned int n)
+{
 	if ((n << FSHIFT) >= 7 * loadfac) {
 		return 0;
+	}
 	while (estcpu != 0 && n > 1) {
 		estcpu = decay_cpu(loadfac, estcpu);
 		n--;
+	}
 	return estcpu;
+}
 /*
  * sched_pstats_hook:
+ *
  * Periodically called from sched_pstats(); used to recalculate priorities.
  */
 void
 sched_pstats_hook(struct lwp *l, int batch)
+{
 	fixpt_t loadfac;
 	/*
 	 * If the LWP has slept an entire second, stop recalculating
 	 * its priority until it wakes up.
 	 */
 	KASSERT(lwp_locked(l, NULL));
 	if (l->l_stat == LSSLEEP || l->l_stat == LSSTOP ||
 	    l->l_stat == LSSUSPENDED) {
 		if (l->l_slptime > 1) {
 			return;
+		}
+	}
 	loadfac = 2 * (averunnable.ldavg[0]);
 	l->l_estcpu = decay_cpu(loadfac, l->l_estcpu);
 	resetpriority(l);
+}
 /*
  * Recalculate the priority of a process after it has slept for a while.
  */
 static void
 updatepri(struct lwp *l)
+{
 	fixpt_t loadfac;
 	KASSERT(lwp_locked(l, NULL));
 	KASSERT(l->l_slptime > 1);
 	loadfac = loadfactor(averunnable.ldavg[0]);
 	l->l_slptime--; /* the first time was done in sched_pstats */
 	l->l_estcpu = decay_cpu_batch(loadfac, l->l_estcpu, l->l_slptime);
 	resetpriority(l);
+}
 void
 sched_rqinit(void)
+{
+}
 void
 sched_setrunnable(struct lwp *l)
+{
  	if (l->l_slptime > 1)
  		updatepri(l);
+}
 void
 sched_nice(struct proc *p, int n)
+{
 	struct lwp *l;
 	KASSERT(mutex_owned(p->p_lock));
 	p->p_nice = n;
 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 		lwp_lock(l);
 		resetpriority(l);
 		lwp_unlock(l);
+	}
+}
 /*
  * Recompute the priority of an LWP.  Arrange to reschedule if
  * the resulting priority is better than that of the current LWP.
  */
 static void
 resetpriority(struct lwp *l)
+{
 	pri_t pri;
 	struct proc *p = l->l_proc;
 	KASSERT(lwp_locked(l, NULL));
 	if (l->l_class != SCHED_OTHER)
 		return;
 	/* See comments above ESTCPU_SHIFT definition. */
 	pri = (PRI_KERNEL - 1) - (l->l_estcpu >> ESTCPU_SHIFT) - p->p_nice;
 	pri = imax(pri, 0);
 	if (pri != l->l_priority)
 		lwp_changepri(l, pri);
+}
 /*
  * We adjust the priority of the current process.  The priority of a process
  * gets worse as it accumulates CPU time.  The CPU usage estimator (l_estcpu)
  * is increased here.  The formula for computing priorities (in kern_synch.c)
  * will compute a different value each time l_estcpu increases. This can
  * cause a switch, but unless the priority crosses a PPQ boundary the actual
  * queue will not change.  The CPU usage estimator ramps up quite quickly
  * when the process is running (linearly), and decays away exponentially, at
  * a rate which is proportionally slower when the system is busy.  The basic
  * principle is that the system will 90% forget that the process used a lot
  * of CPU time in 5 * loadav seconds.  This causes the system to favor
  * processes which haven't run much recently, and to round-robin among other
  * processes.
  */
 void
 sched_schedclock(struct lwp *l)
+{
 	if (l->l_class != SCHED_OTHER)
 		return;
 	KASSERT(!CURCPU_IDLE_P());
 	l->l_estcpu = ESTCPULIM(l->l_estcpu + ESTCPU_ACCUM);
 	lwp_lock(l);
 	resetpriority(l);
 	lwp_unlock(l);
+}
 /*
  * sched_proc_fork:
+ *
  *	Inherit the parent's scheduler history.
  */
 void
 sched_proc_fork(struct proc *parent, struct proc *child)
+{
 	lwp_t *pl;
 	KASSERT(mutex_owned(parent->p_lock));
 	pl = LIST_FIRST(&parent->p_lwps);
 	child->p_estcpu_inherited = pl->l_estcpu;
 	child->p_forktime = sched_pstats_ticks;
+}
 /*
  * sched_proc_exit:
+ *
  *	Chargeback parents for the sins of their children.
  */
 void
 sched_proc_exit(struct proc *parent, struct proc *child)
+{
 	fixpt_t loadfac = loadfactor(averunnable.ldavg[0]);
 	fixpt_t estcpu;
 	lwp_t *pl, *cl;
 	/* XXX Only if parent != init?? */
 	mutex_enter(parent->p_lock);
 	pl = LIST_FIRST(&parent->p_lwps);
 	cl = LIST_FIRST(&child->p_lwps);
 	estcpu = decay_cpu_batch(loadfac, child->p_estcpu_inherited,
 	    sched_pstats_ticks - child->p_forktime);
 	if (cl->l_estcpu > estcpu) {
 		lwp_lock(pl);
 		pl->l_estcpu = ESTCPULIM(pl->l_estcpu + cl->l_estcpu - estcpu);
 		lwp_unlock(pl);
+	}
 	mutex_exit(parent->p_lock);
+}
 void
 sched_wakeup(struct lwp *l)
+{
+}
 void
 sched_slept(struct lwp *l)
+{
+}
 void
 sched_lwp_fork(struct lwp *l1, struct lwp *l2)
+{
 	l2->l_estcpu = l1->l_estcpu;
+}
 void
 sched_lwp_collect(struct lwp *t)
+{
 	lwp_t *l;
 	/* Absorb estcpu value of collected LWP. */
 	l = curlwp;
 	lwp_lock(l);
 	l->l_estcpu += t->l_estcpu;
 	lwp_unlock(l);
+}
 void
 sched_oncpu(lwp_t *l)
+{
+}
 void
 sched_newts(lwp_t *l)
+{
+}
 /*
  * Sysctl nodes and initialization.
  */
 static int
 sysctl_sched_rtts(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node;
 	int rttsms = hztoms(rrticks);
 	node = *rnode;
 	node.sysctl_data = &rttsms;
 	return sysctl_lookup(SYSCTLFN_CALL(&node));
+}
 SYSCTL_SETUP(sysctl_sched_4bsd_setup, "sysctl sched setup")
+{
 	const struct sysctlnode *node = NULL;
 	sysctl_createv(clog, 0, NULL, NULL,
 		CTLFLAG_PERMANENT,
 		CTLTYPE_NODE, "kern", NULL,
 		NULL, 0, NULL, 0,
 		CTL_KERN, CTL_EOL);
 	sysctl_createv(clog, 0, NULL, &node,
 		CTLFLAG_PERMANENT,
 		CTLTYPE_NODE, "sched",
 		SYSCTL_DESCR("Scheduler options"),
 		NULL, 0, NULL, 0,
 		CTL_KERN, CTL_CREATE, CTL_EOL);
 	if (node == NULL)
 		return;
 	rrticks = hz / 10;
 	sysctl_createv(NULL, 0, &node, NULL,
 		CTLFLAG_PERMANENT,
 		CTLTYPE_STRING, "name", NULL,
 		NULL, 0, __UNCONST("4.4BSD"), 0,
 		CTL_CREATE, CTL_EOL);
 	sysctl_createv(NULL, 0, &node, NULL,
 		CTLFLAG_PERMANENT,
 		CTLTYPE_INT, "rtts",
 		SYSCTL_DESCR("Round-robin time quantum (in miliseconds)"),
 		sysctl_sched_rtts, 0, NULL, 0,
 		CTL_CREATE, CTL_EOL);
+}

 @@ -1,370 +1,368 @@
-/*	$NetBSD: subr_percpu.c,v 1.13 2011/05/13 22:16:44 rmind Exp $	*/
+/*	$NetBSD: subr_percpu.c,v 1.14 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c)2007,2008 YAMAMOTO Takashi,
  * 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 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.
  */
 /*
  * per-cpu storage.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_percpu.c,v 1.13 2011/05/13 22:16:44 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_percpu.c,v 1.14 2011/07/27 14:35:34 uebayasi Exp $");
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/kmem.h>
 #include <sys/kernel.h>
 #include <sys/mutex.h>
 #include <sys/percpu.h>
 #include <sys/rwlock.h>
 #include <sys/vmem.h>
 #include <sys/xcall.h>
 #include <uvm/uvm_extern.h>
 #define	PERCPU_QUANTUM_SIZE	(ALIGNBYTES + 1)
 #define	PERCPU_QCACHE_MAX	0
 #define	PERCPU_IMPORT_SIZE	2048
 #if defined(DIAGNOSTIC)
 #define	MAGIC	0x50435055	/* "PCPU" */
 #define	percpu_encrypt(pc)	((pc) ^ MAGIC)
 #define	percpu_decrypt(pc)	((pc) ^ MAGIC)
 #else /* defined(DIAGNOSTIC) */
 #define	percpu_encrypt(pc)	(pc)
 #define	percpu_decrypt(pc)	(pc)
 #endif /* defined(DIAGNOSTIC) */
 static krwlock_t	percpu_swap_lock	__cacheline_aligned;
 static kmutex_t		percpu_allocation_lock	__cacheline_aligned;
 static vmem_t *		percpu_offset_arena	__cacheline_aligned;
 static unsigned int	percpu_nextoff		__cacheline_aligned;
 static percpu_cpu_t *
 cpu_percpu(struct cpu_info *ci)
+{
 	return &ci->ci_data.cpu_percpu;
+}
 static unsigned int
 percpu_offset(percpu_t *pc)
+{
 	const unsigned int off = percpu_decrypt((uintptr_t)pc);
 	KASSERT(off < percpu_nextoff);
 	return off;
+}
 /*
  * percpu_cpu_swap: crosscall handler for percpu_cpu_enlarge
  */
 static void
 percpu_cpu_swap(void *p1, void *p2)
+{
 	struct cpu_info * const ci = p1;
 	percpu_cpu_t * const newpcc = p2;
 	percpu_cpu_t * const pcc = cpu_percpu(ci);
 	KASSERT(ci == curcpu() || !mp_online);
 	/*
 	 * swap *pcc and *newpcc unless anyone has beaten us.
 	 */
 	rw_enter(&percpu_swap_lock, RW_WRITER);
 	if (newpcc->pcc_size > pcc->pcc_size) {
 		percpu_cpu_t tmp;
 		int s;
 		tmp = *pcc;
 		/*
 		 * block interrupts so that we don't lose their modifications.
 		 */
 		s = splhigh();
 		/*
 		 * copy data to new storage.
 		 */
 		memcpy(newpcc->pcc_data, pcc->pcc_data, pcc->pcc_size);
 		/*
 		 * this assignment needs to be atomic for percpu_getptr_remote.
 		 */
 		pcc->pcc_data = newpcc->pcc_data;
 		splx(s);
 		pcc->pcc_size = newpcc->pcc_size;
 		*newpcc = tmp;
+	}
 	rw_exit(&percpu_swap_lock);
+}
 /*
  * percpu_cpu_enlarge: ensure that percpu_cpu_t of each cpus have enough space
  */
 static void
 percpu_cpu_enlarge(size_t size)
+{
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *ci;
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		percpu_cpu_t pcc;
 		pcc.pcc_data = kmem_alloc(size, KM_SLEEP); /* XXX cacheline */
 		pcc.pcc_size = size;
 		if (!mp_online) {
 			percpu_cpu_swap(ci, &pcc);
 		} else {
 			uint64_t where;
 			where = xc_unicast(0, percpu_cpu_swap, ci, &pcc, ci);
 			xc_wait(where);
+		}
 		KASSERT(pcc.pcc_size < size);
 		if (pcc.pcc_data != NULL) {
 			kmem_free(pcc.pcc_data, pcc.pcc_size);
+		}
+	}
+}
 /*
  * percpu_backend_alloc: vmem import callback for percpu_offset_arena
  */
 static vmem_addr_t
 percpu_backend_alloc(vmem_t *dummy, vmem_size_t size, vmem_size_t *resultsize,
     vm_flag_t vmflags)
+{
 	unsigned int offset;
 	unsigned int nextoff;
 	ASSERT_SLEEPABLE();
 	KASSERT(dummy == NULL);
 	if ((vmflags & VM_NOSLEEP) != 0)
 		return VMEM_ADDR_NULL;
 	size = roundup(size, PERCPU_IMPORT_SIZE);
 	mutex_enter(&percpu_allocation_lock);
 	offset = percpu_nextoff;
 	percpu_nextoff = nextoff = percpu_nextoff + size;
 	mutex_exit(&percpu_allocation_lock);
 	percpu_cpu_enlarge(nextoff);
 	*resultsize = size;
 	return (vmem_addr_t)offset;
+}
 static void
 percpu_zero_cb(void *vp, void *vp2, struct cpu_info *ci)
+{
 	size_t sz = (uintptr_t)vp2;
 	memset(vp, 0, sz);
+}
 /*
  * percpu_zero: initialize percpu storage with zero.
  */
 static void
 percpu_zero(percpu_t *pc, size_t sz)
+{
 	percpu_foreach(pc, percpu_zero_cb, (void *)(uintptr_t)sz);
+}
 /*
  * percpu_init: subsystem initialization
  */
 void
 percpu_init(void)
+{
 	ASSERT_SLEEPABLE();
 	rw_init(&percpu_swap_lock);
 	mutex_init(&percpu_allocation_lock, MUTEX_DEFAULT, IPL_NONE);
 	percpu_nextoff = PERCPU_QUANTUM_SIZE;
 	percpu_offset_arena = vmem_create("percpu", 0, 0, PERCPU_QUANTUM_SIZE,
 	    percpu_backend_alloc, NULL, NULL, PERCPU_QCACHE_MAX, VM_SLEEP,
 	    IPL_NONE);
+}
 /*
  * percpu_init_cpu: cpu initialization
+ *
  * => should be called before the cpu appears on the list for CPU_INFO_FOREACH.
  */
 void
 percpu_init_cpu(struct cpu_info *ci)
+{
 	percpu_cpu_t * const pcc = cpu_percpu(ci);
 	size_t size = percpu_nextoff; /* XXX racy */
 	ASSERT_SLEEPABLE();
 	pcc->pcc_size = size;
 	if (size) {
 		pcc->pcc_data = kmem_zalloc(pcc->pcc_size, KM_SLEEP);
+	}
+}
 /*
  * percpu_alloc: allocate percpu storage
+ *
  * => called in thread context.
  * => considered as an expensive and rare operation.
  * => allocated storage is initialized with zeros.
  */
 percpu_t *
 percpu_alloc(size_t size)
+{
 	unsigned int offset;
 	percpu_t *pc;
 	ASSERT_SLEEPABLE();
 	offset = vmem_alloc(percpu_offset_arena, size, VM_SLEEP | VM_BESTFIT);
 	pc = (percpu_t *)percpu_encrypt((uintptr_t)offset);
 	percpu_zero(pc, size);
 	return pc;
+}
 /*
  * percpu_free: free percpu storage
+ *
  * => called in thread context.
  * => considered as an expensive and rare operation.
  */
 void
 percpu_free(percpu_t *pc, size_t size)
+{
 	ASSERT_SLEEPABLE();
 	vmem_free(percpu_offset_arena, (vmem_addr_t)percpu_offset(pc), size);
+}
 /*
  * percpu_getref:
+ *
  * => safe to be used in either thread or interrupt context
  * => disables preemption; must be bracketed with a percpu_putref()
  */
 void *
 percpu_getref(percpu_t *pc)
+{
 	KPREEMPT_DISABLE(curlwp);
 	return percpu_getptr_remote(pc, curcpu());
+}
 /*
  * percpu_putref:
+ *
  * => drops the preemption-disabled count after caller is done with per-cpu
  *    data
  */
 void
 percpu_putref(percpu_t *pc)
+{
 	KPREEMPT_ENABLE(curlwp);
+}
 /*
  * percpu_traverse_enter, percpu_traverse_exit, percpu_getptr_remote:
  * helpers to access remote cpu's percpu data.
+ *
  * => called in thread context.
  * => percpu_traverse_enter can block low-priority xcalls.
  * => typical usage would be:
+ *
  *	sum = 0;
  *	percpu_traverse_enter();
  *	for (CPU_INFO_FOREACH(cii, ci)) {
  *		unsigned int *p = percpu_getptr_remote(pc, ci);
  *		sum += *p;
  *	}
  *	percpu_traverse_exit();
  */
 void
 percpu_traverse_enter(void)
+{
 	ASSERT_SLEEPABLE();
 	rw_enter(&percpu_swap_lock, RW_READER);
+}
 void
 percpu_traverse_exit(void)
+{
 	rw_exit(&percpu_swap_lock);
+}
 void *
 percpu_getptr_remote(percpu_t *pc, struct cpu_info *ci)
+{
 	return &((char *)cpu_percpu(ci)->pcc_data)[percpu_offset(pc)];
+}
 /*
  * percpu_foreach: call the specified callback function for each cpus.
+ *
  * => called in thread context.
  * => caller should not rely on the cpu iteration order.
  * => the callback function should be minimum because it is executed with
  *    holding a global lock, which can block low-priority xcalls.
  *    eg. it's illegal for a callback function to sleep for memory allocation.
  */
 void
 percpu_foreach(percpu_t *pc, percpu_callback_t cb, void *arg)
+{
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *ci;
 	percpu_traverse_enter();
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		(*cb)(percpu_getptr_remote(pc, ci), arg, ci);
+	}
 	percpu_traverse_exit();
+}

 @@ -1,303 +1,301 @@
-/*	$NetBSD: subr_workqueue.c,v 1.30 2009/11/11 14:54:40 rmind Exp $	*/
+/*	$NetBSD: subr_workqueue.c,v 1.31 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c)2002, 2005, 2006, 2007 YAMAMOTO Takashi,
  * 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 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: subr_workqueue.c,v 1.30 2009/11/11 14:54:40 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_workqueue.c,v 1.31 2011/07/27 14:35:34 uebayasi Exp $");
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/systm.h>
 #include <sys/kthread.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/workqueue.h>
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #include <sys/queue.h>
 #include <uvm/uvm_extern.h>
 typedef struct work_impl {
 	SIMPLEQ_ENTRY(work_impl) wk_entry;
 } work_impl_t;
 SIMPLEQ_HEAD(workqhead, work_impl);
 struct workqueue_queue {
 	kmutex_t q_mutex;
 	kcondvar_t q_cv;
 	struct workqhead q_queue;
 	lwp_t *q_worker;
 };
 struct workqueue {
 	void (*wq_func)(struct work *, void *);
 	void *wq_arg;
 	int wq_flags;
 	const char *wq_name;
 	pri_t wq_prio;
 	void *wq_ptr;
 };
 #define	WQ_SIZE		(roundup2(sizeof(struct workqueue), coherency_unit))
 #define	WQ_QUEUE_SIZE	(roundup2(sizeof(struct workqueue_queue), coherency_unit))
 #define	POISON	0xaabbccdd
 static size_t
 workqueue_size(int flags)
+{
 	return WQ_SIZE
 	    + ((flags & WQ_PERCPU) != 0 ? ncpu : 1) * WQ_QUEUE_SIZE
 	    + coherency_unit;
+}
 static struct workqueue_queue *
 workqueue_queue_lookup(struct workqueue *wq, struct cpu_info *ci)
+{
 	u_int idx = 0;
 	if (wq->wq_flags & WQ_PERCPU) {
 		idx = ci ? cpu_index(ci) : cpu_index(curcpu());
+	}
 	return (void *)((uintptr_t)(wq) + WQ_SIZE + (idx * WQ_QUEUE_SIZE));
+}
 static void
 workqueue_runlist(struct workqueue *wq, struct workqhead *list)
+{
 	work_impl_t *wk;
 	work_impl_t *next;
 	/*
 	 * note that "list" is not a complete SIMPLEQ.
 	 */
 	for (wk = SIMPLEQ_FIRST(list); wk != NULL; wk = next) {
 		next = SIMPLEQ_NEXT(wk, wk_entry);
 		(*wq->wq_func)((void *)wk, wq->wq_arg);
+	}
+}
 static void
 workqueue_worker(void *cookie)
+{
 	struct workqueue *wq = cookie;
 	struct workqueue_queue *q;
 	/* find the workqueue of this kthread */
 	q = workqueue_queue_lookup(wq, curlwp->l_cpu);
 	for (;;) {
 		struct workqhead tmp;
 		/*
 		 * we violate abstraction of SIMPLEQ.
 		 */
 #if defined(DIAGNOSTIC)
 		tmp.sqh_last = (void *)POISON;
 #endif /* defined(DIAGNOSTIC) */
 		mutex_enter(&q->q_mutex);
 		while (SIMPLEQ_EMPTY(&q->q_queue))
 			cv_wait(&q->q_cv, &q->q_mutex);
 		tmp.sqh_first = q->q_queue.sqh_first; /* XXX */
 		SIMPLEQ_INIT(&q->q_queue);
 		mutex_exit(&q->q_mutex);
 		workqueue_runlist(wq, &tmp);
+	}
+}
 static void
 workqueue_init(struct workqueue *wq, const char *name,
     void (*callback_func)(struct work *, void *), void *callback_arg,
     pri_t prio, int ipl)
+{
 	wq->wq_prio = prio;
 	wq->wq_name = name;
 	wq->wq_func = callback_func;
 	wq->wq_arg = callback_arg;
+}
 static int
 workqueue_initqueue(struct workqueue *wq, struct workqueue_queue *q,
     int ipl, struct cpu_info *ci)
+{
 	int error, ktf;
 	KASSERT(q->q_worker == NULL);
 	mutex_init(&q->q_mutex, MUTEX_DEFAULT, ipl);
 	cv_init(&q->q_cv, wq->wq_name);
 	SIMPLEQ_INIT(&q->q_queue);
 	ktf = ((wq->wq_flags & WQ_MPSAFE) != 0 ? KTHREAD_MPSAFE : 0);
 	if (ci) {
 		error = kthread_create(wq->wq_prio, ktf, ci, workqueue_worker,
 		    wq, &q->q_worker, "%s/%u", wq->wq_name, ci->ci_index);
 	} else {
 		error = kthread_create(wq->wq_prio, ktf, ci, workqueue_worker,
 		    wq, &q->q_worker, "%s", wq->wq_name);
+	}
 	if (error != 0) {
 		mutex_destroy(&q->q_mutex);
 		cv_destroy(&q->q_cv);
 		KASSERT(q->q_worker == NULL);
+	}
 	return error;
+}
 struct workqueue_exitargs {
 	work_impl_t wqe_wk;
 	struct workqueue_queue *wqe_q;
 };
 static void
 workqueue_exit(struct work *wk, void *arg)
+{
 	struct workqueue_exitargs *wqe = (void *)wk;
 	struct workqueue_queue *q = wqe->wqe_q;
 	/*
 	 * only competition at this point is workqueue_finiqueue.
 	 */
 	KASSERT(q->q_worker == curlwp);
 	KASSERT(SIMPLEQ_EMPTY(&q->q_queue));
 	mutex_enter(&q->q_mutex);
 	q->q_worker = NULL;
 	cv_signal(&q->q_cv);
 	mutex_exit(&q->q_mutex);
 	kthread_exit(0);
+}
 static void
 workqueue_finiqueue(struct workqueue *wq, struct workqueue_queue *q)
+{
 	struct workqueue_exitargs wqe;
 	KASSERT(wq->wq_func == workqueue_exit);
 	wqe.wqe_q = q;
 	KASSERT(SIMPLEQ_EMPTY(&q->q_queue));
 	KASSERT(q->q_worker != NULL);
 	mutex_enter(&q->q_mutex);
 	SIMPLEQ_INSERT_TAIL(&q->q_queue, &wqe.wqe_wk, wk_entry);
 	cv_signal(&q->q_cv);
 	while (q->q_worker != NULL) {
 		cv_wait(&q->q_cv, &q->q_mutex);
+	}
 	mutex_exit(&q->q_mutex);
 	mutex_destroy(&q->q_mutex);
 	cv_destroy(&q->q_cv);
+}
 /* --- */
 int
 workqueue_create(struct workqueue **wqp, const char *name,
     void (*callback_func)(struct work *, void *), void *callback_arg,
     pri_t prio, int ipl, int flags)
+{
 	struct workqueue *wq;
 	struct workqueue_queue *q;
 	void *ptr;
 	int error = 0;
 	CTASSERT(sizeof(work_impl_t) <= sizeof(struct work));
 	ptr = kmem_zalloc(workqueue_size(flags), KM_SLEEP);
 	wq = (void *)roundup2((uintptr_t)ptr, coherency_unit);
 	wq->wq_ptr = ptr;
 	wq->wq_flags = flags;
 	workqueue_init(wq, name, callback_func, callback_arg, prio, ipl);
 	if (flags & WQ_PERCPU) {
 		struct cpu_info *ci;
 		CPU_INFO_ITERATOR cii;
 		/* create the work-queue for each CPU */
 		for (CPU_INFO_FOREACH(cii, ci)) {
 			q = workqueue_queue_lookup(wq, ci);
 			error = workqueue_initqueue(wq, q, ipl, ci);
 			if (error) {
 				break;
+			}
+		}
 	} else {
 		/* initialize a work-queue */
 		q = workqueue_queue_lookup(wq, NULL);
 		error = workqueue_initqueue(wq, q, ipl, NULL);
+	}
 	if (error != 0) {
 		workqueue_destroy(wq);
 	} else {
 		*wqp = wq;
+	}
 	return error;
+}
 void
 workqueue_destroy(struct workqueue *wq)
+{
 	struct workqueue_queue *q;
 	struct cpu_info *ci;
 	CPU_INFO_ITERATOR cii;
 	wq->wq_func = workqueue_exit;
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		q = workqueue_queue_lookup(wq, ci);
 		if (q->q_worker != NULL) {
 			workqueue_finiqueue(wq, q);
+		}
+	}
 	kmem_free(wq->wq_ptr, workqueue_size(wq->wq_flags));
+}
 void
 workqueue_enqueue(struct workqueue *wq, struct work *wk0, struct cpu_info *ci)
+{
 	struct workqueue_queue *q;
 	work_impl_t *wk = (void *)wk0;
 	KASSERT(wq->wq_flags & WQ_PERCPU || ci == NULL);
 	q = workqueue_queue_lookup(wq, ci);
 	mutex_enter(&q->q_mutex);
 	SIMPLEQ_INSERT_TAIL(&q->q_queue, wk, wk_entry);
 	cv_signal(&q->q_cv);
 	mutex_exit(&q->q_mutex);
+}

 @@ -1,677 +1,675 @@
-/*	$NetBSD: sys_generic.c,v 1.126 2011/04/10 15:45:33 christos Exp $	*/
+/*	$NetBSD: sys_generic.c,v 1.127 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c) 2007, 2008, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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) 1982, 1986, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * 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.
+ *
  *	@(#)sys_generic.c	8.9 (Berkeley) 2/14/95
  */
 /*
  * System calls relating to files.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sys_generic.c,v 1.126 2011/04/10 15:45:33 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sys_generic.c,v 1.127 2011/07/27 14:35:34 uebayasi Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/filedesc.h>
 #include <sys/ioctl.h>
 #include <sys/file.h>
 #include <sys/proc.h>
 #include <sys/socketvar.h>
 #include <sys/signalvar.h>
 #include <sys/uio.h>
 #include <sys/kernel.h>
 #include <sys/stat.h>
 #include <sys/kmem.h>
 #include <sys/poll.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/syscallargs.h>
 #include <sys/ktrace.h>
 #include <sys/atomic.h>
 #include <sys/disklabel.h>
 #include <uvm/uvm_extern.h>
 /*
  * Read system call.
  */
 /* ARGSUSED */
 int
 sys_read(struct lwp *l, const struct sys_read_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)		fd;
 		syscallarg(void *)	buf;
 		syscallarg(size_t)	nbyte;
 	} */
 	file_t *fp;
 	int fd;
 	fd = SCARG(uap, fd);
 	if ((fp = fd_getfile(fd)) == NULL)
 		return (EBADF);
 	if ((fp->f_flag & FREAD) == 0) {
 		fd_putfile(fd);
 		return (EBADF);
+	}
 	/* dofileread() will unuse the descriptor for us */
 	return (dofileread(fd, fp, SCARG(uap, buf), SCARG(uap, nbyte),
 	    &fp->f_offset, FOF_UPDATE_OFFSET, retval));
+}
 int
 dofileread(int fd, struct file *fp, void *buf, size_t nbyte,
 	off_t *offset, int flags, register_t *retval)
+{
 	struct iovec aiov;
 	struct uio auio;
 	size_t cnt;
 	int error;
 	lwp_t *l;
 	l = curlwp;
 	aiov.iov_base = (void *)buf;
 	aiov.iov_len = nbyte;
 	auio.uio_iov = &aiov;
 	auio.uio_iovcnt = 1;
 	auio.uio_resid = nbyte;
 	auio.uio_rw = UIO_READ;
 	auio.uio_vmspace = l->l_proc->p_vmspace;
 	/*
 	 * Reads return ssize_t because -1 is returned on error.  Therefore
 	 * we must restrict the length to SSIZE_MAX to avoid garbage return
 	 * values.
 	 */
 	if (auio.uio_resid > SSIZE_MAX) {
 		error = EINVAL;
 		goto out;
+	}
 	cnt = auio.uio_resid;
 	error = (*fp->f_ops->fo_read)(fp, offset, &auio, fp->f_cred, flags);
 	if (error)
 		if (auio.uio_resid != cnt && (error == ERESTART ||
 		    error == EINTR || error == EWOULDBLOCK))
 			error = 0;
 	cnt -= auio.uio_resid;
 	ktrgenio(fd, UIO_READ, buf, cnt, error);
 	*retval = cnt;
  out:
 	fd_putfile(fd);
 	return (error);
+}
 /*
  * Scatter read system call.
  */
 int
 sys_readv(struct lwp *l, const struct sys_readv_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)				fd;
 		syscallarg(const struct iovec *)	iovp;
 		syscallarg(int)				iovcnt;
 	} */
 	return do_filereadv(SCARG(uap, fd), SCARG(uap, iovp),
 	    SCARG(uap, iovcnt), NULL, FOF_UPDATE_OFFSET, retval);
+}
 int
 do_filereadv(int fd, const struct iovec *iovp, int iovcnt,
     off_t *offset, int flags, register_t *retval)
+{
 	struct uio	auio;
 	struct iovec	*iov, *needfree = NULL, aiov[UIO_SMALLIOV];
 	int		i, error;
 	size_t		cnt;
 	u_int		iovlen;
 	struct file	*fp;
 	struct iovec	*ktriov = NULL;
 	if (iovcnt == 0)
 		return EINVAL;
 	if ((fp = fd_getfile(fd)) == NULL)
 		return EBADF;
 	if ((fp->f_flag & FREAD) == 0) {
 		fd_putfile(fd);
 		return EBADF;
+	}
 	if (offset == NULL)
 		offset = &fp->f_offset;
 	else {
 		struct vnode *vp = fp->f_data;
 		if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
 			error = ESPIPE;
 			goto out;
+		}
 		/*
 		 * Test that the device is seekable ?
 		 * XXX This works because no file systems actually
 		 * XXX take any action on the seek operation.
 		 */
 		error = VOP_SEEK(vp, fp->f_offset, *offset, fp->f_cred);
 		if (error != 0)
 			goto out;
+	}
 	iovlen = iovcnt * sizeof(struct iovec);
 	if (flags & FOF_IOV_SYSSPACE)
 		iov = __UNCONST(iovp);
 	else {
 		iov = aiov;
 		if ((u_int)iovcnt > UIO_SMALLIOV) {
 			if ((u_int)iovcnt > IOV_MAX) {
 				error = EINVAL;
 				goto out;
+			}
 			iov = kmem_alloc(iovlen, KM_SLEEP);
 			if (iov == NULL) {
 				error = ENOMEM;
 				goto out;
+			}
 			needfree = iov;
+		}
 		error = copyin(iovp, iov, iovlen);
 		if (error)
 			goto done;
+	}
 	auio.uio_iov = iov;
 	auio.uio_iovcnt = iovcnt;
 	auio.uio_rw = UIO_READ;
 	auio.uio_vmspace = curproc->p_vmspace;
 	auio.uio_resid = 0;
 	for (i = 0; i < iovcnt; i++, iov++) {
 		auio.uio_resid += iov->iov_len;
 		/*
 		 * Reads return ssize_t because -1 is returned on error.
 		 * Therefore we must restrict the length to SSIZE_MAX to
 		 * avoid garbage return values.
 		 */
 		if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
 			error = EINVAL;
 			goto done;
+		}
+	}
 	/*
 	 * if tracing, save a copy of iovec
 	 */
 	if (ktrpoint(KTR_GENIO))  {
 		ktriov = kmem_alloc(iovlen, KM_SLEEP);
 		if (ktriov != NULL)
 			memcpy(ktriov, auio.uio_iov, iovlen);
+	}
 	cnt = auio.uio_resid;
 	error = (*fp->f_ops->fo_read)(fp, offset, &auio, fp->f_cred, flags);
 	if (error)
 		if (auio.uio_resid != cnt && (error == ERESTART ||
 		    error == EINTR || error == EWOULDBLOCK))
 			error = 0;
 	cnt -= auio.uio_resid;
 	*retval = cnt;
 	if (ktriov != NULL) {
 		ktrgeniov(fd, UIO_READ, ktriov, cnt, error);
 		kmem_free(ktriov, iovlen);
+	}
  done:
 	if (needfree)
 		kmem_free(needfree, iovlen);
  out:
 	fd_putfile(fd);
 	return (error);
+}
 /*
  * Write system call
  */
 int
 sys_write(struct lwp *l, const struct sys_write_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)			fd;
 		syscallarg(const void *)	buf;
 		syscallarg(size_t)		nbyte;
 	} */
 	file_t *fp;
 	int fd;
 	fd = SCARG(uap, fd);
 	if ((fp = fd_getfile(fd)) == NULL)
 		return (EBADF);
 	if ((fp->f_flag & FWRITE) == 0) {
 		fd_putfile(fd);
 		return (EBADF);
+	}
 	/* dofilewrite() will unuse the descriptor for us */
 	return (dofilewrite(fd, fp, SCARG(uap, buf), SCARG(uap, nbyte),
 	    &fp->f_offset, FOF_UPDATE_OFFSET, retval));
+}
 int
 dofilewrite(int fd, struct file *fp, const void *buf,
 	size_t nbyte, off_t *offset, int flags, register_t *retval)
+{
 	struct iovec aiov;
 	struct uio auio;
 	size_t cnt;
 	int error;
 	aiov.iov_base = __UNCONST(buf);		/* XXXUNCONST kills const */
 	aiov.iov_len = nbyte;
 	auio.uio_iov = &aiov;
 	auio.uio_iovcnt = 1;
 	auio.uio_resid = nbyte;
 	auio.uio_rw = UIO_WRITE;
 	auio.uio_vmspace = curproc->p_vmspace;
 	/*
 	 * Writes return ssize_t because -1 is returned on error.  Therefore
 	 * we must restrict the length to SSIZE_MAX to avoid garbage return
 	 * values.
 	 */
 	if (auio.uio_resid > SSIZE_MAX) {
 		error = EINVAL;
 		goto out;
+	}
 	cnt = auio.uio_resid;
 	error = (*fp->f_ops->fo_write)(fp, offset, &auio, fp->f_cred, flags);
 	if (error) {
 		if (auio.uio_resid != cnt && (error == ERESTART ||
 		    error == EINTR || error == EWOULDBLOCK))
 			error = 0;
 		if (error == EPIPE) {
 			mutex_enter(proc_lock);
 			psignal(curproc, SIGPIPE);
 			mutex_exit(proc_lock);
+		}
+	}
 	cnt -= auio.uio_resid;
 	ktrgenio(fd, UIO_WRITE, buf, cnt, error);
 	*retval = cnt;
  out:
 	fd_putfile(fd);
 	return (error);
+}
 /*
  * Gather write system call
  */
 int
 sys_writev(struct lwp *l, const struct sys_writev_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)				fd;
 		syscallarg(const struct iovec *)	iovp;
 		syscallarg(int)				iovcnt;
 	} */
 	return do_filewritev(SCARG(uap, fd), SCARG(uap, iovp),
 	    SCARG(uap, iovcnt), NULL, FOF_UPDATE_OFFSET, retval);
+}
 int
 do_filewritev(int fd, const struct iovec *iovp, int iovcnt,
     off_t *offset, int flags, register_t *retval)
+{
 	struct uio	auio;
 	struct iovec	*iov, *needfree = NULL, aiov[UIO_SMALLIOV];
 	int		i, error;
 	size_t		cnt;
 	u_int		iovlen;
 	struct file	*fp;
 	struct iovec	*ktriov = NULL;
 	if (iovcnt == 0)
 		return EINVAL;
 	if ((fp = fd_getfile(fd)) == NULL)
 		return EBADF;
 	if ((fp->f_flag & FWRITE) == 0) {
 		fd_putfile(fd);
 		return EBADF;
+	}
 	if (offset == NULL)
 		offset = &fp->f_offset;
 	else {
 		struct vnode *vp = fp->f_data;
 		if (fp->f_type != DTYPE_VNODE || vp->v_type == VFIFO) {
 			error = ESPIPE;
 			goto out;
+		}
 		/*
 		 * Test that the device is seekable ?
 		 * XXX This works because no file systems actually
 		 * XXX take any action on the seek operation.
 		 */
 		error = VOP_SEEK(vp, fp->f_offset, *offset, fp->f_cred);
 		if (error != 0)
 			goto out;
+	}
 	iovlen = iovcnt * sizeof(struct iovec);
 	if (flags & FOF_IOV_SYSSPACE)
 		iov = __UNCONST(iovp);
 	else {
 		iov = aiov;
 		if ((u_int)iovcnt > UIO_SMALLIOV) {
 			if ((u_int)iovcnt > IOV_MAX) {
 				error = EINVAL;
 				goto out;
+			}
 			iov = kmem_alloc(iovlen, KM_SLEEP);
 			if (iov == NULL) {
 				error = ENOMEM;
 				goto out;
+			}
 			needfree = iov;
+		}
 		error = copyin(iovp, iov, iovlen);
 		if (error)
 			goto done;
+	}
 	auio.uio_iov = iov;
 	auio.uio_iovcnt = iovcnt;
 	auio.uio_rw = UIO_WRITE;
 	auio.uio_vmspace = curproc->p_vmspace;
 	auio.uio_resid = 0;
 	for (i = 0; i < iovcnt; i++, iov++) {
 		auio.uio_resid += iov->iov_len;
 		/*
 		 * Writes return ssize_t because -1 is returned on error.
 		 * Therefore we must restrict the length to SSIZE_MAX to
 		 * avoid garbage return values.
 		 */
 		if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
 			error = EINVAL;
 			goto done;
+		}
+	}
 	/*
 	 * if tracing, save a copy of iovec
 	 */
 	if (ktrpoint(KTR_GENIO))  {
 		ktriov = kmem_alloc(iovlen, KM_SLEEP);
 		if (ktriov != NULL)
 			memcpy(ktriov, auio.uio_iov, iovlen);
+	}
 	cnt = auio.uio_resid;
 	error = (*fp->f_ops->fo_write)(fp, offset, &auio, fp->f_cred, flags);
 	if (error) {
 		if (auio.uio_resid != cnt && (error == ERESTART ||
 		    error == EINTR || error == EWOULDBLOCK))
 			error = 0;
 		if (error == EPIPE) {
 			mutex_enter(proc_lock);
 			psignal(curproc, SIGPIPE);
 			mutex_exit(proc_lock);
+		}
+	}
 	cnt -= auio.uio_resid;
 	*retval = cnt;
 	if (ktriov != NULL) {
 		ktrgeniov(fd, UIO_WRITE, ktriov, cnt, error);
 		kmem_free(ktriov, iovlen);
+	}
  done:
 	if (needfree)
 		kmem_free(needfree, iovlen);
  out:
 	fd_putfile(fd);
 	return (error);
+}
 /*
  * Ioctl system call
  */
 /* ARGSUSED */
 int
 sys_ioctl(struct lwp *l, const struct sys_ioctl_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)		fd;
 		syscallarg(u_long)	com;
 		syscallarg(void *)	data;
 	} */
 	struct file	*fp;
 	proc_t		*p;
 	u_long		com;
 	int		error;
 	size_t		size, alloc_size;
 	void 		*data, *memp;
 #define	STK_PARAMS	128
 	u_long		stkbuf[STK_PARAMS/sizeof(u_long)];
 	memp = NULL;
 	alloc_size = 0;
 	error = 0;
 	p = l->l_proc;
 	if ((fp = fd_getfile(SCARG(uap, fd))) == NULL)
 		return (EBADF);
 	if ((fp->f_flag & (FREAD | FWRITE)) == 0) {
 		error = EBADF;
 		com = 0;
 		goto out;
+	}
 	switch (com = SCARG(uap, com)) {
 	case FIONCLEX:
 	case FIOCLEX:
 		fd_set_exclose(l, SCARG(uap, fd), com == FIOCLEX);
 		goto out;
+	}
 	/*
 	 * Interpret high order word to find amount of data to be
 	 * copied to/from the user's address space.
 	 */
 	size = IOCPARM_LEN(com);
 	alloc_size = size;
 	/*
 	 * The disklabel is now padded to a multiple of 8 bytes however the old
 	 * disklabel on 32bit platforms wasn't.  This leaves a difference in
 	 * size of 4 bytes between the two but are otherwise identical.
 	 * To deal with this, we allocate enough space for the new disklabel
 	 * but only copyin/out the smaller amount.
 	 */
 	if (IOCGROUP(com) == 'd') {
 		u_long ncom = com ^ (DIOCGDINFO ^ DIOCGDINFO32);
 		switch (ncom) {
 		case DIOCGDINFO:
 		case DIOCWDINFO:
 		case DIOCSDINFO:
 		case DIOCGDEFLABEL:
 			com = ncom;
 			if (IOCPARM_LEN(DIOCGDINFO32) < IOCPARM_LEN(DIOCGDINFO))
 				alloc_size = IOCPARM_LEN(DIOCGDINFO);
 			break;
+		}
+	}
 	if (size > IOCPARM_MAX) {
 		error = ENOTTY;
 		goto out;
+	}
 	memp = NULL;
 	if ((com >> IOCPARM_SHIFT) == 0)  {
 		/* UNIX-style ioctl. */
 		data = SCARG(uap, data);
 	} else {
 		if (alloc_size > sizeof(stkbuf)) {
 			memp = kmem_alloc(alloc_size, KM_SLEEP);
 			data = memp;
 		} else {
 			data = (void *)stkbuf;
+		}
 		if (com&IOC_IN) {
 			if (size) {
 				error = copyin(SCARG(uap, data), data, size);
 				if (error) {
 					goto out;
+				}
 				/*
 				 * The data between size and alloc_size has
 				 * not been overwritten.  It shouldn't matter
 				 * but let's clear that anyway.
 				 */
 				if (__predict_false(size < alloc_size)) {
 					memset((char *)data+size, 0,
 					    alloc_size - size);
+				}
 				ktrgenio(SCARG(uap, fd), UIO_WRITE,
 				    SCARG(uap, data), size, 0);
 			} else {
 				*(void **)data = SCARG(uap, data);
+			}
 		} else if ((com&IOC_OUT) && size) {
 			/*
 			 * Zero the buffer so the user always
 			 * gets back something deterministic.
 			 */
 			memset(data, 0, size);
 		} else if (com&IOC_VOID) {
 			*(void **)data = SCARG(uap, data);
+		}
+	}
 	switch (com) {
 	case FIONBIO:
 		/* XXX Code block is not atomic */
 		if (*(int *)data != 0)
 			atomic_or_uint(&fp->f_flag, FNONBLOCK);
 		else
 			atomic_and_uint(&fp->f_flag, ~FNONBLOCK);
 		error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO, data);
 		break;
 	case FIOASYNC:
 		/* XXX Code block is not atomic */
 		if (*(int *)data != 0)
 			atomic_or_uint(&fp->f_flag, FASYNC);
 		else
 			atomic_and_uint(&fp->f_flag, ~FASYNC);
 		error = (*fp->f_ops->fo_ioctl)(fp, FIOASYNC, data);
 		break;
 	default:
 		error = (*fp->f_ops->fo_ioctl)(fp, com, data);
 		/*
 		 * Copy any data to user, size was
 		 * already set and checked above.
 		 */
 		if (error == 0 && (com&IOC_OUT) && size) {
 			error = copyout(data, SCARG(uap, data), size);
 			ktrgenio(SCARG(uap, fd), UIO_READ, SCARG(uap, data),
 			    size, error);
+		}
 		break;
+	}
  out:
 	if (memp)
 		kmem_free(memp, alloc_size);
 	fd_putfile(SCARG(uap, fd));
 	switch (error) {
 	case -1:
 		printf("sys_ioctl: _IO%s%s('%c', %lu, %lu) returned -1: "
 		    "pid=%d comm=%s\n",
 		    (com & IOC_IN) ? "W" : "", (com & IOC_OUT) ? "R" : "",
 		    (char)IOCGROUP(com), (com & 0xff), IOCPARM_LEN(com),
 		    p->p_pid, p->p_comm);
 		/* FALLTHROUGH */
 	case EPASSTHROUGH:
 		error = ENOTTY;
 		/* FALLTHROUGH */
 	default:
 		return (error);
+	}
+}

 @@ -1,1089 +1,1087 @@
-/*	$NetBSD: uipc_mbuf.c,v 1.140 2011/04/24 18:46:23 rmind Exp $	*/
+/*	$NetBSD: uipc_mbuf.c,v 1.141 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c) 1999, 2001 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * 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.
  */
 /*
  * Copyright (c) 1982, 1986, 1988, 1991, 1993
  *	The Regents of the University of California.  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. 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.
+ *
  *	@(#)uipc_mbuf.c	8.4 (Berkeley) 2/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uipc_mbuf.c,v 1.140 2011/04/24 18:46:23 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uipc_mbuf.c,v 1.141 2011/07/27 14:35:34 uebayasi Exp $");
 #include "opt_mbuftrace.h"
 #include "opt_nmbclusters.h"
 #include "opt_ddb.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/atomic.h>
 #include <sys/cpu.h>
 #include <sys/proc.h>
 #define MBTYPES
 #include <sys/mbuf.h>
 #include <sys/kernel.h>
 #include <sys/syslog.h>
 #include <sys/domain.h>
 #include <sys/protosw.h>
 #include <sys/percpu.h>
 #include <sys/pool.h>
 #include <sys/socket.h>
 #include <sys/sysctl.h>
 #include <net/if.h>
 #include <uvm/uvm_extern.h>
 pool_cache_t mb_cache;	/* mbuf cache */
 pool_cache_t mcl_cache;	/* mbuf cluster cache */
 struct mbstat mbstat;
 int	max_linkhdr;
 int	max_protohdr;
 int	max_hdr;
 int	max_datalen;
 static int mb_ctor(void *, void *, int);
 static void	sysctl_kern_mbuf_setup(void);
 static struct sysctllog *mbuf_sysctllog;
 static struct mbuf *m_copym0(struct mbuf *, int, int, int, int);
 static struct mbuf *m_split0(struct mbuf *, int, int, int);
 static int m_copyback0(struct mbuf **, int, int, const void *, int, int);
 /* flags for m_copyback0 */
 #define	M_COPYBACK0_COPYBACK	0x0001	/* copyback from cp */
 #define	M_COPYBACK0_PRESERVE	0x0002	/* preserve original data */
 #define	M_COPYBACK0_COW		0x0004	/* do copy-on-write */
 #define	M_COPYBACK0_EXTEND	0x0008	/* extend chain */
 static const char mclpool_warnmsg[] =
     "WARNING: mclpool limit reached; increase kern.mbuf.nmbclusters";
 MALLOC_DEFINE(M_MBUF, "mbuf", "mbuf");
 static percpu_t *mbstat_percpu;
 #ifdef MBUFTRACE
 struct mownerhead mowners = LIST_HEAD_INITIALIZER(mowners);
 struct mowner unknown_mowners[] = {
 	MOWNER_INIT("unknown", "free"),
 	MOWNER_INIT("unknown", "data"),
 	MOWNER_INIT("unknown", "header"),
 	MOWNER_INIT("unknown", "soname"),
 	MOWNER_INIT("unknown", "soopts"),
 	MOWNER_INIT("unknown", "ftable"),
 	MOWNER_INIT("unknown", "control"),
 	MOWNER_INIT("unknown", "oobdata"),
 };
 struct mowner revoked_mowner = MOWNER_INIT("revoked", "");
 #endif
 #define	MEXT_ISEMBEDDED(m) ((m)->m_ext_ref == (m))
 #define	MCLADDREFERENCE(o, n)						\
 do {									\
 	KASSERT(((o)->m_flags & M_EXT) != 0);				\
 	KASSERT(((n)->m_flags & M_EXT) == 0);				\
 	KASSERT((o)->m_ext.ext_refcnt >= 1);				\
 	(n)->m_flags |= ((o)->m_flags & M_EXTCOPYFLAGS);		\
 	atomic_inc_uint(&(o)->m_ext.ext_refcnt);			\
 	(n)->m_ext_ref = (o)->m_ext_ref;				\
 	mowner_ref((n), (n)->m_flags);					\
 	MCLREFDEBUGN((n), __FILE__, __LINE__);				\
 } while (/* CONSTCOND */ 0)
 static int
 nmbclusters_limit(void)
+{
 #if defined(PMAP_MAP_POOLPAGE)
 	/* direct mapping, doesn't use space in kmem_map */
 	vsize_t max_size = physmem / 4;
 #else
 	vsize_t max_size = MIN(physmem / 4, nkmempages / 2);
 #endif
 	max_size = max_size * PAGE_SIZE / MCLBYTES;
 #ifdef NMBCLUSTERS_MAX
 	max_size = MIN(max_size, NMBCLUSTERS_MAX);
 #endif
 #ifdef NMBCLUSTERS
 	return MIN(max_size, NMBCLUSTERS);
 #else
 	return max_size;
 #endif
+}
 /*
  * Initialize the mbuf allocator.
  */
 void
 mbinit(void)
+{
 	CTASSERT(sizeof(struct _m_ext) <= MHLEN);
 	CTASSERT(sizeof(struct mbuf) == MSIZE);
 	sysctl_kern_mbuf_setup();
 	mb_cache = pool_cache_init(msize, 0, 0, 0, "mbpl",
 	    NULL, IPL_VM, mb_ctor, NULL, NULL);
 	KASSERT(mb_cache != NULL);
 	mcl_cache = pool_cache_init(mclbytes, 0, 0, 0, "mclpl", NULL,
 	    IPL_VM, NULL, NULL, NULL);
 	KASSERT(mcl_cache != NULL);
 	pool_cache_set_drain_hook(mb_cache, m_reclaim, NULL);
 	pool_cache_set_drain_hook(mcl_cache, m_reclaim, NULL);
 	/*
 	 * Set an arbitrary default limit on the number of mbuf clusters.
 	 */
 #ifdef NMBCLUSTERS
 	nmbclusters = nmbclusters_limit();
 #else
 	nmbclusters = MAX(1024,
 	    (vsize_t)physmem * PAGE_SIZE / MCLBYTES / 16);
 	nmbclusters = MIN(nmbclusters, nmbclusters_limit());
 #endif
 	/*
 	 * Set the hard limit on the mclpool to the number of
 	 * mbuf clusters the kernel is to support.  Log the limit
 	 * reached message max once a minute.
 	 */
 	pool_cache_sethardlimit(mcl_cache, nmbclusters, mclpool_warnmsg, 60);
 	mbstat_percpu = percpu_alloc(sizeof(struct mbstat_cpu));
 	/*
 	 * Set a low water mark for both mbufs and clusters.  This should
 	 * help ensure that they can be allocated in a memory starvation
 	 * situation.  This is important for e.g. diskless systems which
 	 * must allocate mbufs in order for the pagedaemon to clean pages.
 	 */
 	pool_cache_setlowat(mb_cache, mblowat);
 	pool_cache_setlowat(mcl_cache, mcllowat);
 #ifdef MBUFTRACE
+	{
 		/*
 		 * Attach the unknown mowners.
 		 */
 		int i;
 		MOWNER_ATTACH(&revoked_mowner);
 		for (i = sizeof(unknown_mowners)/sizeof(unknown_mowners[0]);
 		     i-- > 0; )
 			MOWNER_ATTACH(&unknown_mowners[i]);
+	}
 #endif
+}
 /*
  * sysctl helper routine for the kern.mbuf subtree.
  * nmbclusters, mblowat and mcllowat need range
  * checking and pool tweaking after being reset.
  */
 static int
 sysctl_kern_mbuf(SYSCTLFN_ARGS)
+{
 	int error, newval;
 	struct sysctlnode node;
 	node = *rnode;
 	node.sysctl_data = &newval;
 	switch (rnode->sysctl_num) {
 	case MBUF_NMBCLUSTERS:
 	case MBUF_MBLOWAT:
 	case MBUF_MCLLOWAT:
 		newval = *(int*)rnode->sysctl_data;
 		break;
 	default:
 		return (EOPNOTSUPP);
+	}
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return (error);
 	if (newval < 0)
 		return (EINVAL);
 	switch (node.sysctl_num) {
 	case MBUF_NMBCLUSTERS:
 		if (newval < nmbclusters)
 			return (EINVAL);
 		if (newval > nmbclusters_limit())
 			return (EINVAL);
 		nmbclusters = newval;
 		pool_cache_sethardlimit(mcl_cache, nmbclusters,
 		    mclpool_warnmsg, 60);
 		break;
 	case MBUF_MBLOWAT:
 		mblowat = newval;
 		pool_cache_setlowat(mb_cache, mblowat);
 		break;
 	case MBUF_MCLLOWAT:
 		mcllowat = newval;
 		pool_cache_setlowat(mcl_cache, mcllowat);
 		break;
+	}
 	return (0);
+}
 #ifdef MBUFTRACE
 static void
 mowner_conver_to_user_cb(void *v1, void *v2, struct cpu_info *ci)
+{
 	struct mowner_counter *mc = v1;
 	struct mowner_user *mo_user = v2;
 	int i;
 	for (i = 0; i < MOWNER_COUNTER_NCOUNTERS; i++) {
 		mo_user->mo_counter[i] += mc->mc_counter[i];
+	}
+}
 static void
 mowner_convert_to_user(struct mowner *mo, struct mowner_user *mo_user)
+{
 	memset(mo_user, 0, sizeof(*mo_user));
 	CTASSERT(sizeof(mo_user->mo_name) == sizeof(mo->mo_name));
 	CTASSERT(sizeof(mo_user->mo_descr) == sizeof(mo->mo_descr));
 	memcpy(mo_user->mo_name, mo->mo_name, sizeof(mo->mo_name));
 	memcpy(mo_user->mo_descr, mo->mo_descr, sizeof(mo->mo_descr));
 	percpu_foreach(mo->mo_counters, mowner_conver_to_user_cb, mo_user);
+}
 static int
 sysctl_kern_mbuf_mowners(SYSCTLFN_ARGS)
+{
 	struct mowner *mo;
 	size_t len = 0;
 	int error = 0;
 	if (namelen != 0)
 		return (EINVAL);
 	if (newp != NULL)
 		return (EPERM);
 	LIST_FOREACH(mo, &mowners, mo_link) {
 		struct mowner_user mo_user;
 		mowner_convert_to_user(mo, &mo_user);
 		if (oldp != NULL) {
 			if (*oldlenp - len < sizeof(mo_user)) {
 				error = ENOMEM;
 				break;
+			}
 			error = copyout(&mo_user, (char *)oldp + len,
 			    sizeof(mo_user));
 			if (error)
 				break;
+		}
 		len += sizeof(mo_user);
+	}
 	if (error == 0)
 		*oldlenp = len;
 	return (error);
+}
 #endif /* MBUFTRACE */
 static void
 mbstat_conver_to_user_cb(void *v1, void *v2, struct cpu_info *ci)
+{
 	struct mbstat_cpu *mbsc = v1;
 	struct mbstat *mbs = v2;
 	int i;
 	for (i = 0; i < __arraycount(mbs->m_mtypes); i++) {
 		mbs->m_mtypes[i] += mbsc->m_mtypes[i];
+	}
+}
 static void
 mbstat_convert_to_user(struct mbstat *mbs)
+{
 	memset(mbs, 0, sizeof(*mbs));
 	mbs->m_drain = mbstat.m_drain;
 	percpu_foreach(mbstat_percpu, mbstat_conver_to_user_cb, mbs);
+}
 static int
 sysctl_kern_mbuf_stats(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node;
 	struct mbstat mbs;
 	mbstat_convert_to_user(&mbs);
 	node = *rnode;
 	node.sysctl_data = &mbs;
 	node.sysctl_size = sizeof(mbs);
 	return sysctl_lookup(SYSCTLFN_CALL(&node));
+}
 static void
 sysctl_kern_mbuf_setup(void)
+{
 	KASSERT(mbuf_sysctllog == NULL);
 	sysctl_createv(&mbuf_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_NODE, "kern", NULL,
 		       NULL, 0, NULL, 0,
 		       CTL_KERN, CTL_EOL);
 	sysctl_createv(&mbuf_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_NODE, "mbuf",
 		       SYSCTL_DESCR("mbuf control variables"),
 		       NULL, 0, NULL, 0,
 		       CTL_KERN, KERN_MBUF, CTL_EOL);
 	sysctl_createv(&mbuf_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
 		       CTLTYPE_INT, "msize",
 		       SYSCTL_DESCR("mbuf base size"),
 		       NULL, msize, NULL, 0,
 		       CTL_KERN, KERN_MBUF, MBUF_MSIZE, CTL_EOL);
 	sysctl_createv(&mbuf_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT|CTLFLAG_IMMEDIATE,
 		       CTLTYPE_INT, "mclbytes",
 		       SYSCTL_DESCR("mbuf cluster size"),
 		       NULL, mclbytes, NULL, 0,
 		       CTL_KERN, KERN_MBUF, MBUF_MCLBYTES, CTL_EOL);
 	sysctl_createv(&mbuf_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 		       CTLTYPE_INT, "nmbclusters",
 		       SYSCTL_DESCR("Limit on the number of mbuf clusters"),
 		       sysctl_kern_mbuf, 0, &nmbclusters, 0,
 		       CTL_KERN, KERN_MBUF, MBUF_NMBCLUSTERS, CTL_EOL);
 	sysctl_createv(&mbuf_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 		       CTLTYPE_INT, "mblowat",
 		       SYSCTL_DESCR("mbuf low water mark"),
 		       sysctl_kern_mbuf, 0, &mblowat, 0,
 		       CTL_KERN, KERN_MBUF, MBUF_MBLOWAT, CTL_EOL);
 	sysctl_createv(&mbuf_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 		       CTLTYPE_INT, "mcllowat",
 		       SYSCTL_DESCR("mbuf cluster low water mark"),
 		       sysctl_kern_mbuf, 0, &mcllowat, 0,
 		       CTL_KERN, KERN_MBUF, MBUF_MCLLOWAT, CTL_EOL);
 	sysctl_createv(&mbuf_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_STRUCT, "stats",
 		       SYSCTL_DESCR("mbuf allocation statistics"),
 		       sysctl_kern_mbuf_stats, 0, NULL, 0,
 		       CTL_KERN, KERN_MBUF, MBUF_STATS, CTL_EOL);
 #ifdef MBUFTRACE
 	sysctl_createv(&mbuf_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_STRUCT, "mowners",
 		       SYSCTL_DESCR("Information about mbuf owners"),
 		       sysctl_kern_mbuf_mowners, 0, NULL, 0,
 		       CTL_KERN, KERN_MBUF, MBUF_MOWNERS, CTL_EOL);
 #endif /* MBUFTRACE */
+}
 static int
 mb_ctor(void *arg, void *object, int flags)
+{
 	struct mbuf *m = object;
 #ifdef POOL_VTOPHYS
 	m->m_paddr = POOL_VTOPHYS(m);
 #else
 	m->m_paddr = M_PADDR_INVALID;
 #endif
 	return (0);
+}
 void
 m_reclaim(void *arg, int flags)
+{
 	struct domain *dp;
 	const struct protosw *pr;
 	struct ifnet *ifp;
 	int s;
 	KERNEL_LOCK(1, NULL);
 	s = splvm();
 	DOMAIN_FOREACH(dp) {
 		for (pr = dp->dom_protosw;
 		     pr < dp->dom_protoswNPROTOSW; pr++)
 			if (pr->pr_drain)
 				(*pr->pr_drain)();
+	}
 	IFNET_FOREACH(ifp) {
 		if (ifp->if_drain)
 			(*ifp->if_drain)(ifp);
+	}
 	splx(s);
 	mbstat.m_drain++;
 	KERNEL_UNLOCK_ONE(NULL);
+}
 /*
  * Space allocation routines.
  * These are also available as macros
  * for critical paths.
  */
 struct mbuf *
 m_get(int nowait, int type)
+{
 	struct mbuf *m;
 	m = pool_cache_get(mb_cache,
 	    nowait == M_WAIT ? PR_WAITOK|PR_LIMITFAIL : 0);
 	if (m == NULL)
 		return NULL;
 	mbstat_type_add(type, 1);
 	mowner_init(m, type);
 	m->m_ext_ref = m;
 	m->m_type = type;
 	m->m_next = NULL;
 	m->m_nextpkt = NULL;
 	m->m_data = m->m_dat;
 	m->m_flags = 0;
 	return m;
+}
 struct mbuf *
 m_gethdr(int nowait, int type)
+{
 	struct mbuf *m;
 	m = m_get(nowait, type);
 	if (m == NULL)
 		return NULL;
 	m->m_data = m->m_pktdat;
 	m->m_flags = M_PKTHDR;
 	m->m_pkthdr.rcvif = NULL;
 	m->m_pkthdr.csum_flags = 0;
 	m->m_pkthdr.csum_data = 0;
 	SLIST_INIT(&m->m_pkthdr.tags);
 	return m;
+}
 struct mbuf *
 m_getclr(int nowait, int type)
+{
 	struct mbuf *m;
 	MGET(m, nowait, type);
 	if (m == 0)
 		return (NULL);
 	memset(mtod(m, void *), 0, MLEN);
 	return (m);
+}
 void
 m_clget(struct mbuf *m, int nowait)
+{
 	MCLGET(m, nowait);
+}
 struct mbuf *
 m_free(struct mbuf *m)
+{
 	struct mbuf *n;
 	MFREE(m, n);
 	return (n);
+}
 void
 m_freem(struct mbuf *m)
+{
 	struct mbuf *n;
 	if (m == NULL)
 		return;
 	do {
 		MFREE(m, n);
 		m = n;
 	} while (m);
+}
 #ifdef MBUFTRACE
 /*
  * Walk a chain of mbufs, claiming ownership of each mbuf in the chain.
  */
 void
 m_claimm(struct mbuf *m, struct mowner *mo)
+{
 	for (; m != NULL; m = m->m_next)
 		MCLAIM(m, mo);
+}
 #endif
 /*
  * Mbuffer utility routines.
  */
 /*
  * Lesser-used path for M_PREPEND:
  * allocate new mbuf to prepend to chain,
  * copy junk along.
  */
 struct mbuf *
 m_prepend(struct mbuf *m, int len, int how)
+{
 	struct mbuf *mn;
 	MGET(mn, how, m->m_type);
 	if (mn == (struct mbuf *)NULL) {
 		m_freem(m);
 		return ((struct mbuf *)NULL);
+	}
 	if (m->m_flags & M_PKTHDR) {
 		M_MOVE_PKTHDR(mn, m);
 	} else {
 		MCLAIM(mn, m->m_owner);
+	}
 	mn->m_next = m;
 	m = mn;
 	if (len < MHLEN)
 		MH_ALIGN(m, len);
 	m->m_len = len;
 	return (m);
+}
 /*
  * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
  * continuing for "len" bytes.  If len is M_COPYALL, copy to end of mbuf.
  * The wait parameter is a choice of M_WAIT/M_DONTWAIT from caller.
  */
 int MCFail;
 struct mbuf *
 m_copym(struct mbuf *m, int off0, int len, int wait)
+{
 	return m_copym0(m, off0, len, wait, 0);	/* shallow copy on M_EXT */
+}
 struct mbuf *
 m_dup(struct mbuf *m, int off0, int len, int wait)
+{
 	return m_copym0(m, off0, len, wait, 1);	/* deep copy */
+}
 static struct mbuf *
 m_copym0(struct mbuf *m, int off0, int len, int wait, int deep)
+{
 	struct mbuf *n, **np;
 	int off = off0;
 	struct mbuf *top;
 	int copyhdr = 0;
 	if (off < 0 || len < 0)
 		panic("m_copym: off %d, len %d", off, len);
 	if (off == 0 && m->m_flags & M_PKTHDR)
 		copyhdr = 1;
 	while (off > 0) {
 		if (m == 0)
 			panic("m_copym: m == 0, off %d", off);
 		if (off < m->m_len)
 			break;
 		off -= m->m_len;
 		m = m->m_next;
+	}
 	np = &top;
 	top = 0;
 	while (len > 0) {
 		if (m == 0) {
 			if (len != M_COPYALL)
 				panic("m_copym: m == 0, len %d [!COPYALL]",
 				    len);
 			break;
+		}
 		MGET(n, wait, m->m_type);
 		*np = n;
 		if (n == 0)
 			goto nospace;
 		MCLAIM(n, m->m_owner);
 		if (copyhdr) {
 			M_COPY_PKTHDR(n, m);
 			if (len == M_COPYALL)
 				n->m_pkthdr.len -= off0;
 			else
 				n->m_pkthdr.len = len;
 			copyhdr = 0;
+		}
 		n->m_len = min(len, m->m_len - off);
 		if (m->m_flags & M_EXT) {
 			if (!deep) {
 				n->m_data = m->m_data + off;
 				MCLADDREFERENCE(m, n);
 			} else {
 				/*
 				 * we are unsure about the way m was allocated.
 				 * copy into multiple MCLBYTES cluster mbufs.
 				 */
 				MCLGET(n, wait);
 				n->m_len = 0;
 				n->m_len = M_TRAILINGSPACE(n);
 				n->m_len = min(n->m_len, len);
 				n->m_len = min(n->m_len, m->m_len - off);
 				memcpy(mtod(n, void *), mtod(m, char *) + off,
 				    (unsigned)n->m_len);
+			}
 		} else
 			memcpy(mtod(n, void *), mtod(m, char *) + off,
 			    (unsigned)n->m_len);
 		if (len != M_COPYALL)
 			len -= n->m_len;
 		off += n->m_len;
 #ifdef DIAGNOSTIC
 		if (off > m->m_len)
 			panic("m_copym0 overrun");
 #endif
 		if (off == m->m_len) {
 			m = m->m_next;
 			off = 0;
+		}
 		np = &n->m_next;
+	}
 	if (top == 0)
 		MCFail++;
 	return (top);
 nospace:
 	m_freem(top);
 	MCFail++;
 	return (NULL);
+}
 /*
  * Copy an entire packet, including header (which must be present).
  * An optimization of the common case `m_copym(m, 0, M_COPYALL, how)'.
  */
 struct mbuf *
 m_copypacket(struct mbuf *m, int how)
+{
 	struct mbuf *top, *n, *o;
 	MGET(n, how, m->m_type);
 	top = n;
 	if (!n)
 		goto nospace;
 	MCLAIM(n, m->m_owner);
 	M_COPY_PKTHDR(n, m);
 	n->m_len = m->m_len;
 	if (m->m_flags & M_EXT) {
 		n->m_data = m->m_data;
 		MCLADDREFERENCE(m, n);
 	} else {
 		memcpy(mtod(n, char *), mtod(m, char *), n->m_len);
+	}
 	m = m->m_next;
 	while (m) {
 		MGET(o, how, m->m_type);
 		if (!o)
 			goto nospace;
 		MCLAIM(o, m->m_owner);
 		n->m_next = o;
 		n = n->m_next;
 		n->m_len = m->m_len;
 		if (m->m_flags & M_EXT) {
 			n->m_data = m->m_data;
 			MCLADDREFERENCE(m, n);
 		} else {
 			memcpy(mtod(n, char *), mtod(m, char *), n->m_len);
+		}
 		m = m->m_next;
+	}
 	return top;
 nospace:
 	m_freem(top);
 	MCFail++;
 	return NULL;
+}
 /*
  * Copy data from an mbuf chain starting "off" bytes from the beginning,
  * continuing for "len" bytes, into the indicated buffer.
  */
 void
 m_copydata(struct mbuf *m, int off, int len, void *vp)
+{
 	unsigned	count;
 	void *		cp = vp;
 	if (off < 0 || len < 0)
 		panic("m_copydata: off %d, len %d", off, len);
 	while (off > 0) {
 		if (m == NULL)
 			panic("m_copydata: m == NULL, off %d", off);
 		if (off < m->m_len)
 			break;
 		off -= m->m_len;
 		m = m->m_next;
+	}
 	while (len > 0) {
 		if (m == NULL)
 			panic("m_copydata: m == NULL, len %d", len);
 		count = min(m->m_len - off, len);
 		memcpy(cp, mtod(m, char *) + off, count);
 		len -= count;
 		cp = (char *)cp + count;
 		off = 0;
 		m = m->m_next;
+	}
+}
 /*
  * Concatenate mbuf chain n to m.
  * n might be copied into m (when n->m_len is small), therefore data portion of
  * n could be copied into an mbuf of different mbuf type.
  * Any m_pkthdr is not updated.
  */
 void
 m_cat(struct mbuf *m, struct mbuf *n)
+{
 	while (m->m_next)
 		m = m->m_next;
 	while (n) {
 		if (M_READONLY(m) || n->m_len > M_TRAILINGSPACE(m)) {
 			/* just join the two chains */
 			m->m_next = n;
 			return;
+		}
 		/* splat the data from one into the other */
 		memcpy(mtod(m, char *) + m->m_len, mtod(n, void *),
 		    (u_int)n->m_len);
 		m->m_len += n->m_len;
 		n = m_free(n);
+	}
+}
 void
 m_adj(struct mbuf *mp, int req_len)
+{
 	int len = req_len;
 	struct mbuf *m;
 	int count;
 	if ((m = mp) == NULL)
 		return;
 	if (len >= 0) {
 		/*
 		 * Trim from head.
 		 */
 		while (m != NULL && len > 0) {
 			if (m->m_len <= len) {
 				len -= m->m_len;
 				m->m_len = 0;
 				m = m->m_next;
 			} else {
 				m->m_len -= len;
 				m->m_data += len;
 				len = 0;
+			}
+		}
 		m = mp;
 		if (mp->m_flags & M_PKTHDR)
 			m->m_pkthdr.len -= (req_len - len);
 	} else {
 		/*
 		 * Trim from tail.  Scan the mbuf chain,
 		 * calculating its length and finding the last mbuf.
 		 * If the adjustment only affects this mbuf, then just
 		 * adjust and return.  Otherwise, rescan and truncate
 		 * after the remaining size.
 		 */
 		len = -len;
 		count = 0;
 		for (;;) {
 			count += m->m_len;
 			if (m->m_next == (struct mbuf *)0)
 				break;
 			m = m->m_next;
+		}
 		if (m->m_len >= len) {
 			m->m_len -= len;
 			if (mp->m_flags & M_PKTHDR)
 				mp->m_pkthdr.len -= len;
 			return;
+		}
 		count -= len;
 		if (count < 0)
 			count = 0;
 		/*
 		 * Correct length for chain is "count".
 		 * Find the mbuf with last data, adjust its length,
 		 * and toss data from remaining mbufs on chain.
 		 */
 		m = mp;
 		if (m->m_flags & M_PKTHDR)
 			m->m_pkthdr.len = count;
 		for (; m; m = m->m_next) {
 			if (m->m_len >= count) {
 				m->m_len = count;
 				break;
+			}
 			count -= m->m_len;
+		}
 		if (m)
 			while (m->m_next)
 				(m = m->m_next)->m_len = 0;
+	}
+}
 /*
  * Rearrange an mbuf chain so that len bytes are contiguous
  * and in the data area of an mbuf (so that mtod and dtom
  * will work for a structure of size len).  Returns the resulting
  * mbuf chain on success, frees it and returns null on failure.
  * If there is room, it will add up to max_protohdr-len extra bytes to the
  * contiguous region in an attempt to avoid being called next time.
  */
 int MPFail;
 struct mbuf *
 m_pullup(struct mbuf *n, int len)
+{
 	struct mbuf *m;
 	int count;
 	int space;
 	/*
 	 * If first mbuf has no cluster, and has room for len bytes
 	 * without shifting current data, pullup into it,
 	 * otherwise allocate a new mbuf to prepend to the chain.
 	 */
 	if ((n->m_flags & M_EXT) == 0 &&
 	    n->m_data + len < &n->m_dat[MLEN] && n->m_next) {
 		if (n->m_len >= len)
 			return (n);
 		m = n;
 		n = n->m_next;
 		len -= m->m_len;
 	} else {
 		if (len > MHLEN)
 			goto bad;
 		MGET(m, M_DONTWAIT, n->m_type);
 		if (m == 0)
 			goto bad;
 		MCLAIM(m, n->m_owner);
 		m->m_len = 0;
 		if (n->m_flags & M_PKTHDR) {
 			M_MOVE_PKTHDR(m, n);
+		}
+	}
 	space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
 	do {
 		count = min(min(max(len, max_protohdr), space), n->m_len);
 		memcpy(mtod(m, char *) + m->m_len, mtod(n, void *),
 		  (unsigned)count);
 		len -= count;
 		m->m_len += count;
 		n->m_len -= count;
 		space -= count;
 		if (n->m_len)
 			n->m_data += count;
 		else
 			n = m_free(n);
 	} while (len > 0 && n);
 	if (len > 0) {
 		(void) m_free(m);
 		goto bad;
+	}
 	m->m_next = n;
 	return (m);
 bad:
 	m_freem(n);
 	MPFail++;
 	return (NULL);
+}
 /*
  * Like m_pullup(), except a new mbuf is always allocated, and we allow
  * the amount of empty space before the data in the new mbuf to be specified
  * (in the event that the caller expects to prepend later).
  */
 int MSFail;
 struct mbuf *
 m_copyup(struct mbuf *n, int len, int dstoff)
+{
 	struct mbuf *m;
 	int count, space;
 	if (len > (MHLEN - dstoff))
 		goto bad;
 	MGET(m, M_DONTWAIT, n->m_type);
 	if (m == NULL)
 		goto bad;
 	MCLAIM(m, n->m_owner);
 	m->m_len = 0;
 	if (n->m_flags & M_PKTHDR) {
 		M_MOVE_PKTHDR(m, n);
+	}
 	m->m_data += dstoff;
 	space = &m->m_dat[MLEN] - (m->m_data + m->m_len);
 	do {
 		count = min(min(max(len, max_protohdr), space), n->m_len);
 		memcpy(mtod(m, char *) + m->m_len, mtod(n, void *),
 		    (unsigned)count);
 		len -= count;
 		m->m_len += count;
 		n->m_len -= count;
 		space -= count;
 		if (n->m_len)
 			n->m_data += count;
 		else
 			n = m_free(n);
 	} while (len > 0 && n);
 	if (len > 0) {
 		(void) m_free(m);
 		goto bad;
+	}
 	m->m_next = n;
 	return (m);
  bad:
 	m_freem(n);
 	MSFail++;
 	return (NULL);
+}
 /*
  * Partition an mbuf chain in two pieces, returning the tail --
  * all but the first len0 bytes.  In case of failure, it returns NULL and
  * attempts to restore the chain to its original state.
  */
 struct mbuf *
 m_split(struct mbuf *m0, int len0, int wait)
+{
 	return m_split0(m0, len0, wait, 1);
+}
 static struct mbuf *
 m_split0(struct mbuf *m0, int len0, int wait, int copyhdr)
+{
 	struct mbuf *m, *n;
 	unsigned len = len0, remain, len_save;
 	for (m = m0; m && len > m->m_len; m = m->m_next)
 		len -= m->m_len;
 	if (m == 0)
 		return (NULL);
 	remain = m->m_len - len;
 	if (copyhdr && (m0->m_flags & M_PKTHDR)) {
 		MGETHDR(n, wait, m0->m_type);
 		if (n == 0)
 			return (NULL);
 		MCLAIM(n, m0->m_owner);
 		n->m_pkthdr.rcvif = m0->m_pkthdr.rcvif;
 		n->m_pkthdr.len = m0->m_pkthdr.len - len0;
 		len_save = m0->m_pkthdr.len;
 		m0->m_pkthdr.len = len0;
 		if (m->m_flags & M_EXT)
 			goto extpacket;
 		if (remain > MHLEN) {
 			/* m can't be the lead packet */
 			MH_ALIGN(n, 0);
 			n->m_len = 0;
 			n->m_next = m_split(m, len, wait);
 			if (n->m_next == 0) {
 				(void) m_free(n);
 				m0->m_pkthdr.len = len_save;
 				return (NULL);
 			} else
 				return (n);
 		} else
 			MH_ALIGN(n, remain);
 	} else if (remain == 0) {
 		n = m->m_next;
 		m->m_next = 0;
 		return (n);
 	} else {
 		MGET(n, wait, m->m_type);
 		if (n == 0)
 			return (NULL);
 		MCLAIM(n, m->m_owner);
 		M_ALIGN(n, remain);
+	}
 extpacket:
 	if (m->m_flags & M_EXT) {
 		n->m_data = m->m_data + len;
 		MCLADDREFERENCE(m, n);
 	} else {
 		memcpy(mtod(n, void *), mtod(m, char *) + len, remain);

 @@ -1,1087 +1,1085 @@
-/*	$NetBSD: uipc_syscalls.c,v 1.145 2011/07/15 14:50:19 christos Exp $	*/
+/*	$NetBSD: uipc_syscalls.c,v 1.146 2011/07/27 14:35:34 uebayasi Exp $	*/
 /*-
  * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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) 1982, 1986, 1989, 1990, 1993
  *	The Regents of the University of California.  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. 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.
+ *
  *	@(#)uipc_syscalls.c	8.6 (Berkeley) 2/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uipc_syscalls.c,v 1.145 2011/07/15 14:50:19 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uipc_syscalls.c,v 1.146 2011/07/27 14:35:34 uebayasi Exp $");
 #include "opt_pipe.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/filedesc.h>
 #include <sys/proc.h>
 #include <sys/file.h>
 #include <sys/buf.h>
 #include <sys/mbuf.h>
 #include <sys/protosw.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/signalvar.h>
 #include <sys/un.h>
 #include <sys/ktrace.h>
 #include <sys/event.h>
 #include <sys/kauth.h>
 #include <sys/mount.h>
 #include <sys/syscallargs.h>
 #include <uvm/uvm_extern.h>
 /*
  * System call interface to the socket abstraction.
  */
 extern const struct fileops socketops;
 int
 sys___socket30(struct lwp *l, const struct sys___socket30_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)	domain;
 		syscallarg(int)	type;
 		syscallarg(int)	protocol;
 	} */
 	int		fd, error;
 	error = fsocreate(SCARG(uap, domain), NULL, SCARG(uap, type),
 			 SCARG(uap, protocol), l, &fd);
 	if (error == 0)
 		*retval = fd;
 	return error;
+}
 /* ARGSUSED */
 int
 sys_bind(struct lwp *l, const struct sys_bind_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)				s;
 		syscallarg(const struct sockaddr *)	name;
 		syscallarg(unsigned int)		namelen;
 	} */
 	struct mbuf	*nam;
 	int		error;
 	error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen),
 	    MT_SONAME);
 	if (error)
 		return error;
 	return do_sys_bind(l, SCARG(uap, s), nam);
+}
 int
 do_sys_bind(struct lwp *l, int fd, struct mbuf *nam)
+{
 	struct socket	*so;
 	int		error;
 	if ((error = fd_getsock(fd, &so)) != 0) {
 		m_freem(nam);
 		return (error);
+	}
 	MCLAIM(nam, so->so_mowner);
 	error = sobind(so, nam, l);
 	m_freem(nam);
 	fd_putfile(fd);
 	return error;
+}
 /* ARGSUSED */
 int
 sys_listen(struct lwp *l, const struct sys_listen_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)	s;
 		syscallarg(int)	backlog;
 	} */
 	struct socket	*so;
 	int		error;
 	if ((error = fd_getsock(SCARG(uap, s), &so)) != 0)
 		return (error);
 	error = solisten(so, SCARG(uap, backlog), l);
 	fd_putfile(SCARG(uap, s));
 	return error;
+}
 int
 do_sys_accept(struct lwp *l, int sock, struct mbuf **name, register_t *new_sock,
     const sigset_t *mask, int flags, int clrflags)
+{
 	file_t		*fp, *fp2;
 	struct mbuf	*nam;
 	int		error, fd;
 	struct socket	*so, *so2;
 	short		wakeup_state = 0;
 	if ((fp = fd_getfile(sock)) == NULL)
 		return (EBADF);
 	if (fp->f_type != DTYPE_SOCKET) {
 		fd_putfile(sock);
 		return (ENOTSOCK);
+	}
 	if ((error = fd_allocfile(&fp2, &fd)) != 0) {
 		fd_putfile(sock);
 		return (error);
+	}
 	nam = m_get(M_WAIT, MT_SONAME);
 	*new_sock = fd;
 	so = fp->f_data;
 	solock(so);
 	if (__predict_false(mask))
 		sigsuspendsetup(l, mask);
 	if (!(so->so_proto->pr_flags & PR_LISTEN)) {
 		error = EOPNOTSUPP;
 		goto bad;
+	}
 	if ((so->so_options & SO_ACCEPTCONN) == 0) {
 		error = EINVAL;
 		goto bad;
+	}
 	if (so->so_nbio && so->so_qlen == 0) {
 		error = EWOULDBLOCK;
 		goto bad;
+	}
 	while (so->so_qlen == 0 && so->so_error == 0) {
 		if (so->so_state & SS_CANTRCVMORE) {
 			so->so_error = ECONNABORTED;
 			break;
+		}
 		if (wakeup_state & SS_RESTARTSYS) {
 			error = ERESTART;
 			goto bad;
+		}
 		error = sowait(so, true, 0);
 		if (error) {
 			goto bad;
+		}
 		wakeup_state = so->so_state;
+	}
 	if (so->so_error) {
 		error = so->so_error;
 		so->so_error = 0;
 		goto bad;
+	}
 	/* connection has been removed from the listen queue */
 	KNOTE(&so->so_rcv.sb_sel.sel_klist, NOTE_SUBMIT);
 	so2 = TAILQ_FIRST(&so->so_q);
 	if (soqremque(so2, 1) == 0)
 		panic("accept");
 	fp2->f_type = DTYPE_SOCKET;
 	fp2->f_flag = (fp->f_flag & ~clrflags) |
 	    ((flags & SOCK_NONBLOCK) ? FNONBLOCK : 0);
 	fp2->f_ops = &socketops;
 	fp2->f_data = so2;
 	error = soaccept(so2, nam);
 	so2->so_cred = kauth_cred_dup(so->so_cred);
 	sounlock(so);
 	if (error) {
 		/* an error occurred, free the file descriptor and mbuf */
 		m_freem(nam);
 		mutex_enter(&fp2->f_lock);
 		fp2->f_count++;
 		mutex_exit(&fp2->f_lock);
 		closef(fp2);
 		fd_abort(curproc, NULL, fd);
 	} else {
 		fd_set_exclose(l, fd, (flags & SOCK_CLOEXEC) != 0);
 		fd_affix(curproc, fp2, fd);
 		*name = nam;
+	}
 	fd_putfile(sock);
 	if (__predict_false(mask))
 		sigsuspendteardown(l);
 	return (error);
  bad:
  	sounlock(so);
  	m_freem(nam);
 	fd_putfile(sock);
  	fd_abort(curproc, fp2, fd);
 	if (__predict_false(mask))
 		sigsuspendteardown(l);
  	return (error);
+}
 int
 sys_accept(struct lwp *l, const struct sys_accept_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)			s;
 		syscallarg(struct sockaddr *)	name;
 		syscallarg(unsigned int *)	anamelen;
 	} */
 	int error, fd;
 	struct mbuf *name;
 	error = do_sys_accept(l, SCARG(uap, s), &name, retval, NULL, 0, 0);
 	if (error != 0)
 		return error;
 	error = copyout_sockname(SCARG(uap, name), SCARG(uap, anamelen),
 	    MSG_LENUSRSPACE, name);
 	if (name != NULL)
 		m_free(name);
 	if (error != 0) {
 		fd = (int)*retval;
 		if (fd_getfile(fd) != NULL)
 			(void)fd_close(fd);
+	}
 	return error;
+}
 int
 sys_paccept(struct lwp *l, const struct sys_paccept_args *uap,
     register_t *retval)
+{
 	/* {
 		syscallarg(int)			s;
 		syscallarg(struct sockaddr *)	name;
 		syscallarg(unsigned int *)	anamelen;
 		syscallarg(const sigset_t *)	mask;
 		syscallarg(int)			flags;
 	} */
 	int error, fd;
 	struct mbuf *name;
 	sigset_t *mask, amask;
 	if (SCARG(uap, mask) != NULL) {
 		error = copyin(SCARG(uap, mask), &amask, sizeof(amask));
 		if (error)
 			return error;
 		mask = &amask;
 	} else
 		mask = NULL;
 	error = do_sys_accept(l, SCARG(uap, s), &name, retval, mask,
 	    SCARG(uap, flags), FNONBLOCK);
 	if (error != 0)
 		return error;
 	error = copyout_sockname(SCARG(uap, name), SCARG(uap, anamelen),
 	    MSG_LENUSRSPACE, name);
 	if (name != NULL)
 		m_free(name);
 	if (error != 0) {
 		fd = (int)*retval;
 		if (fd_getfile(fd) != NULL)
 			(void)fd_close(fd);
+	}
 	return error;
+}
 /* ARGSUSED */
 int
 sys_connect(struct lwp *l, const struct sys_connect_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)				s;
 		syscallarg(const struct sockaddr *)	name;
 		syscallarg(unsigned int)		namelen;
 	} */
 	int		error;
 	struct mbuf	*nam;
 	error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen),
 	    MT_SONAME);
 	if (error)
 		return error;
 	return do_sys_connect(l,  SCARG(uap, s), nam);
+}
 int
 do_sys_connect(struct lwp *l, int fd, struct mbuf *nam)
+{
 	struct socket	*so;
 	int		error;
 	int		interrupted = 0;
 	if ((error = fd_getsock(fd, &so)) != 0) {
 		m_freem(nam);
 		return (error);
+	}
 	solock(so);
 	MCLAIM(nam, so->so_mowner);
 	if ((so->so_state & SS_ISCONNECTING) != 0) {
 		error = EALREADY;
 		goto out;
+	}
 	error = soconnect(so, nam, l);
 	if (error)
 		goto bad;
 	if (so->so_nbio && (so->so_state & SS_ISCONNECTING) != 0) {
 		error = EINPROGRESS;
 		goto out;
+	}
 	while ((so->so_state & SS_ISCONNECTING) != 0 && so->so_error == 0) {
 		error = sowait(so, true, 0);
 		if (__predict_false((so->so_state & SS_ISABORTING) != 0)) {
 			error = EPIPE;
 			interrupted = 1;
 			break;
+		}
 		if (error) {
 			if (error == EINTR || error == ERESTART)
 				interrupted = 1;
 			break;
+		}
+	}
 	if (error == 0) {
 		error = so->so_error;
 		so->so_error = 0;
+	}
  bad:
 	if (!interrupted)
 		so->so_state &= ~SS_ISCONNECTING;
 	if (error == ERESTART)
 		error = EINTR;
  out:
  	sounlock(so);
  	fd_putfile(fd);
 	m_freem(nam);
 	return (error);
+}
 int
 sys_socketpair(struct lwp *l, const struct sys_socketpair_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)		domain;
 		syscallarg(int)		type;
 		syscallarg(int)		protocol;
 		syscallarg(int *)	rsv;
 	} */
 	file_t		*fp1, *fp2;
 	struct socket	*so1, *so2;
 	int		fd, error, sv[2];
 	proc_t		*p;
 	int		flags = SCARG(uap, type) & SOCK_FLAGS_MASK;
 	int		type = SCARG(uap, type) & ~SOCK_FLAGS_MASK;
 	int		fnonblock = (flags & SOCK_NONBLOCK) ? FNONBLOCK : 0;
 	p = curproc;
 	error = socreate(SCARG(uap, domain), &so1, type,
 	    SCARG(uap, protocol), l, NULL);
 	if (error)
 		return (error);
 	error = socreate(SCARG(uap, domain), &so2, type,
 	    SCARG(uap, protocol), l, so1);
 	if (error)
 		goto free1;
 	if ((error = fd_allocfile(&fp1, &fd)) != 0)
 		goto free2;
 	fd_set_exclose(l, fd, (flags & SOCK_CLOEXEC) != 0);
 	sv[0] = fd;
 	fp1->f_flag = FREAD|FWRITE|fnonblock;
 	fp1->f_type = DTYPE_SOCKET;
 	fp1->f_ops = &socketops;
 	fp1->f_data = so1;
 	if ((error = fd_allocfile(&fp2, &fd)) != 0)
 		goto free3;
 	fd_set_exclose(l, fd, (flags & SOCK_CLOEXEC) != 0);
 	fp2->f_flag = FREAD|FWRITE|fnonblock;
 	fp2->f_type = DTYPE_SOCKET;
 	fp2->f_ops = &socketops;
 	fp2->f_data = so2;
 	sv[1] = fd;
 	solock(so1);
 	error = soconnect2(so1, so2);
 	if (error == 0 && SCARG(uap, type) == SOCK_DGRAM) {
 		/*
 		 * Datagram socket connection is asymmetric.
 		 */
 		error = soconnect2(so2, so1);
+	}
 	sounlock(so1);
 	if (error == 0)
 		error = copyout(sv, SCARG(uap, rsv), 2 * sizeof(int));
 	if (error == 0) {
 		fd_affix(p, fp2, sv[1]);
 		fd_affix(p, fp1, sv[0]);
 		return (0);
+	}
 	fd_abort(p, fp2, sv[1]);
  free3:
 	fd_abort(p, fp1, sv[0]);
  free2:
 	(void)soclose(so2);
  free1:
 	(void)soclose(so1);
 	return (error);
+}
 int
 sys_sendto(struct lwp *l, const struct sys_sendto_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)				s;
 		syscallarg(const void *)		buf;
 		syscallarg(size_t)			len;
 		syscallarg(int)				flags;
 		syscallarg(const struct sockaddr *)	to;
 		syscallarg(unsigned int)		tolen;
 	} */
 	struct msghdr	msg;
 	struct iovec	aiov;
 	msg.msg_name = __UNCONST(SCARG(uap, to)); /* XXXUNCONST kills const */
 	msg.msg_namelen = SCARG(uap, tolen);
 	msg.msg_iov = &aiov;
 	msg.msg_iovlen = 1;
 	msg.msg_control = NULL;
 	msg.msg_flags = 0;
 	aiov.iov_base = __UNCONST(SCARG(uap, buf)); /* XXXUNCONST kills const */
 	aiov.iov_len = SCARG(uap, len);
 	return do_sys_sendmsg(l, SCARG(uap, s), &msg, SCARG(uap, flags), retval);
+}
 int
 sys_sendmsg(struct lwp *l, const struct sys_sendmsg_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)				s;
 		syscallarg(const struct msghdr *)	msg;
 		syscallarg(int)				flags;
 	} */
 	struct msghdr	msg;
 	int		error;
 	error = copyin(SCARG(uap, msg), &msg, sizeof(msg));
 	if (error)
 		return (error);
 	msg.msg_flags = MSG_IOVUSRSPACE;
 	return do_sys_sendmsg(l, SCARG(uap, s), &msg, SCARG(uap, flags), retval);
+}
 int
 do_sys_sendmsg(struct lwp *l, int s, struct msghdr *mp, int flags,
 		register_t *retsize)
+{
 	struct iovec	aiov[UIO_SMALLIOV], *iov = aiov, *tiov, *ktriov = NULL;
 	struct mbuf	*to, *control;
 	struct socket	*so;
 	struct uio	auio;
 	size_t		len, iovsz;
 	int		i, error;
 	ktrkuser("msghdr", mp, sizeof *mp);
 	/* If the caller passed us stuff in mbufs, we must free them. */
 	to = (mp->msg_flags & MSG_NAMEMBUF) ? mp->msg_name : NULL;
 	control = (mp->msg_flags & MSG_CONTROLMBUF) ? mp->msg_control : NULL;
 	iovsz = mp->msg_iovlen * sizeof(struct iovec);
 	if (mp->msg_flags & MSG_IOVUSRSPACE) {
 		if ((unsigned int)mp->msg_iovlen > UIO_SMALLIOV) {
 			if ((unsigned int)mp->msg_iovlen > IOV_MAX) {
 				error = EMSGSIZE;
 				goto bad;
+			}
 			iov = kmem_alloc(iovsz, KM_SLEEP);
+		}
 		if (mp->msg_iovlen != 0) {
 			error = copyin(mp->msg_iov, iov, iovsz);
 			if (error)
 				goto bad;
+		}
 		mp->msg_iov = iov;
+	}
 	auio.uio_iov = mp->msg_iov;
 	auio.uio_iovcnt = mp->msg_iovlen;
 	auio.uio_rw = UIO_WRITE;
 	auio.uio_offset = 0;			/* XXX */
 	auio.uio_resid = 0;
 	KASSERT(l == curlwp);
 	auio.uio_vmspace = l->l_proc->p_vmspace;
 	for (i = 0, tiov = mp->msg_iov; i < mp->msg_iovlen; i++, tiov++) {
 		/*
 		 * Writes return ssize_t because -1 is returned on error.
 		 * Therefore, we must restrict the length to SSIZE_MAX to
 		 * avoid garbage return values.
 		 */
 		auio.uio_resid += tiov->iov_len;
 		if (tiov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
 			error = EINVAL;
 			goto bad;
+		}
+	}
 	if (mp->msg_name && to == NULL) {
 		error = sockargs(&to, mp->msg_name, mp->msg_namelen,
 		    MT_SONAME);
 		if (error)
 			goto bad;
+	}
 	if (mp->msg_control) {
 		if (mp->msg_controllen < CMSG_ALIGN(sizeof(struct cmsghdr))) {
 			error = EINVAL;
 			goto bad;
+		}
 		if (control == NULL) {
 			error = sockargs(&control, mp->msg_control,
 			    mp->msg_controllen, MT_CONTROL);
 			if (error)
 				goto bad;
+		}
+	}
 	if (ktrpoint(KTR_GENIO)) {
 		ktriov = kmem_alloc(iovsz, KM_SLEEP);
 		memcpy(ktriov, auio.uio_iov, iovsz);
+	}
 	if ((error = fd_getsock(s, &so)) != 0)
 		goto bad;
 	if (mp->msg_name)
 		MCLAIM(to, so->so_mowner);
 	if (mp->msg_control)
 		MCLAIM(control, so->so_mowner);
 	len = auio.uio_resid;
 	error = (*so->so_send)(so, to, &auio, NULL, control, flags, l);
 	/* Protocol is responsible for freeing 'control' */
 	control = NULL;
 	fd_putfile(s);
 	if (error) {
 		if (auio.uio_resid != len && (error == ERESTART ||
 		    error == EINTR || error == EWOULDBLOCK))
 			error = 0;
 		if (error == EPIPE && (flags & MSG_NOSIGNAL) == 0) {
 			mutex_enter(proc_lock);
 			psignal(l->l_proc, SIGPIPE);
 			mutex_exit(proc_lock);
+		}
+	}
 	if (error == 0)
 		*retsize = len - auio.uio_resid;
 bad:
 	if (ktriov != NULL) {
 		ktrgeniov(s, UIO_WRITE, ktriov, *retsize, error);
 		kmem_free(ktriov, iovsz);
+	}
  	if (iov != aiov)
  		kmem_free(iov, iovsz);
 	if (to)
 		m_freem(to);
 	if (control)
 		m_freem(control);
 	return (error);
+}
 int
 sys_recvfrom(struct lwp *l, const struct sys_recvfrom_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)			s;
 		syscallarg(void *)		buf;
 		syscallarg(size_t)		len;
 		syscallarg(int)			flags;
 		syscallarg(struct sockaddr *)	from;
 		syscallarg(unsigned int *)	fromlenaddr;
 	} */
 	struct msghdr	msg;
 	struct iovec	aiov;
 	int		error;
 	struct mbuf	*from;
 	msg.msg_name = NULL;
 	msg.msg_iov = &aiov;
 	msg.msg_iovlen = 1;
 	aiov.iov_base = SCARG(uap, buf);
 	aiov.iov_len = SCARG(uap, len);
 	msg.msg_control = NULL;
 	msg.msg_flags = SCARG(uap, flags) & MSG_USERFLAGS;
 	error = do_sys_recvmsg(l, SCARG(uap, s), &msg, &from, NULL, retval);
 	if (error != 0)
 		return error;
 	error = copyout_sockname(SCARG(uap, from), SCARG(uap, fromlenaddr),
 	    MSG_LENUSRSPACE, from);
 	if (from != NULL)
 		m_free(from);
 	return error;
+}
 int
 sys_recvmsg(struct lwp *l, const struct sys_recvmsg_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)			s;
 		syscallarg(struct msghdr *)	msg;
 		syscallarg(int)			flags;
 	} */
 	struct msghdr	msg;
 	int		error;
 	struct mbuf	*from, *control;
 	error = copyin(SCARG(uap, msg), &msg, sizeof(msg));
 	if (error)
 		return (error);
 	msg.msg_flags = (SCARG(uap, flags) & MSG_USERFLAGS) | MSG_IOVUSRSPACE;
 	error = do_sys_recvmsg(l, SCARG(uap, s), &msg, &from,
 	    msg.msg_control != NULL ? &control : NULL, retval);
 	if (error != 0)
 		return error;
 	if (msg.msg_control != NULL)
 		error = copyout_msg_control(l, &msg, control);
 	if (error == 0)
 		error = copyout_sockname(msg.msg_name, &msg.msg_namelen, 0,
 			from);
 	if (from != NULL)
 		m_free(from);
 	if (error == 0) {
 		ktrkuser("msghdr", &msg, sizeof msg);
 		error = copyout(&msg, SCARG(uap, msg), sizeof(msg));
+	}
 	return (error);
+}
 /*
  * Adjust for a truncated SCM_RIGHTS control message.
  *  This means closing any file descriptors that aren't present
  *  in the returned buffer.
  *  m is the mbuf holding the (already externalized) SCM_RIGHTS message.
  */
 static void
 free_rights(struct mbuf *m)
+{
 	int nfd;
 	int i;
 	int *fdv;
 	nfd = m->m_len < CMSG_SPACE(sizeof(int)) ? 0
 	    : (m->m_len - CMSG_SPACE(sizeof(int))) / sizeof(int) + 1;
 	fdv = (int *) CMSG_DATA(mtod(m,struct cmsghdr *));
 	for (i = 0; i < nfd; i++) {
 		if (fd_getfile(fdv[i]) != NULL)
 			(void)fd_close(fdv[i]);
+	}
+}
 void
 free_control_mbuf(struct lwp *l, struct mbuf *control, struct mbuf *uncopied)
+{
 	struct mbuf *next;
 	struct cmsghdr *cmsg;
 	bool do_free_rights = false;
 	while (control != NULL) {
 		cmsg = mtod(control, struct cmsghdr *);
 		if (control == uncopied)
 			do_free_rights = true;
 		if (do_free_rights && cmsg->cmsg_level == SOL_SOCKET
 		    && cmsg->cmsg_type == SCM_RIGHTS)
 			free_rights(control);
 		next = control->m_next;
 		m_free(control);
 		control = next;
+	}
+}
 /* Copy socket control/CMSG data to user buffer, frees the mbuf */
 int
 copyout_msg_control(struct lwp *l, struct msghdr *mp, struct mbuf *control)
+{
 	int i, len, error = 0;
 	struct cmsghdr *cmsg;
 	struct mbuf *m;
 	char *q;
 	len = mp->msg_controllen;
 	if (len <= 0 || control == 0) {
 		mp->msg_controllen = 0;
 		free_control_mbuf(l, control, control);
 		return 0;
+	}
 	q = (char *)mp->msg_control;
 	for (m = control; m != NULL; ) {
 		cmsg = mtod(m, struct cmsghdr *);
 		i = m->m_len;
 		if (len < i) {
 			mp->msg_flags |= MSG_CTRUNC;
 			if (cmsg->cmsg_level == SOL_SOCKET
 			    && cmsg->cmsg_type == SCM_RIGHTS)
 				/* Do not truncate me ... */
 				break;
 			i = len;
+		}
 		error = copyout(mtod(m, void *), q, i);
 		ktrkuser("msgcontrol", mtod(m, void *), i);
 		if (error != 0) {
 			/* We must free all the SCM_RIGHTS */
 			m = control;
 			break;
+		}
 		m = m->m_next;
 		if (m)
 			i = ALIGN(i);
 		q += i;
 		len -= i;
 		if (len <= 0)
 			break;
+	}
 	free_control_mbuf(l, control, m);
 	mp->msg_controllen = q - (char *)mp->msg_control;
 	return error;
+}
 int
 do_sys_recvmsg(struct lwp *l, int s, struct msghdr *mp, struct mbuf **from,
     struct mbuf **control, register_t *retsize)
+{
 	struct iovec	aiov[UIO_SMALLIOV], *iov = aiov, *tiov, *ktriov;
 	struct socket	*so;
 	struct uio	auio;
 	size_t		len, iovsz;
 	int		i, error;
 	ktrkuser("msghdr", mp, sizeof *mp);
 	*from = NULL;
 	if (control != NULL)
 		*control = NULL;
 	if ((error = fd_getsock(s, &so)) != 0)
 		return (error);
 	iovsz = mp->msg_iovlen * sizeof(struct iovec);
 	if (mp->msg_flags & MSG_IOVUSRSPACE) {
 		if ((unsigned int)mp->msg_iovlen > UIO_SMALLIOV) {
 			if ((unsigned int)mp->msg_iovlen > IOV_MAX) {
 				error = EMSGSIZE;
 				goto out;
+			}
 			iov = kmem_alloc(iovsz, KM_SLEEP);
+		}
 		if (mp->msg_iovlen != 0) {
 			error = copyin(mp->msg_iov, iov, iovsz);
 			if (error)
 				goto out;
+		}
 		auio.uio_iov = iov;
 	} else
 		auio.uio_iov = mp->msg_iov;
 	auio.uio_iovcnt = mp->msg_iovlen;
 	auio.uio_rw = UIO_READ;
 	auio.uio_offset = 0;			/* XXX */
 	auio.uio_resid = 0;
 	KASSERT(l == curlwp);
 	auio.uio_vmspace = l->l_proc->p_vmspace;
 	tiov = auio.uio_iov;
 	for (i = 0; i < mp->msg_iovlen; i++, tiov++) {
 		/*
 		 * Reads return ssize_t because -1 is returned on error.
 		 * Therefore we must restrict the length to SSIZE_MAX to
 		 * avoid garbage return values.
 		 */
 		auio.uio_resid += tiov->iov_len;
 		if (tiov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
 			error = EINVAL;
 			goto out;
+		}
+	}
 	ktriov = NULL;
 	if (ktrpoint(KTR_GENIO)) {
 		ktriov = kmem_alloc(iovsz, KM_SLEEP);
 		memcpy(ktriov, auio.uio_iov, iovsz);
+	}
 	len = auio.uio_resid;
 	mp->msg_flags &= MSG_USERFLAGS;
 	error = (*so->so_receive)(so, from, &auio, NULL, control,
 	    &mp->msg_flags);
 	len -= auio.uio_resid;
 	*retsize = len;
 	if (error != 0 && len != 0
 	    && (error == ERESTART || error == EINTR || error == EWOULDBLOCK))
 		/* Some data transferred */
 		error = 0;
 	if (ktriov != NULL) {
 		ktrgeniov(s, UIO_READ, ktriov, len, error);
 		kmem_free(ktriov, iovsz);
+	}
 	if (error != 0) {
 		m_freem(*from);
 		*from = NULL;
 		if (control != NULL) {
 			free_control_mbuf(l, *control, *control);
 			*control = NULL;
+		}
+	}
  out:
 	if (iov != aiov)
 		kmem_free(iov, iovsz);
 	fd_putfile(s);
 	return (error);
+}
 /* ARGSUSED */
 int
 sys_shutdown(struct lwp *l, const struct sys_shutdown_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)	s;
 		syscallarg(int)	how;
 	} */
 	struct socket	*so;
 	int		error;
 	if ((error = fd_getsock(SCARG(uap, s), &so)) != 0)
 		return (error);
 	solock(so);
 	error = soshutdown(so, SCARG(uap, how));
 	sounlock(so);
 	fd_putfile(SCARG(uap, s));
 	return (error);
+}
 /* ARGSUSED */
 int
 sys_setsockopt(struct lwp *l, const struct sys_setsockopt_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)			s;
 		syscallarg(int)			level;
 		syscallarg(int)			name;
 		syscallarg(const void *)	val;
 		syscallarg(unsigned int)	valsize;
 	} */
 	struct sockopt	sopt;
 	struct socket	*so;
 	int		error;
 	unsigned int	len;
 	len = SCARG(uap, valsize);
 	if (len > 0 && SCARG(uap, val) == NULL)
 		return (EINVAL);
 	if (len > MCLBYTES)
 		return (EINVAL);
 	if ((error = fd_getsock(SCARG(uap, s), &so)) != 0)
 		return (error);
 	sockopt_init(&sopt, SCARG(uap, level), SCARG(uap, name), len);
 	if (len > 0) {
 		error = copyin(SCARG(uap, val), sopt.sopt_data, len);
 		if (error)
 			goto out;
+	}
 	error = sosetopt(so, &sopt);
  out:
 	sockopt_destroy(&sopt);
  	fd_putfile(SCARG(uap, s));
 	return (error);
+}
 /* ARGSUSED */
 int
 sys_getsockopt(struct lwp *l, const struct sys_getsockopt_args *uap, register_t *retval)
+{
 	/* {
 		syscallarg(int)			s;
 		syscallarg(int)			level;
 		syscallarg(int)			name;
 		syscallarg(void *)		val;
 		syscallarg(unsigned int *)	avalsize;
 	} */
 	struct sockopt	sopt;
 	struct socket	*so;
 	unsigned int	valsize, len;
 	int		error;
 	if (SCARG(uap, val) != NULL) {
 		error = copyin(SCARG(uap, avalsize), &valsize, sizeof(valsize));
 		if (error)
 			return (error);
 	} else
 		valsize = 0;
 	if ((error = fd_getsock(SCARG(uap, s), &so)) != 0)
 		return (error);
 	sockopt_init(&sopt, SCARG(uap, level), SCARG(uap, name), 0);
 	error = sogetopt(so, &sopt);
 	if (error)
 		goto out;
 	if (valsize > 0) {
 		len = min(valsize, sopt.sopt_size);
 		error = copyout(sopt.sopt_data, SCARG(uap, val), len);
 		if (error)
 			goto out;
 		error = copyout(&len, SCARG(uap, avalsize), sizeof(len));
 		if (error)
 			goto out;
+	}
  out:
 	sockopt_destroy(&sopt);
  	fd_putfile(SCARG(uap, s));
 	return (error);
+}
 #ifdef PIPE_SOCKETPAIR
 /* ARGSUSED */
 int
 pipe1(struct lwp *l, register_t *retval, int flags)
+{
 	file_t		*rf, *wf;
 	struct socket	*rso, *wso;
 	int		fd, error;
 	proc_t		*p;
 	if (flags & ~(O_CLOEXEC|O_NONBLOCK))
 		return EINVAL;
 	p = curproc;
 	if ((error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, l, NULL)) != 0)
 		return (error);
 	if ((error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, l, rso)) != 0)
 		goto free1;
 	/* remember this socket pair implements a pipe */
 	wso->so_state |= SS_ISAPIPE;
 	rso->so_state |= SS_ISAPIPE;
 	if ((error = fd_allocfile(&rf, &fd)) != 0)
 		goto free2;
 	retval[0] = fd;
 	rf->f_flag = FREAD | flags;
 	rf->f_type = DTYPE_SOCKET;
 	rf->f_ops = &socketops;
 	rf->f_data = rso;
 	if ((error = fd_allocfile(&wf, &fd)) != 0)
 		goto free3;
 	wf->f_flag = FWRITE | flags;
 	wf->f_type = DTYPE_SOCKET;
 	wf->f_ops = &socketops;
 	wf->f_data = wso;
 	retval[1] = fd;
 	solock(wso);
 	error = unp_connect2(wso, rso, PRU_CONNECT2);
 	sounlock(wso);
 	if (error != 0)
 		goto free4;
 	fd_affix(p, wf, (int)retval[1]);
 	fd_affix(p, rf, (int)retval[0]);
 	return (0);
  free4:
 	fd_abort(p, wf, (int)retval[1]);
  free3:
 	fd_abort(p, rf, (int)retval[0]);
  free2:
 	(void)soclose(wso);
  free1:
 	(void)soclose(rso);
 	return (error);
+}
 #endif /* PIPE_SOCKETPAIR */
 /*
  * Get socket name.
  */
 /* ARGSUSED */
 int
 do_sys_getsockname(struct lwp *l, int fd, int which, struct mbuf **nam)
+{
 	struct socket	*so;
 	struct mbuf	*m;
 	int		error;
 	if ((error = fd_getsock(fd, &so)) != 0)
 		return error;
 	m = m_getclr(M_WAIT, MT_SONAME);
 	MCLAIM(m, so->so_mowner);
 	solock(so);
 	if (which == PRU_PEERADDR
 	    && (so->so_state & (SS_ISCONNECTED | SS_ISCONFIRMING)) == 0) {