subr_lockdebug.c revision 1.1.2.3
1 /* $NetBSD: subr_lockdebug.c,v 1.1.2.3 2006/11/17 16:34:37 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 2006 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 primatives. 41 */ 42 43 #include "opt_multiprocessor.h" 44 45 #include <sys/cdefs.h> 46 __KERNEL_RCSID(0, "$NetBSD: subr_lockdebug.c,v 1.1.2.3 2006/11/17 16:34:37 ad Exp $"); 47 48 #include <sys/param.h> 49 #include <sys/proc.h> 50 #include <sys/systm.h> 51 #include <sys/malloc.h> 52 #include <sys/lock.h> 53 #include <sys/lockdebug.h> 54 55 #include <machine/cpu.h> 56 57 #ifdef LOCKDEBUG 58 59 #define LD_BATCH_SHIFT 9 60 #define LD_BATCH (1 << LD_BATCH_SHIFT) 61 #define LD_BATCH_MASK (LD_BATCH - 1) 62 #define LD_MAX_LOCKS 1048576 63 #define LD_SLOP 16 64 65 #define LD_LOCKED 0x01 66 #define LD_SLEEPER 0x02 67 68 #define LD_NOID LD_MAX_LOCKS 69 70 typedef struct lockdebuglk { 71 __cpu_simple_lock_t lk_lock; 72 int lk_oldspl; 73 } volatile lockdebuglk_t; 74 75 typedef struct lockdebug { 76 _TAILQ_ENTRY(struct lockdebug, volatile) ld_chain; 77 volatile void *ld_lock; 78 lockops_t *ld_lockops; 79 struct lwp *ld_lwp; 80 uintptr_t ld_locked; 81 uintptr_t ld_unlocked; 82 u_int ld_id; 83 u_short ld_cpu; 84 u_short ld_shares; 85 u_char ld_flags; 86 } volatile lockdebug_t; 87 88 typedef _TAILQ_HEAD(lockdebuglist, struct lockdebug, volatile) lockdebuglist_t; 89 90 lockdebuglk_t ld_sleeper_lk; 91 lockdebuglk_t ld_spinner_lk; 92 lockdebuglk_t ld_free_lk; 93 94 lockdebuglist_t ld_sleepers; 95 lockdebuglist_t ld_spinners; 96 lockdebuglist_t ld_free; 97 int ld_nfree; 98 int ld_freeptr; 99 int ld_recurse; 100 lockdebug_t *ld_table[LD_MAX_LOCKS / LD_BATCH]; 101 char ld_panicbuf[1024]; 102 103 lockdebug_t ld_prime[LD_BATCH]; 104 105 MALLOC_DEFINE(M_LOCKDEBUG, "lockdebug", "lockdebug structures"); 106 107 void lockdebug_abort1(lockdebug_t *, lockdebuglk_t *lk, const char *, 108 const char *); 109 void lockdebug_more(void); 110 111 static inline void 112 lockdebug_lock(lockdebuglk_t *lk) 113 { 114 int s; 115 116 s = spllock(); 117 __cpu_simple_lock(&lk->lk_lock); 118 lk->lk_oldspl = s; 119 } 120 121 static inline void 122 lockdebug_unlock(lockdebuglk_t *lk) 123 { 124 int s; 125 126 s = lk->lk_oldspl; 127 __cpu_simple_unlock(&lk->lk_lock); 128 splx(s); 129 } 130 131 /* 132 * lockdebug_lookup: 133 * 134 * Find a lockdebug structure by ID and return it locked. 135 */ 136 static inline lockdebug_t * 137 lockdebug_lookup(u_int id, lockdebuglk_t **lk) 138 { 139 lockdebug_t *ld; 140 141 if (id == LD_NOID) 142 return NULL; 143 144 ld = ld_table[id >> LD_BATCH_SHIFT] + (id & LD_BATCH_MASK); 145 146 if (id == 0 || id >= LD_MAX_LOCKS || ld == NULL || ld->ld_lock == NULL) 147 panic("lockdebug_lookup: uninitialized lock (id=%d)", id); 148 149 if (ld->ld_id != id) 150 panic("lockdebug_lookup: corrupt table"); 151 152 if ((ld->ld_flags & LD_SLEEPER) != 0) 153 *lk = &ld_sleeper_lk; 154 else 155 *lk = &ld_spinner_lk; 156 157 lockdebug_lock(*lk); 158 return ld; 159 } 160 161 /* 162 * lockdebug_init: 163 * 164 * Initialize the lockdebug system. Allocate an initial pool of 165 * lockdebug structures before the VM system is up and running. 166 */ 167 void 168 lockdebug_init(void) 169 { 170 lockdebug_t *ld; 171 int i; 172 173 __cpu_simple_lock_init(&ld_sleeper_lk.lk_lock); 174 __cpu_simple_lock_init(&ld_spinner_lk.lk_lock); 175 __cpu_simple_lock_init(&ld_free_lk.lk_lock); 176 177 TAILQ_INIT(&ld_free); 178 TAILQ_INIT(&ld_sleepers); 179 TAILQ_INIT(&ld_spinners); 180 181 ld = ld_prime; 182 ld_table[0] = ld; 183 for (i = 1, ld++; i < LD_BATCH; i++, ld++) { 184 ld->ld_id = i; 185 TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain); 186 } 187 ld_freeptr = 1; 188 ld_nfree = LD_BATCH; 189 } 190 191 /* 192 * lockdebug_alloc: 193 * 194 * A lock is being initialized, so allocate an associated debug 195 * structure. 196 */ 197 u_int 198 lockdebug_alloc(volatile void *lock, lockops_t *lo) 199 { 200 struct cpu_info *ci; 201 lockdebug_t *ld; 202 203 if (panicstr != NULL) 204 return 0; 205 206 ci = curcpu(); 207 208 /* 209 * Pinch a new debug structure. We may recurse because we call 210 * malloc(), which may need to initialize new locks somewhere 211 * down the path. If not recursing, we try to maintain at keep 212 * LD_SLOP structures free, which should hopefully be enough to 213 * satisfy malloc(). If we can't provide a structure, not to 214 * worry: we'll just mark the lock as not having an ID. 215 */ 216 lockdebug_lock(&ld_free_lk); 217 ci->ci_lkdebug_recurse++; 218 219 if (TAILQ_EMPTY(&ld_free)) { 220 if (ci->ci_lkdebug_recurse > 1) { 221 ci->ci_lkdebug_recurse--; 222 lockdebug_unlock(&ld_free_lk); 223 return (LD_NOID); 224 } 225 lockdebug_more(); 226 } else if (ci->ci_lkdebug_recurse == 1 && ld_nfree < LD_SLOP) 227 lockdebug_more(); 228 229 ld = TAILQ_FIRST(&ld_free); 230 TAILQ_REMOVE(&ld_free, ld, ld_chain); 231 ld_nfree--; 232 233 ci->ci_lkdebug_recurse--; 234 lockdebug_unlock(&ld_free_lk); 235 236 if (ld->ld_lock != NULL) 237 panic("lockdebug_alloc: corrupt table"); 238 239 if (lo->lo_sleeplock) 240 lockdebug_lock(&ld_sleeper_lk); 241 else 242 lockdebug_lock(&ld_spinner_lk); 243 244 /* Initialise the structure. */ 245 ld->ld_lock = lock; 246 ld->ld_lockops = lo; 247 ld->ld_locked = 0; 248 ld->ld_unlocked = 0; 249 ld->ld_lwp = NULL; 250 251 if (lo->lo_sleeplock) { 252 ld->ld_flags = LD_SLEEPER; 253 lockdebug_unlock(&ld_sleeper_lk); 254 } else { 255 ld->ld_flags = 0; 256 lockdebug_unlock(&ld_spinner_lk); 257 } 258 259 return ld->ld_id; 260 } 261 262 /* 263 * lockdebug_free: 264 * 265 * A lock is being destroyed, so release debugging resources. 266 */ 267 void 268 lockdebug_free(volatile void *lock, u_int id) 269 { 270 lockdebug_t *ld; 271 lockdebuglk_t *lk; 272 273 if (panicstr != NULL) 274 return; 275 276 if ((ld = lockdebug_lookup(id, &lk)) == NULL) 277 return; 278 279 if (ld->ld_lock != lock) { 280 panic("lockdebug_free: destroying uninitialized lock %p" 281 "(ld_id=%d ld_lock=%p)", lock, id, ld->ld_lock); 282 lockdebug_abort1(ld, lk, __FUNCTION__, "lock record follows"); 283 } 284 if ((ld->ld_flags & LD_LOCKED) != 0) 285 lockdebug_abort1(ld, lk, __FUNCTION__, "is locked"); 286 287 ld->ld_lock = NULL; 288 289 lockdebug_unlock(lk); 290 291 lockdebug_lock(&ld_free_lk); 292 TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain); 293 ld_nfree++; 294 lockdebug_unlock(&ld_free_lk); 295 } 296 297 /* 298 * lockdebug_more: 299 * 300 * Allocate a batch of debug structures and add to the free list. Must 301 * be called with ld_free_lk held. 302 */ 303 void 304 lockdebug_more(void) 305 { 306 lockdebug_t *ld; 307 void *block; 308 int i, base; 309 310 while (ld_nfree < LD_SLOP) { 311 lockdebug_unlock(&ld_free_lk); 312 block = malloc(LD_BATCH * sizeof(lockdebug_t), M_LOCKDEBUG, 313 M_NOWAIT | M_ZERO); /* XXX M_NOWAIT */ 314 lockdebug_lock(&ld_free_lk); 315 316 base = ld_freeptr; 317 if (ld_table[base] != NULL) { 318 /* Somebody beat us to it. */ 319 lockdebug_unlock(&ld_free_lk); 320 free(block, M_LOCKDEBUG); 321 lockdebug_lock(&ld_free_lk); 322 continue; 323 } 324 ld_table[base] = block; 325 ld_freeptr++; 326 ld_nfree += LD_BATCH; 327 ld = block; 328 base <<= LD_BATCH_SHIFT; 329 330 for (i = 0; i < LD_BATCH; i++, ld++) { 331 ld->ld_id = i + base; 332 ld->ld_lock = NULL; 333 TAILQ_INSERT_TAIL(&ld_free, ld, ld_chain); 334 } 335 336 mb_write(); 337 ld_table[base] = ld; 338 } 339 } 340 341 /* 342 * lockdebug_locked: 343 * 344 * Process a lock acquire operation. 345 */ 346 void 347 lockdebug_locked(u_int id, uintptr_t where, int shared) 348 { 349 struct lwp *l = curlwp; 350 lockdebuglk_t *lk; 351 lockdebug_t *ld; 352 353 if (panicstr != NULL) 354 return; 355 356 if ((ld = lockdebug_lookup(id, &lk)) == NULL) 357 return; 358 359 if ((ld->ld_flags & LD_LOCKED) != 0) 360 lockdebug_abort1(ld, lk, __FUNCTION__, "already locked"); 361 362 if (shared) { 363 if (l == NULL) 364 lockdebug_abort1(ld, lk, __FUNCTION__, "releasing " 365 "shared lock from interrupt context"); 366 367 l->l_shlocks++; 368 ld->ld_shares++; 369 } else { 370 ld->ld_flags |= LD_LOCKED; 371 ld->ld_locked = where; 372 ld->ld_cpu = (u_short)cpu_number(); 373 ld->ld_lwp = l; 374 375 if ((ld->ld_flags & LD_SLEEPER) != 0) { 376 l->l_exlocks++; 377 TAILQ_INSERT_TAIL(&ld_sleepers, ld, ld_chain); 378 } else { 379 curcpu()->ci_spin_locks2++; 380 TAILQ_INSERT_TAIL(&ld_spinners, ld, ld_chain); 381 } 382 } 383 384 lockdebug_unlock(lk); 385 } 386 387 /* 388 * lockdebug_unlocked: 389 * 390 * Process a lock release operation. 391 */ 392 void 393 lockdebug_unlocked(u_int id, uintptr_t where, int shared) 394 { 395 struct lwp *l = curlwp; 396 lockdebuglk_t *lk; 397 lockdebug_t *ld; 398 399 if (panicstr != NULL) 400 return; 401 402 if ((ld = lockdebug_lookup(id, &lk)) == NULL) 403 return; 404 405 if (shared) { 406 if (l == NULL) 407 lockdebug_abort1(ld, lk, __FUNCTION__, "acquiring " 408 "shared lock from interrupt context"); 409 if (l->l_shlocks == 0) 410 lockdebug_abort1(ld, lk, __FUNCTION__, "no shared " 411 "locks held by LWP"); 412 if (ld->ld_shares == 0) 413 lockdebug_abort1(ld, lk, __FUNCTION__, "no shared " 414 "holds on this lock"); 415 l->l_shlocks--; 416 ld->ld_shares--; 417 } else { 418 if ((ld->ld_flags & LD_LOCKED) == 0) 419 lockdebug_abort1(ld, lk, __FUNCTION__, "not locked"); 420 421 if ((ld->ld_flags & LD_SLEEPER) != 0) { 422 if (ld->ld_lwp != curlwp) 423 lockdebug_abort1(ld, lk, __FUNCTION__, 424 "not held by current LWP"); 425 ld->ld_flags &= ~LD_LOCKED; 426 ld->ld_unlocked = where; 427 ld->ld_lwp = NULL; 428 curlwp->l_exlocks--; 429 TAILQ_REMOVE(&ld_sleepers, ld, ld_chain); 430 } else { 431 if (ld->ld_cpu != (u_short)cpu_number()) 432 lockdebug_abort1(ld, lk, __FUNCTION__, 433 "not held by current CPU"); 434 ld->ld_flags &= ~LD_LOCKED; 435 ld->ld_unlocked = where; 436 ld->ld_lwp = NULL; 437 curcpu()->ci_spin_locks2--; 438 TAILQ_REMOVE(&ld_spinners, ld, ld_chain); 439 } 440 } 441 442 lockdebug_unlock(lk); 443 } 444 445 /* 446 * lockdebug_barrier: 447 * 448 * Panic if we hold more than one specified spin lock, and optionally, 449 * if we hold sleep locks. 450 */ 451 void 452 lockdebug_barrier(volatile void *spinlock, int slplocks) 453 { 454 struct lwp *l = curlwp; 455 lockdebug_t *ld; 456 u_short cpuno; 457 458 if (panicstr != NULL) 459 return; 460 461 if (curcpu()->ci_spin_locks2 != 0) { 462 cpuno = (u_short)cpu_number(); 463 464 lockdebug_lock(&ld_spinner_lk); 465 TAILQ_FOREACH(ld, &ld_spinners, ld_chain) { 466 if (ld->ld_lock == spinlock) { 467 if (ld->ld_cpu != cpuno) 468 lockdebug_abort1(ld, &ld_spinner_lk, 469 __FUNCTION__, 470 "not held by current CPU"); 471 continue; 472 } 473 if (ld->ld_cpu == cpuno) 474 lockdebug_abort1(ld, &ld_spinner_lk, 475 __FUNCTION__, "spin lock held"); 476 } 477 lockdebug_unlock(&ld_spinner_lk); 478 } 479 480 if (!slplocks) { 481 if (l->l_exlocks != 0) { 482 lockdebug_lock(&ld_sleeper_lk); 483 TAILQ_FOREACH(ld, &ld_sleepers, ld_chain) { 484 if (ld->ld_lwp == l) 485 lockdebug_abort1(ld, &ld_sleeper_lk, 486 __FUNCTION__, "sleep lock held"); 487 } 488 lockdebug_unlock(&ld_sleeper_lk); 489 } 490 if (l->l_shlocks != 0) 491 panic("lockdebug_barrier: holding %d shared locks", 492 l->l_shlocks); 493 } 494 } 495 496 void 497 lockdebug_abort1(lockdebug_t *ld, lockdebuglk_t *lk, const char *func, 498 const char *msg) 499 { 500 char *buf; 501 int p; 502 503 /* 504 * The kernel is about to fall flat on its face, so assume that 1k 505 * will be enough to hold the dump and abuse the return value from 506 * snprintf. 507 */ 508 buf = ld_panicbuf; 509 510 p = snprintf(buf, sizeof(buf), "%s error: %s: %s\n\n", 511 ld->ld_lockops->lo_name, func, msg); 512 513 p += snprintf(buf + p, sizeof(buf) - p, 514 "lock address : %#018lx type : %18s\n" 515 "shared holds : %18d exclusive: %12slocked\n" 516 "last locked : %#018lx unlocked : %#018lx\n" 517 "current cpu : %18d last held: %18d\n" 518 "current lwp : %#018lx last held: %#018lx\n", 519 (long)ld->ld_lock, 520 ((ld->ld_flags & LD_SLEEPER) == 0 ? "spin" : "sleep"), 521 ld->ld_shares, ((ld->ld_flags & LD_LOCKED) == 0 ? "un" : " "), 522 (long)ld->ld_locked, (long)ld->ld_unlocked, 523 (int)cpu_number(), (int)ld->ld_cpu, 524 (long)curlwp, (long)ld->ld_lwp); 525 526 if (ld->ld_lockops->lo_dump != NULL) 527 (void)(*ld->ld_lockops->lo_dump)(ld->ld_lock, buf + p, 528 sizeof(buf) - p); 529 530 lockdebug_unlock(lk); 531 printf("%s", buf); 532 panic("LOCKDEBUG"); 533 } 534 535 #endif /* LOCKDEBUG */ 536 537 /* 538 * lockdebug_abort: 539 * 540 * An error has been trapped - dump lock info and call panic(). 541 */ 542 void 543 lockdebug_abort(int id, volatile void *lock, lockops_t *ops, 544 const char *func, const char *msg) 545 { 546 char buf[192]; 547 #ifdef LOCKDEBUG 548 lockdebug_t *ld; 549 lockdebuglk_t *lk; 550 551 if ((ld = lockdebug_lookup(id, &lk)) != NULL) { 552 lockdebug_abort1(ld, lk, func, msg); 553 /* NOTREACHED */ 554 } 555 #endif /* LOCKDEBUG */ 556 557 /* 558 * The kernel is about to fall flat on its face, so assume that 192 559 * bytes will be enough to hold the dump. 560 */ 561 printf("%s error: %s: %s\n\n" 562 "lock address : %#018lx\n" 563 "current cpu : %18d\n" 564 "current lwp : %#018lx\n", 565 ops->lo_name, func, msg, (long)lock, (int)cpu_number(), 566 (long)curlwp); 567 568 (void)(*ops->lo_dump)(lock, buf, sizeof(buf)); 569 570 printf("%s", buf); 571 572 panic("lock error"); 573 } 574
Indexes created Sun Sep 21 20:09:37 GMT 2025