1 /* $NetBSD: subr_lockdebug.c,v 1.21 2007/11/26 08:16:49 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.21 2007/11/26 08:16:49 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 const uintptr_t a = (uintptr_t)ld1->ld_lock; 131 const uintptr_t b = (uintptr_t)ld2->ld_lock; 132 133 if (a < b) 134 return 1; 135 if (a > b) 136 return -1; 137 return 0; 138 } 139 140 static signed int 141 ld_rb_compare_key(const struct rb_node *n, const void *key) 142 { 143 const lockdebug_t *ld = (const void *)n; 144 const uintptr_t a = (uintptr_t)ld->ld_lock; 145 const uintptr_t b = (uintptr_t)key; 146 147 if (a < b) 148 return 1; 149 if (a > b) 150 return -1; 151 return 0; 152 } 153 154 static struct rb_tree ld_rb_tree; 155 156 static const struct rb_tree_ops ld_rb_tree_ops = { 157 .rb_compare_nodes = ld_rb_compare_nodes, 158 .rb_compare_key = ld_rb_compare_key, 159 }; 160 161 static inline void 162 lockdebug_lock(lockdebuglk_t *lk) 163 { 164 int s; 165 166 s = splhigh(); 167 __cpu_simple_lock(&lk->lk_lock); 168 lk->lk_oldspl = s; 169 } 170 171 static inline void 172 lockdebug_unlock(lockdebuglk_t *lk) 173 { 174 int s; 175 176 s = lk->lk_oldspl; 177 __cpu_simple_unlock(&(lk->lk_lock)); 178 splx(s); 179 } 180 181 static inline lockdebug_t * 182 lockdebug_lookup1(volatile void *lock, lockdebuglk_t **lk) 183 { 184 lockdebug_t *ld; 185 186 lockdebug_lock(&ld_tree_lk); 187 ld = (lockdebug_t *)rb_tree_find_node(&ld_rb_tree, __UNVOLATILE(lock)); 188 lockdebug_unlock(&ld_tree_lk); 189 if (ld == NULL) 190 return NULL; 191 192 if ((ld->ld_flags & LD_SLEEPER) != 0) 193 *lk = &ld_sleeper_lk; 194 else 195 *lk = &ld_spinner_lk; 196 197 lockdebug_lock(*lk); 198 return ld; 199 } 200 201 /* 202 * lockdebug_lookup: 203 * 204 * Find a lockdebug structure by a pointer to a lock and return it locked. 205 */ 206 static inline lockdebug_t * 207 lockdebug_lookup(volatile void *lock, lockdebuglk_t **lk) 208 { 209 lockdebug_t *ld; 210 211 ld = lockdebug_lookup1(lock, lk); 212 if (ld == NULL) 213 panic("lockdebug_lookup: uninitialized lock (lock=%p)", lock); 214 return ld; 215 } 216 217 /* 218 * lockdebug_init: 219 * 220 * Initialize the lockdebug system. Allocate an initial pool of 221 * lockdebug structures before the VM system is up and running. 222 */ 223 static void 224 lockdebug_init(void) 225 { 226 lockdebug_t *ld; 227 int i; 228 229 __cpu_simple_lock_init(&ld_tree_lk.lk_lock); 230 __cpu_simple_lock_init(&ld_sleeper_lk.lk_lock); 231 __cpu_simple_lock_init(&ld_spinner_lk.lk_lock); 232 __cpu_simple_lock_init(&ld_free_lk.lk_lock); 233 234 rb_tree_init(&ld_rb_tree, &ld_rb_tree_ops); 235 236 ld = ld_prime; 237 ld_table[0] = ld; 238 for (i = 1, ld++; i < LD_BATCH; i++, ld++) { 239 TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain); 240 TAILQ_INSERT_TAIL(&ld_all, ld, ld_achain); 241 } 242 ld_freeptr = 1; 243 ld_nfree = LD_BATCH - 1; 244 } 245 246 /* 247 * lockdebug_alloc: 248 * 249 * A lock is being initialized, so allocate an associated debug 250 * structure. 251 */ 252 bool 253 lockdebug_alloc(volatile void *lock, lockops_t *lo, uintptr_t initaddr) 254 { 255 struct cpu_info *ci; 256 lockdebug_t *ld; 257 lockdebuglk_t *lk; 258 259 if (lo == NULL || panicstr != NULL) 260 return false; 261 if (ld_freeptr == 0) 262 lockdebug_init(); 263 264 if ((ld = lockdebug_lookup1(lock, &lk)) != NULL) { 265 lockdebug_abort1(ld, lk, __func__, "already initialized", true); 266 /* NOTREACHED */ 267 } 268 269 ci = curcpu(); 270 271 /* 272 * Pinch a new debug structure. We may recurse because we call 273 * kmem_alloc(), which may need to initialize new locks somewhere 274 * down the path. If not recursing, we try to maintain at least 275 * LD_SLOP structures free, which should hopefully be enough to 276 * satisfy kmem_alloc(). If we can't provide a structure, not to 277 * worry: we'll just mark the lock as not having an ID. 278 */ 279 lockdebug_lock(&ld_free_lk); 280 ci->ci_lkdebug_recurse++; 281 282 if (TAILQ_EMPTY(&ld_free)) { 283 if (ci->ci_lkdebug_recurse > 1 || ld_nomore) { 284 ci->ci_lkdebug_recurse--; 285 lockdebug_unlock(&ld_free_lk); 286 return false; 287 } 288 lockdebug_more(); 289 } else if (ci->ci_lkdebug_recurse == 1 && ld_nfree < LD_SLOP) 290 lockdebug_more(); 291 292 if ((ld = TAILQ_FIRST(&ld_free)) == NULL) { 293 lockdebug_unlock(&ld_free_lk); 294 return false; 295 } 296 297 TAILQ_REMOVE(&ld_free, ld, ld_chain); 298 ld_nfree--; 299 300 ci->ci_lkdebug_recurse--; 301 lockdebug_unlock(&ld_free_lk); 302 303 if (ld->ld_lock != NULL) 304 panic("lockdebug_alloc: corrupt table"); 305 306 if (lo->lo_sleeplock) 307 lockdebug_lock(&ld_sleeper_lk); 308 else 309 lockdebug_lock(&ld_spinner_lk); 310 311 /* Initialise the structure. */ 312 ld->ld_lock = lock; 313 ld->ld_lockops = lo; 314 ld->ld_locked = 0; 315 ld->ld_unlocked = 0; 316 ld->ld_lwp = NULL; 317 ld->ld_initaddr = initaddr; 318 319 lockdebug_lock(&ld_tree_lk); 320 rb_tree_insert_node(&ld_rb_tree, __UNVOLATILE(&ld->ld_rb_node)); 321 lockdebug_unlock(&ld_tree_lk); 322 323 if (lo->lo_sleeplock) { 324 ld->ld_flags = LD_SLEEPER; 325 lockdebug_unlock(&ld_sleeper_lk); 326 } else { 327 ld->ld_flags = 0; 328 lockdebug_unlock(&ld_spinner_lk); 329 } 330 331 return true; 332 } 333 334 /* 335 * lockdebug_free: 336 * 337 * A lock is being destroyed, so release debugging resources. 338 */ 339 void 340 lockdebug_free(volatile void *lock) 341 { 342 lockdebug_t *ld; 343 lockdebuglk_t *lk; 344 345 if (panicstr != NULL) 346 return; 347 348 ld = lockdebug_lookup(lock, &lk); 349 if (ld == NULL) { 350 panic("lockdebug_free: destroying uninitialized lock %p" 351 "(ld_lock=%p)", lock, ld->ld_lock); 352 lockdebug_abort1(ld, lk, __func__, "lock record follows", 353 true); 354 } 355 if ((ld->ld_flags & LD_LOCKED) != 0 || ld->ld_shares != 0) 356 lockdebug_abort1(ld, lk, __func__, "is locked", true); 357 lockdebug_lock(&ld_tree_lk); 358 rb_tree_remove_node(&ld_rb_tree, __UNVOLATILE(&ld->ld_rb_node)); 359 lockdebug_unlock(&ld_tree_lk); 360 ld->ld_lock = NULL; 361 lockdebug_unlock(lk); 362 363 lockdebug_lock(&ld_free_lk); 364 TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain); 365 ld_nfree++; 366 lockdebug_unlock(&ld_free_lk); 367 } 368 369 /* 370 * lockdebug_more: 371 * 372 * Allocate a batch of debug structures and add to the free list. 373 * Must be called with ld_free_lk held. 374 */ 375 static void 376 lockdebug_more(void) 377 { 378 lockdebug_t *ld; 379 void *block; 380 int i, base, m; 381 382 while (ld_nfree < LD_SLOP) { 383 lockdebug_unlock(&ld_free_lk); 384 block = kmem_zalloc(LD_BATCH * sizeof(lockdebug_t), KM_SLEEP); 385 lockdebug_lock(&ld_free_lk); 386 387 if (block == NULL) 388 return; 389 390 if (ld_nfree > LD_SLOP) { 391 /* Somebody beat us to it. */ 392 lockdebug_unlock(&ld_free_lk); 393 kmem_free(block, LD_BATCH * sizeof(lockdebug_t)); 394 lockdebug_lock(&ld_free_lk); 395 continue; 396 } 397 398 base = ld_freeptr; 399 ld_nfree += LD_BATCH; 400 ld = block; 401 base <<= LD_BATCH_SHIFT; 402 m = min(LD_MAX_LOCKS, base + LD_BATCH); 403 404 if (m == LD_MAX_LOCKS) 405 ld_nomore = true; 406 407 for (i = base; i < m; i++, ld++) { 408 TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain); 409 TAILQ_INSERT_TAIL(&ld_all, ld, ld_achain); 410 } 411 412 mb_write(); 413 ld_table[ld_freeptr++] = block; 414 } 415 } 416 417 /* 418 * lockdebug_wantlock: 419 * 420 * Process the preamble to a lock acquire. 421 */ 422 void 423 lockdebug_wantlock(volatile void *lock, uintptr_t where, int shared) 424 { 425 struct lwp *l = curlwp; 426 lockdebuglk_t *lk; 427 lockdebug_t *ld; 428 bool recurse; 429 430 (void)shared; 431 recurse = false; 432 433 if (panicstr != NULL) 434 return; 435 436 if ((ld = lockdebug_lookup(lock, &lk)) == NULL) 437 return; 438 439 if ((ld->ld_flags & LD_LOCKED) != 0) { 440 if ((ld->ld_flags & LD_SLEEPER) != 0) { 441 if (ld->ld_lwp == l) 442 recurse = true; 443 } else if (ld->ld_cpu == (uint16_t)cpu_number()) 444 recurse = true; 445 } 446 447 #ifdef notyet 448 if (cpu_intr_p()) { 449 if ((ld->ld_flags & LD_SLEEPER) != 0) 450 lockdebug_abort1(ld, lk, __func__, 451 "acquiring sleep lock from interrupt context", 452 true); 453 } 454 #endif 455 456 if (shared) 457 ld->ld_shwant++; 458 else 459 ld->ld_exwant++; 460 461 if (recurse) 462 lockdebug_abort1(ld, lk, __func__, "locking against myself", 463 true); 464 465 lockdebug_unlock(lk); 466 } 467 468 /* 469 * lockdebug_locked: 470 * 471 * Process a lock acquire operation. 472 */ 473 void 474 lockdebug_locked(volatile void *lock, uintptr_t where, int shared) 475 { 476 struct lwp *l = curlwp; 477 lockdebuglk_t *lk; 478 lockdebug_t *ld; 479 480 if (panicstr != NULL) 481 return; 482 483 if ((ld = lockdebug_lookup(lock, &lk)) == NULL) 484 return; 485 486 if (shared) { 487 l->l_shlocks++; 488 ld->ld_shares++; 489 ld->ld_shwant--; 490 } else { 491 if ((ld->ld_flags & LD_LOCKED) != 0) 492 lockdebug_abort1(ld, lk, __func__, 493 "already locked", true); 494 495 ld->ld_flags |= LD_LOCKED; 496 ld->ld_locked = where; 497 ld->ld_cpu = (uint16_t)cpu_number(); 498 ld->ld_lwp = l; 499 ld->ld_exwant--; 500 501 if ((ld->ld_flags & LD_SLEEPER) != 0) { 502 l->l_exlocks++; 503 TAILQ_INSERT_TAIL(&ld_sleepers, ld, ld_chain); 504 } else { 505 curcpu()->ci_spin_locks2++; 506 TAILQ_INSERT_TAIL(&ld_spinners, ld, ld_chain); 507 } 508 } 509 510 lockdebug_unlock(lk); 511 } 512 513 /* 514 * lockdebug_unlocked: 515 * 516 * Process a lock release operation. 517 */ 518 void 519 lockdebug_unlocked(volatile void *lock, uintptr_t where, int shared) 520 { 521 struct lwp *l = curlwp; 522 lockdebuglk_t *lk; 523 lockdebug_t *ld; 524 525 if (panicstr != NULL) 526 return; 527 528 if ((ld = lockdebug_lookup(lock, &lk)) == NULL) 529 return; 530 531 if (shared) { 532 if (l->l_shlocks == 0) 533 lockdebug_abort1(ld, lk, __func__, 534 "no shared locks held by LWP", true); 535 if (ld->ld_shares == 0) 536 lockdebug_abort1(ld, lk, __func__, 537 "no shared holds on this lock", true); 538 l->l_shlocks--; 539 ld->ld_shares--; 540 } else { 541 if ((ld->ld_flags & LD_LOCKED) == 0) 542 lockdebug_abort1(ld, lk, __func__, "not locked", 543 true); 544 545 if ((ld->ld_flags & LD_SLEEPER) != 0) { 546 if (ld->ld_lwp != curlwp) 547 lockdebug_abort1(ld, lk, __func__, 548 "not held by current LWP", true); 549 ld->ld_flags &= ~LD_LOCKED; 550 ld->ld_unlocked = where; 551 ld->ld_lwp = NULL; 552 curlwp->l_exlocks--; 553 TAILQ_REMOVE(&ld_sleepers, ld, ld_chain); 554 } else { 555 if (ld->ld_cpu != (uint16_t)cpu_number()) 556 lockdebug_abort1(ld, lk, __func__, 557 "not held by current CPU", true); 558 ld->ld_flags &= ~LD_LOCKED; 559 ld->ld_unlocked = where; 560 ld->ld_lwp = NULL; 561 curcpu()->ci_spin_locks2--; 562 TAILQ_REMOVE(&ld_spinners, ld, ld_chain); 563 } 564 } 565 566 lockdebug_unlock(lk); 567 } 568 569 /* 570 * lockdebug_barrier: 571 * 572 * Panic if we hold more than one specified spin lock, and optionally, 573 * if we hold sleep locks. 574 */ 575 void 576 lockdebug_barrier(volatile void *spinlock, int slplocks) 577 { 578 struct lwp *l = curlwp; 579 lockdebug_t *ld; 580 uint16_t cpuno; 581 582 if (panicstr != NULL) 583 return; 584 585 if (curcpu()->ci_spin_locks2 != 0) { 586 cpuno = (uint16_t)cpu_number(); 587 588 lockdebug_lock(&ld_spinner_lk); 589 TAILQ_FOREACH(ld, &ld_spinners, ld_chain) { 590 if (ld->ld_lock == spinlock) { 591 if (ld->ld_cpu != cpuno) 592 lockdebug_abort1(ld, &ld_spinner_lk, 593 __func__, 594 "not held by current CPU", true); 595 continue; 596 } 597 if (ld->ld_cpu == cpuno && (l->l_pflag & LP_INTR) == 0) 598 lockdebug_abort1(ld, &ld_spinner_lk, 599 __func__, "spin lock held", true); 600 } 601 lockdebug_unlock(&ld_spinner_lk); 602 } 603 604 if (!slplocks) { 605 if (l->l_exlocks != 0) { 606 lockdebug_lock(&ld_sleeper_lk); 607 TAILQ_FOREACH(ld, &ld_sleepers, ld_chain) { 608 if (ld->ld_lwp == l) 609 lockdebug_abort1(ld, &ld_sleeper_lk, 610 __func__, "sleep lock held", true); 611 } 612 lockdebug_unlock(&ld_sleeper_lk); 613 } 614 if (l->l_shlocks != 0) 615 panic("lockdebug_barrier: holding %d shared locks", 616 l->l_shlocks); 617 } 618 } 619 620 /* 621 * lockdebug_mem_check: 622 * 623 * Check for in-use locks within a memory region that is 624 * being freed. 625 */ 626 void 627 lockdebug_mem_check(const char *func, void *base, size_t sz) 628 { 629 lockdebug_t *ld; 630 lockdebuglk_t *lk; 631 uintptr_t lock; 632 633 lockdebug_lock(&ld_tree_lk); 634 ld = (lockdebug_t *)rb_tree_find_node_geq(&ld_rb_tree, base); 635 lockdebug_unlock(&ld_tree_lk); 636 if (ld == NULL) 637 return; 638 639 if ((ld->ld_flags & LD_SLEEPER) != 0) 640 lk = &ld_sleeper_lk; 641 else 642 lk = &ld_spinner_lk; 643 644 lockdebug_lock(lk); 645 lock = (uintptr_t)ld->ld_lock; 646 if ((uintptr_t)base > lock) 647 lockdebug_abort1(ld, lk, func, "corrupt tree", true); 648 if (lock < (uintptr_t)base + sz) { 649 lockdebug_abort1(ld, lk, func, 650 "allocation contains active lock", !cold); 651 return; 652 } 653 lockdebug_unlock(lk); 654 } 655 656 /* 657 * lockdebug_dump: 658 * 659 * Dump information about a lock on panic, or for DDB. 660 */ 661 static void 662 lockdebug_dump(lockdebug_t *ld, void (*pr)(const char *, ...)) 663 { 664 int sleeper = (ld->ld_flags & LD_SLEEPER); 665 666 (*pr)( 667 "lock address : %#018lx type : %18s\n" 668 "shared holds : %18u exclusive: %18u\n" 669 "shares wanted: %18u exclusive: %18u\n" 670 "current cpu : %18u last held: %18u\n" 671 "current lwp : %#018lx last held: %#018lx\n" 672 "last locked : %#018lx unlocked : %#018lx\n" 673 "initialized : %#018lx\n", 674 (long)ld->ld_lock, (sleeper ? "sleep/adaptive" : "spin"), 675 (unsigned)ld->ld_shares, ((ld->ld_flags & LD_LOCKED) != 0), 676 (unsigned)ld->ld_shwant, (unsigned)ld->ld_exwant, 677 (unsigned)cpu_number(), (unsigned)ld->ld_cpu, 678 (long)curlwp, (long)ld->ld_lwp, 679 (long)ld->ld_locked, (long)ld->ld_unlocked, 680 (long)ld->ld_initaddr); 681 682 if (ld->ld_lockops->lo_dump != NULL) 683 (*ld->ld_lockops->lo_dump)(ld->ld_lock); 684 685 if (sleeper) { 686 (*pr)("\n"); 687 turnstile_print(ld->ld_lock, pr); 688 } 689 } 690 691 /* 692 * lockdebug_dump: 693 * 694 * Dump information about a known lock. 695 */ 696 static void 697 lockdebug_abort1(lockdebug_t *ld, lockdebuglk_t *lk, const char *func, 698 const char *msg, bool dopanic) 699 { 700 701 printf_nolog("%s error: %s: %s\n\n", ld->ld_lockops->lo_name, 702 func, msg); 703 lockdebug_dump(ld, printf_nolog); 704 lockdebug_unlock(lk); 705 printf_nolog("\n"); 706 if (dopanic) 707 panic("LOCKDEBUG"); 708 } 709 710 #endif /* LOCKDEBUG */ 711 712 /* 713 * lockdebug_lock_print: 714 * 715 * Handle the DDB 'show lock' command. 716 */ 717 #ifdef DDB 718 void 719 lockdebug_lock_print(void *addr, void (*pr)(const char *, ...)) 720 { 721 #ifdef LOCKDEBUG 722 lockdebug_t *ld; 723 724 TAILQ_FOREACH(ld, &ld_all, ld_achain) { 725 if (ld->ld_lock == addr) { 726 lockdebug_dump(ld, pr); 727 return; 728 } 729 } 730 (*pr)("Sorry, no record of a lock with address %p found.\n", addr); 731 #else 732 (*pr)("Sorry, kernel not built with the LOCKDEBUG option.\n"); 733 #endif /* LOCKDEBUG */ 734 } 735 #endif /* DDB */ 736 737 /* 738 * lockdebug_abort: 739 * 740 * An error has been trapped - dump lock info and call panic(). 741 */ 742 void 743 lockdebug_abort(volatile void *lock, lockops_t *ops, const char *func, 744 const char *msg) 745 { 746 #ifdef LOCKDEBUG 747 lockdebug_t *ld; 748 lockdebuglk_t *lk; 749 750 if ((ld = lockdebug_lookup(lock, &lk)) != NULL) { 751 lockdebug_abort1(ld, lk, func, msg, true); 752 /* NOTREACHED */ 753 } 754 #endif /* LOCKDEBUG */ 755 756 printf_nolog("%s error: %s: %s\n\n" 757 "lock address : %#018lx\n" 758 "current cpu : %18d\n" 759 "current lwp : %#018lx\n", 760 ops->lo_name, func, msg, (long)lock, (int)cpu_number(), 761 (long)curlwp); 762 763 (*ops->lo_dump)(lock); 764 765 printf_nolog("\n"); 766 panic("lock error"); 767 } 768