sys/kern/kern_mutex.c

   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_mprof.h"
  42 #include "opt_mutex_wake_all.h"
  43 #include "opt_sched.h"
  44
  45 #include <sys/param.h>
  46 #include <sys/systm.h>
  47 #include <sys/bus.h>
  48 #include <sys/conf.h>
  49 #include <sys/kdb.h>
  50 #include <sys/kernel.h>
  51 #include <sys/ktr.h>
  52 #include <sys/lock.h>
  53 #include <sys/malloc.h>
  54 #include <sys/mutex.h>
  55 #include <sys/proc.h>
  56 #include <sys/resourcevar.h>
  57 #include <sys/sched.h>
  58 #include <sys/sbuf.h>
  59 #include <sys/sysctl.h>
  60 #include <sys/turnstile.h>
  61 #include <sys/vmmeter.h>
  62
  63 #include <machine/atomic.h>
  64 #include <machine/bus.h>
  65 #include <machine/cpu.h>
  66
  67 #include <ddb/ddb.h>
  68
  69 #include <fs/devfs/devfs_int.h>
  70
  71 #include <vm/vm.h>
  72 #include <vm/vm_extern.h>
  73
  74 /*
  75  * Force MUTEX_WAKE_ALL for now.
  76  * single thread wakeup needs fixes to avoid race conditions with
  77  * priority inheritance.
  78  */
  79 #ifndef MUTEX_WAKE_ALL
  80 #define MUTEX_WAKE_ALL
  81 #endif
  82
  83 /*
  84  * Internal utility macros.
  85  */
  86 #define mtx_unowned(m)  ((m)->mtx_lock == MTX_UNOWNED)
  87
  88 #define mtx_owner(m)    ((struct thread *)((m)->mtx_lock & ~MTX_FLAGMASK))
  89
  90 #ifdef DDB
  91 static void     db_show_mtx(struct lock_object *lock);
  92 #endif
  93
  94 /*
  95  * Lock classes for sleep and spin mutexes.
  96  */
  97 struct lock_class lock_class_mtx_sleep = {
  98         "sleep mutex",
  99         LC_SLEEPLOCK | LC_RECURSABLE,
 100 #ifdef DDB
 101         db_show_mtx
 102 #endif
 103 };
 104 struct lock_class lock_class_mtx_spin = {
 105         "spin mutex",
 106         LC_SPINLOCK | LC_RECURSABLE,
 107 #ifdef DDB
 108         db_show_mtx
 109 #endif
 110 };
 111
 112 /*
 113  * System-wide mutexes
 114  */
 115 struct mtx sched_lock;
 116 struct mtx Giant;
 117
 118 #ifdef MUTEX_PROFILING
 119 SYSCTL_NODE(_debug, OID_AUTO, mutex, CTLFLAG_RD, NULL, "mutex debugging");
 120 SYSCTL_NODE(_debug_mutex, OID_AUTO, prof, CTLFLAG_RD, NULL, "mutex profiling");
 121 static int mutex_prof_enable = 0;
 122 SYSCTL_INT(_debug_mutex_prof, OID_AUTO, enable, CTLFLAG_RW,
 123     &mutex_prof_enable, 0, "Enable tracing of mutex holdtime");
 124
 125 struct mutex_prof {
 126         const char      *name;
 127         const char      *file;
 128         int             line;
 129         uintmax_t       cnt_max;
 130         uintmax_t       cnt_tot;
 131         uintmax_t       cnt_cur;
 132         uintmax_t       cnt_contest_holding;
 133         uintmax_t       cnt_contest_locking;
 134         struct mutex_prof *next;
 135 };
 136
 137 /*
 138  * mprof_buf is a static pool of profiling records to avoid possible
 139  * reentrance of the memory allocation functions.
 140  *
 141  * Note: NUM_MPROF_BUFFERS must be smaller than MPROF_HASH_SIZE.
 142  */
 143 #ifdef MPROF_BUFFERS
 144 #define NUM_MPROF_BUFFERS       MPROF_BUFFERS
 145 #else
 146 #define NUM_MPROF_BUFFERS       1000
 147 #endif
 148 static struct mutex_prof mprof_buf[NUM_MPROF_BUFFERS];
 149 static int first_free_mprof_buf;
 150 #ifndef MPROF_HASH_SIZE
 151 #define MPROF_HASH_SIZE         1009
 152 #endif
 153 #if NUM_MPROF_BUFFERS >= MPROF_HASH_SIZE
 154 #error MPROF_BUFFERS must be larger than MPROF_HASH_SIZE
 155 #endif
 156 static struct mutex_prof *mprof_hash[MPROF_HASH_SIZE];
 157 /* SWAG: sbuf size = avg stat. line size * number of locks */
 158 #define MPROF_SBUF_SIZE         256 * 400
 159
 160 static int mutex_prof_acquisitions;
 161 SYSCTL_INT(_debug_mutex_prof, OID_AUTO, acquisitions, CTLFLAG_RD,
 162     &mutex_prof_acquisitions, 0, "Number of mutex acquistions recorded");
 163 static int mutex_prof_records;
 164 SYSCTL_INT(_debug_mutex_prof, OID_AUTO, records, CTLFLAG_RD,
 165     &mutex_prof_records, 0, "Number of profiling records");
 166 static int mutex_prof_maxrecords = NUM_MPROF_BUFFERS;
 167 SYSCTL_INT(_debug_mutex_prof, OID_AUTO, maxrecords, CTLFLAG_RD,
 168     &mutex_prof_maxrecords, 0, "Maximum number of profiling records");
 169 static int mutex_prof_rejected;
 170 SYSCTL_INT(_debug_mutex_prof, OID_AUTO, rejected, CTLFLAG_RD,
 171     &mutex_prof_rejected, 0, "Number of rejected profiling records");
 172 static int mutex_prof_hashsize = MPROF_HASH_SIZE;
 173 SYSCTL_INT(_debug_mutex_prof, OID_AUTO, hashsize, CTLFLAG_RD,
 174     &mutex_prof_hashsize, 0, "Hash size");
 175 static int mutex_prof_collisions = 0;
 176 SYSCTL_INT(_debug_mutex_prof, OID_AUTO, collisions, CTLFLAG_RD,
 177     &mutex_prof_collisions, 0, "Number of hash collisions");
 178
 179 /*
 180  * mprof_mtx protects the profiling buffers and the hash.
 181  */
 182 static struct mtx mprof_mtx;
 183 MTX_SYSINIT(mprof, &mprof_mtx, "mutex profiling lock", MTX_SPIN | MTX_QUIET);
 184
 185 static u_int64_t
 186 nanoseconds(void)
 187 {
 188         struct timespec tv;
 189
 190         nanotime(&tv);
 191         return (tv.tv_sec * (u_int64_t)1000000000 + tv.tv_nsec);
 192 }
 193
 194 static int
 195 dump_mutex_prof_stats(SYSCTL_HANDLER_ARGS)
 196 {
 197         struct sbuf *sb;
 198         int error, i;
 199         static int multiplier = 1;
 200
 201         if (first_free_mprof_buf == 0)
 202                 return (SYSCTL_OUT(req, "No locking recorded",
 203                     sizeof("No locking recorded")));
 204
 205 retry_sbufops:
 206         sb = sbuf_new(NULL, NULL, MPROF_SBUF_SIZE * multiplier, SBUF_FIXEDLEN);
 207         sbuf_printf(sb, "\n%6s %12s %11s %5s %12s %12s %s\n",
 208             "max", "total", "count", "avg", "cnt_hold", "cnt_lock", "name");
 209         /*
 210          * XXX this spinlock seems to be by far the largest perpetrator
 211          * of spinlock latency (1.6 msec on an Athlon1600 was recorded
 212          * even before I pessimized it further by moving the average
 213          * computation here).
 214          */
 215         mtx_lock_spin(&mprof_mtx);
 216         for (i = 0; i < first_free_mprof_buf; ++i) {
 217                 sbuf_printf(sb, "%6ju %12ju %11ju %5ju %12ju %12ju %s:%d (%s)\n",
 218                     mprof_buf[i].cnt_max / 1000,
 219                     mprof_buf[i].cnt_tot / 1000,
 220                     mprof_buf[i].cnt_cur,
 221                     mprof_buf[i].cnt_cur == 0 ? (uintmax_t)0 :
 222                         mprof_buf[i].cnt_tot / (mprof_buf[i].cnt_cur * 1000),
 223                     mprof_buf[i].cnt_contest_holding,
 224                     mprof_buf[i].cnt_contest_locking,
 225                     mprof_buf[i].file, mprof_buf[i].line, mprof_buf[i].name);
 226                 if (sbuf_overflowed(sb)) {
 227                         mtx_unlock_spin(&mprof_mtx);
 228                         sbuf_delete(sb);
 229                         multiplier++;
 230                         goto retry_sbufops;
 231                 }
 232         }
 233         mtx_unlock_spin(&mprof_mtx);
 234         sbuf_finish(sb);
 235         error = SYSCTL_OUT(req, sbuf_data(sb), sbuf_len(sb) + 1);
 236         sbuf_delete(sb);
 237         return (error);
 238 }
 239 SYSCTL_PROC(_debug_mutex_prof, OID_AUTO, stats, CTLTYPE_STRING | CTLFLAG_RD,
 240     NULL, 0, dump_mutex_prof_stats, "A", "Mutex profiling statistics");
 241
 242 static int
 243 reset_mutex_prof_stats(SYSCTL_HANDLER_ARGS)
 244 {
 245         int error, v;
 246
 247         if (first_free_mprof_buf == 0)
 248                 return (0);
 249
 250         v = 0;
 251         error = sysctl_handle_int(oidp, &v, 0, req);
 252         if (error)
 253                 return (error);
 254         if (req->newptr == NULL)
 255                 return (error);
 256         if (v == 0)
 257                 return (0);
 258
 259         mtx_lock_spin(&mprof_mtx);
 260         bzero(mprof_buf, sizeof(*mprof_buf) * first_free_mprof_buf);
 261         bzero(mprof_hash, sizeof(struct mtx *) * MPROF_HASH_SIZE);
 262         first_free_mprof_buf = 0;
 263         mtx_unlock_spin(&mprof_mtx);
 264         return (0);
 265 }
 266 SYSCTL_PROC(_debug_mutex_prof, OID_AUTO, reset, CTLTYPE_INT | CTLFLAG_RW,
 267     NULL, 0, reset_mutex_prof_stats, "I", "Reset mutex profiling statistics");
 268 #endif
 269
 270 /*
 271  * Function versions of the inlined __mtx_* macros.  These are used by
 272  * modules and can also be called from assembly language if needed.
 273  */
 274 void
 275 _mtx_lock_flags(struct mtx *m, int opts, const char *file, int line)
 276 {
 277
 278         MPASS(curthread != NULL);
 279         KASSERT(m->mtx_lock != MTX_DESTROYED,
 280             ("mtx_lock() of destroyed mutex @ %s:%d", file, line));
 281         KASSERT(LOCK_CLASS(&m->mtx_object) == &lock_class_mtx_sleep,
 282             ("mtx_lock() of spin mutex %s @ %s:%d", m->mtx_object.lo_name,
 283             file, line));
 284         WITNESS_CHECKORDER(&m->mtx_object, opts | LOP_NEWORDER | LOP_EXCLUSIVE,
 285             file, line);
 286         _get_sleep_lock(m, curthread, opts, file, line);
 287         LOCK_LOG_LOCK("LOCK", &m->mtx_object, opts, m->mtx_recurse, file,
 288             line);
 289         WITNESS_LOCK(&m->mtx_object, opts | LOP_EXCLUSIVE, file, line);
 290         curthread->td_locks++;
 291 #ifdef MUTEX_PROFILING
 292         /* don't reset the timer when/if recursing */
 293         if (m->mtx_acqtime == 0) {
 294                 m->mtx_filename = file;
 295                 m->mtx_lineno = line;
 296                 m->mtx_acqtime = mutex_prof_enable ? nanoseconds() : 0;
 297                 ++mutex_prof_acquisitions;
 298         }
 299 #endif
 300 }
 301
 302 void
 303 _mtx_unlock_flags(struct mtx *m, int opts, const char *file, int line)
 304 {
 305
 306         MPASS(curthread != NULL);
 307         KASSERT(m->mtx_lock != MTX_DESTROYED,
 308             ("mtx_unlock() of destroyed mutex @ %s:%d", file, line));
 309         KASSERT(LOCK_CLASS(&m->mtx_object) == &lock_class_mtx_sleep,
 310             ("mtx_unlock() of spin mutex %s @ %s:%d", m->mtx_object.lo_name,
 311             file, line));
 312         curthread->td_locks--;
 313         WITNESS_UNLOCK(&m->mtx_object, opts | LOP_EXCLUSIVE, file, line);
 314         LOCK_LOG_LOCK("UNLOCK", &m->mtx_object, opts, m->mtx_recurse, file,
 315             line);
 316         mtx_assert(m, MA_OWNED);
 317 #ifdef MUTEX_PROFILING
 318         if (m->mtx_acqtime != 0) {
 319                 static const char *unknown = "(unknown)";
 320                 struct mutex_prof *mpp;
 321                 u_int64_t acqtime, now;
 322                 const char *p, *q;
 323                 volatile u_int hash;
 324
 325                 now = nanoseconds();
 326                 acqtime = m->mtx_acqtime;
 327                 m->mtx_acqtime = 0;
 328                 if (now <= acqtime)
 329                         goto out;
 330                 for (p = m->mtx_filename;
 331                     p != NULL && strncmp(p, "../", 3) == 0; p += 3)
 332                         /* nothing */ ;
 333                 if (p == NULL || *p == '\0')
 334                         p = unknown;
 335                 for (hash = m->mtx_lineno, q = p; *q != '\0'; ++q)
 336                         hash = (hash * 2 + *q) % MPROF_HASH_SIZE;
 337                 mtx_lock_spin(&mprof_mtx);
 338                 for (mpp = mprof_hash[hash]; mpp != NULL; mpp = mpp->next)
 339                         if (mpp->line == m->mtx_lineno &&
 340                             strcmp(mpp->file, p) == 0)
 341                                 break;
 342                 if (mpp == NULL) {
 343                         /* Just exit if we cannot get a trace buffer */
 344                         if (first_free_mprof_buf >= NUM_MPROF_BUFFERS) {
 345                                 ++mutex_prof_rejected;
 346                                 goto unlock;
 347                         }
 348                         mpp = &mprof_buf[first_free_mprof_buf++];
 349                         mpp->name = mtx_name(m);
 350                         mpp->file = p;
 351                         mpp->line = m->mtx_lineno;
 352                         mpp->next = mprof_hash[hash];
 353                         if (mprof_hash[hash] != NULL)
 354                                 ++mutex_prof_collisions;
 355                         mprof_hash[hash] = mpp;
 356                         ++mutex_prof_records;
 357                 }
 358                 /*
 359                  * Record if the mutex has been held longer now than ever
 360                  * before.
 361                  */
 362                 if (now - acqtime > mpp->cnt_max)
 363                         mpp->cnt_max = now - acqtime;
 364                 mpp->cnt_tot += now - acqtime;
 365                 mpp->cnt_cur++;
 366                 /*
 367                  * There's a small race, really we should cmpxchg
 368                  * 0 with the current value, but that would bill
 369                  * the contention to the wrong lock instance if
 370                  * it followed this also.
 371                  */
 372                 mpp->cnt_contest_holding += m->mtx_contest_holding;
 373                 m->mtx_contest_holding = 0;
 374                 mpp->cnt_contest_locking += m->mtx_contest_locking;
 375                 m->mtx_contest_locking = 0;
 376 unlock:
 377                 mtx_unlock_spin(&mprof_mtx);
 378         }
 379 out:
 380 #endif
 381         _rel_sleep_lock(m, curthread, opts, file, line);
 382 }
 383
 384 void
 385 _mtx_lock_spin_flags(struct mtx *m, int opts, const char *file, int line)
 386 {
 387
 388         MPASS(curthread != NULL);
 389         KASSERT(m->mtx_lock != MTX_DESTROYED,
 390             ("mtx_lock_spin() of destroyed mutex @ %s:%d", file, line));
 391         KASSERT(LOCK_CLASS(&m->mtx_object) == &lock_class_mtx_spin,
 392             ("mtx_lock_spin() of sleep mutex %s @ %s:%d",
 393             m->mtx_object.lo_name, file, line));
 394         WITNESS_CHECKORDER(&m->mtx_object, opts | LOP_NEWORDER | LOP_EXCLUSIVE,
 395             file, line);
 396         _get_spin_lock(m, curthread, opts, file, line);
 397         LOCK_LOG_LOCK("LOCK", &m->mtx_object, opts, m->mtx_recurse, file,
 398             line);
 399         WITNESS_LOCK(&m->mtx_object, opts | LOP_EXCLUSIVE, file, line);
 400 }
 401
 402 void
 403 _mtx_unlock_spin_flags(struct mtx *m, int opts, const char *file, int line)
 404 {
 405
 406         MPASS(curthread != NULL);
 407         KASSERT(m->mtx_lock != MTX_DESTROYED,
 408             ("mtx_unlock_spin() of destroyed mutex @ %s:%d", file, line));
 409         KASSERT(LOCK_CLASS(&m->mtx_object) == &lock_class_mtx_spin,
 410             ("mtx_unlock_spin() of sleep mutex %s @ %s:%d",
 411             m->mtx_object.lo_name, file, line));
 412         WITNESS_UNLOCK(&m->mtx_object, opts | LOP_EXCLUSIVE, file, line);
 413         LOCK_LOG_LOCK("UNLOCK", &m->mtx_object, opts, m->mtx_recurse, file,
 414             line);
 415         mtx_assert(m, MA_OWNED);
 416         _rel_spin_lock(m);
 417 }
 418
 419 /*
 420  * The important part of mtx_trylock{,_flags}()
 421  * Tries to acquire lock `m.'  If this function is called on a mutex that
 422  * is already owned, it will recursively acquire the lock.
 423  */
 424 int
 425 _mtx_trylock(struct mtx *m, int opts, const char *file, int line)
 426 {
 427         int rval;
 428
 429         MPASS(curthread != NULL);
 430         KASSERT(m->mtx_lock != MTX_DESTROYED,
 431             ("mtx_trylock() of destroyed mutex @ %s:%d", file, line));
 432         KASSERT(LOCK_CLASS(&m->mtx_object) == &lock_class_mtx_sleep,
 433             ("mtx_trylock() of spin mutex %s @ %s:%d", m->mtx_object.lo_name,
 434             file, line));
 435
 436         if (mtx_owned(m) && (m->mtx_object.lo_flags & LO_RECURSABLE) != 0) {
 437                 m->mtx_recurse++;
 438                 atomic_set_ptr(&m->mtx_lock, MTX_RECURSED);
 439                 rval = 1;
 440         } else
 441                 rval = _obtain_lock(m, (uintptr_t)curthread);
 442
 443         LOCK_LOG_TRY("LOCK", &m->mtx_object, opts, rval, file, line);
 444         if (rval) {
 445                 WITNESS_LOCK(&m->mtx_object, opts | LOP_EXCLUSIVE | LOP_TRYLOCK,
 446                     file, line);
 447                 curthread->td_locks++;
 448         }
 449
 450         return (rval);
 451 }
 452
 453 /*
 454  * _mtx_lock_sleep: the tougher part of acquiring an MTX_DEF lock.
 455  *
 456  * We call this if the lock is either contested (i.e. we need to go to
 457  * sleep waiting for it), or if we need to recurse on it.
 458  */
 459 void
 460 _mtx_lock_sleep(struct mtx *m, uintptr_t tid, int opts, const char *file,
 461     int line)
 462 {
 463 #if defined(SMP) && !defined(NO_ADAPTIVE_MUTEXES)
 464         volatile struct thread *owner;
 465 #endif
 466         uintptr_t v;
 467 #ifdef KTR
 468         int cont_logged = 0;
 469 #endif
 470 #ifdef MUTEX_PROFILING
 471         int contested;
 472 #endif
 473
 474         if (mtx_owned(m)) {
 475                 KASSERT((m->mtx_object.lo_flags & LO_RECURSABLE) != 0,
 476             ("_mtx_lock_sleep: recursed on non-recursive mutex %s @ %s:%d\n",
 477                     m->mtx_object.lo_name, file, line));
 478                 m->mtx_recurse++;
 479                 atomic_set_ptr(&m->mtx_lock, MTX_RECURSED);
 480                 if (LOCK_LOG_TEST(&m->mtx_object, opts))
 481                         CTR1(KTR_LOCK, "_mtx_lock_sleep: %p recursing", m);
 482                 return;
 483         }
 484
 485         if (LOCK_LOG_TEST(&m->mtx_object, opts))
 486                 CTR4(KTR_LOCK,
 487                     "_mtx_lock_sleep: %s contested (lock=%p) at %s:%d",
 488                     m->mtx_object.lo_name, (void *)m->mtx_lock, file, line);
 489
 490 #ifdef MUTEX_PROFILING
 491         contested = 0;
 492 #endif
 493         while (!_obtain_lock(m, tid)) {
 494 #ifdef MUTEX_PROFILING
 495                 contested = 1;
 496                 atomic_add_int(&m->mtx_contest_holding, 1);
 497 #endif
 498                 turnstile_lock(&m->mtx_object);
 499                 v = m->mtx_lock;
 500
 501                 /*
 502                  * Check if the lock has been released while spinning for
 503                  * the turnstile chain lock.
 504                  */
 505                 if (v == MTX_UNOWNED) {
 506                         turnstile_release(&m->mtx_object);
 507                         cpu_spinwait();
 508                         continue;
 509                 }
 510
 511 #ifdef MUTEX_WAKE_ALL
 512                 MPASS(v != MTX_CONTESTED);
 513 #else
 514                 /*
 515                  * The mutex was marked contested on release. This means that
 516                  * there are other threads blocked on it.  Grab ownership of
 517                  * it and propagate its priority to the current thread if
 518                  * necessary.
 519                  */
 520                 if (v == MTX_CONTESTED) {
 521                         m->mtx_lock = tid | MTX_CONTESTED;
 522                         turnstile_claim(&m->mtx_object);
 523                         break;
 524                 }
 525 #endif
 526
 527                 /*
 528                  * If the mutex isn't already contested and a failure occurs
 529                  * setting the contested bit, the mutex was either released
 530                  * or the state of the MTX_RECURSED bit changed.
 531                  */
 532                 if ((v & MTX_CONTESTED) == 0 &&
 533                     !atomic_cmpset_ptr(&m->mtx_lock, v, v | MTX_CONTESTED)) {
 534                         turnstile_release(&m->mtx_object);
 535                         cpu_spinwait();
 536                         continue;
 537                 }
 538
 539 #if defined(SMP) && !defined(NO_ADAPTIVE_MUTEXES)
 540                 /*
 541                  * If the current owner of the lock is executing on another
 542                  * CPU, spin instead of blocking.
 543                  */
 544                 owner = (struct thread *)(v & ~MTX_FLAGMASK);
 545 #ifdef ADAPTIVE_GIANT
 546                 if (TD_IS_RUNNING(owner)) {
 547 #else
 548                 if (m != &Giant && TD_IS_RUNNING(owner)) {
 549 #endif
 550                         turnstile_release(&m->mtx_object);
 551                         while (mtx_owner(m) == owner && TD_IS_RUNNING(owner)) {
 552                                 cpu_spinwait();
 553                         }
 554                         continue;
 555                 }
 556 #endif  /* SMP && !NO_ADAPTIVE_MUTEXES */
 557
 558                 /*
 559                  * We definitely must sleep for this lock.
 560                  */
 561                 mtx_assert(m, MA_NOTOWNED);
 562
 563 #ifdef KTR
 564                 if (!cont_logged) {
 565                         CTR6(KTR_CONTENTION,
 566                             "contention: %p at %s:%d wants %s, taken by %s:%d",
 567                             (void *)tid, file, line, m->mtx_object.lo_name,
 568                             WITNESS_FILE(&m->mtx_object),
 569                             WITNESS_LINE(&m->mtx_object));
 570                         cont_logged = 1;
 571                 }
 572 #endif
 573
 574                 /*
 575                  * Block on the turnstile.
 576                  */
 577                 turnstile_wait(&m->mtx_object, mtx_owner(m),
 578                     TS_EXCLUSIVE_QUEUE);
 579         }
 580
 581 #ifdef KTR
 582         if (cont_logged) {
 583                 CTR4(KTR_CONTENTION,
 584                     "contention end: %s acquired by %p at %s:%d",
 585                     m->mtx_object.lo_name, (void *)tid, file, line);
 586         }
 587 #endif
 588 #ifdef MUTEX_PROFILING
 589         if (contested)
 590                 m->mtx_contest_locking++;
 591         m->mtx_contest_holding = 0;
 592 #endif
 593         return;
 594 }
 595
 596 #ifdef SMP
 597 /*
 598  * _mtx_lock_spin: the tougher part of acquiring an MTX_SPIN lock.
 599  *
 600  * This is only called if we need to actually spin for the lock. Recursion
 601  * is handled inline.
 602  */
 603 void
 604 _mtx_lock_spin(struct mtx *m, uintptr_t tid, int opts, const char *file,
 605     int line)
 606 {
 607         struct thread *td;
 608         int i = 0;
 609
 610         if (LOCK_LOG_TEST(&m->mtx_object, opts))
 611                 CTR1(KTR_LOCK, "_mtx_lock_spin: %p spinning", m);
 612
 613         while (!_obtain_lock(m, tid)) {
 614
 615                 /* Give interrupts a chance while we spin. */
 616                 spinlock_exit();
 617                 while (m->mtx_lock != MTX_UNOWNED) {
 618                         if (i++ < 10000000) {
 619                                 cpu_spinwait();
 620                                 continue;
 621                         }
 622                         if (i < 60000000 || kdb_active || panicstr != NULL)
 623                                 DELAY(1);
 624                         else {
 625                                 td = mtx_owner(m);
 626
 627                                 /* If the mutex is unlocked, try again. */
 628                                 if (td == NULL)
 629                                         continue;
 630                                 printf(
 631                         "spin lock %p (%s) held by %p (tid %d) too long\n",
 632                                     m, m->mtx_object.lo_name, td, td->td_tid);
 633 #ifdef WITNESS
 634                                 witness_display_spinlock(&m->mtx_object, td);
 635 #endif
 636                                 panic("spin lock held too long");
 637                         }
 638                         cpu_spinwait();
 639                 }
 640                 spinlock_enter();
 641         }
 642
 643         if (LOCK_LOG_TEST(&m->mtx_object, opts))
 644                 CTR1(KTR_LOCK, "_mtx_lock_spin: %p spin done", m);
 645
 646         return;
 647 }
 648 #endif /* SMP */
 649
 650 /*
 651  * _mtx_unlock_sleep: the tougher part of releasing an MTX_DEF lock.
 652  *
 653  * We are only called here if the lock is recursed or contested (i.e. we
 654  * need to wake up a blocked thread).
 655  */
 656 void
 657 _mtx_unlock_sleep(struct mtx *m, int opts, const char *file, int line)
 658 {
 659         struct turnstile *ts;
 660 #ifndef PREEMPTION
 661         struct thread *td, *td1;
 662 #endif
 663
 664         if (mtx_recursed(m)) {
 665                 if (--(m->mtx_recurse) == 0)
 666                         atomic_clear_ptr(&m->mtx_lock, MTX_RECURSED);
 667                 if (LOCK_LOG_TEST(&m->mtx_object, opts))
 668                         CTR1(KTR_LOCK, "_mtx_unlock_sleep: %p unrecurse", m);
 669                 return;
 670         }
 671
 672         turnstile_lock(&m->mtx_object);
 673         ts = turnstile_lookup(&m->mtx_object);
 674         if (LOCK_LOG_TEST(&m->mtx_object, opts))
 675                 CTR1(KTR_LOCK, "_mtx_unlock_sleep: %p contested", m);
 676
 677 #if defined(SMP) && !defined(NO_ADAPTIVE_MUTEXES)
 678         if (ts == NULL) {
 679                 _release_lock_quick(m);
 680                 if (LOCK_LOG_TEST(&m->mtx_object, opts))
 681                         CTR1(KTR_LOCK, "_mtx_unlock_sleep: %p no sleepers", m);
 682                 turnstile_release(&m->mtx_object);
 683                 return;
 684         }
 685 #else
 686         MPASS(ts != NULL);
 687 #endif
 688 #ifndef PREEMPTION
 689         /* XXX */
 690         td1 = turnstile_head(ts, TS_EXCLUSIVE_QUEUE);
 691 #endif
 692 #ifdef MUTEX_WAKE_ALL
 693         turnstile_broadcast(ts, TS_EXCLUSIVE_QUEUE);
 694         _release_lock_quick(m);
 695 #else
 696         if (turnstile_signal(ts, TS_EXCLUSIVE_QUEUE)) {
 697                 _release_lock_quick(m);
 698                 if (LOCK_LOG_TEST(&m->mtx_object, opts))
 699                         CTR1(KTR_LOCK, "_mtx_unlock_sleep: %p not held", m);
 700         } else {
 701                 m->mtx_lock = MTX_CONTESTED;
 702                 if (LOCK_LOG_TEST(&m->mtx_object, opts))
 703                         CTR1(KTR_LOCK, "_mtx_unlock_sleep: %p still contested",
 704                             m);
 705         }
 706 #endif
 707         turnstile_unpend(ts, TS_EXCLUSIVE_LOCK);
 708
 709 #ifndef PREEMPTION
 710         /*
 711          * XXX: This is just a hack until preemption is done.  However,
 712          * once preemption is done we need to either wrap the
 713          * turnstile_signal() and release of the actual lock in an
 714          * extra critical section or change the preemption code to
 715          * always just set a flag and never do instant-preempts.
 716          */
 717         td = curthread;
 718         if (td->td_critnest > 0 || td1->td_priority >= td->td_priority)
 719                 return;
 720         mtx_lock_spin(&sched_lock);
 721         if (!TD_IS_RUNNING(td1)) {
 722 #ifdef notyet
 723                 if (td->td_ithd != NULL) {
 724                         struct ithd *it = td->td_ithd;
 725
 726                         if (it->it_interrupted) {
 727                                 if (LOCK_LOG_TEST(&m->mtx_object, opts))
 728                                         CTR2(KTR_LOCK,
 729                                     "_mtx_unlock_sleep: %p interrupted %p",
 730                                             it, it->it_interrupted);
 731                                 intr_thd_fixup(it);
 732                         }
 733                 }
 734 #endif
 735                 if (LOCK_LOG_TEST(&m->mtx_object, opts))
 736                         CTR2(KTR_LOCK,
 737                             "_mtx_unlock_sleep: %p switching out lock=%p", m,
 738                             (void *)m->mtx_lock);
 739
 740                 mi_switch(SW_INVOL, NULL);
 741                 if (LOCK_LOG_TEST(&m->mtx_object, opts))
 742                         CTR2(KTR_LOCK, "_mtx_unlock_sleep: %p resuming lock=%p",
 743                             m, (void *)m->mtx_lock);
 744         }
 745         mtx_unlock_spin(&sched_lock);
 746 #endif
 747
 748         return;
 749 }
 750
 751 /*
 752  * All the unlocking of MTX_SPIN locks is done inline.
 753  * See the _rel_spin_lock() macro for the details.
 754  */
 755
 756 /*
 757  * The backing function for the INVARIANTS-enabled mtx_assert()
 758  */
 759 #ifdef INVARIANT_SUPPORT
 760 void
 761 _mtx_assert(struct mtx *m, int what, const char *file, int line)
 762 {
 763
 764         if (panicstr != NULL || dumping)
 765                 return;
 766         switch (what) {
 767         case MA_OWNED:
 768         case MA_OWNED | MA_RECURSED:
 769         case MA_OWNED | MA_NOTRECURSED:
 770                 if (!mtx_owned(m))
 771                         panic("mutex %s not owned at %s:%d",
 772                             m->mtx_object.lo_name, file, line);
 773                 if (mtx_recursed(m)) {
 774                         if ((what & MA_NOTRECURSED) != 0)
 775                                 panic("mutex %s recursed at %s:%d",
 776                                     m->mtx_object.lo_name, file, line);
 777                 } else if ((what & MA_RECURSED) != 0) {
 778                         panic("mutex %s unrecursed at %s:%d",
 779                             m->mtx_object.lo_name, file, line);
 780                 }
 781                 break;
 782         case MA_NOTOWNED:
 783                 if (mtx_owned(m))
 784                         panic("mutex %s owned at %s:%d",
 785                             m->mtx_object.lo_name, file, line);
 786                 break;
 787         default:
 788                 panic("unknown mtx_assert at %s:%d", file, line);
 789         }
 790 }
 791 #endif
 792
 793 /*
 794  * The MUTEX_DEBUG-enabled mtx_validate()
 795  *
 796  * Most of these checks have been moved off into the LO_INITIALIZED flag
 797  * maintained by the witness code.
 798  */
 799 #ifdef MUTEX_DEBUG
 800
 801 void    mtx_validate(struct mtx *);
 802
 803 void
 804 mtx_validate(struct mtx *m)
 805 {
 806
 807 /*
 808  * XXX: When kernacc() does not require Giant we can reenable this check
 809  */
 810 #ifdef notyet
 811         /*
 812          * Can't call kernacc() from early init386(), especially when
 813          * initializing Giant mutex, because some stuff in kernacc()
 814          * requires Giant itself.
 815          */
 816         if (!cold)
 817                 if (!kernacc((caddr_t)m, sizeof(m),
 818                     VM_PROT_READ | VM_PROT_WRITE))
 819                         panic("Can't read and write to mutex %p", m);
 820 #endif
 821 }
 822 #endif
 823
 824 /*
 825  * General init routine used by the MTX_SYSINIT() macro.
 826  */
 827 void
 828 mtx_sysinit(void *arg)
 829 {
 830         struct mtx_args *margs = arg;
 831
 832         mtx_init(margs->ma_mtx, margs->ma_desc, NULL, margs->ma_opts);
 833 }
 834
 835 /*
 836  * Mutex initialization routine; initialize lock `m' of type contained in
 837  * `opts' with options contained in `opts' and name `name.'  The optional
 838  * lock type `type' is used as a general lock category name for use with
 839  * witness.
 840  */
 841 void
 842 mtx_init(struct mtx *m, const char *name, const char *type, int opts)
 843 {
 844         struct lock_class *class;
 845         int flags;
 846
 847         MPASS((opts & ~(MTX_SPIN | MTX_QUIET | MTX_RECURSE |
 848             MTX_NOWITNESS | MTX_DUPOK)) == 0);
 849
 850 #ifdef MUTEX_DEBUG
 851         /* Diagnostic and error correction */
 852         mtx_validate(m);
 853 #endif
 854
 855         /* Determine lock class and lock flags. */
 856         if (opts & MTX_SPIN)
 857                 class = &lock_class_mtx_spin;
 858         else
 859                 class = &lock_class_mtx_sleep;
 860         flags = 0;
 861         if (opts & MTX_QUIET)
 862                 flags |= LO_QUIET;
 863         if (opts & MTX_RECURSE)
 864                 flags |= LO_RECURSABLE;
 865         if ((opts & MTX_NOWITNESS) == 0)
 866                 flags |= LO_WITNESS;
 867         if (opts & MTX_DUPOK)
 868                 flags |= LO_DUPOK;
 869
 870         /* Initialize mutex. */
 871         m->mtx_lock = MTX_UNOWNED;
 872         m->mtx_recurse = 0;
 873 #ifdef MUTEX_PROFILING
 874         m->mtx_acqtime = 0;
 875         m->mtx_filename = NULL;
 876         m->mtx_lineno = 0;
 877         m->mtx_contest_holding = 0;
 878         m->mtx_contest_locking = 0;
 879 #endif
 880
 881         lock_init(&m->mtx_object, class, name, type, flags);
 882 }
 883
 884 /*
 885  * Remove lock `m' from all_mtx queue.  We don't allow MTX_QUIET to be
 886  * passed in as a flag here because if the corresponding mtx_init() was
 887  * called with MTX_QUIET set, then it will already be set in the mutex's
 888  * flags.
 889  */
 890 void
 891 mtx_destroy(struct mtx *m)
 892 {
 893
 894         if (!mtx_owned(m))
 895                 MPASS(mtx_unowned(m));
 896         else {
 897                 MPASS((m->mtx_lock & (MTX_RECURSED|MTX_CONTESTED)) == 0);
 898
 899                 /* Perform the non-mtx related part of mtx_unlock_spin(). */
 900                 if (LOCK_CLASS(&m->mtx_object) == &lock_class_mtx_spin)
 901                         spinlock_exit();
 902                 else
 903                         curthread->td_locks--;
 904
 905                 /* Tell witness this isn't locked to make it happy. */
 906                 WITNESS_UNLOCK(&m->mtx_object, LOP_EXCLUSIVE, __FILE__,
 907                     __LINE__);
 908         }
 909
 910         m->mtx_lock = MTX_DESTROYED;
 911         lock_destroy(&m->mtx_object);
 912 }
 913
 914 /*
 915  * Intialize the mutex code and system mutexes.  This is called from the MD
 916  * startup code prior to mi_startup().  The per-CPU data space needs to be
 917  * setup before this is called.
 918  */
 919 void
 920 mutex_init(void)
 921 {
 922
 923         /* Setup turnstiles so that sleep mutexes work. */
 924         init_turnstiles();
 925
 926         /*
 927          * Initialize mutexes.
 928          */
 929         mtx_init(&Giant, "Giant", NULL, MTX_DEF | MTX_RECURSE);
 930         mtx_init(&sched_lock, "sched lock", NULL, MTX_SPIN | MTX_RECURSE);
 931         mtx_init(&proc0.p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK);
 932         mtx_init(&devmtx, "cdev", NULL, MTX_DEF);
 933         mtx_lock(&Giant);
 934 }
 935
 936 #ifdef DDB
 937 void
 938 db_show_mtx(struct lock_object *lock)
 939 {
 940         struct thread *td;
 941         struct mtx *m;
 942
 943         m = (struct mtx *)lock;
 944
 945         db_printf(" flags: {");
 946         if (LOCK_CLASS(lock) == &lock_class_mtx_spin)
 947                 db_printf("SPIN");
 948         else
 949                 db_printf("DEF");
 950         if (m->mtx_object.lo_flags & LO_RECURSABLE)
 951                 db_printf(", RECURSE");
 952         if (m->mtx_object.lo_flags & LO_DUPOK)
 953                 db_printf(", DUPOK");
 954         db_printf("}\n");
 955         db_printf(" state: {");
 956         if (mtx_unowned(m))
 957                 db_printf("UNOWNED");
 958         else {
 959                 db_printf("OWNED");
 960                 if (m->mtx_lock & MTX_CONTESTED)
 961                         db_printf(", CONTESTED");
 962                 if (m->mtx_lock & MTX_RECURSED)
 963                         db_printf(", RECURSED");
 964         }
 965         db_printf("}\n");
 966         if (!mtx_unowned(m)) {
 967                 td = mtx_owner(m);
 968                 db_printf(" owner: %p (tid %d, pid %d, \"%s\")\n", td,
 969                     td->td_tid, td->td_proc->p_pid, td->td_proc->p_comm);
 970                 if (mtx_recursed(m))
 971                         db_printf(" recursed: %d\n", m->mtx_recurse);
 972         }
 973 }
 974 #endif