Home | History | Annotate | Line # | Download | only in kern
subr_lockdebug.c revision 1.16 
      1 /*	$NetBSD: subr_lockdebug.c,v 1.16 2007/11/21 10:19:10 yamt Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2006, 2007 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Andrew Doran.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *	This product includes software developed by the NetBSD
     21  *	Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 
     39 /*
     40  * Basic lock debugging code shared among lock primitives.
     41  */
     42 
     43 #include <sys/cdefs.h>
     44 __KERNEL_RCSID(0, "$NetBSD: subr_lockdebug.c,v 1.16 2007/11/21 10:19:10 yamt Exp $");
     45 
     46 #include "opt_multiprocessor.h"
     47 #include "opt_ddb.h"
     48 
     49 #include <sys/param.h>
     50 #include <sys/proc.h>
     51 #include <sys/systm.h>
     52 #include <sys/kernel.h>
     53 #include <sys/kmem.h>
     54 #include <sys/lock.h>
     55 #include <sys/lockdebug.h>
     56 #include <sys/sleepq.h>
     57 #include <sys/cpu.h>
     58 
     59 #include <lib/libkern/rb.h>
     60 
     61 #ifdef LOCKDEBUG
     62 
     63 #define	LD_BATCH_SHIFT	9
     64 #define	LD_BATCH	(1 << LD_BATCH_SHIFT)
     65 #define	LD_BATCH_MASK	(LD_BATCH - 1)
     66 #define	LD_MAX_LOCKS	1048576
     67 #define	LD_SLOP		16
     68 
     69 #define	LD_LOCKED	0x01
     70 #define	LD_SLEEPER	0x02
     71 
     72 typedef union lockdebuglk {
     73 	struct {
     74 		__cpu_simple_lock_t	lku_lock;
     75 		int			lku_oldspl;
     76 	} ul;
     77 	uint8_t	lk_pad[64];
     78 } volatile __aligned(64) lockdebuglk_t;
     79 
     80 #define	lk_lock		ul.lku_lock
     81 #define	lk_oldspl	ul.lku_oldspl
     82 
     83 typedef struct lockdebug {
     84 	struct rb_node	ld_rb_node;	/* must be the first member */
     85 	_TAILQ_ENTRY(struct lockdebug, volatile) ld_chain;
     86 	_TAILQ_ENTRY(struct lockdebug, volatile) ld_achain;
     87 	volatile void	*ld_lock;
     88 	lockops_t	*ld_lockops;
     89 	struct lwp	*ld_lwp;
     90 	uintptr_t	ld_locked;
     91 	uintptr_t	ld_unlocked;
     92 	uintptr_t	ld_initaddr;
     93 	uint16_t	ld_shares;
     94 	uint16_t	ld_cpu;
     95 	uint8_t		ld_flags;
     96 	uint8_t		ld_shwant;	/* advisory */
     97 	uint8_t		ld_exwant;	/* advisory */
     98 	uint8_t		ld_unused;
     99 } volatile lockdebug_t;
    100 
    101 typedef _TAILQ_HEAD(lockdebuglist, struct lockdebug, volatile) lockdebuglist_t;
    102 
    103 lockdebuglk_t		ld_tree_lk;
    104 lockdebuglk_t		ld_sleeper_lk;
    105 lockdebuglk_t		ld_spinner_lk;
    106 lockdebuglk_t		ld_free_lk;
    107 
    108 lockdebuglist_t		ld_sleepers = TAILQ_HEAD_INITIALIZER(ld_sleepers);
    109 lockdebuglist_t		ld_spinners = TAILQ_HEAD_INITIALIZER(ld_spinners);
    110 lockdebuglist_t		ld_free = TAILQ_HEAD_INITIALIZER(ld_free);
    111 lockdebuglist_t		ld_all = TAILQ_HEAD_INITIALIZER(ld_all);
    112 int			ld_nfree;
    113 int			ld_freeptr;
    114 int			ld_recurse;
    115 bool			ld_nomore;
    116 lockdebug_t		*ld_table[LD_MAX_LOCKS / LD_BATCH];
    117 
    118 lockdebug_t		ld_prime[LD_BATCH];
    119 
    120 static void	lockdebug_abort1(lockdebug_t *, lockdebuglk_t *lk,
    121 				 const char *, const char *, bool);
    122 static void	lockdebug_more(void);
    123 static void	lockdebug_init(void);
    124 
    125 static signed int
    126 ld_rb_compare_nodes(const struct rb_node *n1, const struct rb_node *n2)
    127 {
    128 	const lockdebug_t *ld1 = (const void *)n1;
    129 	const lockdebug_t *ld2 = (const void *)n2;
    130 	intptr_t diff = (intptr_t)ld1->ld_lock - (intptr_t)ld2->ld_lock;
    131 	if (diff < 0)
    132 		return -1;
    133 	else if (diff > 0)
    134 		return 1;
    135 	return 0;
    136 }
    137 
    138 static signed int
    139 ld_rb_compare_key(const struct rb_node *n, const void *key)
    140 {
    141 	const lockdebug_t *ld = (const void *)n;
    142 	intptr_t diff = (intptr_t)ld->ld_lock - (intptr_t)key;
    143 	if (diff < 0)
    144 		return -1;
    145 	else if (diff > 0)
    146 		return 1;
    147 	return 0;
    148 }
    149 
    150 static struct rb_tree ld_rb_tree;
    151 
    152 static const struct rb_tree_ops ld_rb_tree_ops = {
    153 	.rb_compare_nodes = ld_rb_compare_nodes,
    154 	.rb_compare_key = ld_rb_compare_key,
    155 };
    156 
    157 static inline void
    158 lockdebug_lock(lockdebuglk_t *lk)
    159 {
    160 	int s;
    161 
    162 	s = splhigh();
    163 	__cpu_simple_lock(&lk->lk_lock);
    164 	lk->lk_oldspl = s;
    165 }
    166 
    167 static inline void
    168 lockdebug_unlock(lockdebuglk_t *lk)
    169 {
    170 	int s;
    171 
    172 	s = lk->lk_oldspl;
    173 	__cpu_simple_unlock(&(lk->lk_lock));
    174 	splx(s);
    175 }
    176 
    177 /*
    178  * lockdebug_lookup:
    179  *
    180  *	Find a lockdebug structure by a pointer to a lock and return it locked.
    181  */
    182 static inline lockdebug_t *
    183 lockdebug_lookup(volatile void *lock, lockdebuglk_t **lk)
    184 {
    185 	lockdebug_t *ld;
    186 
    187 	lockdebug_lock(&ld_tree_lk);
    188 	ld = (lockdebug_t *)rb_tree_find_node(&ld_rb_tree, __UNVOLATILE(lock));
    189 	lockdebug_unlock(&ld_tree_lk);
    190 	if (ld == NULL)
    191 		panic("lockdebug_lookup: uninitialized lock (lock=%p)", lock);
    192 
    193 	if ((ld->ld_flags & LD_SLEEPER) != 0)
    194 		*lk = &ld_sleeper_lk;
    195 	else
    196 		*lk = &ld_spinner_lk;
    197 
    198 	lockdebug_lock(*lk);
    199 	return ld;
    200 }
    201 
    202 /*
    203  * lockdebug_init:
    204  *
    205  *	Initialize the lockdebug system.  Allocate an initial pool of
    206  *	lockdebug structures before the VM system is up and running.
    207  */
    208 static void
    209 lockdebug_init(void)
    210 {
    211 	lockdebug_t *ld;
    212 	int i;
    213 
    214 	__cpu_simple_lock_init(&ld_tree_lk.lk_lock);
    215 	__cpu_simple_lock_init(&ld_sleeper_lk.lk_lock);
    216 	__cpu_simple_lock_init(&ld_spinner_lk.lk_lock);
    217 	__cpu_simple_lock_init(&ld_free_lk.lk_lock);
    218 
    219 	rb_tree_init(&ld_rb_tree, &ld_rb_tree_ops);
    220 
    221 	ld = ld_prime;
    222 	ld_table[0] = ld;
    223 	for (i = 1, ld++; i < LD_BATCH; i++, ld++) {
    224 		TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain);
    225 		TAILQ_INSERT_TAIL(&ld_all, ld, ld_achain);
    226 	}
    227 	ld_freeptr = 1;
    228 	ld_nfree = LD_BATCH - 1;
    229 }
    230 
    231 /*
    232  * lockdebug_alloc:
    233  *
    234  *	A lock is being initialized, so allocate an associated debug
    235  *	structure.
    236  */
    237 bool
    238 lockdebug_alloc(volatile void *lock, lockops_t *lo, uintptr_t initaddr)
    239 {
    240 #if 0
    241 	lockdebuglist_t *head;
    242 	lockdebuglk_t *lk;
    243 #endif
    244 	struct cpu_info *ci;
    245 	lockdebug_t *ld;
    246 
    247 	if (lo == NULL || panicstr != NULL)
    248 		return false;
    249 	if (ld_freeptr == 0)
    250 		lockdebug_init();
    251 
    252 	ci = curcpu();
    253 
    254 	/*
    255 	 * Pinch a new debug structure.  We may recurse because we call
    256 	 * kmem_alloc(), which may need to initialize new locks somewhere
    257 	 * down the path.  If not recursing, we try to maintain at least
    258 	 * LD_SLOP structures free, which should hopefully be enough to
    259 	 * satisfy kmem_alloc().  If we can't provide a structure, not to
    260 	 * worry: we'll just mark the lock as not having an ID.
    261 	 */
    262 	lockdebug_lock(&ld_free_lk);
    263 	ci->ci_lkdebug_recurse++;
    264 
    265 	if (TAILQ_EMPTY(&ld_free)) {
    266 		if (ci->ci_lkdebug_recurse > 1 || ld_nomore) {
    267 			ci->ci_lkdebug_recurse--;
    268 			lockdebug_unlock(&ld_free_lk);
    269 			return false;
    270 		}
    271 		lockdebug_more();
    272 	} else if (ci->ci_lkdebug_recurse == 1 && ld_nfree < LD_SLOP)
    273 		lockdebug_more();
    274 
    275 	if ((ld = TAILQ_FIRST(&ld_free)) == NULL) {
    276 		lockdebug_unlock(&ld_free_lk);
    277 		return false;
    278 	}
    279 
    280 	TAILQ_REMOVE(&ld_free, ld, ld_chain);
    281 	ld_nfree--;
    282 
    283 	ci->ci_lkdebug_recurse--;
    284 	lockdebug_unlock(&ld_free_lk);
    285 
    286 	if (ld->ld_lock != NULL)
    287 		panic("lockdebug_alloc: corrupt table");
    288 
    289 	if (lo->lo_sleeplock)
    290 		lockdebug_lock(&ld_sleeper_lk);
    291 	else
    292 		lockdebug_lock(&ld_spinner_lk);
    293 
    294 	/* Initialise the structure. */
    295 	ld->ld_lock = lock;
    296 	ld->ld_lockops = lo;
    297 	ld->ld_locked = 0;
    298 	ld->ld_unlocked = 0;
    299 	ld->ld_lwp = NULL;
    300 	ld->ld_initaddr = initaddr;
    301 
    302 	lockdebug_lock(&ld_tree_lk);
    303 	rb_tree_insert_node(&ld_rb_tree, __UNVOLATILE(&ld->ld_rb_node));
    304 	lockdebug_unlock(&ld_tree_lk);
    305 
    306 	if (lo->lo_sleeplock) {
    307 		ld->ld_flags = LD_SLEEPER;
    308 		lockdebug_unlock(&ld_sleeper_lk);
    309 	} else {
    310 		ld->ld_flags = 0;
    311 		lockdebug_unlock(&ld_spinner_lk);
    312 	}
    313 
    314 	return true;
    315 }
    316 
    317 /*
    318  * lockdebug_free:
    319  *
    320  *	A lock is being destroyed, so release debugging resources.
    321  */
    322 void
    323 lockdebug_free(volatile void *lock)
    324 {
    325 	lockdebug_t *ld;
    326 	lockdebuglk_t *lk;
    327 
    328 	if (panicstr != NULL)
    329 		return;
    330 
    331 	ld = lockdebug_lookup(lock, &lk);
    332 	if (ld == NULL) {
    333 		panic("lockdebug_free: destroying uninitialized lock %p"
    334 		    "(ld_lock=%p)", lock, ld->ld_lock);
    335 		lockdebug_abort1(ld, lk, __func__, "lock record follows",
    336 		    true);
    337 	}
    338 	if ((ld->ld_flags & LD_LOCKED) != 0 || ld->ld_shares != 0)
    339 		lockdebug_abort1(ld, lk, __func__, "is locked", true);
    340 	lockdebug_lock(&ld_tree_lk);
    341 	rb_tree_remove_node(&ld_rb_tree, __UNVOLATILE(&ld->ld_rb_node));
    342 	lockdebug_unlock(&ld_tree_lk);
    343 	ld->ld_lock = NULL;
    344 	lockdebug_unlock(lk);
    345 
    346 	lockdebug_lock(&ld_free_lk);
    347 	TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain);
    348 	ld_nfree++;
    349 	lockdebug_unlock(&ld_free_lk);
    350 }
    351 
    352 /*
    353  * lockdebug_more:
    354  *
    355  *	Allocate a batch of debug structures and add to the free list.
    356  *	Must be called with ld_free_lk held.
    357  */
    358 static void
    359 lockdebug_more(void)
    360 {
    361 	lockdebug_t *ld;
    362 	void *block;
    363 	int i, base, m;
    364 
    365 	while (ld_nfree < LD_SLOP) {
    366 		lockdebug_unlock(&ld_free_lk);
    367 		block = kmem_zalloc(LD_BATCH * sizeof(lockdebug_t), KM_SLEEP);
    368 		lockdebug_lock(&ld_free_lk);
    369 
    370 		if (block == NULL)
    371 			return;
    372 
    373 		if (ld_nfree > LD_SLOP) {
    374 			/* Somebody beat us to it. */
    375 			lockdebug_unlock(&ld_free_lk);
    376 			kmem_free(block, LD_BATCH * sizeof(lockdebug_t));
    377 			lockdebug_lock(&ld_free_lk);
    378 			continue;
    379 		}
    380 
    381 		base = ld_freeptr;
    382 		ld_nfree += LD_BATCH;
    383 		ld = block;
    384 		base <<= LD_BATCH_SHIFT;
    385 		m = min(LD_MAX_LOCKS, base + LD_BATCH);
    386 
    387 		if (m == LD_MAX_LOCKS)
    388 			ld_nomore = true;
    389 
    390 		for (i = base; i < m; i++, ld++) {
    391 			TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain);
    392 			TAILQ_INSERT_TAIL(&ld_all, ld, ld_achain);
    393 		}
    394 
    395 		mb_write();
    396 		ld_table[ld_freeptr++] = block;
    397 	}
    398 }
    399 
    400 /*
    401  * lockdebug_wantlock:
    402  *
    403  *	Process the preamble to a lock acquire.
    404  */
    405 void
    406 lockdebug_wantlock(volatile void *lock, uintptr_t where, int shared)
    407 {
    408 	struct lwp *l = curlwp;
    409 	lockdebuglk_t *lk;
    410 	lockdebug_t *ld;
    411 	bool recurse;
    412 
    413 	(void)shared;
    414 	recurse = false;
    415 
    416 	if (panicstr != NULL)
    417 		return;
    418 
    419 	if ((ld = lockdebug_lookup(lock, &lk)) == NULL)
    420 		return;
    421 
    422 	if ((ld->ld_flags & LD_LOCKED) != 0) {
    423 		if ((ld->ld_flags & LD_SLEEPER) != 0) {
    424 			if (ld->ld_lwp == l)
    425 				recurse = true;
    426 		} else if (ld->ld_cpu == (uint16_t)cpu_number())
    427 			recurse = true;
    428 	}
    429 
    430 #ifdef notyet
    431 	if (cpu_intr_p()) {
    432 		if ((ld->ld_flags & LD_SLEEPER) != 0)
    433 			lockdebug_abort1(ld, lk, __func__,
    434 			    "acquiring sleep lock from interrupt context",
    435 			    true);
    436 	}
    437 #endif
    438 
    439 	if (shared)
    440 		ld->ld_shwant++;
    441 	else
    442 		ld->ld_exwant++;
    443 
    444 	if (recurse)
    445 		lockdebug_abort1(ld, lk, __func__, "locking against myself",
    446 		    true);
    447 
    448 	lockdebug_unlock(lk);
    449 }
    450 
    451 /*
    452  * lockdebug_locked:
    453  *
    454  *	Process a lock acquire operation.
    455  */
    456 void
    457 lockdebug_locked(volatile void *lock, uintptr_t where, int shared)
    458 {
    459 	struct lwp *l = curlwp;
    460 	lockdebuglk_t *lk;
    461 	lockdebug_t *ld;
    462 
    463 	if (panicstr != NULL)
    464 		return;
    465 
    466 	if ((ld = lockdebug_lookup(lock, &lk)) == NULL)
    467 		return;
    468 
    469 	if (shared) {
    470 		l->l_shlocks++;
    471 		ld->ld_shares++;
    472 		ld->ld_shwant--;
    473 	} else {
    474 		if ((ld->ld_flags & LD_LOCKED) != 0)
    475 			lockdebug_abort1(ld, lk, __func__,
    476 			    "already locked", true);
    477 
    478 		ld->ld_flags |= LD_LOCKED;
    479 		ld->ld_locked = where;
    480 		ld->ld_cpu = (uint16_t)cpu_number();
    481 		ld->ld_lwp = l;
    482 		ld->ld_exwant--;
    483 
    484 		if ((ld->ld_flags & LD_SLEEPER) != 0) {
    485 			l->l_exlocks++;
    486 			TAILQ_INSERT_TAIL(&ld_sleepers, ld, ld_chain);
    487 		} else {
    488 			curcpu()->ci_spin_locks2++;
    489 			TAILQ_INSERT_TAIL(&ld_spinners, ld, ld_chain);
    490 		}
    491 	}
    492 
    493 	lockdebug_unlock(lk);
    494 }
    495 
    496 /*
    497  * lockdebug_unlocked:
    498  *
    499  *	Process a lock release operation.
    500  */
    501 void
    502 lockdebug_unlocked(volatile void *lock, uintptr_t where, int shared)
    503 {
    504 	struct lwp *l = curlwp;
    505 	lockdebuglk_t *lk;
    506 	lockdebug_t *ld;
    507 
    508 	if (panicstr != NULL)
    509 		return;
    510 
    511 	if ((ld = lockdebug_lookup(lock, &lk)) == NULL)
    512 		return;
    513 
    514 	if (shared) {
    515 		if (l->l_shlocks == 0)
    516 			lockdebug_abort1(ld, lk, __func__,
    517 			    "no shared locks held by LWP", true);
    518 		if (ld->ld_shares == 0)
    519 			lockdebug_abort1(ld, lk, __func__,
    520 			    "no shared holds on this lock", true);
    521 		l->l_shlocks--;
    522 		ld->ld_shares--;
    523 	} else {
    524 		if ((ld->ld_flags & LD_LOCKED) == 0)
    525 			lockdebug_abort1(ld, lk, __func__, "not locked",
    526 			    true);
    527 
    528 		if ((ld->ld_flags & LD_SLEEPER) != 0) {
    529 			if (ld->ld_lwp != curlwp)
    530 				lockdebug_abort1(ld, lk, __func__,
    531 				    "not held by current LWP", true);
    532 			ld->ld_flags &= ~LD_LOCKED;
    533 			ld->ld_unlocked = where;
    534 			ld->ld_lwp = NULL;
    535 			curlwp->l_exlocks--;
    536 			TAILQ_REMOVE(&ld_sleepers, ld, ld_chain);
    537 		} else {
    538 			if (ld->ld_cpu != (uint16_t)cpu_number())
    539 				lockdebug_abort1(ld, lk, __func__,
    540 				    "not held by current CPU", true);
    541 			ld->ld_flags &= ~LD_LOCKED;
    542 			ld->ld_unlocked = where;
    543 			ld->ld_lwp = NULL;
    544 			curcpu()->ci_spin_locks2--;
    545 			TAILQ_REMOVE(&ld_spinners, ld, ld_chain);
    546 		}
    547 	}
    548 
    549 	lockdebug_unlock(lk);
    550 }
    551 
    552 /*
    553  * lockdebug_barrier:
    554  *
    555  *	Panic if we hold more than one specified spin lock, and optionally,
    556  *	if we hold sleep locks.
    557  */
    558 void
    559 lockdebug_barrier(volatile void *spinlock, int slplocks)
    560 {
    561 	struct lwp *l = curlwp;
    562 	lockdebug_t *ld;
    563 	uint16_t cpuno;
    564 
    565 	if (panicstr != NULL)
    566 		return;
    567 
    568 	if (curcpu()->ci_spin_locks2 != 0) {
    569 		cpuno = (uint16_t)cpu_number();
    570 
    571 		lockdebug_lock(&ld_spinner_lk);
    572 		TAILQ_FOREACH(ld, &ld_spinners, ld_chain) {
    573 			if (ld->ld_lock == spinlock) {
    574 				if (ld->ld_cpu != cpuno)
    575 					lockdebug_abort1(ld, &ld_spinner_lk,
    576 					    __func__,
    577 					    "not held by current CPU", true);
    578 				continue;
    579 			}
    580 			if (ld->ld_cpu == cpuno && (l->l_pflag & LP_INTR) == 0)
    581 				lockdebug_abort1(ld, &ld_spinner_lk,
    582 				    __func__, "spin lock held", true);
    583 		}
    584 		lockdebug_unlock(&ld_spinner_lk);
    585 	}
    586 
    587 	if (!slplocks) {
    588 		if (l->l_exlocks != 0) {
    589 			lockdebug_lock(&ld_sleeper_lk);
    590 			TAILQ_FOREACH(ld, &ld_sleepers, ld_chain) {
    591 				if (ld->ld_lwp == l)
    592 					lockdebug_abort1(ld, &ld_sleeper_lk,
    593 					    __func__, "sleep lock held", true);
    594 			}
    595 			lockdebug_unlock(&ld_sleeper_lk);
    596 		}
    597 		if (l->l_shlocks != 0)
    598 			panic("lockdebug_barrier: holding %d shared locks",
    599 			    l->l_shlocks);
    600 	}
    601 }
    602 
    603 /*
    604  * lockdebug_mem_check:
    605  *
    606  *	Check for in-use locks within a memory region that is
    607  *	being freed.
    608  */
    609 void
    610 lockdebug_mem_check(const char *func, void *base, size_t sz)
    611 {
    612 #if 0
    613 	lockdebug_t *ld;
    614 	lockdebuglk_t *lk;
    615 	uintptr_t lock;
    616 
    617 	lockdebug_lock(&ld_tree_lk);
    618 	ld = (lockdebug_t *)rb_tree_find_node_geq(&ld_rb_tree, base);
    619 	lockdebug_unlock(&ld_tree_lk);
    620 	if (ld == NULL)
    621 		return;
    622 
    623 	if ((ld->ld_flags & LD_SLEEPER) != 0)
    624 		lk = &ld_sleeper_lk;
    625 	else
    626 		lk = &ld_spinner_lk;
    627 
    628 	lockdebug_lock(lk);
    629 	lock = (uintptr_t)ld->ld_lock;
    630 	if ((uintptr_t)base <= lock && lock < (uintptr_t)base + sz) {
    631 		lockdebug_abort1(ld, lk, func,
    632 		    "allocation contains active lock", !cold);
    633 		return;
    634 	}
    635 	lockdebug_unlock(lk);
    636 #endif
    637 }
    638 
    639 /*
    640  * lockdebug_dump:
    641  *
    642  *	Dump information about a lock on panic, or for DDB.
    643  */
    644 static void
    645 lockdebug_dump(lockdebug_t *ld, void (*pr)(const char *, ...))
    646 {
    647 	int sleeper = (ld->ld_flags & LD_SLEEPER);
    648 
    649 	(*pr)(
    650 	    "lock address : %#018lx type     : %18s\n"
    651 	    "shared holds : %18u exclusive: %18u\n"
    652 	    "shares wanted: %18u exclusive: %18u\n"
    653 	    "current cpu  : %18u last held: %18u\n"
    654 	    "current lwp  : %#018lx last held: %#018lx\n"
    655 	    "last locked  : %#018lx unlocked : %#018lx\n"
    656 	    "initialized  : %#018lx\n",
    657 	    (long)ld->ld_lock, (sleeper ? "sleep/adaptive" : "spin"),
    658 	    (unsigned)ld->ld_shares, ((ld->ld_flags & LD_LOCKED) != 0),
    659 	    (unsigned)ld->ld_shwant, (unsigned)ld->ld_exwant,
    660 	    (unsigned)cpu_number(), (unsigned)ld->ld_cpu,
    661 	    (long)curlwp, (long)ld->ld_lwp,
    662 	    (long)ld->ld_locked, (long)ld->ld_unlocked,
    663 	    (long)ld->ld_initaddr);
    664 
    665 	if (ld->ld_lockops->lo_dump != NULL)
    666 		(*ld->ld_lockops->lo_dump)(ld->ld_lock);
    667 
    668 	if (sleeper) {
    669 		(*pr)("\n");
    670 		turnstile_print(ld->ld_lock, pr);
    671 	}
    672 }
    673 
    674 /*
    675  * lockdebug_dump:
    676  *
    677  *	Dump information about a known lock.
    678  */
    679 static void
    680 lockdebug_abort1(lockdebug_t *ld, lockdebuglk_t *lk, const char *func,
    681 		 const char *msg, bool dopanic)
    682 {
    683 
    684 	printf_nolog("%s error: %s: %s\n\n", ld->ld_lockops->lo_name,
    685 	    func, msg);
    686 	lockdebug_dump(ld, printf_nolog);
    687 	lockdebug_unlock(lk);
    688 	printf_nolog("\n");
    689 	if (dopanic)
    690 		panic("LOCKDEBUG");
    691 }
    692 
    693 #endif	/* LOCKDEBUG */
    694 
    695 /*
    696  * lockdebug_lock_print:
    697  *
    698  *	Handle the DDB 'show lock' command.
    699  */
    700 #ifdef DDB
    701 void
    702 lockdebug_lock_print(void *addr, void (*pr)(const char *, ...))
    703 {
    704 #ifdef LOCKDEBUG
    705 	lockdebug_t *ld;
    706 
    707 	TAILQ_FOREACH(ld, &ld_all, ld_achain) {
    708 		if (ld->ld_lock == addr) {
    709 			lockdebug_dump(ld, pr);
    710 			return;
    711 		}
    712 	}
    713 	(*pr)("Sorry, no record of a lock with address %p found.\n", addr);
    714 #else
    715 	(*pr)("Sorry, kernel not built with the LOCKDEBUG option.\n");
    716 #endif	/* LOCKDEBUG */
    717 }
    718 #endif	/* DDB */
    719 
    720 /*
    721  * lockdebug_abort:
    722  *
    723  *	An error has been trapped - dump lock info and call panic().
    724  */
    725 void
    726 lockdebug_abort(volatile void *lock, lockops_t *ops, const char *func,
    727 		const char *msg)
    728 {
    729 #ifdef LOCKDEBUG
    730 	lockdebug_t *ld;
    731 	lockdebuglk_t *lk;
    732 
    733 	if ((ld = lockdebug_lookup(lock, &lk)) != NULL) {
    734 		lockdebug_abort1(ld, lk, func, msg, true);
    735 		/* NOTREACHED */
    736 	}
    737 #endif	/* LOCKDEBUG */
    738 
    739 	printf_nolog("%s error: %s: %s\n\n"
    740 	    "lock address : %#018lx\n"
    741 	    "current cpu  : %18d\n"
    742 	    "current lwp  : %#018lx\n",
    743 	    ops->lo_name, func, msg, (long)lock, (int)cpu_number(),
    744 	    (long)curlwp);
    745 
    746 	(*ops->lo_dump)(lock);
    747 
    748 	printf_nolog("\n");
    749 	panic("lock error");
    750 }
    751