 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_lock.c,v 1.134 2008/01/30 14:54:26 ad Exp $	*/
+/*	$NetBSD: kern_lock.c,v 1.135 2008/03/17 08:27:50 yamt Exp $	*/
 /*-
  * Copyright (c) 2002, 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, 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
 @@ -28,65 +28,83 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_lock.c,v 1.134 2008/01/30 14:54:26 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_lock.c,v 1.135 2008/03/17 08:27:50 yamt Exp $");
 #include "opt_multiprocessor.h"
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/lock.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/lockdebug.h>
 #include <sys/cpu.h>
 #include <sys/syslog.h>
 #include <sys/atomic.h>
 #include <machine/stdarg.h>
 #include <machine/lock.h>
 #include <dev/lockstat.h>
 #define	RETURN_ADDRESS	(uintptr_t)__builtin_return_address(0)
 bool	kernel_lock_dodebug;
 __cpu_simple_lock_t kernel_lock[CACHE_LINE_SIZE / sizeof(__cpu_simple_lock_t)]
     __aligned(CACHE_LINE_SIZE);
-#if defined(LOCKDEBUG)
+#if defined(DEBUG) || defined(LKM)
 void
-assert_sleepable(struct simplelock *interlock, const char *msg)
+assert_sleepable(void)
+{
 #if !defined(_RUMPKERNEL)
 	const char *reason;
-	if (panicstr != NULL)
+	if (panicstr != NULL) {
 		return;
+	}
 	LOCKDEBUG_BARRIER(kernel_lock, 1);
 	reason = NULL;
 	if (CURCPU_IDLE_P() && !cold) {
-		panic("assert_sleepable: idle");
+		reason = "idle";
+	}
 	if (cpu_intr_p()) {
 		reason = "interrupt";
+	}
 	if ((curlwp->l_pflag & LP_INTR) != 0) {
 		reason = "softint";
+	}
 	if (reason) {
 		panic("%s: %s caller=%p", __func__, reason,
 		    (void *)RETURN_ADDRESS);
+	}
 #endif /* !defined(_RUMPKERNEL) */
+}
-#endif
+#endif /* defined(DEBUG) || defined(LKM) */
 /*
  * rump doesn't need the kernel lock so force it out.  We cannot
  * currently easily include it for compilation because of
  * a) SPINLOCK_* b) membar_producer().  They are defined in different
  * places / way for each arch, so just simply do not bother to
  * fight a lot for no gain (i.e. pain but still no gain).
  */
 #ifndef _RUMPKERNEL
 /*
  * Functions for manipulating the kernel_lock.  We put them here
  * so that they show up in profiles.
  */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_malloc.c,v 1.117 2008/01/03 01:21:08 yamt Exp $	*/
+/*	$NetBSD: kern_malloc.c,v 1.118 2008/03/17 08:27:50 yamt Exp $	*/
 /*
  * Copyright (c) 1987, 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.
 @@ -56,27 +56,27 @@
  * 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_malloc.c	8.4 (Berkeley) 5/20/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_malloc.c,v 1.117 2008/01/03 01:21:08 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_malloc.c,v 1.118 2008/03/17 08:27:50 yamt Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/systm.h>
 #include <sys/debug.h>
 #include <sys/mutex.h>
 #include <sys/lockdebug.h>
 #include <uvm/uvm_extern.h>
 static struct vm_map_kernel kmem_map_store;
 @@ -318,27 +318,27 @@ malloc(unsigned long size, struct malloc
+{
 	struct kmembuckets *kbp;
 	struct kmemusage *kup;
 	struct freelist *freep;
 	long indx, npg, allocsize;
 	char *va, *cp, *savedlist;
 #ifdef DIAGNOSTIC
 	uint32_t *end, *lp;
 	int copysize;
 #endif
 #ifdef LOCKDEBUG
 	if ((flags & M_NOWAIT) == 0)
-		ASSERT_SLEEPABLE(NULL, "malloc");
+		ASSERT_SLEEPABLE();
 #endif
 #ifdef MALLOC_DEBUG
 	if (debug_malloc(size, ksp, flags, (void *) &va)) {
 		if (va != 0)
 			FREECHECK_OUT(&malloc_freecheck, (void *)va);
 		return ((void *) va);
+	}
 #endif
 	indx = BUCKETINDX(size);
 	kbp = &kmembuckets[indx];
 	mutex_spin_enter(&malloc_lock);
 #ifdef KMEMSTATS
 	while (ksp->ks_memuse >= ksp->ks_limit) {
 @@ -679,27 +679,27 @@ realloc(void *curaddr, unsigned long new
 	if (curaddr == NULL)
 		return (malloc(newsize, ksp, flags));
 	/*
 	 * realloc() with zero size is the same as free().
 	 */
 	if (newsize == 0) {
 		free(curaddr, ksp);
 		return (NULL);
+	}
 #ifdef LOCKDEBUG
 	if ((flags & M_NOWAIT) == 0)
-		ASSERT_SLEEPABLE(NULL, "realloc");
+		ASSERT_SLEEPABLE();
 #endif
 	/*
 	 * Find out how large the old allocation was (and do some
 	 * sanity checking).
 	 */
 	kup = btokup(curaddr);
 	cursize = 1 << kup->ku_indx;
 #ifdef DIAGNOSTIC
 	/*
 	 * Check for returns of data that do not point to the
 	 * beginning of the allocation.

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_subr.c,v 1.182 2008/02/28 14:25:12 drochner Exp $	*/
+/*	$NetBSD: kern_subr.c,v 1.183 2008/03/17 08:27:50 yamt Exp $	*/
 /*-
  * Copyright (c) 1997, 1998, 1999, 2002, 2007, 2006 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
 @@ -76,27 +76,27 @@
  * 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.182 2008/02/28 14:25:12 drochner Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_subr.c,v 1.183 2008/03/17 08:27:50 yamt Exp $");
 #include "opt_ddb.h"
 #include "opt_md.h"
 #include "opt_syscall_debug.h"
 #include "opt_ktrace.h"
 #include "opt_ptrace.h"
 #include "opt_powerhook.h"
 #include "opt_tftproot.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/malloc.h>
 @@ -150,27 +150,27 @@ uio_setup_sysspace(struct uio *uio)
 	uio->uio_vmspace = vmspace_kernel();
+}
 int
 uiomove(void *buf, size_t n, struct uio *uio)
+{
 	struct vmspace *vm = uio->uio_vmspace;
 	struct iovec *iov;
 	size_t cnt;
 	int error = 0;
 	char *cp = buf;
-	ASSERT_SLEEPABLE(NULL, "uiomove");
+	ASSERT_SLEEPABLE();
 #ifdef DIAGNOSTIC
 	if (uio->uio_rw != UIO_READ && uio->uio_rw != UIO_WRITE)
 		panic("uiomove: mode");
 #endif
 	while (n > 0 && uio->uio_resid) {
 		iov = uio->uio_iov;
 		cnt = iov->iov_len;
 		if (cnt == 0) {
 			KASSERT(uio->uio_iovcnt > 0);
 			uio->uio_iov++;
 			uio->uio_iovcnt--;
 			continue;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_extent.c,v 1.69 2007/12/05 07:06:54 ad Exp $	*/
+/*	$NetBSD: subr_extent.c,v 1.70 2008/03/17 08:27:50 yamt Exp $	*/
 /*-
  * Copyright (c) 1996, 1998, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe and Matthias Drochner.
+ *
  * 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.
 @@ -31,27 +31,27 @@
  * 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.
  */
 /*
  * General purpose extent manager.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_extent.c,v 1.69 2007/12/05 07:06:54 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_extent.c,v 1.70 2008/03/17 08:27:50 yamt Exp $");
 #ifdef _KERNEL
 #include "opt_lockdebug.h"
 #include <sys/param.h>
 #include <sys/extent.h>
 #include <sys/malloc.h>
 #include <sys/pool.h>
 #include <sys/time.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <uvm/uvm_extern.h>
 @@ -479,27 +479,27 @@ extent_alloc_region(struct extent *ex, u
 		printf("extent_alloc_region: extent `%s', size 0x%lx\n",
 		    ex->ex_name, size);
 		panic("extent_alloc_region: bad size");
+	}
 	if (end < start) {
 		printf(
 		 "extent_alloc_region: extent `%s', start 0x%lx, size 0x%lx\n",
 		 ex->ex_name, start, size);
 		panic("extent_alloc_region: overflow");
+	}
 #endif
 #ifdef LOCKDEBUG
 	if (flags & EX_WAITSPACE)
-		ASSERT_SLEEPABLE(NULL, "extent_alloc_region(EX_WAITSPACE)");
+		ASSERT_SLEEPABLE();
 #endif
 	/*
 	 * Make sure the requested region lies within the
 	 * extent.
+	 *
 	 * We don't lock to check the range, because those values
 	 * are never modified, and if another thread deletes the
 	 * extent, we're screwed anyway.
 	 */
 	if ((start < ex->ex_start) || (end > ex->ex_end)) {
 #ifdef DIAGNOSTIC
 		printf("extent_alloc_region: extent `%s' (0x%lx - 0x%lx)\n",
 @@ -651,27 +651,27 @@ extent_alloc_subregion1(struct extent *e
 		panic("extent_alloc_subregion: bad size");
+	}
 	if (alignment == 0)
 		panic("extent_alloc_subregion: bad alignment");
 	if (boundary && (boundary < size)) {
 		printf(
 		    "extent_alloc_subregion: extent `%s', size 0x%lx, "
 		    "boundary 0x%lx\n", ex->ex_name, size, boundary);
 		panic("extent_alloc_subregion: bad boundary");
+	}
 #endif
 #ifdef LOCKDEBUG
 	if (flags & EX_WAITSPACE)
-		ASSERT_SLEEPABLE(NULL, "extent_alloc_subregion1(EX_WAITSPACE)");
+		ASSERT_SLEEPABLE();
 #endif
 	/*
 	 * Allocate the region descriptor.  It will be freed later
 	 * if we can coalesce with another region.  Don't lock before
 	 * here!  This could block.
 	 */
 	myrp = extent_alloc_region_descriptor(ex, flags);
 	if (myrp == NULL) {
 #ifdef DIAGNOSTIC
 		printf(
 		 "extent_alloc_subregion: can't allocate region descriptor\n");
 #endif

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_percpu.c,v 1.2 2008/01/17 09:01:57 yamt Exp $	*/
+/*	$NetBSD: subr_percpu.c,v 1.3 2008/03/17 08:27:50 yamt 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.
 @@ -21,27 +21,27 @@
  * 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.2 2008/01/17 09:01:57 yamt Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_percpu.c,v 1.3 2008/03/17 08:27:50 yamt 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>
 @@ -149,27 +149,27 @@ percpu_cpu_enlarge(size_t 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(NULL, __func__);
+	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);
 @@ -194,87 +194,87 @@ 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(NULL, __func__);
+	ASSERT_SLEEPABLE();
 	rw_init(&percpu_swap_lock);
 	mutex_init(&percpu_allocation_lock, MUTEX_DEFAULT, IPL_NONE);
 	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(NULL, __func__);
+	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(NULL, __func__);
+	ASSERT_SLEEPABLE();
 	offset = vmem_alloc(percpu_offset_arena, size, VM_SLEEP | VM_BESTFIT);
 	pc = (percpu_t *)(uintptr_t)offset;
 	percpu_zero(pc, size);
 	return pc;
+}
 /*
  * percpu_alloc: 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(NULL, __func__);
+	ASSERT_SLEEPABLE();
 	vmem_free(percpu_offset_arena, (vmem_addr_t)percpu_offset(pc), size);
+}
 /*
  * percpu_getptr:
+ *
  * => called with preemption disabled
  * => safe to be used in either thread or interrupt context
  */
 void *
 percpu_getptr(percpu_t *pc)
+{
 @@ -293,27 +293,27 @@ percpu_getptr(percpu_t *pc)
  *	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(NULL, __func__);
+	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)
+{

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_pool.c,v 1.153 2008/03/10 22:20:14 martin Exp $	*/
+/*	$NetBSD: subr_pool.c,v 1.154 2008/03/17 08:27:50 yamt Exp $	*/
 /*-
  * Copyright (c) 1997, 1999, 2000, 2002, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Paul Kranenburg; by Jason R. Thorpe of the Numerical Aerospace
  * Simulation Facility, NASA Ames Research Center, 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
 @@ -28,27 +28,27 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_pool.c,v 1.153 2008/03/10 22:20:14 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_pool.c,v 1.154 2008/03/17 08:27:50 yamt Exp $");
 #include "opt_ddb.h"
 #include "opt_pool.h"
 #include "opt_poollog.h"
 #include "opt_lockdebug.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/bitops.h>
 #include <sys/proc.h>
 #include <sys/errno.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 @@ -986,27 +986,27 @@ pool_get(struct pool *pp, int flags)
 	void *v;
 #ifdef DIAGNOSTIC
 	if (__predict_false(pp->pr_itemsperpage == 0))
 		panic("pool_get: pool %p: pr_itemsperpage is zero, "
 		    "pool not initialized?", pp);
 	if (__predict_false(curlwp == NULL && doing_shutdown == 0 &&
 			    (flags & PR_WAITOK) != 0))
 		panic("pool_get: %s: must have NOWAIT", pp->pr_wchan);
 #endif /* DIAGNOSTIC */
 #ifdef LOCKDEBUG
 	if (flags & PR_WAITOK)
-		ASSERT_SLEEPABLE(NULL, "pool_get(PR_WAITOK)");
+		ASSERT_SLEEPABLE();
 #endif
 	mutex_enter(&pp->pr_lock);
 	pr_enter(pp, file, line);
  startover:
 	/*
 	 * Check to see if we've reached the hard limit.  If we have,
 	 * and we can wait, then wait until an item has been returned to
 	 * the pool.
 	 */
 #ifdef DIAGNOSTIC
 	if (__predict_false(pp->pr_nout > pp->pr_hardlimit)) {
 @@ -2512,27 +2512,27 @@ pool_cache_get_slow(pool_cache_cpu_t *cc
  *	Get an object from a pool cache (optionally returning
  *	the physical address of the object).
  */
 void *
 pool_cache_get_paddr(pool_cache_t pc, int flags, paddr_t *pap)
+{
 	pool_cache_cpu_t *cc;
 	pcg_t *pcg;
 	void *object;
 	int s;
 #ifdef LOCKDEBUG
 	if (flags & PR_WAITOK)
-		ASSERT_SLEEPABLE(NULL, "pool_cache_get(PR_WAITOK)");
+		ASSERT_SLEEPABLE();
 #endif
 	cc = pool_cache_cpu_enter(pc, &s);
 	do {
 		/* Try and allocate an object from the current group. */
 	 	pcg = cc->cc_current;
 		if (pcg != NULL && pcg->pcg_avail > 0) {
 			object = pcg->pcg_objects[--pcg->pcg_avail].pcgo_va;
 			if (pap != NULL)
 				*pap = pcg->pcg_objects[pcg->pcg_avail].pcgo_pa;
 #if defined(DIAGNOSTIC)
 			pcg->pcg_objects[pcg->pcg_avail].pcgo_va = NULL;
 #endif /* defined(DIAGNOSTIC) */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_specificdata.c,v 1.11 2007/11/07 00:23:23 ad Exp $	*/
+/*	$NetBSD: subr_specificdata.c,v 1.12 2008/03/17 08:27:50 yamt Exp $	*/
 /*-
  * Copyright (c) 2006, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe.
+ *
  * 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.
 @@ -53,31 +53,30 @@
  * 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_specificdata.c,v 1.11 2007/11/07 00:23:23 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_specificdata.c,v 1.12 2008/03/17 08:27:50 yamt Exp $");
 #include <sys/param.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/specificdata.h>
 #include <sys/queue.h>
 #include <sys/mutex.h>
 /*
  * Locking notes:
+ *
  * The specdataref_container pointer in the specificdata_reference
  * is volatile.  To read it, you must hold EITHER the domain lock
  * or the ref lock.  To write it, you must hold BOTH the domain lock
  * and the ref lock.  The locks must be acquired in the following
  * order:
  *	domain -> ref
 @@ -183,27 +182,27 @@ specificdata_domain_delete(specificdata_
  * specificdata_key_create --
  *	Create a specificdata key for a domain.
+ *
  *	Note: This is a rare operation.
  */
 int
 specificdata_key_create(specificdata_domain_t sd, specificdata_key_t *keyp,
 			specificdata_dtor_t dtor)
+{
 	specificdata_key_impl *newkeys;
 	specificdata_key_t key = 0;
 	size_t nsz;
-	ASSERT_SLEEPABLE(NULL, __func__);
+	ASSERT_SLEEPABLE();
 	if (dtor == NULL)
 		dtor = specificdata_noop_dtor;
 	mutex_enter(&sd->sd_lock);
 	if (sd->sd_keys == NULL)
 		goto needalloc;
 	for (; key < sd->sd_nkey; key++) {
 		if (sd->sd_keys[key].ski_dtor == NULL)
 			goto gotit;
+	}
 @@ -279,27 +278,27 @@ specificdata_init(specificdata_domain_t
+}
 /*
  * specificdata_fini --
  *	Destroy a specificdata container.  We destroy all of the datums
  *	stuffed into the container just as if the key were destroyed.
  */
 void
 specificdata_fini(specificdata_domain_t sd, specificdata_reference *ref)
+{
 	specificdata_container_t sc;
 	specificdata_key_t key;
-	ASSERT_SLEEPABLE(NULL, __func__);
+	ASSERT_SLEEPABLE();
 	mutex_destroy(&ref->specdataref_lock);
 	sc = ref->specdataref_container;
 	if (sc == NULL)
 		return;
 	ref->specdataref_container = NULL;
 	mutex_enter(&sd->sd_lock);
 	specificdata_container_unlink(sd, sc);
 	for (key = 0; key < sc->sc_nkey; key++) {
 		specificdata_destroy_datum(sd, sc, key);
 @@ -357,27 +356,27 @@ specificdata_getspecific_unlocked(specif
 /*
  * specificdata_setspecific --
  *      Put a datum into a container.
  */
 void
 specificdata_setspecific(specificdata_domain_t sd,
 			 specificdata_reference *ref,
 			 specificdata_key_t key, void *data)
+{
 	specificdata_container_t sc, newsc;
 	size_t newnkey, sz;
-	ASSERT_SLEEPABLE(NULL, __func__);
+	ASSERT_SLEEPABLE();
 	mutex_enter(&ref->specdataref_lock);
 	sc = ref->specdataref_container;
 	if (__predict_true(sc != NULL && key < sc->sc_nkey)) {
 		sc->sc_data[key] = data;
 		mutex_exit(&ref->specdataref_lock);
 		return;
+	}
 	mutex_exit(&ref->specdataref_lock);
 	/*

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_vmem.c,v 1.41 2008/01/24 13:57:52 ad Exp $	*/
+/*	$NetBSD: subr_vmem.c,v 1.42 2008/03/17 08:27:50 yamt Exp $	*/
 /*-
  * Copyright (c)2006 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.
 @@ -28,67 +28,66 @@
 /*
  * reference:
  * -	Magazines and Vmem: Extending the Slab Allocator
  *	to Many CPUs and Arbitrary Resources
  *	http://www.usenix.org/event/usenix01/bonwick.html
+ *
  * todo:
  * -	decide how to import segments for vmem_xalloc.
  * -	don't rely on malloc(9).
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_vmem.c,v 1.41 2008/01/24 13:57:52 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_vmem.c,v 1.42 2008/03/17 08:27:50 yamt Exp $");
 #define	VMEM_DEBUG
 #if defined(_KERNEL)
 #include "opt_ddb.h"
 #define	QCACHE
 #endif /* defined(_KERNEL) */
 #include <sys/param.h>
 #include <sys/hash.h>
 #include <sys/queue.h>
 #if defined(_KERNEL)
 #include <sys/systm.h>
 #include <sys/kernel.h>	/* hz */
 #include <sys/callout.h>
 #include <sys/malloc.h>
 #include <sys/once.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/vmem.h>
 #include <sys/workqueue.h>
 #else /* defined(_KERNEL) */
 #include "../sys/vmem.h"
 #endif /* defined(_KERNEL) */
 #if defined(_KERNEL)
 #define	LOCK_DECL(name)		kmutex_t name
 #else /* defined(_KERNEL) */
 #include <errno.h>
 #include <assert.h>
 #include <stdlib.h>
 #define	KASSERT(a)		assert(a)
 #define	LOCK_DECL(name)		/* nothing */
 #define	mutex_init(a, b, c)	/* nothing */
 #define	mutex_destroy(a)	/* nothing */
 #define	mutex_enter(a)		/* nothing */
 #define	mutex_exit(a)		/* nothing */
 #define	mutex_owned(a)		/* nothing */
-#define	ASSERT_SLEEPABLE(lk, msg) /* nothing */
+#define	ASSERT_SLEEPABLE()	 /* nothing */
 #define	IPL_VM			0
 #endif /* defined(_KERNEL) */
 struct vmem;
 struct vmem_btag;
 #if defined(VMEM_DEBUG)
 void vmem_dump(const vmem_t *);
 #endif /* defined(VMEM_DEBUG) */
 #define	VMEM_MAXORDER		(sizeof(vmem_size_t) * CHAR_BIT)
 #define	VMEM_HASHSIZE_MIN	1	/* XXX */
 @@ -847,27 +846,27 @@ vmem_roundup_size(vmem_t *vm, vmem_size_
  */
 vmem_addr_t
 vmem_alloc(vmem_t *vm, vmem_size_t size, vm_flag_t flags)
+{
 	const vm_flag_t strat __unused = flags & VM_FITMASK;
 	KASSERT((flags & (VM_SLEEP|VM_NOSLEEP)) != 0);
 	KASSERT((~flags & (VM_SLEEP|VM_NOSLEEP)) != 0);
 	KASSERT(size > 0);
 	KASSERT(strat == VM_BESTFIT || strat == VM_INSTANTFIT);
 	if ((flags & VM_SLEEP) != 0) {
-		ASSERT_SLEEPABLE(NULL, __func__);
+		ASSERT_SLEEPABLE();
+	}
 #if defined(QCACHE)
 	if (size <= vm->vm_qcache_max) {
 		int qidx = (size + vm->vm_quantum_mask) >> vm->vm_quantum_shift;
 		qcache_t *qc = vm->vm_qcache[qidx - 1];
 		return (vmem_addr_t)pool_cache_get(qc->qc_cache,
 		    vmf_to_prf(flags));
+	}
 #endif /* defined(QCACHE) */
 	return vmem_xalloc(vm, size, 0, 0, 0, 0, 0, flags);
 @@ -882,27 +881,27 @@ vmem_xalloc(vmem_t *vm, vmem_size_t size
 	struct vmem_freelist *first;
 	struct vmem_freelist *end;
 	bt_t *bt;
 	bt_t *btnew;
 	bt_t *btnew2;
 	const vmem_size_t size = vmem_roundup_size(vm, size0);
 	vm_flag_t strat = flags & VM_FITMASK;
 	vmem_addr_t start;
 	KASSERT(size0 > 0);
 	KASSERT(size > 0);
 	KASSERT(strat == VM_BESTFIT || strat == VM_INSTANTFIT);
 	if ((flags & VM_SLEEP) != 0) {
-		ASSERT_SLEEPABLE(NULL, __func__);
+		ASSERT_SLEEPABLE();
+	}
 	KASSERT((align & vm->vm_quantum_mask) == 0);
 	KASSERT((align & (align - 1)) == 0);
 	KASSERT((phase & vm->vm_quantum_mask) == 0);
 	KASSERT((nocross & vm->vm_quantum_mask) == 0);
 	KASSERT((nocross & (nocross - 1)) == 0);
 	KASSERT((align == 0 && phase == 0) || phase < align);
 	KASSERT(nocross == 0 || nocross >= size);
 	KASSERT(maxaddr == 0 || minaddr < maxaddr);
 	KASSERT(!VMEM_CROSS_P(phase, phase + size - 1, nocross));
 	if (align == 0) {
 		align = vm->vm_quantum_mask + 1;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_trans.c,v 1.17 2008/02/02 16:51:34 hannken Exp $	*/
+/*	$NetBSD: vfs_trans.c,v 1.18 2008/03/17 08:27:50 yamt Exp $	*/
 /*-
  * Copyright (c) 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Juergen Hannken-Illjes.
+ *
  * 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.
 @@ -27,27 +27,27 @@
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_trans.c,v 1.17 2008/02/02 16:51:34 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_trans.c,v 1.18 2008/03/17 08:27:50 yamt Exp $");
 /*
  * File system transaction operations.
  */
 #include "opt_ddb.h"
 #if defined(DDB)
 #define _LWP_API_PRIVATE	/* Need _lwp_getspecific_by_lwp() */
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 @@ -167,27 +167,27 @@ fstrans_unmount(struct mount *mp)
  * file system increment the reference counter.
  * A thread with an exclusive transaction lock may get a shared or lazy one.
  * A thread with a shared or lazy transaction lock cannot upgrade to an
  * exclusive one yet.
  */
 int
 _fstrans_start(struct mount *mp, enum fstrans_lock_type lock_type, int wait)
+{
 	krwlock_t *lock_p;
 	krw_t lock_op;
 	struct fstrans_lwp_info *fli, *new_fli;
 	struct fstrans_mount_info *fmi;
-	ASSERT_SLEEPABLE(NULL, __func__);
+	ASSERT_SLEEPABLE();
 	if (mp == NULL || (mp->mnt_iflag & IMNT_HAS_TRANS) == 0)
 		return 0;
 	new_fli = NULL;
 	for (fli = lwp_getspecific(lwp_data_key); fli; fli = fli->fli_succ) {
 		if (fli->fli_mount == NULL && new_fli == NULL)
 			new_fli = fli;
 		if (fli->fli_mount == mp) {
 			KASSERT(fli->fli_count > 0);
 			if (fli->fli_lock_type != FSTRANS_EXCL &&
 			    lock_type == FSTRANS_EXCL)
 				panic("fstrans_start: cannot upgrade lock");

 @@ -1,14 +1,14 @@
-/*	$NetBSD: proc.h,v 1.270 2008/02/19 20:27:27 ad Exp $	*/
+/*	$NetBSD: proc.h,v 1.271 2008/03/17 08:27:50 yamt 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.
 @@ -569,33 +569,26 @@ _proclist_skipmarker(struct proc *p0)
+{
 	struct proc *p = p0;
 	while (p != NULL && p->p_flag & PK_MARKER)
 		p = LIST_NEXT(p, p_list);
 	return p;
+}
 #define	PROCLIST_FOREACH(var, head)					\
 	for ((var) = LIST_FIRST(head);					\
 		((var) = _proclist_skipmarker(var)) != NULL;		\
 		(var) = LIST_NEXT(var, p_list))
 #if defined(LOCKDEBUG)
 void assert_sleepable(struct simplelock *, const char *);
 #define	ASSERT_SLEEPABLE(lk, msg)	assert_sleepable((lk), (msg))
 #else /* defined(LOCKDEBUG) */
 #define	ASSERT_SLEEPABLE(lk, msg)	/* nothing */
 #endif /* defined(LOCKDEBUG) */
 /* Compatibility with old, non-interlocked tsleep call */
 #define	tsleep(chan, pri, wmesg, timo)					\
 	ltsleep(chan, pri, wmesg, timo, NULL)
 #ifdef KSTACK_CHECK_MAGIC
 void kstack_setup_magic(const struct lwp *);
 void kstack_check_magic(const struct lwp *);
 #endif
 /*
  * kernel stack paramaters
  * XXX require sizeof(struct user)
  */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: systm.h,v 1.214 2008/02/06 22:12:42 dsl Exp $	*/
+/*	$NetBSD: systm.h,v 1.215 2008/03/17 08:27:50 yamt Exp $	*/
 /*-
  * Copyright (c) 1982, 1988, 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:
 @@ -474,14 +474,21 @@ do {						\
 #else
 #define	KERNEL_LOCK(count, lwp)		/* nothing */
 #define	KERNEL_UNLOCK(all, lwp, ptr)	/* nothing */
 #endif
 #define	KERNEL_UNLOCK_LAST(l)		KERNEL_UNLOCK(-1, (l), NULL)
 #define	KERNEL_UNLOCK_ALL(l, p)		KERNEL_UNLOCK(0, (l), (p))
 #define	KERNEL_UNLOCK_ONE(l)		KERNEL_UNLOCK(1, (l), NULL)
 /* Preemption control. */
 void	crit_enter(void);
 void	crit_exit(void);
 void assert_sleepable(void);
 #if defined(DEBUG)
 #define	ASSERT_SLEEPABLE()	assert_sleepable()
 #else /* defined(DEBUG) */
 #define	ASSERT_SLEEPABLE()	/* nothing */
 #endif /* defined(DEBUG) */
 #endif	/* !_SYS_SYSTM_H_ */