diff options
Diffstat (limited to 'debian/htdig/htdig-3.2.0b6/db/lock.c')
| -rw-r--r-- | debian/htdig/htdig-3.2.0b6/db/lock.c | 1383 |
1 files changed, 1383 insertions, 0 deletions
diff --git a/debian/htdig/htdig-3.2.0b6/db/lock.c b/debian/htdig/htdig-3.2.0b6/db/lock.c new file mode 100644 index 00000000..a752a154 --- /dev/null +++ b/debian/htdig/htdig-3.2.0b6/db/lock.c @@ -0,0 +1,1383 @@ +/*- + * See the file LICENSE for redistribution information. + * + * Copyright (c) 1996, 1997, 1998, 1999 + * Sleepycat Software. All rights reserved. + */ + +#include "db_config.h" + +#ifndef lint +static const char sccsid[] = "@(#)lock.c 11.8 (Sleepycat) 10/19/99"; +#endif /* not lint */ + +#ifndef NO_SYSTEM_INCLUDES +#include <sys/types.h> + +#include <errno.h> +#include <string.h> +#endif + +#include "db_int.h" +#include "db_page.h" +#include "db_shash.h" +#include "lock.h" +#include "db_am.h" +#include "txn.h" + +static int CDB___lock_checklocker __P((DB_LOCKTAB *, + struct __db_lock *, u_int32_t, u_int32_t, int *)); +static int CDB___lock_get_internal __P((DB_LOCKTAB *, u_int32_t, + u_int32_t, const DBT *, db_lockmode_t, DB_LOCK *)); +static int CDB___lock_is_parent __P((DB_LOCKTAB *, u_int32_t, DB_LOCKER *)); +static int CDB___lock_put_internal __P((DB_LOCKTAB *, + struct __db_lock *, u_int32_t, u_int32_t)); +static int CDB___lock_put_nolock __P((DB_ENV *, DB_LOCK *, int *)); +static void CDB___lock_remove_waiter __P((DB_LOCKOBJ *, + struct __db_lock *, db_status_t)); + +/* + * CDB_lock_id -- + * Generate a unique locker id. + */ +int +CDB_lock_id(dbenv, idp) + DB_ENV *dbenv; + u_int32_t *idp; +{ + DB_LOCKTAB *lt; + DB_LOCKREGION *region; + + PANIC_CHECK(dbenv); + ENV_REQUIRES_CONFIG(dbenv, dbenv->lk_handle, DB_INIT_LOCK); + + lt = dbenv->lk_handle; + region = lt->reginfo.primary; + + /* + * Note that we are letting locker IDs wrap. + * + * This is potentially dangerous in that it's conceivable that you + * could be allocating a new locker id and still have someone using + * it. However, the alternatives are that we keep a bitmap of + * locker ids or we forbid wrapping. Both are probably bad. The + * bitmap of locker ids will take up 64 MB of space. Forbidding + * wrapping means that we'll run out of locker IDs after 2 billion. + * In order for the wrap bug to fire, we'd need to have something + * that stayed open while 2 billion locker ids were used up. Since + * we cache cursors it means that something would have to stay open + * sufficiently long that we open and close a lot of files and a + * lot of cursors within them. Betting that this won't happen seems + * to the lesser of the evils. + */ + LOCKREGION(dbenv, lt); + if (region->id >= DB_LOCK_MAXID) + region->id = 0; + *idp = ++region->id; + UNLOCKREGION(dbenv, lt); + + return (0); +} + +/* + * Vector lock routine. This function takes a set of operations + * and performs them all at once. In addition, CDB_lock_vec provides + * functionality for lock inheritance, releasing all locks for a + * given locker (used during transaction commit/abort), releasing + * all locks on a given object, and generating debugging information. + */ +int +CDB_lock_vec(dbenv, locker, flags, list, nlist, elistp) + DB_ENV *dbenv; + u_int32_t locker, flags; + int nlist; + DB_LOCKREQ *list, **elistp; +{ + struct __db_lock *lp, *next_lock; + DB_LOCKER *sh_locker, *sh_parent; + DB_LOCKOBJ *sh_obj; + DB_LOCKREGION *region; + DB_LOCKTAB *lt; + u_int32_t lndx, ndx, pndx; + int did_abort, i, ret, run_dd; + + PANIC_CHECK(dbenv); + ENV_REQUIRES_CONFIG(dbenv, dbenv->lk_handle, DB_INIT_LOCK); + + /* Validate arguments. */ + if ((ret = CDB___db_fchk(dbenv, "CDB_lock_vec", flags, DB_LOCK_NOWAIT)) != 0) + return (ret); + + lt = dbenv->lk_handle; + region = lt->reginfo.primary; + + run_dd = 0; + LOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle); + for (i = 0, ret = 0; i < nlist && ret == 0; i++) + switch (list[i].op) { + case DB_LOCK_GET: + ret = CDB___lock_get_internal(dbenv->lk_handle, + locker, flags, + list[i].obj, list[i].mode, &list[i].lock); + break; + case DB_LOCK_INHERIT: + + /* + * Get the committing locker and mark it as deleted. + * This allows us to traverse the locker links without + * worrying that someone else is deleting locks out + * from under us. However, if the locker doesn't + * exist, that just means that the child holds no + * locks, so inheritance is easy! + */ + LOCKER_LOCK(lt, region, locker, ndx); + if ((ret = CDB___lock_getlocker(lt, + locker, ndx, 0, &sh_locker)) != 0 || + sh_locker == NULL || + F_ISSET(sh_locker, DB_LOCKER_DELETED)) { + if (ret == 0 && sh_locker != NULL) + ret = EACCES; + LOCKER_UNLOCK(lt, ndx); + break; + } + + /* Make sure we are a child transaction. */ + if (sh_locker->parent_locker == INVALID_ROFF) { + ret = EINVAL; + LOCKER_UNLOCK(lt, ndx); + break; + } + sh_parent = (DB_LOCKER *) + R_ADDR(<->reginfo, sh_locker->parent_locker); + F_SET(sh_locker, DB_LOCKER_DELETED); + LOCKER_UNLOCK(lt, ndx); + + /* + * Now, lock the parent locker; move locks from + * the committing list to the parent's list. + */ + LOCKER_LOCK(lt, region, sh_parent->id, pndx); + if (F_ISSET(sh_parent, DB_LOCKER_DELETED)) { + if (ret == 0) + ret = EACCES; + LOCKER_UNLOCK(lt, pndx); + break; + } + + for (lp = SH_LIST_FIRST(&sh_locker->heldby, __db_lock); + lp != NULL; + lp = SH_LIST_FIRST(&sh_locker->heldby, __db_lock)) { + SH_LIST_REMOVE(lp, locker_links, __db_lock); + SH_LIST_INSERT_HEAD(&sh_parent->heldby, lp, + locker_links, __db_lock); + lp->holder = sh_parent->id; + } + LOCKER_UNLOCK(lt, pndx); + + /* Now free the original locker. */ + ret = CDB___lock_checklocker(lt, + NULL, locker, DB_LOCK_IGNOREDEL, NULL); + break; + case DB_LOCK_PUT: + ret = CDB___lock_put_nolock(dbenv, &list[i].lock, &run_dd); + break; + case DB_LOCK_PUT_ALL: + /* + * Get the locker and mark it as deleted. This + * allows us to traverse the locker links without + * worrying that someone else is deleting locks out + * from under us. Since the locker may hold no + * locks (i.e., you could call abort before you've + * done any work), it's perfectly reasonable for there + * to be no locker; this is not an error. + */ + LOCKER_LOCK(lt, region, locker, ndx); + if ((ret = CDB___lock_getlocker(lt, + locker, ndx, 0, &sh_locker)) != 0 || + sh_locker == NULL || + F_ISSET(sh_locker, DB_LOCKER_DELETED)) { + /* + * If ret is set, then we'll generate an + * error. If it's not set, we have nothing + * to do. + */ + LOCKER_UNLOCK(lt, ndx); + break; + } + F_SET(sh_locker, DB_LOCKER_DELETED); + LOCKER_UNLOCK(lt, ndx); + + /* Now traverse the locks, releasing each one. */ + for (lp = SH_LIST_FIRST(&sh_locker->heldby, __db_lock); + lp != NULL; + lp = SH_LIST_FIRST(&sh_locker->heldby, __db_lock)) { + SH_LIST_REMOVE(lp, locker_links, __db_lock); + sh_obj = + (DB_LOCKOBJ *)((u_int8_t *)lp + lp->obj); + SHOBJECT_LOCK(lt, region, sh_obj, lndx); + ret = CDB___lock_put_internal(lt, + lp, lndx, DB_LOCK_FREE | DB_LOCK_DOALL); + OBJECT_UNLOCK(lt, lndx); + if (ret != 0) + break; + } + ret = CDB___lock_checklocker(lt, + NULL, locker, DB_LOCK_IGNOREDEL, NULL); + break; + case DB_LOCK_PUT_OBJ: + /* Remove all the locks associated with an object. */ + OBJECT_LOCK(lt, region, list[i].obj, ndx); + if ((ret = CDB___lock_getobj(lt, list[i].obj, + ndx, 0, &sh_obj)) != 0 || sh_obj == NULL) { + if (ret == 0) + ret = EINVAL; + OBJECT_UNLOCK(lt, ndx); + break; + } + + /* + * Go through both waiters and holders. Don't bother + * to run promotion, because everyone is getting + * released. The processes waiting will still get + * awakened as their waiters are released. + */ + for (lp = SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock); + ret == 0 && lp != NULL; + lp = SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock)) + ret = CDB___lock_put_internal(lt, + lp, ndx, DB_LOCK_NOPROMOTE | DB_LOCK_DOALL); + + /* + * On the last time around, the object will get + * reclaimed by CDB___lock_put_internal, structure the + * loop carefully so we do not get bitten. + */ + for (lp = SH_TAILQ_FIRST(&sh_obj->holders, __db_lock); + ret == 0 && lp != NULL; + lp = next_lock) { + next_lock = SH_TAILQ_NEXT(lp, links, __db_lock); + ret = CDB___lock_put_internal(lt, + lp, ndx, DB_LOCK_NOPROMOTE | DB_LOCK_DOALL); + } + OBJECT_UNLOCK(lt, ndx); + break; +#ifdef DEBUG + case DB_LOCK_DUMP: + /* Find the locker. */ + LOCKER_LOCK(lt, region, locker, ndx); + if ((ret = CDB___lock_getlocker(lt, + locker, ndx, 0, &sh_locker)) != 0 + || sh_locker == NULL + || F_ISSET(sh_locker, DB_LOCKER_DELETED)) { + LOCKER_UNLOCK(lt, ndx); + break; + } + + for (lp = SH_LIST_FIRST(&sh_locker->heldby, __db_lock); + lp != NULL; + lp = SH_LIST_NEXT(lp, locker_links, __db_lock)) { + CDB___lock_printlock(lt, lp, 1); + } + LOCKER_UNLOCK(lt, ndx); + break; +#endif + default: + ret = EINVAL; + break; + } + + if (ret == 0) { + MEMORY_LOCK(lt); + if (region->need_dd && region->detect != DB_LOCK_NORUN) { + run_dd = 1; + region->need_dd = 0; + } + MEMORY_UNLOCK(lt); + } + UNLOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle); + + if (run_dd) + (void)CDB_lock_detect(dbenv, 0, region->detect, &did_abort); + + if (ret != 0 && elistp != NULL) + *elistp = &list[i - 1]; + + return (ret); +} + +/* + * Lock acquisition routines. There are two library interfaces: + * + * CDB_lock_get -- + * original lock get interface that takes a locker id. + * + * All the work for CDB_lock_get (and for the GET option of CDB_lock_vec) is done + * inside of lock_get_internal. + */ +int +CDB_lock_get(dbenv, locker, flags, obj, lock_mode, lock) + DB_ENV *dbenv; + u_int32_t locker, flags; + const DBT *obj; + db_lockmode_t lock_mode; + DB_LOCK *lock; +{ + int ret; + + PANIC_CHECK(dbenv); + ENV_REQUIRES_CONFIG(dbenv, dbenv->lk_handle, DB_INIT_LOCK); + + /* Validate arguments. */ + if ((ret = CDB___db_fchk(dbenv, + "CDB_lock_get", flags, DB_LOCK_NOWAIT | DB_LOCK_UPGRADE)) != 0) + return (ret); + + if (lock == NULL) + return (EINVAL); + + LOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle); + ret = CDB___lock_get_internal(dbenv->lk_handle, + locker, flags, obj, lock_mode, lock); + UNLOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle); + return (ret); +} + +static int +CDB___lock_get_internal(lt, locker, flags, obj, lock_mode, lock) + DB_LOCKTAB *lt; + u_int32_t locker, flags; + const DBT *obj; + db_lockmode_t lock_mode; + DB_LOCK *lock; +{ + struct __db_lock *newl, *lp; + DB_ENV *dbenv; + DB_LOCKER *sh_locker; + DB_LOCKOBJ *sh_obj; + DB_LOCKREGION *region; + u_int32_t locker_ndx; + int did_abort, freed, ihold, on_locker_list, no_dd, ret; + + no_dd = ret = 0; + on_locker_list = 0; + region = lt->reginfo.primary; + dbenv = lt->dbenv; + + /* + * Check that the lock mode is valid. + */ + if ((u_int32_t)lock_mode >= region->nmodes) { + CDB___db_err(dbenv, + "CDB_lock_get: invalid lock mode %lu\n", (u_long)lock_mode); + return (EINVAL); + } + + /* Allocate a new lock. Optimize for the common case of a grant. */ + MEMORY_LOCK(lt); + region->nrequests++; + if ((newl = SH_TAILQ_FIRST(®ion->free_locks, __db_lock)) != NULL) + SH_TAILQ_REMOVE(®ion->free_locks, newl, links, __db_lock); + MEMORY_UNLOCK(lt); + if (newl == NULL) + return (ENOMEM); + + /* Allocate a new object. */ + OBJECT_LOCK(lt, region, obj, lock->ndx); + if ((ret = CDB___lock_getobj(lt, obj, lock->ndx, 1, &sh_obj)) != 0) + goto err; + + /* Get the locker, we may need it to find our parent. */ + LOCKER_LOCK(lt, region, locker, locker_ndx); + if ((ret = + CDB___lock_getlocker(lt, locker, locker_ndx, 1, &sh_locker)) != 0) { + /* + * XXX: Margo + * CLEANUP the object and the lock. + */ + LOCKER_UNLOCK(lt, locker_ndx); + OBJECT_UNLOCK(lt, lock->ndx); + return (ret); + } + + /* + * Now we have a lock and an object and we need to see if we should + * grant the lock. We use a FIFO ordering so we can only grant a + * new lock if it does not conflict with anyone on the holders list + * OR anyone on the waiters list. The reason that we don't grant if + * there's a conflict is that this can lead to starvation (a writer + * waiting on a popularly read item will never be granted). The + * downside of this is that a waiting reader can prevent an upgrade + * from reader to writer, which is not uncommon. + * + * There is one exception to the no-conflict rule. If a lock is held + * by the requesting locker AND the new lock does not conflict with + * any other holders, then we grant the lock. The most common place + * this happens is when the holder has a WRITE lock and a READ lock + * request comes in for the same locker. If we do not grant the read + * lock, then we guarantee deadlock. + * + * In case of conflict, we put the new lock on the end of the waiters + * list, unless we are upgrading in which case the locker goes on the + * front of the list. + */ + ihold = 0; + for (lp = SH_TAILQ_FIRST(&sh_obj->holders, __db_lock); + lp != NULL; + lp = SH_TAILQ_NEXT(lp, links, __db_lock)) { + if (locker == lp->holder || + CDB___lock_is_parent(lt, lp->holder, sh_locker)) { + if (lp->mode == lock_mode && + lp->status == DB_LSTAT_HELD) { + if (LF_ISSET(DB_LOCK_UPGRADE)) + goto upgrade; + + /* + * Lock is held, so we can increment the + * reference count and return this lock. + */ + lp->refcount++; + lock->off = R_OFFSET(<->reginfo, lp); + lock->gen = lp->gen; + + ret = 0; + LOCKER_UNLOCK(lt, locker_ndx); + goto done; + } else + ihold = 1; + } else if (CONFLICTS(lt, region, lp->mode, lock_mode)) + break; + } + + /* + * Make the new lock point to the new object, initialize fields. + * + * This lock is not linked in anywhere, so we can muck with it + * without holding any mutexes. + */ + newl->holder = locker; + newl->refcount = 1; + newl->mode = lock_mode; + newl->obj = SH_PTR_TO_OFF(newl, sh_obj); + newl->status = DB_LSTAT_HELD; + + /* + * If we are upgrading, then there are two scenarios. Either + * we had no conflicts, so we can do the upgrade. Or, there + * is a conflict and we should wait at the HEAD of the waiters + * list. + */ + if (LF_ISSET(DB_LOCK_UPGRADE)) { + if (lp == NULL) { + LOCKER_UNLOCK(lt, locker_ndx); + goto upgrade; + } + + /* There was a conflict, wait. */ + SH_TAILQ_INSERT_HEAD(&sh_obj->waiters, newl, links, __db_lock); + goto llist; + } + + if (lp == NULL && !ihold) + for (lp = SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock); + lp != NULL; + lp = SH_TAILQ_NEXT(lp, links, __db_lock)) { + if (CONFLICTS(lt, region, lp->mode, lock_mode) && + locker != lp->holder) + break; + } + if (lp == NULL) + SH_TAILQ_INSERT_TAIL(&sh_obj->holders, newl, links); + else if (!(flags & DB_LOCK_NOWAIT)) + SH_TAILQ_INSERT_TAIL(&sh_obj->waiters, newl, links); + else { + ret = DB_LOCK_NOTGRANTED; + LOCKER_UNLOCK(lt, locker_ndx); + goto err; + } + +llist: + /* + * Now, insert the lock onto its locker's list. If the locker does + * not currently hold any locks, there's no reason to run a deadlock + * detector, save that information. + */ + on_locker_list = 1; + no_dd = sh_locker->master_locker == INVALID_ROFF + && SH_LIST_FIRST(&sh_locker->child_locker, __db_locker) == NULL + && SH_LIST_FIRST(&sh_locker->heldby, __db_lock) == NULL; + + SH_LIST_INSERT_HEAD(&sh_locker->heldby, newl, locker_links, __db_lock); + LOCKER_UNLOCK(lt, locker_ndx); + + if (lp != NULL) { + /* + * This is really a blocker for the thread. It should be + * initized locked, so that when we try to acquire it, we + * block. + */ + newl->status = DB_LSTAT_WAITING; + MEMORY_LOCK(lt); + region->nconflicts++; + if (region->detect == DB_LOCK_NORUN) + region->need_dd = 1; + MEMORY_UNLOCK(lt); + OBJECT_UNLOCK(lt, lock->ndx); + UNLOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle); + + /* + * We are about to wait; before waiting, see if the deadlock + * detector should be run. + */ + if (region->detect != DB_LOCK_NORUN && !no_dd) + (void)CDB_lock_detect(dbenv, 0, region->detect, &did_abort); + + MUTEX_LOCK(&newl->mutex, dbenv->lockfhp); + LOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle); + + OBJECT_LOCK_NDX(lt, lock->ndx); + if (newl->status != DB_LSTAT_PENDING) { + (void)CDB___lock_checklocker(lt, + newl, newl->holder, 0, &freed); + switch (newl->status) { + case DB_LSTAT_ABORTED: + on_locker_list = 0; + ret = DB_LOCK_DEADLOCK; + break; + case DB_LSTAT_NOGRANT: + ret = DB_LOCK_NOTGRANTED; + break; + default: + ret = EINVAL; + break; + } + goto err; + } else if (LF_ISSET(DB_LOCK_UPGRADE)) { + /* + * The lock that was just granted got put on the + * holders list. Since we're upgrading some other + * lock, we've got to remove it here. + */ + SH_TAILQ_REMOVE( + &sh_obj->holders, newl, links, __db_lock); + /* + * Ensure that the object is not believed to be on + * the object's lists, if we're traversing by locker. + */ + newl->links.stqe_prev = -1; + goto upgrade; + } else + newl->status = DB_LSTAT_HELD; + } + + lock->off = R_OFFSET(<->reginfo, newl); + lock->gen = newl->gen; + + OBJECT_UNLOCK(lt, lock->ndx); + return (0); + +upgrade:/* + * This was an upgrade, so return the new lock to the free list and + * upgrade the mode of the original lock. + */ + ((struct __db_lock *)R_ADDR(<->reginfo, lock->off))->mode = lock_mode; + + ret = 0; + /* FALLTHROUGH */ + +done: +err: OBJECT_UNLOCK(lt, lock->ndx); + + newl->status = DB_LSTAT_FREE; + if (on_locker_list) { + LOCKER_LOCK(lt, region, locker, locker_ndx); + SH_LIST_REMOVE(newl, locker_links, __db_lock); + LOCKER_UNLOCK(lt, locker_ndx); + } + MEMORY_LOCK(lt); + SH_TAILQ_INSERT_HEAD(®ion->free_locks, newl, links, __db_lock); + MEMORY_UNLOCK(lt); + return (ret); +} + +/* + * Lock release routines. + * + * The user callable one is CDB_lock_put and the three we use internally are + * CDB___lock_put_nolock, CDB___lock_put_internal and CDB___lock_downgrade. + */ +int +CDB_lock_put(dbenv, lock) + DB_ENV *dbenv; + DB_LOCK *lock; +{ + DB_LOCKTAB *lt; + int ret, run_dd; + + PANIC_CHECK(dbenv); + ENV_REQUIRES_CONFIG(dbenv, dbenv->lk_handle, DB_INIT_LOCK); + + lt = dbenv->lk_handle; + + LOCKREGION(dbenv, lt); + ret = CDB___lock_put_nolock(dbenv, lock, &run_dd); + UNLOCKREGION(dbenv, lt); + + lock->off = LOCK_INVALID; + + if (ret == 0 && run_dd) + (void)CDB_lock_detect(dbenv, 0, + ((DB_LOCKREGION *)lt->reginfo.primary)->detect, NULL); + return (ret); +} + +static int +CDB___lock_put_nolock(dbenv, lock, runp) + DB_ENV *dbenv; + DB_LOCK *lock; + int *runp; +{ + struct __db_lock *lockp; + DB_LOCKREGION *region; + DB_LOCKTAB *lt; + u_int32_t locker; + int ret; + + lt = dbenv->lk_handle; + region = lt->reginfo.primary; + + OBJECT_LOCK_NDX(lt, lock->ndx); + lockp = (struct __db_lock *)R_ADDR(<->reginfo, lock->off); + if (lock->gen != lockp->gen) { + OBJECT_UNLOCK(lt, lock->ndx); + return(EACCES); + } + + locker = lockp->holder; + ret = CDB___lock_put_internal(lt, + lockp, lock->ndx, DB_LOCK_UNLINK | DB_LOCK_FREE); + + OBJECT_UNLOCK(lt, lock->ndx); + + *runp = 0; + if (ret == 0) { + MEMORY_LOCK(lt); + if (region->need_dd && region->detect != DB_LOCK_NORUN) { + *runp = 1; + region->need_dd = 0; + } + MEMORY_UNLOCK(lt); + } + + return (ret); +} + +/* + * CDB___lock_downgrade -- + * Used by the concurrent access product to downgrade write locks + * back to iwrite locks. + * + * PUBLIC: int CDB___lock_downgrade __P((DB_ENV *, + * PUBLIC: DB_LOCK *, db_lockmode_t, u_int32_t)); + */ +int +CDB___lock_downgrade(dbenv, lock, new_mode, flags) + DB_ENV *dbenv; + DB_LOCK *lock; + db_lockmode_t new_mode; + u_int32_t flags; +{ + struct __db_lock *lockp; + DB_LOCKOBJ *obj; + DB_LOCKREGION *region; + DB_LOCKTAB *lt; + int ret; + + COMPQUIET(flags, 0); + + PANIC_CHECK(dbenv); + + lt = dbenv->lk_handle; + region = lt->reginfo.primary; + + LOCKREGION(dbenv, lt); + + OBJECT_LOCK_NDX(lt, lock->ndx); + lockp = (struct __db_lock *)R_ADDR(<->reginfo, lock->off); + if (lock->gen != lockp->gen) { + OBJECT_UNLOCK(lt, lock->ndx); + ret = EACCES; + goto out; + } + + lockp->mode = new_mode; + + /* Get the object associated with this lock. */ + obj = (DB_LOCKOBJ *)((u_int8_t *)lockp + lockp->obj); + (void)CDB___lock_promote(lt, obj); + OBJECT_UNLOCK(lt, lock->ndx); + + MEMORY_LOCK(lt); + ++region->nreleases; + MEMORY_UNLOCK(lt); +out: UNLOCKREGION(dbenv, lt); + + return (0); +} + +static int +CDB___lock_put_internal(lt, lockp, obj_ndx, flags) + DB_LOCKTAB *lt; + struct __db_lock *lockp; + u_int32_t obj_ndx; + u_int32_t flags; +{ + DB_LOCKOBJ *sh_obj; + DB_LOCKREGION *region; + int no_reclaim, ret, state_changed; + + region = lt->reginfo.primary; + no_reclaim = ret = state_changed = 0; + + if (!OBJ_LINKS_VALID(lockp)) { + /* + * Someone removed this lock while we were doing a release + * by locker id. We are trying to free this lock, but it's + * already been done; all we need to do is return it to the + * free list. + */ + MEMORY_LOCK(lt); + lockp->status = DB_LSTAT_FREE; + SH_TAILQ_INSERT_HEAD( + ®ion->free_locks, lockp, links, __db_lock); + MEMORY_UNLOCK(lt); + return (0); + } + + MEMORY_LOCK(lt); + if (LF_ISSET(DB_LOCK_DOALL)) + region->nreleases += lockp->refcount; + else + region->nreleases++; + MEMORY_UNLOCK(lt); + + if (!LF_ISSET(DB_LOCK_DOALL) && lockp->refcount > 1) { + lockp->refcount--; + return (0); + } + + /* Increment generation number. */ + lockp->gen++; + + /* Get the object associated with this lock. */ + sh_obj = (DB_LOCKOBJ *)((u_int8_t *)lockp + lockp->obj); + + /* Remove this lock from its holders/waitlist. */ + if (lockp->status != DB_LSTAT_HELD) + CDB___lock_remove_waiter(sh_obj, lockp, DB_LSTAT_FREE); + else { + SH_TAILQ_REMOVE(&sh_obj->holders, lockp, links, __db_lock); + lockp->links.stqe_prev = -1; + } + + if (LF_ISSET(DB_LOCK_NOPROMOTE)) + state_changed = 0; + else + state_changed = CDB___lock_promote(lt, sh_obj); + + if (LF_ISSET(DB_LOCK_UNLINK)) + ret = CDB___lock_checklocker(lt, lockp, lockp->holder, flags, NULL); + + /* Check if object should be reclaimed. */ + if (SH_TAILQ_FIRST(&sh_obj->holders, __db_lock) == NULL) { + HASHREMOVE_EL(lt->obj_tab, + obj_ndx, __db_lockobj, links, sh_obj); + if (sh_obj->lockobj.size > sizeof(sh_obj->objdata)) + CDB___db_shalloc_free(lt->reginfo.addr, + SH_DBT_PTR(&sh_obj->lockobj)); + MEMORY_LOCK(lt); + SH_TAILQ_INSERT_HEAD( + ®ion->free_objs, sh_obj, links, __db_lockobj); + MEMORY_UNLOCK(lt); + state_changed = 1; + } + + /* Free lock. */ + if (!LF_ISSET(DB_LOCK_UNLINK) && LF_ISSET(DB_LOCK_FREE)) { + MEMORY_LOCK(lt); + lockp->status = DB_LSTAT_FREE; + SH_TAILQ_INSERT_HEAD( + ®ion->free_locks, lockp, links, __db_lock); + MEMORY_UNLOCK(lt); + } + + /* + * If we did not promote anyone; we need to run the deadlock + * detector again. + */ + MEMORY_LOCK(lt); + if (state_changed == 0) + region->need_dd = 1; + MEMORY_UNLOCK(lt); + + return (ret); +} + +/* + * Utility functions; listed alphabetically. + */ + +/* + * CDB___lock_checklocker -- + * If a locker has no more locks, then we can free the object. + * Return a boolean indicating whether we freed the object or not. + * + * Must be called without the locker's lock set. + */ +static int +CDB___lock_checklocker(lt, lockp, locker, flags, freed) + DB_LOCKTAB *lt; + struct __db_lock *lockp; + u_int32_t locker, flags; + int *freed; +{ + DB_ENV *dbenv; + DB_LOCKER *sh_locker; + DB_LOCKREGION *region; + u_int32_t indx; + int ret; + + dbenv = lt->dbenv; + region = lt->reginfo.primary; + ret = 0; + + if (freed != NULL) + *freed = 0; + + LOCKER_LOCK(lt, region, locker, indx); + + /* If the locker's list is NULL, free up the locker. */ + if ((ret = CDB___lock_getlocker(lt, + locker, indx, 0, &sh_locker)) != 0 || sh_locker == NULL) { + if (ret == 0) + ret = EACCES; + goto freelock; + } + + if (F_ISSET(sh_locker, DB_LOCKER_DELETED)) { + LF_CLR(DB_LOCK_FREE); + if (!LF_ISSET(DB_LOCK_IGNOREDEL)) + goto freelock; + } + + if (LF_ISSET(DB_LOCK_UNLINK)) + SH_LIST_REMOVE(lockp, locker_links, __db_lock); + + if (SH_LIST_FIRST(&sh_locker->heldby, __db_lock) == NULL + && LOCKER_FREEABLE(sh_locker)) { + CDB___lock_freelocker( lt, region, sh_locker, indx); + if (freed != NULL) + *freed = 1; + } + +freelock: + if (LF_ISSET(DB_LOCK_FREE)) { + lockp->status = DB_LSTAT_FREE; + MEMORY_LOCK(lt); + SH_TAILQ_INSERT_HEAD( + ®ion->free_locks, lockp, links, __db_lock); + MEMORY_UNLOCK(lt); + } + + LOCKER_UNLOCK(lt, indx); + return (ret); +} + +/* + * CDB___lock_addfamilylocker + * Put a locker entry in for a child transaction. + * + * PUBLIC: int CDB___lock_addfamilylocker __P((DB_ENV *, u_int32_t, u_int32_t)); + */ +int +CDB___lock_addfamilylocker(dbenv, pid, id) + DB_ENV *dbenv; + u_int32_t pid, id; +{ + DB_LOCKER *lockerp, *mlockerp; + DB_LOCKREGION *region; + DB_LOCKTAB *lt; + u_int32_t ndx; + int ret; + + lt = dbenv->lk_handle; + region = lt->reginfo.primary; + LOCKREGION(dbenv, lt); + + /* get/create the parent locker info */ + LOCKER_LOCK(lt, region, pid, ndx); + if ((ret = CDB___lock_getlocker(dbenv->lk_handle, + pid, ndx, 1, &mlockerp)) != 0) + goto err; + + LOCKER_UNLOCK(lt, ndx); + + /* + * We assume that only one thread can manipulate + * a single transaction family. + * Therefore the master locker cannot go away while + * we manipulate it, nor can another child in the + * family be created at the same time. + */ + LOCKER_LOCK(lt, region, id, ndx); + if ((ret = CDB___lock_getlocker(dbenv->lk_handle, + id, ndx, 1, &lockerp)) != 0) + goto err; + + /* Point to our parent. */ + lockerp->parent_locker = R_OFFSET(<->reginfo, mlockerp); + + /* See if this locker is the family master. */ + if (mlockerp->master_locker == INVALID_ROFF) + lockerp->master_locker = R_OFFSET(<->reginfo, mlockerp); + else { + lockerp->master_locker = mlockerp->master_locker; + mlockerp = R_ADDR(<->reginfo, mlockerp->master_locker); + } + + /* + * Link the child at the head of the master's list. + * The guess is when looking for deadlock that + * the most recent child is the one thats blocked. + */ + SH_LIST_INSERT_HEAD( + &mlockerp->child_locker, lockerp, child_link, __db_locker); + +err: + LOCKER_UNLOCK(lt, ndx); + UNLOCKREGION(dbenv, lt); + + return (ret); +} + +/* + * CDB___lock_freefamilylocker + * Remove a locker from the hash table and its family. + * + * This must be called without the locker bucket locked. + * + * PUBLIC: int CDB___lock_freefamilylocker __P((DB_LOCKTAB *, u_int32_t)); + */ +int +CDB___lock_freefamilylocker(lt, locker) + DB_LOCKTAB *lt; + u_int32_t locker; +{ + DB_ENV *dbenv; + DB_LOCKER *sh_locker; + DB_LOCKREGION *region; + u_int32_t indx; + int ret; + + dbenv = lt->dbenv; + region = lt->reginfo.primary; + + LOCKREGION(dbenv, lt); + LOCKER_LOCK(lt, region, locker, indx); + + if ((ret = CDB___lock_getlocker(lt, + locker, indx, 0, &sh_locker)) != 0 || sh_locker == NULL) { + if (ret == 0) + ret = EACCES; + goto freelock; + } + if (SH_LIST_FIRST(&sh_locker->heldby, __db_lock) != NULL) { + ret = EINVAL; + goto freelock; + } + + /* If this is part of a family, we must fix up its links. */ + if (sh_locker->master_locker != INVALID_ROFF) + SH_LIST_REMOVE(sh_locker, child_link, __db_locker); + + CDB___lock_freelocker(lt, region, sh_locker, indx); + + +freelock: + LOCKER_UNLOCK(lt, indx); + UNLOCKREGION(dbenv, lt); + return (ret); +} + +/* + * CDB___lock_freelocker + * common code for deleting a locker. + * + * This must be called with the locker bucket locked. + * + * PUBLIC: void CDB___lock_freelocker __P((DB_LOCKTAB *, + * PUBLIC: DB_LOCKREGION *, DB_LOCKER *, u_int32_t)); + */ +void +CDB___lock_freelocker(lt, region, sh_locker, indx) + DB_LOCKTAB *lt; + DB_LOCKREGION *region; + DB_LOCKER *sh_locker; + u_int32_t indx; + +{ + HASHREMOVE_EL( + lt->locker_tab, indx, __db_locker, links, sh_locker); + MEMORY_LOCK(lt); + SH_TAILQ_INSERT_HEAD( + ®ion->free_lockers, sh_locker, links, __db_locker); + region->nlockers--; + MEMORY_UNLOCK(lt); +} +/* + * CDB___lock_getlocker -- + * Get a locker in the locker hash table. The create parameter + * indicates if the locker should be created if it doesn't exist in + * the table. + * + * This must be called with the locker bucket locked. + * + * PUBLIC: int CDB___lock_getlocker __P((DB_LOCKTAB *, + * PUBLIC: u_int32_t, u_int32_t, int, DB_LOCKER **)); + */ +int +CDB___lock_getlocker(lt, locker, indx, create, retp) + DB_LOCKTAB *lt; + u_int32_t locker, indx; + int create; + DB_LOCKER **retp; +{ + DB_ENV *dbenv; + DB_LOCKER *sh_locker; + DB_LOCKREGION *region; + + dbenv = lt->dbenv; + region = lt->reginfo.primary; + + HASHLOOKUP(lt->locker_tab, + indx, __db_locker, links, locker, sh_locker, CDB___lock_locker_cmp); + + /* + * If we found the locker, then we can just return it. If + * we didn't find the locker, then we need to create it. + */ + if (sh_locker == NULL && create) { + /* Create new locker and then insert it into hash table. */ + MEMORY_LOCK(lt); + if ((sh_locker = SH_TAILQ_FIRST( + ®ion->free_lockers, __db_locker)) == NULL) { + MEMORY_UNLOCK(lt); + return (ENOMEM); + } + SH_TAILQ_REMOVE( + ®ion->free_lockers, sh_locker, links, __db_locker); + if (++region->nlockers > region->maxnlockers) + region->maxnlockers = region->nlockers; + MEMORY_UNLOCK(lt); + + sh_locker->id = locker; + sh_locker->dd_id = 0; + sh_locker->master_locker = INVALID_ROFF; + sh_locker->parent_locker = INVALID_ROFF; + SH_LIST_INIT(&sh_locker->child_locker); + sh_locker->flags = 0; + SH_LIST_INIT(&sh_locker->heldby); + + HASHINSERT(lt->locker_tab, indx, __db_locker, links, sh_locker); + } + + *retp = sh_locker; + return (0); +} + +/* + * CDB___lock_getobj -- + * Get an object in the object hash table. The create parameter + * indicates if the object should be created if it doesn't exist in + * the table. + * + * This must be called with the object bucket locked. + * + * PUBLIC: int CDB___lock_getobj __P((DB_LOCKTAB *, + * PUBLIC: const DBT *, u_int32_t, int, DB_LOCKOBJ **)); + */ +int +CDB___lock_getobj(lt, obj, ndx, create, retp) + DB_LOCKTAB *lt; + const DBT *obj; + u_int32_t ndx; + int create; + DB_LOCKOBJ **retp; +{ + DB_ENV *dbenv; + DB_LOCKOBJ *sh_obj; + DB_LOCKREGION *region; + int ret; + void *p; + + dbenv = lt->dbenv; + region = lt->reginfo.primary; + + /* Look up the object in the hash table. */ + HASHLOOKUP(lt->obj_tab, + ndx, __db_lockobj, links, obj, sh_obj, CDB___lock_cmp); + + /* + * If we found the object, then we can just return it. If + * we didn't find the object, then we need to create it. + */ + if (sh_obj == NULL && create) { + /* Create new object and then insert it into hash table. */ + MEMORY_LOCK(lt); + if ((sh_obj = + SH_TAILQ_FIRST(®ion->free_objs, __db_lockobj)) == NULL) + goto err; + + /* + * If we can fit this object in the structure, do so instead + * of shalloc-ing space for it. + */ + if (obj->size <= sizeof(sh_obj->objdata)) + p = sh_obj->objdata; + else + if ((ret = CDB___db_shalloc( + lt->reginfo.addr, obj->size, 0, &p)) != 0) + goto err; + + memcpy(p, obj->data, obj->size); + + SH_TAILQ_REMOVE( + ®ion->free_objs, sh_obj, links, __db_lockobj); + MEMORY_UNLOCK(lt); + + SH_TAILQ_INIT(&sh_obj->waiters); + SH_TAILQ_INIT(&sh_obj->holders); + sh_obj->lockobj.size = obj->size; + sh_obj->lockobj.off = SH_PTR_TO_OFF(&sh_obj->lockobj, p); + + HASHINSERT(lt->obj_tab, ndx, __db_lockobj, links, sh_obj); + } + + *retp = sh_obj; + return (0); + +err: MEMORY_UNLOCK(lt); + return (ENOMEM); +} + +/* + * CDB___lock_is_parent -- + * Given a locker and a transaction, return 1 if the locker is + * an ancestor of the designcated transaction. This is used to determine + * if we should grant locks that appear to conflict, but don't because + * the lock is already held by an ancestor. + */ +static int +CDB___lock_is_parent(lt, locker, sh_locker) + DB_LOCKTAB *lt; + u_int32_t locker; + DB_LOCKER *sh_locker; +{ + DB_LOCKER *parent; + + parent = sh_locker; + while (parent->parent_locker != INVALID_ROFF) { + parent = (DB_LOCKER *) + R_ADDR(<->reginfo, parent->parent_locker); + if (parent->id == locker) + return (1); + } + + return (0); +} + +/* + * CDB___lock_promote -- + * + * Look through the waiters and holders lists and decide which (if any) + * locks can be promoted. Promote any that are eligible. + * + * This function must be called with the object bucket locked. + * + * PUBLIC: int CDB___lock_promote __P((DB_LOCKTAB *, DB_LOCKOBJ *)); + */ +int +CDB___lock_promote(lt, obj) + DB_LOCKTAB *lt; + DB_LOCKOBJ *obj; +{ + struct __db_lock *lp_w, *lp_h, *next_waiter; + DB_LOCKREGION *region; + int state_changed, waiter_is_txn; + + region = lt->reginfo.primary; + + /* + * We need to do lock promotion. We also need to determine if we're + * going to need to run the deadlock detector again. If we release + * locks, and there are waiters, but no one gets promoted, then we + * haven't fundamentally changed the lockmgr state, so we may still + * have a deadlock and we have to run again. However, if there were + * no waiters, or we actually promoted someone, then we are OK and we + * don't have to run it immediately. + * + * During promotion, we look for state changes so we can return this + * information to the caller. + */ + for (lp_w = SH_TAILQ_FIRST(&obj->waiters, __db_lock), + state_changed = lp_w == NULL; + lp_w != NULL; + lp_w = next_waiter) { + waiter_is_txn = TXN_IS_HOLDING(lp_w); + next_waiter = SH_TAILQ_NEXT(lp_w, links, __db_lock); + for (lp_h = SH_TAILQ_FIRST(&obj->holders, __db_lock); + lp_h != NULL; + lp_h = SH_TAILQ_NEXT(lp_h, links, __db_lock)) { + if (CONFLICTS(lt, region, lp_h->mode, lp_w->mode) && + lp_h->holder != lp_w->holder && + !(waiter_is_txn && TXN_IS_HOLDING(lp_h) && + CDB___txn_is_ancestor( + lt->dbenv, lp_h->txnoff, lp_w->txnoff))) + break; + } + if (lp_h != NULL) /* Found a conflict. */ + break; + + /* No conflict, promote the waiting lock. */ + SH_TAILQ_REMOVE(&obj->waiters, lp_w, links, __db_lock); + lp_w->status = DB_LSTAT_PENDING; + SH_TAILQ_INSERT_TAIL(&obj->holders, lp_w, links); + + /* Wake up waiter. */ + MUTEX_UNLOCK(&lp_w->mutex); + state_changed = 1; + } + + return (state_changed); +} + +/* + * CDB___lock_remove_waiter -- + * Any lock on the waitlist has a process waiting for it. Therefore, + * we can't return the lock to the freelist immediately. Instead, we can + * remove the lock from the list of waiters, set the status field of the + * lock, and then let the process waking up return the lock to the + * free list. + * + * This must be called with the Object bucket locked. + */ +static void +CDB___lock_remove_waiter(sh_obj, lockp, status) + DB_LOCKOBJ *sh_obj; + struct __db_lock *lockp; + db_status_t status; +{ + int do_wakeup; + + do_wakeup = lockp->status == DB_LSTAT_WAITING; + + SH_TAILQ_REMOVE(&sh_obj->waiters, lockp, links, __db_lock); + lockp->links.stqe_prev = -1; + lockp->status = status; + + /* + * Wake whoever is waiting on this lock. + * + * The MUTEX_UNLOCK macro normally resolves to a single argument, + * keep the compiler quiet. + */ + if (do_wakeup) + MUTEX_UNLOCK(&lockp->mutex); +} + +/* + * CDB___lock_printlock -- + * + * PUBLIC: void CDB___lock_printlock __P((DB_LOCKTAB *, struct __db_lock *, int)); + */ +void +CDB___lock_printlock(lt, lp, ispgno) + DB_LOCKTAB *lt; + struct __db_lock *lp; + int ispgno; +{ + DB_LOCKOBJ *lockobj; + db_pgno_t pgno; + u_int32_t *fidp; + u_int8_t *ptr, type; + const char *mode, *status; + + switch (lp->mode) { + case DB_LOCK_IREAD: + mode = "IREAD"; + break; + case DB_LOCK_IWR: + mode = "IWR"; + break; + case DB_LOCK_IWRITE: + mode = "IWRITE"; + break; + case DB_LOCK_NG: + mode = "NG"; + break; + case DB_LOCK_READ: + mode = "READ"; + break; + case DB_LOCK_WRITE: + mode = "WRITE"; + break; + default: + mode = "UNKNOWN"; + break; + } + switch (lp->status) { + case DB_LSTAT_ABORTED: + status = "ABORT"; + break; + case DB_LSTAT_ERR: + status = "ERROR"; + break; + case DB_LSTAT_FREE: + status = "FREE"; + break; + case DB_LSTAT_HELD: + status = "HELD"; + break; + case DB_LSTAT_NOGRANT: + status = "NONE"; + break; + case DB_LSTAT_WAITING: + status = "WAIT"; + break; + case DB_LSTAT_PENDING: + status = "PENDING"; + break; + default: + status = "UNKNOWN"; + break; + } + printf("\t%lx\t%s\t%lu\t%s\t", + (u_long)lp->holder, mode, (u_long)lp->refcount, status); + + lockobj = (DB_LOCKOBJ *)((u_int8_t *)lp + lp->obj); + ptr = SH_DBT_PTR(&lockobj->lockobj); + if (ispgno && lockobj->lockobj.size == sizeof(struct __db_ilock)) { + /* Assume this is a DBT lock. */ + memcpy(&pgno, ptr, sizeof(db_pgno_t)); + fidp = (u_int32_t *)(ptr + sizeof(db_pgno_t)); + type = *(u_int8_t *)(ptr + sizeof(db_pgno_t) + DB_FILE_ID_LEN); + printf("%s %lu (%lu %lu %lu %lu %lu)\n", + type == DB_PAGE_LOCK ? "page" : "record", + (u_long)pgno, + (u_long)fidp[0], (u_long)fidp[1], (u_long)fidp[2], + (u_long)fidp[3], (u_long)fidp[4]); + } else { + printf("0x%lx ", (u_long)R_OFFSET(<->reginfo, lockobj)); + CDB___db_pr(ptr, lockobj->lockobj.size); + printf("\n"); + } +} |