Goodbye lockmgr().
This commit is contained in:
ad
parent
08da6a8594
commit
0430885280
@ -1,16 +1,13 @@
|
||||
/* $NetBSD: kern_lock.c,v 1.133 2008/01/26 14:29:31 ad Exp $ */
|
||||
/* $NetBSD: kern_lock.c,v 1.134 2008/01/30 14:54:26 ad Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1999, 2000, 2006, 2007, 2008 The NetBSD Foundation, Inc.
|
||||
* Copyright (c) 2002, 2006, 2007, 2008 The NetBSD Foundation, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to The NetBSD Foundation
|
||||
* by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
|
||||
* NASA Ames Research Center, and by Andrew Doran.
|
||||
*
|
||||
* This code is derived from software contributed to The NetBSD Foundation
|
||||
* by Ross Harvey.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@ -40,43 +37,8 @@
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Copyright (c) 1995
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* 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. 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
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
__KERNEL_RCSID(0, "$NetBSD: kern_lock.c,v 1.133 2008/01/26 14:29:31 ad Exp $");
|
||||
__KERNEL_RCSID(0, "$NetBSD: kern_lock.c,v 1.134 2008/01/30 14:54:26 ad Exp $");
|
||||
|
||||
#include "opt_multiprocessor.h"
|
||||
|
||||
@ -95,511 +57,13 @@ __KERNEL_RCSID(0, "$NetBSD: kern_lock.c,v 1.133 2008/01/26 14:29:31 ad Exp $");
|
||||
|
||||
#include <dev/lockstat.h>
|
||||
|
||||
/*
|
||||
* note that stdarg.h and the ansi style va_start macro is used for both
|
||||
* ansi and traditional c compiles.
|
||||
* XXX: this requires that stdarg.h define: va_alist and va_dcl
|
||||
*/
|
||||
void lock_printf(const char *fmt, ...)
|
||||
__attribute__((__format__(__printf__,1,2)));
|
||||
#define RETURN_ADDRESS (uintptr_t)__builtin_return_address(0)
|
||||
|
||||
static int acquire(struct lock **, int *, int, int, int, uintptr_t);
|
||||
|
||||
int lock_debug_syslog = 0; /* defaults to printf, but can be patched */
|
||||
bool kernel_lock_dodebug;
|
||||
|
||||
__cpu_simple_lock_t kernel_lock[CACHE_LINE_SIZE / sizeof(__cpu_simple_lock_t)]
|
||||
__aligned(CACHE_LINE_SIZE);
|
||||
|
||||
#ifdef LOCKDEBUG
|
||||
static lockops_t lockmgr_lockops = {
|
||||
"lockmgr",
|
||||
1,
|
||||
(void *)nullop
|
||||
};
|
||||
#endif
|
||||
|
||||
#if defined(LOCKDEBUG) || defined(DIAGNOSTIC) /* { */
|
||||
#define COUNT(lkp, l, cpu_id, x) (l)->l_locks += (x)
|
||||
#else
|
||||
#define COUNT(lkp, p, cpu_id, x)
|
||||
#endif /* LOCKDEBUG || DIAGNOSTIC */ /* } */
|
||||
|
||||
#define RETURN_ADDRESS ((uintptr_t)__builtin_return_address(0))
|
||||
|
||||
/*
|
||||
* Acquire a resource.
|
||||
*/
|
||||
static int
|
||||
acquire(struct lock **lkpp, int *s, int extflags,
|
||||
int drain, int wanted, uintptr_t ra)
|
||||
{
|
||||
int error;
|
||||
struct lock *lkp = *lkpp;
|
||||
|
||||
KASSERT(drain || (wanted & LK_WAIT_NONZERO) == 0);
|
||||
|
||||
for (error = 0; (lkp->lk_flags & wanted) != 0; ) {
|
||||
if (drain)
|
||||
lkp->lk_flags |= LK_WAITDRAIN;
|
||||
else {
|
||||
lkp->lk_waitcount++;
|
||||
lkp->lk_flags |= LK_WAIT_NONZERO;
|
||||
}
|
||||
error = mtsleep(drain ? (void *)&lkp->lk_flags : (void *)lkp,
|
||||
lkp->lk_prio, lkp->lk_wmesg, lkp->lk_timo,
|
||||
__UNVOLATILE(&lkp->lk_interlock));
|
||||
if (!drain) {
|
||||
lkp->lk_waitcount--;
|
||||
if (lkp->lk_waitcount == 0)
|
||||
lkp->lk_flags &= ~LK_WAIT_NONZERO;
|
||||
}
|
||||
if (error)
|
||||
break;
|
||||
if (extflags & LK_SLEEPFAIL) {
|
||||
error = ENOLCK;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
#define SETHOLDER(lkp, pid, lid, cpu_id) \
|
||||
do { \
|
||||
(lkp)->lk_lockholder = pid; \
|
||||
(lkp)->lk_locklwp = lid; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define WEHOLDIT(lkp, pid, lid, cpu_id) \
|
||||
((lkp)->lk_lockholder == (pid) && (lkp)->lk_locklwp == (lid))
|
||||
|
||||
#define WAKEUP_WAITER(lkp) \
|
||||
do { \
|
||||
if (((lkp)->lk_flags & LK_WAIT_NONZERO) != 0) { \
|
||||
wakeup((lkp)); \
|
||||
} \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#if defined(LOCKDEBUG)
|
||||
/*
|
||||
* Lock debug printing routine; can be configured to print to console
|
||||
* or log to syslog.
|
||||
*/
|
||||
void
|
||||
lock_printf(const char *fmt, ...)
|
||||
{
|
||||
char b[150];
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
if (lock_debug_syslog)
|
||||
vlog(LOG_DEBUG, fmt, ap);
|
||||
else {
|
||||
vsnprintf(b, sizeof(b), fmt, ap);
|
||||
printf_nolog("%s", b);
|
||||
}
|
||||
va_end(ap);
|
||||
}
|
||||
#endif /* LOCKDEBUG */
|
||||
|
||||
static void
|
||||
lockpanic(struct lock *lkp, const char *fmt, ...)
|
||||
{
|
||||
char s[150], b[150];
|
||||
static const char *locktype[] = {
|
||||
"*0*", "shared", "exclusive", "*3*", "*4*", "downgrade",
|
||||
"*release*", "drain", "exclother", "*9*", "*10*",
|
||||
"*11*", "*12*", "*13*", "*14*", "*15*"
|
||||
};
|
||||
va_list ap;
|
||||
va_start(ap, fmt);
|
||||
vsnprintf(s, sizeof(s), fmt, ap);
|
||||
va_end(ap);
|
||||
bitmask_snprintf(lkp->lk_flags, __LK_FLAG_BITS, b, sizeof(b));
|
||||
panic("%s ("
|
||||
"type %s flags %s, sharecount %d, exclusivecount %d, "
|
||||
"recurselevel %d, waitcount %d, wmesg %s"
|
||||
", lock_addr %p, unlock_addr %p"
|
||||
")\n",
|
||||
s, locktype[lkp->lk_flags & LK_TYPE_MASK],
|
||||
b, lkp->lk_sharecount, lkp->lk_exclusivecount,
|
||||
lkp->lk_recurselevel, lkp->lk_waitcount, lkp->lk_wmesg,
|
||||
(void *)lkp->lk_lock_addr, (void *)lkp->lk_unlock_addr
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialize a lock; required before use.
|
||||
*/
|
||||
void
|
||||
lockinit(struct lock *lkp, pri_t prio, const char *wmesg, int timo, int flags)
|
||||
{
|
||||
|
||||
memset(lkp, 0, sizeof(struct lock));
|
||||
lkp->lk_flags = flags & LK_EXTFLG_MASK;
|
||||
mutex_init(&lkp->lk_interlock, MUTEX_DEFAULT, IPL_NONE);
|
||||
lkp->lk_lockholder = LK_NOPROC;
|
||||
lkp->lk_prio = prio;
|
||||
lkp->lk_timo = timo;
|
||||
lkp->lk_wmesg = wmesg;
|
||||
lkp->lk_lock_addr = 0;
|
||||
lkp->lk_unlock_addr = 0;
|
||||
|
||||
if (LOCKDEBUG_ALLOC(lkp, &lockmgr_lockops,
|
||||
(uintptr_t)__builtin_return_address(0))) {
|
||||
lkp->lk_flags |= LK_DODEBUG;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
lockdestroy(struct lock *lkp)
|
||||
{
|
||||
|
||||
LOCKDEBUG_FREE(((lkp->lk_flags & LK_DODEBUG) != 0), lkp);
|
||||
mutex_destroy(&lkp->lk_interlock);
|
||||
}
|
||||
|
||||
/*
|
||||
* Determine the status of a lock.
|
||||
*/
|
||||
int
|
||||
lockstatus(struct lock *lkp)
|
||||
{
|
||||
int lock_type = 0;
|
||||
struct lwp *l = curlwp; /* XXX */
|
||||
pid_t pid;
|
||||
lwpid_t lid;
|
||||
cpuid_t cpu_num;
|
||||
|
||||
if (l == NULL) {
|
||||
cpu_num = cpu_number();
|
||||
pid = LK_KERNPROC;
|
||||
lid = 0;
|
||||
} else {
|
||||
cpu_num = LK_NOCPU;
|
||||
pid = l->l_proc->p_pid;
|
||||
lid = l->l_lid;
|
||||
}
|
||||
|
||||
mutex_enter(&lkp->lk_interlock);
|
||||
if (lkp->lk_exclusivecount != 0) {
|
||||
if (WEHOLDIT(lkp, pid, lid, cpu_num))
|
||||
lock_type = LK_EXCLUSIVE;
|
||||
else
|
||||
lock_type = LK_EXCLOTHER;
|
||||
} else if (lkp->lk_sharecount != 0)
|
||||
lock_type = LK_SHARED;
|
||||
else if (lkp->lk_flags & LK_WANT_EXCL)
|
||||
lock_type = LK_EXCLOTHER;
|
||||
mutex_exit(&lkp->lk_interlock);
|
||||
return (lock_type);
|
||||
}
|
||||
|
||||
/*
|
||||
* XXX XXX kludge around another kludge..
|
||||
*
|
||||
* vfs_shutdown() may be called from interrupt context, either as a result
|
||||
* of a panic, or from the debugger. It proceeds to call
|
||||
* sys_sync(&proc0, ...), pretending its running on behalf of proc0
|
||||
*
|
||||
* We would like to make an attempt to sync the filesystems in this case, so
|
||||
* if this happens, we treat attempts to acquire locks specially.
|
||||
* All locks are acquired on behalf of proc0.
|
||||
*
|
||||
* If we've already paniced, we don't block waiting for locks, but
|
||||
* just barge right ahead since we're already going down in flames.
|
||||
*/
|
||||
|
||||
/*
|
||||
* 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 to go away.
|
||||
*/
|
||||
int
|
||||
lockmgr(struct lock *lkp, u_int flags, kmutex_t *interlkp)
|
||||
{
|
||||
int error;
|
||||
pid_t pid;
|
||||
lwpid_t lid;
|
||||
int extflags;
|
||||
cpuid_t cpu_num;
|
||||
struct lwp *l = curlwp;
|
||||
int lock_shutdown_noblock = 0;
|
||||
int s = 0;
|
||||
|
||||
error = 0;
|
||||
|
||||
/* LK_RETRY is for vn_lock, not for lockmgr. */
|
||||
KASSERT((flags & LK_RETRY) == 0);
|
||||
KASSERT((l->l_pflag & LP_INTR) == 0 || panicstr != NULL);
|
||||
|
||||
mutex_enter(&lkp->lk_interlock);
|
||||
if (flags & LK_INTERLOCK)
|
||||
mutex_exit(interlkp);
|
||||
extflags = (flags | lkp->lk_flags) & LK_EXTFLG_MASK;
|
||||
|
||||
if (l == NULL) {
|
||||
if (!doing_shutdown) {
|
||||
panic("lockmgr: no context");
|
||||
} else {
|
||||
l = &lwp0;
|
||||
if (panicstr && (!(flags & LK_NOWAIT))) {
|
||||
flags |= LK_NOWAIT;
|
||||
lock_shutdown_noblock = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
lid = l->l_lid;
|
||||
pid = l->l_proc->p_pid;
|
||||
cpu_num = cpu_number();
|
||||
|
||||
/*
|
||||
* Once a lock has drained, the LK_DRAINING flag is set and an
|
||||
* exclusive lock is returned. The only valid operation thereafter
|
||||
* is a single release of that exclusive lock. This final release
|
||||
* clears the LK_DRAINING flag and sets the LK_DRAINED flag. Any
|
||||
* further requests of any sort will result in a panic. The bits
|
||||
* selected for these two flags are chosen so that they will be set
|
||||
* in memory that is freed (freed memory is filled with 0xdeadbeef).
|
||||
* The final release is permitted to give a new lease on life to
|
||||
* the lock by specifying LK_REENABLE.
|
||||
*/
|
||||
if (lkp->lk_flags & (LK_DRAINING|LK_DRAINED)) {
|
||||
#ifdef DIAGNOSTIC /* { */
|
||||
if (lkp->lk_flags & LK_DRAINED)
|
||||
lockpanic(lkp, "lockmgr: using decommissioned lock");
|
||||
if ((flags & LK_TYPE_MASK) != LK_RELEASE ||
|
||||
WEHOLDIT(lkp, pid, lid, cpu_num) == 0)
|
||||
lockpanic(lkp, "lockmgr: non-release on draining lock: %d",
|
||||
flags & LK_TYPE_MASK);
|
||||
#endif /* DIAGNOSTIC */ /* } */
|
||||
lkp->lk_flags &= ~LK_DRAINING;
|
||||
if ((flags & LK_REENABLE) == 0)
|
||||
lkp->lk_flags |= LK_DRAINED;
|
||||
}
|
||||
|
||||
switch (flags & LK_TYPE_MASK) {
|
||||
|
||||
case LK_SHARED:
|
||||
if (WEHOLDIT(lkp, pid, lid, cpu_num) == 0) {
|
||||
/*
|
||||
* If just polling, check to see if we will block.
|
||||
*/
|
||||
if ((extflags & LK_NOWAIT) && (lkp->lk_flags &
|
||||
(LK_HAVE_EXCL | LK_WANT_EXCL))) {
|
||||
error = EBUSY;
|
||||
break;
|
||||
}
|
||||
/*
|
||||
* Wait for exclusive locks to clear.
|
||||
*/
|
||||
error = acquire(&lkp, &s, extflags, 0,
|
||||
LK_HAVE_EXCL | LK_WANT_EXCL,
|
||||
RETURN_ADDRESS);
|
||||
if (error)
|
||||
break;
|
||||
lkp->lk_sharecount++;
|
||||
lkp->lk_flags |= LK_SHARE_NONZERO;
|
||||
COUNT(lkp, l, cpu_num, 1);
|
||||
break;
|
||||
}
|
||||
/*
|
||||
* We hold an exclusive lock, so downgrade it to shared.
|
||||
* An alternative would be to fail with EDEADLK.
|
||||
*/
|
||||
lkp->lk_sharecount++;
|
||||
lkp->lk_flags |= LK_SHARE_NONZERO;
|
||||
COUNT(lkp, l, cpu_num, 1);
|
||||
/* fall into downgrade */
|
||||
|
||||
case LK_DOWNGRADE:
|
||||
if (WEHOLDIT(lkp, pid, lid, cpu_num) == 0 ||
|
||||
lkp->lk_exclusivecount == 0)
|
||||
lockpanic(lkp, "lockmgr: not holding exclusive lock");
|
||||
lkp->lk_sharecount += lkp->lk_exclusivecount;
|
||||
lkp->lk_flags |= LK_SHARE_NONZERO;
|
||||
lkp->lk_exclusivecount = 0;
|
||||
lkp->lk_recurselevel = 0;
|
||||
lkp->lk_flags &= ~LK_HAVE_EXCL;
|
||||
SETHOLDER(lkp, LK_NOPROC, 0, LK_NOCPU);
|
||||
#if defined(LOCKDEBUG)
|
||||
lkp->lk_unlock_addr = RETURN_ADDRESS;
|
||||
#endif
|
||||
WAKEUP_WAITER(lkp);
|
||||
break;
|
||||
|
||||
case LK_EXCLUSIVE:
|
||||
if (WEHOLDIT(lkp, pid, lid, cpu_num)) {
|
||||
/*
|
||||
* Recursive lock.
|
||||
*/
|
||||
if ((extflags & LK_CANRECURSE) == 0 &&
|
||||
lkp->lk_recurselevel == 0) {
|
||||
if (extflags & LK_RECURSEFAIL) {
|
||||
error = EDEADLK;
|
||||
break;
|
||||
} else
|
||||
lockpanic(lkp, "lockmgr: locking against myself");
|
||||
}
|
||||
lkp->lk_exclusivecount++;
|
||||
COUNT(lkp, l, cpu_num, 1);
|
||||
break;
|
||||
}
|
||||
/*
|
||||
* If we are just polling, check to see if we will sleep.
|
||||
*/
|
||||
if ((extflags & LK_NOWAIT) && (lkp->lk_flags &
|
||||
(LK_HAVE_EXCL | LK_WANT_EXCL | LK_SHARE_NONZERO))) {
|
||||
error = EBUSY;
|
||||
break;
|
||||
}
|
||||
/*
|
||||
* Try to acquire the want_exclusive flag.
|
||||
*/
|
||||
error = acquire(&lkp, &s, extflags, 0,
|
||||
LK_HAVE_EXCL | LK_WANT_EXCL, RETURN_ADDRESS);
|
||||
if (error)
|
||||
break;
|
||||
lkp->lk_flags |= LK_WANT_EXCL;
|
||||
/*
|
||||
* Wait for shared locks to finish.
|
||||
*/
|
||||
error = acquire(&lkp, &s, extflags, 0,
|
||||
LK_HAVE_EXCL | LK_SHARE_NONZERO,
|
||||
RETURN_ADDRESS);
|
||||
lkp->lk_flags &= ~LK_WANT_EXCL;
|
||||
if (error) {
|
||||
WAKEUP_WAITER(lkp);
|
||||
break;
|
||||
}
|
||||
lkp->lk_flags |= LK_HAVE_EXCL;
|
||||
SETHOLDER(lkp, pid, lid, cpu_num);
|
||||
#if defined(LOCKDEBUG)
|
||||
lkp->lk_lock_addr = RETURN_ADDRESS;
|
||||
#endif
|
||||
if (lkp->lk_exclusivecount != 0)
|
||||
lockpanic(lkp, "lockmgr: non-zero exclusive count");
|
||||
lkp->lk_exclusivecount = 1;
|
||||
COUNT(lkp, l, cpu_num, 1);
|
||||
break;
|
||||
|
||||
case LK_RELEASE:
|
||||
if (lkp->lk_exclusivecount != 0) {
|
||||
if (WEHOLDIT(lkp, pid, lid, cpu_num) == 0) {
|
||||
lockpanic(lkp, "lockmgr: pid %d.%d, not "
|
||||
"exclusive lock holder %d.%d "
|
||||
"unlocking", pid, lid,
|
||||
lkp->lk_lockholder,
|
||||
lkp->lk_locklwp);
|
||||
}
|
||||
if (lkp->lk_exclusivecount == lkp->lk_recurselevel)
|
||||
lkp->lk_recurselevel = 0;
|
||||
lkp->lk_exclusivecount--;
|
||||
COUNT(lkp, l, cpu_num, -1);
|
||||
if (lkp->lk_exclusivecount == 0) {
|
||||
lkp->lk_flags &= ~LK_HAVE_EXCL;
|
||||
SETHOLDER(lkp, LK_NOPROC, 0, LK_NOCPU);
|
||||
#if defined(LOCKDEBUG)
|
||||
lkp->lk_unlock_addr = RETURN_ADDRESS;
|
||||
#endif
|
||||
}
|
||||
} else if (lkp->lk_sharecount != 0) {
|
||||
lkp->lk_sharecount--;
|
||||
if (lkp->lk_sharecount == 0)
|
||||
lkp->lk_flags &= ~LK_SHARE_NONZERO;
|
||||
COUNT(lkp, l, cpu_num, -1);
|
||||
}
|
||||
#ifdef DIAGNOSTIC
|
||||
else
|
||||
lockpanic(lkp, "lockmgr: release of unlocked lock!");
|
||||
#endif
|
||||
WAKEUP_WAITER(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.
|
||||
*/
|
||||
if (WEHOLDIT(lkp, pid, lid, cpu_num))
|
||||
lockpanic(lkp, "lockmgr: draining against myself");
|
||||
/*
|
||||
* If we are just polling, check to see if we will sleep.
|
||||
*/
|
||||
if ((extflags & LK_NOWAIT) && (lkp->lk_flags &
|
||||
(LK_HAVE_EXCL | LK_WANT_EXCL |
|
||||
LK_SHARE_NONZERO | LK_WAIT_NONZERO))) {
|
||||
error = EBUSY;
|
||||
break;
|
||||
}
|
||||
error = acquire(&lkp, &s, extflags, 1,
|
||||
LK_HAVE_EXCL | LK_WANT_EXCL |
|
||||
LK_SHARE_NONZERO | LK_WAIT_NONZERO,
|
||||
RETURN_ADDRESS);
|
||||
if (error)
|
||||
break;
|
||||
lkp->lk_flags |= LK_HAVE_EXCL;
|
||||
if ((extflags & LK_RESURRECT) == 0)
|
||||
lkp->lk_flags |= LK_DRAINING;
|
||||
SETHOLDER(lkp, pid, lid, cpu_num);
|
||||
#if defined(LOCKDEBUG)
|
||||
lkp->lk_lock_addr = RETURN_ADDRESS;
|
||||
#endif
|
||||
lkp->lk_exclusivecount = 1;
|
||||
COUNT(lkp, l, cpu_num, 1);
|
||||
break;
|
||||
|
||||
default:
|
||||
mutex_exit(&lkp->lk_interlock);
|
||||
lockpanic(lkp, "lockmgr: unknown locktype request %d",
|
||||
flags & LK_TYPE_MASK);
|
||||
/* NOTREACHED */
|
||||
}
|
||||
if ((lkp->lk_flags & LK_WAITDRAIN) != 0 &&
|
||||
((lkp->lk_flags &
|
||||
(LK_HAVE_EXCL | LK_WANT_EXCL |
|
||||
LK_SHARE_NONZERO | LK_WAIT_NONZERO)) == 0)) {
|
||||
lkp->lk_flags &= ~LK_WAITDRAIN;
|
||||
wakeup(&lkp->lk_flags);
|
||||
}
|
||||
/*
|
||||
* Note that this panic will be a recursive panic, since
|
||||
* we only set lock_shutdown_noblock above if panicstr != NULL.
|
||||
*/
|
||||
if (error && lock_shutdown_noblock)
|
||||
lockpanic(lkp, "lockmgr: deadlock (see previous panic)");
|
||||
|
||||
mutex_exit(&lkp->lk_interlock);
|
||||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
* Print out information about state of a lock. Used by VOP_PRINT
|
||||
* routines to display ststus about contained locks.
|
||||
*/
|
||||
void
|
||||
lockmgr_printinfo(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) {
|
||||
printf(" lock type %s: EXCL (count %d) by ",
|
||||
lkp->lk_wmesg, lkp->lk_exclusivecount);
|
||||
printf("pid %d.%d", lkp->lk_lockholder,
|
||||
lkp->lk_locklwp);
|
||||
} else
|
||||
printf(" not locked");
|
||||
if (lkp->lk_waitcount > 0)
|
||||
printf(" with %d pending", lkp->lk_waitcount);
|
||||
}
|
||||
|
||||
#if defined(LOCKDEBUG)
|
||||
void
|
||||
assert_sleepable(struct simplelock *interlock, const char *msg)
|
||||
|
||||
126
sys/sys/lock.h
126
sys/sys/lock.h
@ -1,4 +1,4 @@
|
||||
/* $NetBSD: lock.h,v 1.81 2008/01/10 20:14:12 ad Exp $ */
|
||||
/* $NetBSD: lock.h,v 1.82 2008/01/30 14:54:25 ad Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1999, 2000, 2006, 2007 The NetBSD Foundation, Inc.
|
||||
@ -80,142 +80,20 @@
|
||||
|
||||
#include <machine/lock.h>
|
||||
|
||||
/*
|
||||
* The general lock structure.
|
||||
*/
|
||||
struct lock {
|
||||
u_int lk_flags; /* see below */
|
||||
int lk_sharecount; /* # of accepted shared locks */
|
||||
kmutex_t lk_interlock; /* lock on structure */
|
||||
short lk_exclusivecount; /* # of recursive exclusive locks */
|
||||
short lk_recurselevel; /* lvl above which recursion ok */
|
||||
int lk_waitcount; /* # of sleepers */
|
||||
const char *lk_wmesg; /* sleep wait channel */
|
||||
pid_t lk_lockholder; /* pid of exclusive holder */
|
||||
lwpid_t lk_locklwp; /* lid of exclusive holder */
|
||||
pri_t lk_prio; /* priority at which to sleep */
|
||||
int lk_timo; /* max sleep time */
|
||||
uintptr_t lk_lock_addr;
|
||||
uintptr_t lk_unlock_addr;
|
||||
};
|
||||
|
||||
/*
|
||||
* Lock request types:
|
||||
* LK_SHARED - get one of many possible shared locks. If a process
|
||||
* holding an exclusive lock requests a shared lock, the exclusive
|
||||
* lock(s) will be downgraded to shared locks.
|
||||
* LK_EXCLUSIVE - stop further shared locks, when they are cleared,
|
||||
* grant then grant an exclusive lock.
|
||||
* Only one exclusive lock may exist at a time, except that
|
||||
* a process holding an exclusive lock may get additional exclusive
|
||||
* locks if it explicitly sets the LK_CANRECURSE flag in the lock
|
||||
* request, or if the LK_CANRECURSE flag was set when the lock was
|
||||
* initialized.
|
||||
* LK_DOWNGRADE - the process must hold an exclusive lock that it wants
|
||||
* to have downgraded to a shared lock. If the process holds multiple
|
||||
* (recursive) exclusive locks, they will all be downgraded to shared
|
||||
* locks.
|
||||
* LK_RELEASE - release one instance of a lock.
|
||||
* LK_DRAIN - wait for all activity on the lock to end, then mark it
|
||||
* decommissioned. This feature is used before freeing a lock that
|
||||
* is part of a piece of memory that is about to be freed.
|
||||
*
|
||||
* These are flags that are passed to the lockmgr routine.
|
||||
*/
|
||||
#define LK_TYPE_MASK 0x0000000f /* type of lock sought */
|
||||
#define LK_SHARED 0x00000001 /* shared lock */
|
||||
#define LK_EXCLUSIVE 0x00000002 /* exclusive lock */
|
||||
#define LK_DOWNGRADE 0x00000005 /* exclusive-to-shared downgrade */
|
||||
#define LK_RELEASE 0x00000006 /* release any type of lock */
|
||||
#define LK_DRAIN 0x00000007 /* wait for all lock activity to end */
|
||||
#define LK_EXCLOTHER 0x00000008 /* other process holds lock */
|
||||
/*
|
||||
* External lock flags.
|
||||
*
|
||||
* The first three flags may be set in lock_init to set their mode permanently,
|
||||
* or passed in as arguments to the lock manager. The LK_REENABLE flag may be
|
||||
* set only at the release of a lock obtained by drain.
|
||||
*/
|
||||
#define LK_EXTFLG_MASK 0x00f00070 /* mask of external flags */
|
||||
|
||||
#define LK_NOWAIT 0x00000010 /* do not sleep to await lock */
|
||||
#define LK_SLEEPFAIL 0x00000020 /* sleep, then return failure */
|
||||
#define LK_CANRECURSE 0x00000040 /* this may be recursive lock attempt */
|
||||
#define LK_REENABLE 0x00000080 /* lock is be reenabled after drain */
|
||||
#define LK_RECURSEFAIL 0x00200000 /* attempt at recursive lock fails */
|
||||
#define LK_RESURRECT 0x00800000 /* immediately reenable drained lock */
|
||||
/*
|
||||
* Internal lock flags.
|
||||
*
|
||||
* These flags are used internally to the lock manager.
|
||||
*/
|
||||
#define LK_WANT_EXCL 0x00000200 /* exclusive lock sought */
|
||||
#define LK_HAVE_EXCL 0x00000400 /* exclusive lock obtained */
|
||||
#define LK_WAITDRAIN 0x00000800 /* process waiting for lock to drain */
|
||||
#define LK_DRAINING 0x00004000 /* lock is being drained */
|
||||
#define LK_DRAINED 0x00008000 /* lock has been decommissioned */
|
||||
#define LK_DODEBUG 0x00010000 /* has lockdebug bits */
|
||||
/*
|
||||
* Internal state flags corresponding to lk_sharecount, and lk_waitcount
|
||||
*/
|
||||
#define LK_SHARE_NONZERO 0x00040000 /* lk_sharecount != 0 */
|
||||
#define LK_WAIT_NONZERO 0x00080000 /* lk_waitcount != 0 */
|
||||
/*
|
||||
* Control flags
|
||||
*
|
||||
* Non-persistent external flags.
|
||||
*/
|
||||
#define LK_INTERLOCK 0x00010000 /* unlock passed simple lock after
|
||||
getting lk_interlock */
|
||||
#define LK_RETRY 0x00020000 /* vn_lock: retry until locked */
|
||||
|
||||
#define __LK_FLAG_BITS \
|
||||
"\20" \
|
||||
"\22LK_RECURSEFAIL" \
|
||||
"\20LK_WAIT_NOZERO" \
|
||||
"\19LK_SHARE_NOZERO" \
|
||||
"\18LK_RETRY" \
|
||||
"\17LK_INTERLOCK" \
|
||||
"\16LK_DRAINED" \
|
||||
"\15LK_DRAINING" \
|
||||
"\12LK_WAITDRAIN" \
|
||||
"\11LK_HAVE_EXCL" \
|
||||
"\10LK_WANT_EXCL" \
|
||||
"\08LK_REENABLE" \
|
||||
"\07LK_CANRECURSE" \
|
||||
"\06LK_SLEEPFAIL" \
|
||||
"\05LK_NOWAIT"
|
||||
/*
|
||||
* Lock return status.
|
||||
*
|
||||
* Successfully obtained locks return 0. Locks will always succeed
|
||||
* unless one of the following is true:
|
||||
* LK_NOWAIT is set and a sleep would be required (returns EBUSY).
|
||||
* LK_SLEEPFAIL is set and a sleep was done (returns ENOLCK).
|
||||
* PCATCH is set in lock priority and a signal arrives (returns
|
||||
* either EINTR or ERESTART if system calls is to be restarted).
|
||||
* Non-null lock timeout and timeout expires (returns EWOULDBLOCK).
|
||||
* A failed lock attempt always returns a non-zero error value. No lock
|
||||
* is held after an error return.
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* Indicator that no process/cpu holds exclusive lock
|
||||
*/
|
||||
#define LK_KERNPROC ((pid_t) -2)
|
||||
#define LK_NOPROC ((pid_t) -1)
|
||||
#define LK_NOCPU ((cpuid_t) -1)
|
||||
|
||||
#ifdef _KERNEL
|
||||
|
||||
struct proc;
|
||||
|
||||
void lockinit(struct lock *, pri_t, const char *, int, int);
|
||||
void lockdestroy(struct lock *);
|
||||
int lockmgr(struct lock *, u_int flags, kmutex_t *);
|
||||
int lockstatus(struct lock *);
|
||||
void lockmgr_printinfo(struct lock *);
|
||||
|
||||
/*
|
||||
* From <machine/lock.h>.
|
||||
*/
|
||||
|
||||
Loading…
Reference in New Issue
Block a user