1/*- 2 * Copyright (c) 1998 Berkeley Software Design, Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 3. Berkeley Software Design Inc's name may not be used to endorse or 13 * promote products derived from this software without specific prior 14 * written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY BERKELEY SOFTWARE DESIGN INC ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL BERKELEY SOFTWARE DESIGN INC BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * from BSDI $Id: mutex_witness.c,v 1.1.2.20 2000/04/27 03:10:27 cp Exp $ 29 * and BSDI $Id: synch_machdep.c,v 2.3.2.39 2000/04/27 03:10:25 cp Exp $ 30 */ 31 32/* 33 * Machine independent bits of mutex implementation. 34 */ 35 36#include <sys/cdefs.h> 37__FBSDID("$FreeBSD$"); 38 39#include "opt_adaptive_mutexes.h" 40#include "opt_ddb.h" 41#include "opt_global.h" 42#include "opt_hwpmc_hooks.h" 43#include "opt_kdtrace.h" 44#include "opt_sched.h" 45 46#include <sys/param.h> 47#include <sys/systm.h> 48#include <sys/bus.h> 49#include <sys/conf.h> 50#include <sys/kdb.h> 51#include <sys/kernel.h> 52#include <sys/ktr.h> 53#include <sys/lock.h> 54#include <sys/malloc.h> 55#include <sys/mutex.h> 56#include <sys/proc.h> 57#include <sys/resourcevar.h> 58#include <sys/sched.h> 59#include <sys/sbuf.h> 60#include <sys/sysctl.h> 61#include <sys/turnstile.h> 62#include <sys/vmmeter.h> 63#include <sys/lock_profile.h> 64 65#include <machine/atomic.h> 66#include <machine/bus.h> 67#include <machine/cpu.h> 68 69#include <ddb/ddb.h> 70 71#include <fs/devfs/devfs_int.h> 72 73#include <vm/vm.h> 74#include <vm/vm_extern.h> 75 76#if defined(SMP) && !defined(NO_ADAPTIVE_MUTEXES) 77#define ADAPTIVE_MUTEXES 78#endif 79 80#ifdef HWPMC_HOOKS 81#include <sys/pmckern.h> 82PMC_SOFT_DEFINE( , , lock, failed); 83#endif 84 85/* 86 * Return the mutex address when the lock cookie address is provided. 87 * This functionality assumes that struct mtx* have a member named mtx_lock. 88 */ 89#define mtxlock2mtx(c) (__containerof(c, struct mtx, mtx_lock)) 90 91/* 92 * Internal utility macros. 93 */ 94#define mtx_unowned(m) ((m)->mtx_lock == MTX_UNOWNED) 95 96#define mtx_destroyed(m) ((m)->mtx_lock == MTX_DESTROYED) 97 98#define mtx_owner(m) ((struct thread *)((m)->mtx_lock & ~MTX_FLAGMASK)) 99 100static void assert_mtx(const struct lock_object *lock, int what); 101#ifdef DDB 102static void db_show_mtx(const struct lock_object *lock); 103#endif 104static void lock_mtx(struct lock_object *lock, uintptr_t how); 105static void lock_spin(struct lock_object *lock, uintptr_t how); 106#ifdef KDTRACE_HOOKS 107static int owner_mtx(const struct lock_object *lock, 108 struct thread **owner); 109#endif 110static uintptr_t unlock_mtx(struct lock_object *lock); 111static uintptr_t unlock_spin(struct lock_object *lock); 112 113/* 114 * Lock classes for sleep and spin mutexes. 115 */ 116struct lock_class lock_class_mtx_sleep = { 117 .lc_name = "sleep mutex", 118 .lc_flags = LC_SLEEPLOCK | LC_RECURSABLE, 119 .lc_assert = assert_mtx, 120#ifdef DDB 121 .lc_ddb_show = db_show_mtx, 122#endif 123 .lc_lock = lock_mtx, 124 .lc_unlock = unlock_mtx, 125#ifdef KDTRACE_HOOKS 126 .lc_owner = owner_mtx, 127#endif 128}; 129struct lock_class lock_class_mtx_spin = { 130 .lc_name = "spin mutex", 131 .lc_flags = LC_SPINLOCK | LC_RECURSABLE, 132 .lc_assert = assert_mtx, 133#ifdef DDB 134 .lc_ddb_show = db_show_mtx, 135#endif 136 .lc_lock = lock_spin, 137 .lc_unlock = unlock_spin, 138#ifdef KDTRACE_HOOKS 139 .lc_owner = owner_mtx, 140#endif 141}; 142 143/* 144 * System-wide mutexes 145 */ 146struct mtx blocked_lock; 147struct mtx Giant; 148 149void 150assert_mtx(const struct lock_object *lock, int what) 151{ 152 153 mtx_assert((const struct mtx *)lock, what); 154} 155 156void 157lock_mtx(struct lock_object *lock, uintptr_t how) 158{ 159 160 mtx_lock((struct mtx *)lock); 161} 162 163void 164lock_spin(struct lock_object *lock, uintptr_t how) 165{ 166 167 panic("spin locks can only use msleep_spin"); 168} 169 170uintptr_t 171unlock_mtx(struct lock_object *lock) 172{ 173 struct mtx *m; 174 175 m = (struct mtx *)lock; 176 mtx_assert(m, MA_OWNED | MA_NOTRECURSED); 177 mtx_unlock(m); 178 return (0); 179} 180 181uintptr_t 182unlock_spin(struct lock_object *lock) 183{ 184 185 panic("spin locks can only use msleep_spin"); 186} 187 188#ifdef KDTRACE_HOOKS 189int 190owner_mtx(const struct lock_object *lock, struct thread **owner) 191{ 192 const struct mtx *m = (const struct mtx *)lock; 193 194 *owner = mtx_owner(m); 195 return (mtx_unowned(m) == 0); 196} 197#endif 198 199/* 200 * Function versions of the inlined __mtx_* macros. These are used by 201 * modules and can also be called from assembly language if needed. 202 */ 203void 204__mtx_lock_flags(volatile uintptr_t *c, int opts, const char *file, int line) 205{ 206 struct mtx *m; 207 208 if (SCHEDULER_STOPPED()) 209 return; 210 211 m = mtxlock2mtx(c); 212 213 KASSERT(kdb_active != 0 || !TD_IS_IDLETHREAD(curthread), 214 ("mtx_lock() by idle thread %p on sleep mutex %s @ %s:%d", 215 curthread, m->lock_object.lo_name, file, line)); 216 KASSERT(m->mtx_lock != MTX_DESTROYED, 217 ("mtx_lock() of destroyed mutex @ %s:%d", file, line)); 218 KASSERT(LOCK_CLASS(&m->lock_object) == &lock_class_mtx_sleep, 219 ("mtx_lock() of spin mutex %s @ %s:%d", m->lock_object.lo_name, 220 file, line)); 221 WITNESS_CHECKORDER(&m->lock_object, (opts & ~MTX_RECURSE) | 222 LOP_NEWORDER | LOP_EXCLUSIVE, file, line, NULL); 223 224 __mtx_lock(m, curthread, opts, file, line); 225 LOCK_LOG_LOCK("LOCK", &m->lock_object, opts, m->mtx_recurse, file, 226 line); 227 WITNESS_LOCK(&m->lock_object, (opts & ~MTX_RECURSE) | LOP_EXCLUSIVE, 228 file, line); 229 curthread->td_locks++; 230} 231 232void 233__mtx_unlock_flags(volatile uintptr_t *c, int opts, const char *file, int line) 234{ 235 struct mtx *m; 236 237 if (SCHEDULER_STOPPED()) 238 return; 239 240 m = mtxlock2mtx(c); 241 242 KASSERT(m->mtx_lock != MTX_DESTROYED, 243 ("mtx_unlock() of destroyed mutex @ %s:%d", file, line)); 244 KASSERT(LOCK_CLASS(&m->lock_object) == &lock_class_mtx_sleep, 245 ("mtx_unlock() of spin mutex %s @ %s:%d", m->lock_object.lo_name, 246 file, line)); 247 WITNESS_UNLOCK(&m->lock_object, opts | LOP_EXCLUSIVE, file, line); 248 LOCK_LOG_LOCK("UNLOCK", &m->lock_object, opts, m->mtx_recurse, file, 249 line); 250 mtx_assert(m, MA_OWNED); 251 252 if (m->mtx_recurse == 0) 253 LOCKSTAT_PROFILE_RELEASE_LOCK(LS_MTX_UNLOCK_RELEASE, m); 254 __mtx_unlock(m, curthread, opts, file, line); 255 curthread->td_locks--; 256} 257 258void 259__mtx_lock_spin_flags(volatile uintptr_t *c, int opts, const char *file, 260 int line) 261{ 262 struct mtx *m; 263 264 if (SCHEDULER_STOPPED()) 265 return; 266 267 m = mtxlock2mtx(c); 268 269 KASSERT(m->mtx_lock != MTX_DESTROYED, 270 ("mtx_lock_spin() of destroyed mutex @ %s:%d", file, line)); 271 KASSERT(LOCK_CLASS(&m->lock_object) == &lock_class_mtx_spin, 272 ("mtx_lock_spin() of sleep mutex %s @ %s:%d", 273 m->lock_object.lo_name, file, line)); 274 if (mtx_owned(m)) 275 KASSERT((m->lock_object.lo_flags & LO_RECURSABLE) != 0 || 276 (opts & MTX_RECURSE) != 0, 277 ("mtx_lock_spin: recursed on non-recursive mutex %s @ %s:%d\n", 278 m->lock_object.lo_name, file, line)); 279 opts &= ~MTX_RECURSE; 280 WITNESS_CHECKORDER(&m->lock_object, opts | LOP_NEWORDER | LOP_EXCLUSIVE, 281 file, line, NULL); 282 __mtx_lock_spin(m, curthread, opts, file, line); 283 LOCK_LOG_LOCK("LOCK", &m->lock_object, opts, m->mtx_recurse, file, 284 line); 285 WITNESS_LOCK(&m->lock_object, opts | LOP_EXCLUSIVE, file, line); 286} 287 288void 289__mtx_unlock_spin_flags(volatile uintptr_t *c, int opts, const char *file, 290 int line) 291{ 292 struct mtx *m; 293 294 if (SCHEDULER_STOPPED()) 295 return; 296 297 m = mtxlock2mtx(c); 298 299 KASSERT(m->mtx_lock != MTX_DESTROYED, 300 ("mtx_unlock_spin() of destroyed mutex @ %s:%d", file, line)); 301 KASSERT(LOCK_CLASS(&m->lock_object) == &lock_class_mtx_spin, 302 ("mtx_unlock_spin() of sleep mutex %s @ %s:%d", 303 m->lock_object.lo_name, file, line)); 304 WITNESS_UNLOCK(&m->lock_object, opts | LOP_EXCLUSIVE, file, line); 305 LOCK_LOG_LOCK("UNLOCK", &m->lock_object, opts, m->mtx_recurse, file, 306 line); 307 mtx_assert(m, MA_OWNED); 308 309 __mtx_unlock_spin(m); 310} 311 312/* 313 * The important part of mtx_trylock{,_flags}() 314 * Tries to acquire lock `m.' If this function is called on a mutex that 315 * is already owned, it will recursively acquire the lock. 316 */ 317int 318_mtx_trylock_flags_(volatile uintptr_t *c, int opts, const char *file, int line) 319{ 320 struct mtx *m; 321#ifdef LOCK_PROFILING 322 uint64_t waittime = 0; 323 int contested = 0; 324#endif 325 int rval; 326 327 if (SCHEDULER_STOPPED()) 328 return (1); 329 330 m = mtxlock2mtx(c); 331 332 KASSERT(kdb_active != 0 || !TD_IS_IDLETHREAD(curthread), 333 ("mtx_trylock() by idle thread %p on sleep mutex %s @ %s:%d", 334 curthread, m->lock_object.lo_name, file, line)); 335 KASSERT(m->mtx_lock != MTX_DESTROYED, 336 ("mtx_trylock() of destroyed mutex @ %s:%d", file, line)); 337 KASSERT(LOCK_CLASS(&m->lock_object) == &lock_class_mtx_sleep, 338 ("mtx_trylock() of spin mutex %s @ %s:%d", m->lock_object.lo_name, 339 file, line)); 340 341 if (mtx_owned(m) && ((m->lock_object.lo_flags & LO_RECURSABLE) != 0 || 342 (opts & MTX_RECURSE) != 0)) { 343 m->mtx_recurse++; 344 atomic_set_ptr(&m->mtx_lock, MTX_RECURSED); 345 rval = 1; 346 } else 347 rval = _mtx_obtain_lock(m, (uintptr_t)curthread); 348 opts &= ~MTX_RECURSE; 349 350 LOCK_LOG_TRY("LOCK", &m->lock_object, opts, rval, file, line); 351 if (rval) { 352 WITNESS_LOCK(&m->lock_object, opts | LOP_EXCLUSIVE | LOP_TRYLOCK, 353 file, line); 354 curthread->td_locks++; 355 if (m->mtx_recurse == 0) 356 LOCKSTAT_PROFILE_OBTAIN_LOCK_SUCCESS(LS_MTX_LOCK_ACQUIRE, 357 m, contested, waittime, file, line); 358 359 } 360 361 return (rval); 362} 363 364/* 365 * __mtx_lock_sleep: the tougher part of acquiring an MTX_DEF lock. 366 * 367 * We call this if the lock is either contested (i.e. we need to go to 368 * sleep waiting for it), or if we need to recurse on it. 369 */ 370void 371__mtx_lock_sleep(volatile uintptr_t *c, uintptr_t tid, int opts, 372 const char *file, int line) 373{ 374 struct mtx *m; 375 struct turnstile *ts; 376 uintptr_t v; 377#ifdef ADAPTIVE_MUTEXES 378 volatile struct thread *owner; 379#endif 380#ifdef KTR 381 int cont_logged = 0; 382#endif 383#ifdef LOCK_PROFILING 384 int contested = 0; 385 uint64_t waittime = 0; 386#endif 387#ifdef KDTRACE_HOOKS 388 uint64_t spin_cnt = 0; 389 uint64_t sleep_cnt = 0; 390 int64_t sleep_time = 0; 391#endif 392 393 if (SCHEDULER_STOPPED()) 394 return; 395 396 m = mtxlock2mtx(c); 397 398 if (mtx_owned(m)) { 399 KASSERT((m->lock_object.lo_flags & LO_RECURSABLE) != 0 || 400 (opts & MTX_RECURSE) != 0, 401 ("_mtx_lock_sleep: recursed on non-recursive mutex %s @ %s:%d\n", 402 m->lock_object.lo_name, file, line)); 403 opts &= ~MTX_RECURSE; 404 m->mtx_recurse++; 405 atomic_set_ptr(&m->mtx_lock, MTX_RECURSED); 406 if (LOCK_LOG_TEST(&m->lock_object, opts)) 407 CTR1(KTR_LOCK, "_mtx_lock_sleep: %p recursing", m); 408 return; 409 } 410 opts &= ~MTX_RECURSE; 411 412#ifdef HWPMC_HOOKS 413 PMC_SOFT_CALL( , , lock, failed); 414#endif 415 lock_profile_obtain_lock_failed(&m->lock_object, 416 &contested, &waittime); 417 if (LOCK_LOG_TEST(&m->lock_object, opts)) 418 CTR4(KTR_LOCK, 419 "_mtx_lock_sleep: %s contested (lock=%p) at %s:%d", 420 m->lock_object.lo_name, (void *)m->mtx_lock, file, line); 421 422 while (!_mtx_obtain_lock(m, tid)) { 423#ifdef KDTRACE_HOOKS 424 spin_cnt++; 425#endif 426#ifdef ADAPTIVE_MUTEXES 427 /* 428 * If the owner is running on another CPU, spin until the 429 * owner stops running or the state of the lock changes. 430 */ 431 v = m->mtx_lock; 432 if (v != MTX_UNOWNED) { 433 owner = (struct thread *)(v & ~MTX_FLAGMASK); 434 if (TD_IS_RUNNING(owner)) { 435 if (LOCK_LOG_TEST(&m->lock_object, 0)) 436 CTR3(KTR_LOCK, 437 "%s: spinning on %p held by %p", 438 __func__, m, owner); 439 while (mtx_owner(m) == owner && 440 TD_IS_RUNNING(owner)) { 441 cpu_spinwait(); 442#ifdef KDTRACE_HOOKS 443 spin_cnt++; 444#endif 445 } 446 continue; 447 } 448 } 449#endif 450 451 ts = turnstile_trywait(&m->lock_object); 452 v = m->mtx_lock; 453 454 /* 455 * Check if the lock has been released while spinning for 456 * the turnstile chain lock. 457 */ 458 if (v == MTX_UNOWNED) { 459 turnstile_cancel(ts); 460 continue; 461 } 462 463#ifdef ADAPTIVE_MUTEXES 464 /* 465 * The current lock owner might have started executing 466 * on another CPU (or the lock could have changed 467 * owners) while we were waiting on the turnstile 468 * chain lock. If so, drop the turnstile lock and try 469 * again. 470 */ 471 owner = (struct thread *)(v & ~MTX_FLAGMASK); 472 if (TD_IS_RUNNING(owner)) { 473 turnstile_cancel(ts); 474 continue; 475 } 476#endif 477 478 /* 479 * If the mutex isn't already contested and a failure occurs 480 * setting the contested bit, the mutex was either released 481 * or the state of the MTX_RECURSED bit changed. 482 */ 483 if ((v & MTX_CONTESTED) == 0 && 484 !atomic_cmpset_ptr(&m->mtx_lock, v, v | MTX_CONTESTED)) { 485 turnstile_cancel(ts); 486 continue; 487 } 488 489 /* 490 * We definitely must sleep for this lock. 491 */ 492 mtx_assert(m, MA_NOTOWNED); 493 494#ifdef KTR 495 if (!cont_logged) { 496 CTR6(KTR_CONTENTION, 497 "contention: %p at %s:%d wants %s, taken by %s:%d", 498 (void *)tid, file, line, m->lock_object.lo_name, 499 WITNESS_FILE(&m->lock_object), 500 WITNESS_LINE(&m->lock_object)); 501 cont_logged = 1; 502 } 503#endif 504 505 /* 506 * Block on the turnstile. 507 */ 508#ifdef KDTRACE_HOOKS 509 sleep_time -= lockstat_nsecs(); 510#endif 511 turnstile_wait(ts, mtx_owner(m), TS_EXCLUSIVE_QUEUE); 512#ifdef KDTRACE_HOOKS 513 sleep_time += lockstat_nsecs(); 514 sleep_cnt++; 515#endif 516 } 517#ifdef KTR 518 if (cont_logged) { 519 CTR4(KTR_CONTENTION, 520 "contention end: %s acquired by %p at %s:%d", 521 m->lock_object.lo_name, (void *)tid, file, line); 522 } 523#endif 524 LOCKSTAT_PROFILE_OBTAIN_LOCK_SUCCESS(LS_MTX_LOCK_ACQUIRE, m, contested, 525 waittime, file, line); 526#ifdef KDTRACE_HOOKS 527 if (sleep_time) 528 LOCKSTAT_RECORD1(LS_MTX_LOCK_BLOCK, m, sleep_time); 529 530 /* 531 * Only record the loops spinning and not sleeping. 532 */ 533 if (spin_cnt > sleep_cnt) 534 LOCKSTAT_RECORD1(LS_MTX_LOCK_SPIN, m, (spin_cnt - sleep_cnt)); 535#endif 536} 537 538static void 539_mtx_lock_spin_failed(struct mtx *m) 540{ 541 struct thread *td; 542 543 td = mtx_owner(m); 544 545 /* If the mutex is unlocked, try again. */ 546 if (td == NULL) 547 return; 548 549 printf( "spin lock %p (%s) held by %p (tid %d) too long\n", 550 m, m->lock_object.lo_name, td, td->td_tid); 551#ifdef WITNESS 552 witness_display_spinlock(&m->lock_object, td, printf); 553#endif 554 panic("spin lock held too long"); 555} 556 557#ifdef SMP 558/* 559 * _mtx_lock_spin_cookie: the tougher part of acquiring an MTX_SPIN lock. 560 * 561 * This is only called if we need to actually spin for the lock. Recursion 562 * is handled inline. 563 */ 564void 565_mtx_lock_spin_cookie(volatile uintptr_t *c, uintptr_t tid, int opts, 566 const char *file, int line) 567{ 568 struct mtx *m; 569 int i = 0; 570#ifdef LOCK_PROFILING 571 int contested = 0; 572 uint64_t waittime = 0; 573#endif 574 575 if (SCHEDULER_STOPPED()) 576 return; 577 578 m = mtxlock2mtx(c); 579 580 if (LOCK_LOG_TEST(&m->lock_object, opts)) 581 CTR1(KTR_LOCK, "_mtx_lock_spin: %p spinning", m); 582 583#ifdef HWPMC_HOOKS 584 PMC_SOFT_CALL( , , lock, failed); 585#endif 586 lock_profile_obtain_lock_failed(&m->lock_object, &contested, &waittime); 587 while (!_mtx_obtain_lock(m, tid)) { 588 589 /* Give interrupts a chance while we spin. */ 590 spinlock_exit(); 591 while (m->mtx_lock != MTX_UNOWNED) { 592 if (i++ < 10000000) { 593 cpu_spinwait(); 594 continue; 595 } 596 if (i < 60000000 || kdb_active || panicstr != NULL) 597 DELAY(1); 598 else 599 _mtx_lock_spin_failed(m); 600 cpu_spinwait(); 601 } 602 spinlock_enter(); 603 } 604 605 if (LOCK_LOG_TEST(&m->lock_object, opts)) 606 CTR1(KTR_LOCK, "_mtx_lock_spin: %p spin done", m); 607 608 LOCKSTAT_PROFILE_OBTAIN_LOCK_SUCCESS(LS_MTX_SPIN_LOCK_ACQUIRE, m, 609 contested, waittime, (file), (line)); 610 LOCKSTAT_RECORD1(LS_MTX_SPIN_LOCK_SPIN, m, i); 611} 612#endif /* SMP */ 613 614void 615thread_lock_flags_(struct thread *td, int opts, const char *file, int line) 616{ 617 struct mtx *m; 618 uintptr_t tid; 619 int i; 620#ifdef LOCK_PROFILING 621 int contested = 0; 622 uint64_t waittime = 0; 623#endif 624#ifdef KDTRACE_HOOKS 625 uint64_t spin_cnt = 0; 626#endif 627 628 i = 0; 629 tid = (uintptr_t)curthread; 630 631 if (SCHEDULER_STOPPED()) 632 return; 633 634 for (;;) { 635retry: 636 spinlock_enter(); 637 m = td->td_lock; 638 KASSERT(m->mtx_lock != MTX_DESTROYED, 639 ("thread_lock() of destroyed mutex @ %s:%d", file, line)); 640 KASSERT(LOCK_CLASS(&m->lock_object) == &lock_class_mtx_spin, 641 ("thread_lock() of sleep mutex %s @ %s:%d", 642 m->lock_object.lo_name, file, line)); 643 if (mtx_owned(m)) 644 KASSERT((m->lock_object.lo_flags & LO_RECURSABLE) != 0, 645 ("thread_lock: recursed on non-recursive mutex %s @ %s:%d\n", 646 m->lock_object.lo_name, file, line)); 647 WITNESS_CHECKORDER(&m->lock_object, 648 opts | LOP_NEWORDER | LOP_EXCLUSIVE, file, line, NULL); 649 while (!_mtx_obtain_lock(m, tid)) { 650#ifdef KDTRACE_HOOKS 651 spin_cnt++; 652#endif 653 if (m->mtx_lock == tid) { 654 m->mtx_recurse++; 655 break; 656 } 657#ifdef HWPMC_HOOKS 658 PMC_SOFT_CALL( , , lock, failed); 659#endif 660 lock_profile_obtain_lock_failed(&m->lock_object, 661 &contested, &waittime); 662 /* Give interrupts a chance while we spin. */ 663 spinlock_exit(); 664 while (m->mtx_lock != MTX_UNOWNED) { 665 if (i++ < 10000000) 666 cpu_spinwait(); 667 else if (i < 60000000 || 668 kdb_active || panicstr != NULL) 669 DELAY(1); 670 else 671 _mtx_lock_spin_failed(m); 672 cpu_spinwait(); 673 if (m != td->td_lock) 674 goto retry; 675 } 676 spinlock_enter(); 677 } 678 if (m == td->td_lock) 679 break; 680 __mtx_unlock_spin(m); /* does spinlock_exit() */ 681#ifdef KDTRACE_HOOKS 682 spin_cnt++; 683#endif 684 } 685 if (m->mtx_recurse == 0) 686 LOCKSTAT_PROFILE_OBTAIN_LOCK_SUCCESS(LS_MTX_SPIN_LOCK_ACQUIRE, 687 m, contested, waittime, (file), (line)); 688 LOCK_LOG_LOCK("LOCK", &m->lock_object, opts, m->mtx_recurse, file, 689 line); 690 WITNESS_LOCK(&m->lock_object, opts | LOP_EXCLUSIVE, file, line); 691 LOCKSTAT_RECORD1(LS_THREAD_LOCK_SPIN, m, spin_cnt); 692} 693 694struct mtx * 695thread_lock_block(struct thread *td) 696{ 697 struct mtx *lock; 698 699 THREAD_LOCK_ASSERT(td, MA_OWNED); 700 lock = td->td_lock; 701 td->td_lock = &blocked_lock; 702 mtx_unlock_spin(lock); 703 704 return (lock); 705} 706 707void 708thread_lock_unblock(struct thread *td, struct mtx *new) 709{ 710 mtx_assert(new, MA_OWNED); 711 MPASS(td->td_lock == &blocked_lock); 712 atomic_store_rel_ptr((volatile void *)&td->td_lock, (uintptr_t)new); 713} 714 715void 716thread_lock_set(struct thread *td, struct mtx *new) 717{ 718 struct mtx *lock; 719 720 mtx_assert(new, MA_OWNED); 721 THREAD_LOCK_ASSERT(td, MA_OWNED); 722 lock = td->td_lock; 723 td->td_lock = new; 724 mtx_unlock_spin(lock); 725} 726 727/* 728 * __mtx_unlock_sleep: the tougher part of releasing an MTX_DEF lock. 729 * 730 * We are only called here if the lock is recursed or contested (i.e. we 731 * need to wake up a blocked thread). 732 */ 733void 734__mtx_unlock_sleep(volatile uintptr_t *c, int opts, const char *file, int line) 735{ 736 struct mtx *m; 737 struct turnstile *ts; 738 739 if (SCHEDULER_STOPPED()) 740 return; 741 742 m = mtxlock2mtx(c); 743 744 if (mtx_recursed(m)) { 745 if (--(m->mtx_recurse) == 0) 746 atomic_clear_ptr(&m->mtx_lock, MTX_RECURSED); 747 if (LOCK_LOG_TEST(&m->lock_object, opts)) 748 CTR1(KTR_LOCK, "_mtx_unlock_sleep: %p unrecurse", m); 749 return; 750 } 751 752 /* 753 * We have to lock the chain before the turnstile so this turnstile 754 * can be removed from the hash list if it is empty. 755 */ 756 turnstile_chain_lock(&m->lock_object); 757 ts = turnstile_lookup(&m->lock_object); 758 if (LOCK_LOG_TEST(&m->lock_object, opts)) 759 CTR1(KTR_LOCK, "_mtx_unlock_sleep: %p contested", m); 760 MPASS(ts != NULL); 761 turnstile_broadcast(ts, TS_EXCLUSIVE_QUEUE); 762 _mtx_release_lock_quick(m); 763 764 /* 765 * This turnstile is now no longer associated with the mutex. We can 766 * unlock the chain lock so a new turnstile may take it's place. 767 */ 768 turnstile_unpend(ts, TS_EXCLUSIVE_LOCK); 769 turnstile_chain_unlock(&m->lock_object); 770} 771 772/* 773 * All the unlocking of MTX_SPIN locks is done inline. 774 * See the __mtx_unlock_spin() macro for the details. 775 */ 776 777/* 778 * The backing function for the INVARIANTS-enabled mtx_assert() 779 */ 780#ifdef INVARIANT_SUPPORT 781void 782__mtx_assert(const volatile uintptr_t *c, int what, const char *file, int line) 783{ 784 const struct mtx *m; 785 786 if (panicstr != NULL || dumping) 787 return; 788 789 m = mtxlock2mtx(c); 790 791 switch (what) { 792 case MA_OWNED: 793 case MA_OWNED | MA_RECURSED: 794 case MA_OWNED | MA_NOTRECURSED: 795 if (!mtx_owned(m)) 796 panic("mutex %s not owned at %s:%d", 797 m->lock_object.lo_name, file, line); 798 if (mtx_recursed(m)) { 799 if ((what & MA_NOTRECURSED) != 0) 800 panic("mutex %s recursed at %s:%d", 801 m->lock_object.lo_name, file, line); 802 } else if ((what & MA_RECURSED) != 0) { 803 panic("mutex %s unrecursed at %s:%d", 804 m->lock_object.lo_name, file, line); 805 } 806 break; 807 case MA_NOTOWNED: 808 if (mtx_owned(m)) 809 panic("mutex %s owned at %s:%d", 810 m->lock_object.lo_name, file, line); 811 break; 812 default: 813 panic("unknown mtx_assert at %s:%d", file, line); 814 } 815} 816#endif 817 818/* 819 * The MUTEX_DEBUG-enabled mtx_validate() 820 * 821 * Most of these checks have been moved off into the LO_INITIALIZED flag 822 * maintained by the witness code. 823 */ 824#ifdef MUTEX_DEBUG 825 826void mtx_validate(struct mtx *); 827 828void 829mtx_validate(struct mtx *m) 830{ 831 832/* 833 * XXX: When kernacc() does not require Giant we can reenable this check 834 */ 835#ifdef notyet 836 /* 837 * Can't call kernacc() from early init386(), especially when 838 * initializing Giant mutex, because some stuff in kernacc() 839 * requires Giant itself. 840 */ 841 if (!cold) 842 if (!kernacc((caddr_t)m, sizeof(m), 843 VM_PROT_READ | VM_PROT_WRITE)) 844 panic("Can't read and write to mutex %p", m); 845#endif 846} 847#endif 848 849/* 850 * General init routine used by the MTX_SYSINIT() macro. 851 */ 852void 853mtx_sysinit(void *arg) 854{ 855 struct mtx_args *margs = arg; 856 857 mtx_init((struct mtx *)margs->ma_mtx, margs->ma_desc, NULL, 858 margs->ma_opts); 859} 860 861/* 862 * Mutex initialization routine; initialize lock `m' of type contained in 863 * `opts' with options contained in `opts' and name `name.' The optional 864 * lock type `type' is used as a general lock category name for use with 865 * witness. 866 */ 867void 868_mtx_init(volatile uintptr_t *c, const char *name, const char *type, int opts) 869{ 870 struct mtx *m; 871 struct lock_class *class; 872 int flags; 873 874 m = mtxlock2mtx(c); 875 876 MPASS((opts & ~(MTX_SPIN | MTX_QUIET | MTX_RECURSE | 877 MTX_NOWITNESS | MTX_DUPOK | MTX_NOPROFILE)) == 0); 878 ASSERT_ATOMIC_LOAD_PTR(m->mtx_lock, 879 ("%s: mtx_lock not aligned for %s: %p", __func__, name, 880 &m->mtx_lock)); 881 882#ifdef MUTEX_DEBUG 883 /* Diagnostic and error correction */ 884 mtx_validate(m); 885#endif 886 887 /* Determine lock class and lock flags. */ 888 if (opts & MTX_SPIN) 889 class = &lock_class_mtx_spin; 890 else 891 class = &lock_class_mtx_sleep; 892 flags = 0; 893 if (opts & MTX_QUIET) 894 flags |= LO_QUIET; 895 if (opts & MTX_RECURSE) 896 flags |= LO_RECURSABLE; 897 if ((opts & MTX_NOWITNESS) == 0) 898 flags |= LO_WITNESS; 899 if (opts & MTX_DUPOK) 900 flags |= LO_DUPOK; 901 if (opts & MTX_NOPROFILE) 902 flags |= LO_NOPROFILE; 903 904 /* Initialize mutex. */ 905 lock_init(&m->lock_object, class, name, type, flags); 906 907 m->mtx_lock = MTX_UNOWNED; 908 m->mtx_recurse = 0; 909} 910 911/* 912 * Remove lock `m' from all_mtx queue. We don't allow MTX_QUIET to be 913 * passed in as a flag here because if the corresponding mtx_init() was 914 * called with MTX_QUIET set, then it will already be set in the mutex's 915 * flags. 916 */ 917void 918_mtx_destroy(volatile uintptr_t *c) 919{ 920 struct mtx *m; 921 922 m = mtxlock2mtx(c); 923 924 if (!mtx_owned(m)) 925 MPASS(mtx_unowned(m)); 926 else { 927 MPASS((m->mtx_lock & (MTX_RECURSED|MTX_CONTESTED)) == 0); 928 929 /* Perform the non-mtx related part of mtx_unlock_spin(). */ 930 if (LOCK_CLASS(&m->lock_object) == &lock_class_mtx_spin) 931 spinlock_exit(); 932 else 933 curthread->td_locks--; 934 935 lock_profile_release_lock(&m->lock_object); 936 /* Tell witness this isn't locked to make it happy. */ 937 WITNESS_UNLOCK(&m->lock_object, LOP_EXCLUSIVE, __FILE__, 938 __LINE__); 939 } 940 941 m->mtx_lock = MTX_DESTROYED; 942 lock_destroy(&m->lock_object); 943} 944 945/* 946 * Intialize the mutex code and system mutexes. This is called from the MD 947 * startup code prior to mi_startup(). The per-CPU data space needs to be 948 * setup before this is called. 949 */ 950void 951mutex_init(void) 952{ 953 954 /* Setup turnstiles so that sleep mutexes work. */ 955 init_turnstiles(); 956 957 /* 958 * Initialize mutexes. 959 */ 960 mtx_init(&Giant, "Giant", NULL, MTX_DEF | MTX_RECURSE); 961 mtx_init(&blocked_lock, "blocked lock", NULL, MTX_SPIN); 962 blocked_lock.mtx_lock = 0xdeadc0de; /* Always blocked. */ 963 mtx_init(&proc0.p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK); 964 mtx_init(&proc0.p_slock, "process slock", NULL, MTX_SPIN | MTX_RECURSE); 965 mtx_init(&devmtx, "cdev", NULL, MTX_DEF); 966 mtx_lock(&Giant); 967} 968 969#ifdef DDB 970void 971db_show_mtx(const struct lock_object *lock) 972{ 973 struct thread *td; 974 const struct mtx *m; 975 976 m = (const struct mtx *)lock; 977 978 db_printf(" flags: {"); 979 if (LOCK_CLASS(lock) == &lock_class_mtx_spin) 980 db_printf("SPIN"); 981 else 982 db_printf("DEF"); 983 if (m->lock_object.lo_flags & LO_RECURSABLE) 984 db_printf(", RECURSE"); 985 if (m->lock_object.lo_flags & LO_DUPOK) 986 db_printf(", DUPOK"); 987 db_printf("}\n"); 988 db_printf(" state: {"); 989 if (mtx_unowned(m)) 990 db_printf("UNOWNED"); 991 else if (mtx_destroyed(m)) 992 db_printf("DESTROYED"); 993 else { 994 db_printf("OWNED"); 995 if (m->mtx_lock & MTX_CONTESTED) 996 db_printf(", CONTESTED"); 997 if (m->mtx_lock & MTX_RECURSED) 998 db_printf(", RECURSED"); 999 } 1000 db_printf("}\n"); 1001 if (!mtx_unowned(m) && !mtx_destroyed(m)) { 1002 td = mtx_owner(m); 1003 db_printf(" owner: %p (tid %d, pid %d, \"%s\")\n", td, 1004 td->td_tid, td->td_proc->p_pid, td->td_name); 1005 if (mtx_recursed(m)) 1006 db_printf(" recursed: %d\n", m->mtx_recurse); 1007 } 1008} 1009#endif 1010