1997-03-25 16:27:20 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1995
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
1997-08-18 02:06:35 +00:00
|
|
|
* Copyright (C) 1997
|
|
|
|
* John S. Dyson. All rights reserved.
|
|
|
|
*
|
1997-03-25 16:27:20 +00:00
|
|
|
* This code contains ideas from software contributed to Berkeley by
|
|
|
|
* Avadis Tevanian, Jr., Michael Wayne Young, and the Mach Operating
|
|
|
|
* System project at Carnegie-Mellon University.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)kern_lock.c 8.18 (Berkeley) 5/21/95
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1997-03-25 16:27:20 +00:00
|
|
|
#include <sys/param.h>
|
2000-10-12 22:37:28 +00:00
|
|
|
#include <sys/kernel.h>
|
2001-10-11 17:53:43 +00:00
|
|
|
#include <sys/ktr.h>
|
1997-03-25 16:27:20 +00:00
|
|
|
#include <sys/lock.h>
|
2002-08-27 09:59:47 +00:00
|
|
|
#include <sys/lockmgr.h>
|
2000-10-20 07:28:00 +00:00
|
|
|
#include <sys/mutex.h>
|
2002-08-27 09:59:47 +00:00
|
|
|
#include <sys/proc.h>
|
1997-03-25 16:36:35 +00:00
|
|
|
#include <sys/systm.h>
|
1997-03-25 16:27:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Locking primitives implementation.
|
|
|
|
* Locks provide shared/exclusive sychronization.
|
|
|
|
*/
|
|
|
|
|
1997-08-18 02:06:35 +00:00
|
|
|
#define LOCK_WAIT_TIME 100
|
|
|
|
#define LOCK_SAMPLE_WAIT 7
|
1997-03-25 16:27:20 +00:00
|
|
|
|
1997-08-18 02:06:35 +00:00
|
|
|
#if defined(DIAGNOSTIC)
|
|
|
|
#define LOCK_INLINE
|
|
|
|
#else
|
1998-04-17 04:53:44 +00:00
|
|
|
#define LOCK_INLINE __inline
|
1997-08-18 02:06:35 +00:00
|
|
|
#endif
|
1997-03-25 16:27:20 +00:00
|
|
|
|
1997-09-21 04:24:27 +00:00
|
|
|
#define LK_ALL (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE | \
|
|
|
|
LK_SHARE_NONZERO | LK_WAIT_NONZERO)
|
|
|
|
|
2000-10-12 22:37:28 +00:00
|
|
|
/*
|
|
|
|
* Mutex array variables. Rather than each lockmgr lock having its own mutex,
|
|
|
|
* share a fixed (at boot time) number of mutexes across all lockmgr locks in
|
|
|
|
* order to keep sizeof(struct lock) down.
|
|
|
|
*/
|
2001-01-21 07:52:20 +00:00
|
|
|
static struct mtx lock_mtx;
|
2000-10-12 22:37:28 +00:00
|
|
|
|
2002-11-30 19:00:51 +00:00
|
|
|
static int acquire(struct lock **lkpp, int extflags, int wanted);
|
1997-09-21 04:24:27 +00:00
|
|
|
static int apause(struct lock *lkp, int flags);
|
|
|
|
static int acquiredrain(struct lock *lkp, int extflags) ;
|
1997-03-25 16:27:20 +00:00
|
|
|
|
2000-10-12 22:37:28 +00:00
|
|
|
static void
|
|
|
|
lockmgr_init(void *dummy __unused)
|
|
|
|
{
|
2003-07-16 01:00:39 +00:00
|
|
|
mtx_init(&lock_mtx, "lockmgr", NULL, MTX_DEF);
|
2000-10-12 22:37:28 +00:00
|
|
|
}
|
2003-07-16 01:00:39 +00:00
|
|
|
SYSINIT(lmgrinit, SI_SUB_LOCKMGR, SI_ORDER_FIRST, lockmgr_init, NULL)
|
2000-10-12 22:37:28 +00:00
|
|
|
|
1997-08-18 02:06:35 +00:00
|
|
|
static LOCK_INLINE void
|
|
|
|
sharelock(struct lock *lkp, int incr) {
|
|
|
|
lkp->lk_flags |= LK_SHARE_NONZERO;
|
|
|
|
lkp->lk_sharecount += incr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static LOCK_INLINE void
|
|
|
|
shareunlock(struct lock *lkp, int decr) {
|
1999-01-10 01:58:29 +00:00
|
|
|
|
1999-01-08 17:31:30 +00:00
|
|
|
KASSERT(lkp->lk_sharecount >= decr, ("shareunlock: count < decr"));
|
1997-03-25 16:27:20 +00:00
|
|
|
|
1998-03-07 19:25:34 +00:00
|
|
|
if (lkp->lk_sharecount == decr) {
|
1997-08-18 02:06:35 +00:00
|
|
|
lkp->lk_flags &= ~LK_SHARE_NONZERO;
|
1998-03-07 19:25:34 +00:00
|
|
|
if (lkp->lk_flags & (LK_WANT_UPGRADE | LK_WANT_EXCL)) {
|
|
|
|
wakeup(lkp);
|
|
|
|
}
|
|
|
|
lkp->lk_sharecount = 0;
|
|
|
|
} else {
|
|
|
|
lkp->lk_sharecount -= decr;
|
|
|
|
}
|
1997-08-18 02:06:35 +00:00
|
|
|
}
|
1997-03-25 16:27:20 +00:00
|
|
|
|
1997-09-21 04:24:27 +00:00
|
|
|
/*
|
2001-01-24 12:35:55 +00:00
|
|
|
* This is the waitloop optimization.
|
1997-09-21 04:24:27 +00:00
|
|
|
*/
|
1997-08-18 02:06:35 +00:00
|
|
|
static int
|
1999-11-11 03:02:03 +00:00
|
|
|
apause(struct lock *lkp, int flags)
|
|
|
|
{
|
|
|
|
#ifdef SMP
|
|
|
|
int i, lock_wait;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if ((lkp->lk_flags & flags) == 0)
|
|
|
|
return 0;
|
|
|
|
#ifdef SMP
|
|
|
|
for (lock_wait = LOCK_WAIT_TIME; lock_wait > 0; lock_wait--) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(lkp->lk_interlock);
|
1999-11-11 03:02:03 +00:00
|
|
|
for (i = LOCK_SAMPLE_WAIT; i > 0; i--)
|
|
|
|
if ((lkp->lk_flags & flags) == 0)
|
1997-08-18 02:06:35 +00:00
|
|
|
break;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(lkp->lk_interlock);
|
1999-11-11 03:02:03 +00:00
|
|
|
if ((lkp->lk_flags & flags) == 0)
|
|
|
|
return 0;
|
1997-08-18 02:06:35 +00:00
|
|
|
}
|
1999-11-11 03:02:03 +00:00
|
|
|
#endif
|
1997-08-18 02:06:35 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2002-11-30 19:00:51 +00:00
|
|
|
acquire(struct lock **lkpp, int extflags, int wanted) {
|
|
|
|
struct lock *lkp = *lkpp;
|
1998-03-07 19:25:34 +00:00
|
|
|
int s, error;
|
1997-08-18 02:06:35 +00:00
|
|
|
|
2003-03-11 20:00:37 +00:00
|
|
|
CTR3(KTR_LOCK,
|
2004-07-23 20:12:56 +00:00
|
|
|
"acquire(): lkp == %p, extflags == 0x%x, wanted == 0x%x",
|
2000-10-04 01:29:17 +00:00
|
|
|
lkp, extflags, wanted);
|
|
|
|
|
1997-08-18 02:06:35 +00:00
|
|
|
if ((extflags & LK_NOWAIT) && (lkp->lk_flags & wanted)) {
|
|
|
|
return EBUSY;
|
1997-03-25 16:27:20 +00:00
|
|
|
}
|
|
|
|
|
1997-09-21 04:24:27 +00:00
|
|
|
if (((lkp->lk_flags | extflags) & LK_NOPAUSE) == 0) {
|
|
|
|
error = apause(lkp, wanted);
|
|
|
|
if (error == 0)
|
|
|
|
return 0;
|
|
|
|
}
|
1997-08-18 02:06:35 +00:00
|
|
|
|
1998-03-07 19:25:34 +00:00
|
|
|
s = splhigh();
|
1997-08-18 02:06:35 +00:00
|
|
|
while ((lkp->lk_flags & wanted) != 0) {
|
|
|
|
lkp->lk_flags |= LK_WAIT_NONZERO;
|
|
|
|
lkp->lk_waitcount++;
|
2000-12-01 02:18:38 +00:00
|
|
|
error = msleep(lkp, lkp->lk_interlock, lkp->lk_prio,
|
2001-12-20 22:42:27 +00:00
|
|
|
lkp->lk_wmesg,
|
|
|
|
((extflags & LK_TIMELOCK) ? lkp->lk_timo : 0));
|
1998-03-07 19:25:34 +00:00
|
|
|
if (lkp->lk_waitcount == 1) {
|
1997-08-18 02:06:35 +00:00
|
|
|
lkp->lk_flags &= ~LK_WAIT_NONZERO;
|
1998-03-07 19:25:34 +00:00
|
|
|
lkp->lk_waitcount = 0;
|
|
|
|
} else {
|
|
|
|
lkp->lk_waitcount--;
|
|
|
|
}
|
|
|
|
if (error) {
|
|
|
|
splx(s);
|
1997-08-18 02:06:35 +00:00
|
|
|
return error;
|
1998-03-07 19:25:34 +00:00
|
|
|
}
|
1997-08-18 02:06:35 +00:00
|
|
|
if (extflags & LK_SLEEPFAIL) {
|
1998-03-07 19:25:34 +00:00
|
|
|
splx(s);
|
1997-08-18 02:06:35 +00:00
|
|
|
return ENOLCK;
|
|
|
|
}
|
2002-11-30 19:00:51 +00:00
|
|
|
if (lkp->lk_newlock != NULL) {
|
|
|
|
mtx_lock(lkp->lk_newlock->lk_interlock);
|
|
|
|
mtx_unlock(lkp->lk_interlock);
|
|
|
|
if (lkp->lk_waitcount == 0)
|
|
|
|
wakeup((void *)(&lkp->lk_newlock));
|
|
|
|
*lkpp = lkp = lkp->lk_newlock;
|
|
|
|
}
|
1997-08-18 02:06:35 +00:00
|
|
|
}
|
1998-03-07 19:25:34 +00:00
|
|
|
splx(s);
|
1997-08-18 02:06:35 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1997-03-25 16:27:20 +00:00
|
|
|
/*
|
|
|
|
* Set, change, or release a lock.
|
|
|
|
*
|
|
|
|
* Shared requests increment the shared count. Exclusive requests set the
|
|
|
|
* LK_WANT_EXCL flag (preventing further shared locks), and wait for already
|
|
|
|
* accepted shared locks and shared-to-exclusive upgrades to go away.
|
|
|
|
*/
|
|
|
|
int
|
1999-01-20 14:49:12 +00:00
|
|
|
#ifndef DEBUG_LOCKS
|
2001-09-12 08:38:13 +00:00
|
|
|
lockmgr(lkp, flags, interlkp, td)
|
1999-01-20 14:49:12 +00:00
|
|
|
#else
|
2001-09-12 08:38:13 +00:00
|
|
|
debuglockmgr(lkp, flags, interlkp, td, name, file, line)
|
1999-01-20 14:49:12 +00:00
|
|
|
#endif
|
1997-08-04 19:11:26 +00:00
|
|
|
struct lock *lkp;
|
1997-03-25 16:27:20 +00:00
|
|
|
u_int flags;
|
2000-10-04 01:29:17 +00:00
|
|
|
struct mtx *interlkp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1999-01-20 14:49:12 +00:00
|
|
|
#ifdef DEBUG_LOCKS
|
|
|
|
const char *name; /* Name of lock function */
|
|
|
|
const char *file; /* Name of file call is from */
|
|
|
|
int line; /* Line number in file */
|
|
|
|
#endif
|
1997-03-25 16:27:20 +00:00
|
|
|
{
|
|
|
|
int error;
|
2003-02-05 19:36:58 +00:00
|
|
|
struct thread *thr;
|
2001-02-09 16:27:41 +00:00
|
|
|
int extflags, lockflags;
|
1997-03-25 16:27:20 +00:00
|
|
|
|
2003-03-11 20:00:37 +00:00
|
|
|
CTR5(KTR_LOCK,
|
2000-10-04 01:29:17 +00:00
|
|
|
"lockmgr(): lkp == %p (lk_wmesg == \"%s\"), flags == 0x%x, "
|
2001-09-12 08:38:13 +00:00
|
|
|
"interlkp == %p, td == %p", lkp, lkp->lk_wmesg, flags, interlkp, td);
|
2000-10-04 01:29:17 +00:00
|
|
|
|
1997-03-25 16:27:20 +00:00
|
|
|
error = 0;
|
2001-09-12 08:38:13 +00:00
|
|
|
if (td == NULL)
|
2003-02-05 19:36:58 +00:00
|
|
|
thr = LK_KERNPROC;
|
1997-08-19 00:27:07 +00:00
|
|
|
else
|
2003-02-05 19:36:58 +00:00
|
|
|
thr = td;
|
1997-08-18 02:06:35 +00:00
|
|
|
|
2003-02-25 03:37:48 +00:00
|
|
|
if ((flags & LK_INTERNAL) == 0)
|
|
|
|
mtx_lock(lkp->lk_interlock);
|
2001-04-20 22:38:40 +00:00
|
|
|
if (flags & LK_INTERLOCK) {
|
2001-04-28 12:11:01 +00:00
|
|
|
mtx_assert(interlkp, MA_OWNED | MA_NOTRECURSED);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(interlkp);
|
2001-04-20 22:38:40 +00:00
|
|
|
}
|
1997-08-18 02:06:35 +00:00
|
|
|
|
2003-02-25 03:37:48 +00:00
|
|
|
if ((flags & (LK_NOWAIT|LK_RELEASE)) == 0)
|
2003-03-04 21:03:05 +00:00
|
|
|
WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK,
|
|
|
|
&lkp->lk_interlock->mtx_object,
|
|
|
|
"Acquiring lockmgr lock \"%s\"", lkp->lk_wmesg);
|
2003-02-25 03:37:48 +00:00
|
|
|
|
2001-08-10 23:29:15 +00:00
|
|
|
if (panicstr != NULL) {
|
|
|
|
mtx_unlock(lkp->lk_interlock);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1997-03-25 16:27:20 +00:00
|
|
|
extflags = (flags | lkp->lk_flags) & LK_EXTFLG_MASK;
|
|
|
|
|
|
|
|
switch (flags & LK_TYPE_MASK) {
|
|
|
|
|
|
|
|
case LK_SHARED:
|
1999-03-12 03:09:29 +00:00
|
|
|
/*
|
|
|
|
* If we are not the exclusive lock holder, we have to block
|
|
|
|
* while there is an exclusive lock holder or while an
|
|
|
|
* exclusive lock request or upgrade request is in progress.
|
|
|
|
*
|
2004-06-03 01:47:37 +00:00
|
|
|
* However, if TDP_DEADLKTREAT is set, we override exclusive
|
1999-03-12 03:09:29 +00:00
|
|
|
* lock requests or upgrade requests ( but not the exclusive
|
|
|
|
* lock itself ).
|
|
|
|
*/
|
2003-02-05 19:36:58 +00:00
|
|
|
if (lkp->lk_lockholder != thr) {
|
2001-02-09 16:27:41 +00:00
|
|
|
lockflags = LK_HAVE_EXCL;
|
2004-06-03 01:47:37 +00:00
|
|
|
if (td != NULL && !(td->td_pflags & TDP_DEADLKTREAT))
|
2001-09-13 22:33:37 +00:00
|
|
|
lockflags |= LK_WANT_EXCL | LK_WANT_UPGRADE;
|
2002-11-30 19:00:51 +00:00
|
|
|
error = acquire(&lkp, extflags, lockflags);
|
1997-03-25 16:27:20 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
1997-08-18 02:06:35 +00:00
|
|
|
sharelock(lkp, 1);
|
2002-05-30 05:55:22 +00:00
|
|
|
#if defined(DEBUG_LOCKS)
|
2003-02-05 19:36:58 +00:00
|
|
|
lkp->lk_slockholder = thr;
|
2002-05-30 05:55:22 +00:00
|
|
|
lkp->lk_sfilename = file;
|
|
|
|
lkp->lk_slineno = line;
|
|
|
|
lkp->lk_slockername = name;
|
|
|
|
#endif
|
1997-03-25 16:27:20 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We hold an exclusive lock, so downgrade it to shared.
|
|
|
|
* An alternative would be to fail with EDEADLK.
|
|
|
|
*/
|
1997-08-18 02:06:35 +00:00
|
|
|
sharelock(lkp, 1);
|
2002-08-25 13:23:09 +00:00
|
|
|
/* FALLTHROUGH downgrade */
|
1997-03-25 16:27:20 +00:00
|
|
|
|
|
|
|
case LK_DOWNGRADE:
|
2003-02-05 19:36:58 +00:00
|
|
|
KASSERT(lkp->lk_lockholder == thr && lkp->lk_exclusivecount != 0,
|
2001-04-13 10:15:53 +00:00
|
|
|
("lockmgr: not holding exclusive lock "
|
2003-02-05 19:36:58 +00:00
|
|
|
"(owner thread (%p) != thread (%p), exlcnt (%d) != 0",
|
|
|
|
lkp->lk_lockholder, thr, lkp->lk_exclusivecount));
|
1997-08-18 02:06:35 +00:00
|
|
|
sharelock(lkp, lkp->lk_exclusivecount);
|
1997-03-25 16:27:20 +00:00
|
|
|
lkp->lk_exclusivecount = 0;
|
|
|
|
lkp->lk_flags &= ~LK_HAVE_EXCL;
|
2003-02-01 12:17:09 +00:00
|
|
|
lkp->lk_lockholder = LK_NOPROC;
|
1997-03-25 16:27:20 +00:00
|
|
|
if (lkp->lk_waitcount)
|
|
|
|
wakeup((void *)lkp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LK_EXCLUPGRADE:
|
|
|
|
/*
|
|
|
|
* If another process is ahead of us to get an upgrade,
|
|
|
|
* then we want to fail rather than have an intervening
|
|
|
|
* exclusive access.
|
|
|
|
*/
|
|
|
|
if (lkp->lk_flags & LK_WANT_UPGRADE) {
|
1997-08-18 02:06:35 +00:00
|
|
|
shareunlock(lkp, 1);
|
1997-03-25 16:27:20 +00:00
|
|
|
error = EBUSY;
|
|
|
|
break;
|
|
|
|
}
|
2002-08-25 13:23:09 +00:00
|
|
|
/* FALLTHROUGH normal upgrade */
|
1997-03-25 16:27:20 +00:00
|
|
|
|
|
|
|
case LK_UPGRADE:
|
|
|
|
/*
|
|
|
|
* Upgrade a shared lock to an exclusive one. If another
|
|
|
|
* shared lock has already requested an upgrade to an
|
|
|
|
* exclusive lock, our shared lock is released and an
|
|
|
|
* exclusive lock is requested (which will be granted
|
|
|
|
* after the upgrade). If we return an error, the file
|
|
|
|
* will always be unlocked.
|
|
|
|
*/
|
2003-02-05 19:36:58 +00:00
|
|
|
if ((lkp->lk_lockholder == thr) || (lkp->lk_sharecount <= 0))
|
1997-03-25 16:27:20 +00:00
|
|
|
panic("lockmgr: upgrade exclusive lock");
|
1997-08-18 02:06:35 +00:00
|
|
|
shareunlock(lkp, 1);
|
1997-03-25 16:27:20 +00:00
|
|
|
/*
|
|
|
|
* If we are just polling, check to see if we will block.
|
|
|
|
*/
|
|
|
|
if ((extflags & LK_NOWAIT) &&
|
|
|
|
((lkp->lk_flags & LK_WANT_UPGRADE) ||
|
|
|
|
lkp->lk_sharecount > 1)) {
|
|
|
|
error = EBUSY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((lkp->lk_flags & LK_WANT_UPGRADE) == 0) {
|
|
|
|
/*
|
|
|
|
* We are first shared lock to request an upgrade, so
|
|
|
|
* request upgrade and wait for the shared count to
|
|
|
|
* drop to zero, then take exclusive lock.
|
|
|
|
*/
|
|
|
|
lkp->lk_flags |= LK_WANT_UPGRADE;
|
2002-11-30 19:00:51 +00:00
|
|
|
error = acquire(&lkp, extflags, LK_SHARE_NONZERO);
|
1997-03-25 16:27:20 +00:00
|
|
|
lkp->lk_flags &= ~LK_WANT_UPGRADE;
|
1998-03-07 19:25:34 +00:00
|
|
|
|
1997-03-25 16:27:20 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
lkp->lk_flags |= LK_HAVE_EXCL;
|
2003-02-05 19:36:58 +00:00
|
|
|
lkp->lk_lockholder = thr;
|
1997-03-25 16:27:20 +00:00
|
|
|
if (lkp->lk_exclusivecount != 0)
|
|
|
|
panic("lockmgr: non-zero exclusive count");
|
|
|
|
lkp->lk_exclusivecount = 1;
|
1999-01-20 14:49:12 +00:00
|
|
|
#if defined(DEBUG_LOCKS)
|
|
|
|
lkp->lk_filename = file;
|
|
|
|
lkp->lk_lineno = line;
|
|
|
|
lkp->lk_lockername = name;
|
|
|
|
#endif
|
1997-03-25 16:27:20 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Someone else has requested upgrade. Release our shared
|
|
|
|
* lock, awaken upgrade requestor if we are the last shared
|
|
|
|
* lock, then request an exclusive lock.
|
|
|
|
*/
|
1997-08-18 02:06:35 +00:00
|
|
|
if ( (lkp->lk_flags & (LK_SHARE_NONZERO|LK_WAIT_NONZERO)) ==
|
|
|
|
LK_WAIT_NONZERO)
|
1997-03-25 16:27:20 +00:00
|
|
|
wakeup((void *)lkp);
|
2002-08-25 13:23:09 +00:00
|
|
|
/* FALLTHROUGH exclusive request */
|
1997-03-25 16:27:20 +00:00
|
|
|
|
|
|
|
case LK_EXCLUSIVE:
|
2003-02-05 19:36:58 +00:00
|
|
|
if (lkp->lk_lockholder == thr && thr != LK_KERNPROC) {
|
1997-03-25 16:27:20 +00:00
|
|
|
/*
|
|
|
|
* Recursive lock.
|
|
|
|
*/
|
1999-06-28 07:54:58 +00:00
|
|
|
if ((extflags & (LK_NOWAIT | LK_CANRECURSE)) == 0)
|
1997-03-25 16:27:20 +00:00
|
|
|
panic("lockmgr: locking against myself");
|
1999-06-28 07:54:58 +00:00
|
|
|
if ((extflags & LK_CANRECURSE) != 0) {
|
|
|
|
lkp->lk_exclusivecount++;
|
|
|
|
break;
|
|
|
|
}
|
1997-03-25 16:27:20 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If we are just polling, check to see if we will sleep.
|
|
|
|
*/
|
1997-08-18 02:06:35 +00:00
|
|
|
if ((extflags & LK_NOWAIT) &&
|
|
|
|
(lkp->lk_flags & (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE | LK_SHARE_NONZERO))) {
|
1997-03-25 16:27:20 +00:00
|
|
|
error = EBUSY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Try to acquire the want_exclusive flag.
|
|
|
|
*/
|
2002-11-30 19:00:51 +00:00
|
|
|
error = acquire(&lkp, extflags, (LK_HAVE_EXCL | LK_WANT_EXCL));
|
1997-03-25 16:27:20 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
lkp->lk_flags |= LK_WANT_EXCL;
|
|
|
|
/*
|
|
|
|
* Wait for shared locks and upgrades to finish.
|
|
|
|
*/
|
2002-11-30 19:00:51 +00:00
|
|
|
error = acquire(&lkp, extflags, LK_WANT_UPGRADE | LK_SHARE_NONZERO);
|
1997-03-25 16:27:20 +00:00
|
|
|
lkp->lk_flags &= ~LK_WANT_EXCL;
|
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
lkp->lk_flags |= LK_HAVE_EXCL;
|
2003-02-05 19:36:58 +00:00
|
|
|
lkp->lk_lockholder = thr;
|
1997-03-25 16:27:20 +00:00
|
|
|
if (lkp->lk_exclusivecount != 0)
|
|
|
|
panic("lockmgr: non-zero exclusive count");
|
|
|
|
lkp->lk_exclusivecount = 1;
|
1999-01-20 14:49:12 +00:00
|
|
|
#if defined(DEBUG_LOCKS)
|
|
|
|
lkp->lk_filename = file;
|
|
|
|
lkp->lk_lineno = line;
|
|
|
|
lkp->lk_lockername = name;
|
|
|
|
#endif
|
1997-03-25 16:27:20 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case LK_RELEASE:
|
|
|
|
if (lkp->lk_exclusivecount != 0) {
|
2003-02-05 19:36:58 +00:00
|
|
|
if (lkp->lk_lockholder != thr &&
|
1999-09-27 00:21:43 +00:00
|
|
|
lkp->lk_lockholder != LK_KERNPROC) {
|
2003-02-05 19:36:58 +00:00
|
|
|
panic("lockmgr: thread %p, not %s %p unlocking",
|
|
|
|
thr, "exclusive lock holder",
|
1997-03-25 16:27:20 +00:00
|
|
|
lkp->lk_lockholder);
|
1999-09-27 00:21:43 +00:00
|
|
|
}
|
1998-03-07 19:25:34 +00:00
|
|
|
if (lkp->lk_exclusivecount == 1) {
|
1997-03-25 16:27:20 +00:00
|
|
|
lkp->lk_flags &= ~LK_HAVE_EXCL;
|
|
|
|
lkp->lk_lockholder = LK_NOPROC;
|
1998-03-07 19:25:34 +00:00
|
|
|
lkp->lk_exclusivecount = 0;
|
|
|
|
} else {
|
|
|
|
lkp->lk_exclusivecount--;
|
1997-03-25 16:27:20 +00:00
|
|
|
}
|
2001-01-24 12:35:55 +00:00
|
|
|
} else if (lkp->lk_flags & LK_SHARE_NONZERO)
|
1997-08-18 02:06:35 +00:00
|
|
|
shareunlock(lkp, 1);
|
|
|
|
if (lkp->lk_flags & LK_WAIT_NONZERO)
|
1997-03-25 16:27:20 +00:00
|
|
|
wakeup((void *)lkp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LK_DRAIN:
|
|
|
|
/*
|
|
|
|
* Check that we do not already hold the lock, as it can
|
|
|
|
* never drain if we do. Unfortunately, we have no way to
|
|
|
|
* check for holding a shared lock, but at least we can
|
|
|
|
* check for an exclusive one.
|
|
|
|
*/
|
2003-02-05 19:36:58 +00:00
|
|
|
if (lkp->lk_lockholder == thr)
|
1997-03-25 16:27:20 +00:00
|
|
|
panic("lockmgr: draining against myself");
|
1997-08-18 02:06:35 +00:00
|
|
|
|
|
|
|
error = acquiredrain(lkp, extflags);
|
|
|
|
if (error)
|
1997-03-25 16:27:20 +00:00
|
|
|
break;
|
|
|
|
lkp->lk_flags |= LK_DRAINING | LK_HAVE_EXCL;
|
2003-02-05 19:36:58 +00:00
|
|
|
lkp->lk_lockholder = thr;
|
1997-03-25 16:27:20 +00:00
|
|
|
lkp->lk_exclusivecount = 1;
|
1999-01-20 14:49:12 +00:00
|
|
|
#if defined(DEBUG_LOCKS)
|
|
|
|
lkp->lk_filename = file;
|
|
|
|
lkp->lk_lineno = line;
|
|
|
|
lkp->lk_lockername = name;
|
|
|
|
#endif
|
1997-03-25 16:27:20 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(lkp->lk_interlock);
|
1997-03-25 16:27:20 +00:00
|
|
|
panic("lockmgr: unknown locktype request %d",
|
|
|
|
flags & LK_TYPE_MASK);
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
1997-08-18 02:06:35 +00:00
|
|
|
if ((lkp->lk_flags & LK_WAITDRAIN) &&
|
|
|
|
(lkp->lk_flags & (LK_HAVE_EXCL | LK_WANT_EXCL | LK_WANT_UPGRADE |
|
|
|
|
LK_SHARE_NONZERO | LK_WAIT_NONZERO)) == 0) {
|
1997-03-25 16:27:20 +00:00
|
|
|
lkp->lk_flags &= ~LK_WAITDRAIN;
|
|
|
|
wakeup((void *)&lkp->lk_flags);
|
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(lkp->lk_interlock);
|
1997-03-25 16:27:20 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
1997-09-21 04:24:27 +00:00
|
|
|
static int
|
|
|
|
acquiredrain(struct lock *lkp, int extflags) {
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if ((extflags & LK_NOWAIT) && (lkp->lk_flags & LK_ALL)) {
|
|
|
|
return EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
error = apause(lkp, LK_ALL);
|
|
|
|
if (error == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while (lkp->lk_flags & LK_ALL) {
|
|
|
|
lkp->lk_flags |= LK_WAITDRAIN;
|
2000-12-01 02:18:38 +00:00
|
|
|
error = msleep(&lkp->lk_flags, lkp->lk_interlock, lkp->lk_prio,
|
2001-12-20 22:42:27 +00:00
|
|
|
lkp->lk_wmesg,
|
|
|
|
((extflags & LK_TIMELOCK) ? lkp->lk_timo : 0));
|
1997-09-21 04:24:27 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
if (extflags & LK_SLEEPFAIL) {
|
|
|
|
return ENOLCK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-11-30 19:00:51 +00:00
|
|
|
/*
|
|
|
|
* Transfer any waiting processes from one lock to another.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
transferlockers(from, to)
|
|
|
|
struct lock *from;
|
|
|
|
struct lock *to;
|
|
|
|
{
|
|
|
|
|
|
|
|
KASSERT(from != to, ("lock transfer to self"));
|
|
|
|
KASSERT((from->lk_flags&LK_WAITDRAIN) == 0, ("transfer draining lock"));
|
|
|
|
if (from->lk_waitcount == 0)
|
|
|
|
return;
|
|
|
|
from->lk_newlock = to;
|
|
|
|
wakeup((void *)from);
|
|
|
|
msleep(&from->lk_newlock, NULL, from->lk_prio, "lkxfer", 0);
|
|
|
|
from->lk_newlock = NULL;
|
|
|
|
from->lk_flags &= ~(LK_WANT_EXCL | LK_WANT_UPGRADE);
|
|
|
|
KASSERT(from->lk_waitcount == 0, ("active lock"));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1997-09-21 04:24:27 +00:00
|
|
|
/*
|
|
|
|
* Initialize a lock; required before use.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
lockinit(lkp, prio, wmesg, timo, flags)
|
|
|
|
struct lock *lkp;
|
|
|
|
int prio;
|
2002-03-05 17:45:12 +00:00
|
|
|
const char *wmesg;
|
1997-09-21 04:24:27 +00:00
|
|
|
int timo;
|
|
|
|
int flags;
|
|
|
|
{
|
2003-03-11 20:00:37 +00:00
|
|
|
CTR5(KTR_LOCK, "lockinit(): lkp == %p, prio == %d, wmesg == \"%s\", "
|
2000-10-04 01:29:17 +00:00
|
|
|
"timo == %d, flags = 0x%x\n", lkp, prio, wmesg, timo, flags);
|
1997-09-21 04:24:27 +00:00
|
|
|
|
2003-07-16 01:00:39 +00:00
|
|
|
lkp->lk_interlock = mtx_pool_alloc(mtxpool_lockbuilder);
|
2000-10-12 22:37:28 +00:00
|
|
|
lkp->lk_flags = (flags & LK_EXTFLG_MASK);
|
1997-09-21 04:24:27 +00:00
|
|
|
lkp->lk_sharecount = 0;
|
|
|
|
lkp->lk_waitcount = 0;
|
|
|
|
lkp->lk_exclusivecount = 0;
|
|
|
|
lkp->lk_prio = prio;
|
|
|
|
lkp->lk_wmesg = wmesg;
|
|
|
|
lkp->lk_timo = timo;
|
|
|
|
lkp->lk_lockholder = LK_NOPROC;
|
2002-11-30 19:00:51 +00:00
|
|
|
lkp->lk_newlock = NULL;
|
2002-10-18 01:34:10 +00:00
|
|
|
#ifdef DEBUG_LOCKS
|
|
|
|
lkp->lk_filename = "none";
|
|
|
|
lkp->lk_lockername = "never exclusive locked";
|
|
|
|
lkp->lk_lineno = 0;
|
|
|
|
lkp->lk_slockholder = LK_NOPROC;
|
|
|
|
lkp->lk_sfilename = "none";
|
|
|
|
lkp->lk_slockername = "never share locked";
|
|
|
|
lkp->lk_slineno = 0;
|
|
|
|
#endif
|
1997-09-21 04:24:27 +00:00
|
|
|
}
|
|
|
|
|
2000-10-04 01:29:17 +00:00
|
|
|
/*
|
|
|
|
* Destroy a lock.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
lockdestroy(lkp)
|
|
|
|
struct lock *lkp;
|
|
|
|
{
|
2003-03-11 20:00:37 +00:00
|
|
|
CTR2(KTR_LOCK, "lockdestroy(): lkp == %p (lk_wmesg == \"%s\")",
|
2000-10-04 01:29:17 +00:00
|
|
|
lkp, lkp->lk_wmesg);
|
|
|
|
}
|
|
|
|
|
1997-09-21 04:24:27 +00:00
|
|
|
/*
|
|
|
|
* Determine the status of a lock.
|
|
|
|
*/
|
|
|
|
int
|
2001-09-12 08:38:13 +00:00
|
|
|
lockstatus(lkp, td)
|
1997-09-21 04:24:27 +00:00
|
|
|
struct lock *lkp;
|
2001-09-12 08:38:13 +00:00
|
|
|
struct thread *td;
|
1997-09-21 04:24:27 +00:00
|
|
|
{
|
|
|
|
int lock_type = 0;
|
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(lkp->lk_interlock);
|
1999-12-11 16:13:02 +00:00
|
|
|
if (lkp->lk_exclusivecount != 0) {
|
2003-02-05 19:36:58 +00:00
|
|
|
if (td == NULL || lkp->lk_lockholder == td)
|
1999-12-11 16:13:02 +00:00
|
|
|
lock_type = LK_EXCLUSIVE;
|
|
|
|
else
|
|
|
|
lock_type = LK_EXCLOTHER;
|
|
|
|
} else if (lkp->lk_sharecount != 0)
|
1997-09-21 04:24:27 +00:00
|
|
|
lock_type = LK_SHARED;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(lkp->lk_interlock);
|
1997-09-21 04:24:27 +00:00
|
|
|
return (lock_type);
|
|
|
|
}
|
|
|
|
|
1999-06-26 02:47:16 +00:00
|
|
|
/*
|
|
|
|
* Determine the number of holders of a lock.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
lockcount(lkp)
|
|
|
|
struct lock *lkp;
|
|
|
|
{
|
|
|
|
int count;
|
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock(lkp->lk_interlock);
|
1999-06-26 02:47:16 +00:00
|
|
|
count = lkp->lk_exclusivecount + lkp->lk_sharecount;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock(lkp->lk_interlock);
|
1999-06-26 02:47:16 +00:00
|
|
|
return (count);
|
|
|
|
}
|
|
|
|
|
1997-03-25 16:27:20 +00:00
|
|
|
/*
|
|
|
|
* Print out information about state of a lock. Used by VOP_PRINT
|
1997-08-22 07:16:46 +00:00
|
|
|
* routines to display status about contained locks.
|
1997-03-25 16:27:20 +00:00
|
|
|
*/
|
1997-03-25 16:32:46 +00:00
|
|
|
void
|
1997-03-25 16:27:20 +00:00
|
|
|
lockmgr_printinfo(lkp)
|
|
|
|
struct lock *lkp;
|
|
|
|
{
|
|
|
|
|
|
|
|
if (lkp->lk_sharecount)
|
|
|
|
printf(" lock type %s: SHARED (count %d)", lkp->lk_wmesg,
|
|
|
|
lkp->lk_sharecount);
|
|
|
|
else if (lkp->lk_flags & LK_HAVE_EXCL)
|
2004-01-06 04:34:13 +00:00
|
|
|
printf(" lock type %s: EXCL (count %d) by thread %p (pid %d)",
|
|
|
|
lkp->lk_wmesg, lkp->lk_exclusivecount,
|
|
|
|
lkp->lk_lockholder, lkp->lk_lockholder->td_proc->p_pid);
|
1997-03-25 16:27:20 +00:00
|
|
|
if (lkp->lk_waitcount > 0)
|
|
|
|
printf(" with %d pending", lkp->lk_waitcount);
|
|
|
|
}
|