lock.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:49k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: lock.c,v 11.108 2002/08/06 06:11:34 bostic Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #include <string.h>
  14. #endif
  15. #include "db_int.h"
  16. #include "dbinc/db_shash.h"
  17. #include "dbinc/lock.h"
  18. #include "dbinc/log.h"
  19. #include "dbinc/txn.h"
  20. static int  __lock_checklocker __P((DB_LOCKTAB *,
  21. struct __db_lock *, u_int32_t, u_int32_t));
  22. static void __lock_expires __P((DB_ENV *, db_timeval_t *, db_timeout_t));
  23. static void __lock_freelocker
  24. __P((DB_LOCKTAB *, DB_LOCKREGION *, DB_LOCKER *, u_int32_t));
  25. static int  __lock_get_internal __P((DB_LOCKTAB *, u_int32_t, u_int32_t,
  26. const DBT *, db_lockmode_t, db_timeout_t, DB_LOCK *));
  27. static int  __lock_getobj
  28. __P((DB_LOCKTAB *, const DBT *, u_int32_t, int, DB_LOCKOBJ **));
  29. static int  __lock_is_parent __P((DB_LOCKTAB *, u_int32_t, DB_LOCKER *));
  30. static int  __lock_put_internal __P((DB_LOCKTAB *,
  31. struct __db_lock *, u_int32_t,  u_int32_t));
  32. static int  __lock_put_nolock __P((DB_ENV *, DB_LOCK *, int *, u_int32_t));
  33. static void __lock_remove_waiter __P((DB_LOCKTAB *,
  34. DB_LOCKOBJ *, struct __db_lock *, db_status_t));
  35. static int __lock_trade __P((DB_ENV *, DB_LOCK *, u_int32_t));
  36. static const char __db_lock_err[] = "Lock table is out of available %s";
  37. static const char __db_lock_invalid[] = "%s: Lock is no longer valid";
  38. static const char __db_locker_invalid[] = "Locker is not valid";
  39. /*
  40.  * __lock_id --
  41.  * Generate a unique locker id.
  42.  *
  43.  * PUBLIC: int __lock_id __P((DB_ENV *, u_int32_t *));
  44.  */
  45. int
  46. __lock_id(dbenv, idp)
  47. DB_ENV *dbenv;
  48. u_int32_t *idp;
  49. {
  50. DB_LOCKER *lk;
  51. DB_LOCKTAB *lt;
  52. DB_LOCKREGION *region;
  53. u_int32_t *ids, locker_ndx;
  54. int nids, ret;
  55. PANIC_CHECK(dbenv);
  56. ENV_REQUIRES_CONFIG(dbenv,
  57.     dbenv->lk_handle, "DB_ENV->lock_id", DB_INIT_LOCK);
  58. lt = dbenv->lk_handle;
  59. region = lt->reginfo.primary;
  60. ret = 0;
  61. /*
  62.  * Allocate a new lock id.  If we wrap around then we
  63.  * find the minimum currently in use and make sure we
  64.  * can stay below that.  This code is similar to code
  65.  * in __txn_begin_int for recovering txn ids.
  66.  */
  67. LOCKREGION(dbenv, lt);
  68. /*
  69.  * Our current valid range can span the maximum valid value, so check
  70.  * for it and wrap manually.
  71.  */
  72. if (region->stat.st_id == DB_LOCK_MAXID &&
  73.     region->stat.st_cur_maxid != DB_LOCK_MAXID)
  74. region->stat.st_id = DB_LOCK_INVALIDID;
  75. if (region->stat.st_id == region->stat.st_cur_maxid) {
  76. if ((ret = __os_malloc(dbenv,
  77.     sizeof(u_int32_t) * region->stat.st_nlockers, &ids)) != 0)
  78. goto err;
  79. nids = 0;
  80. for (lk = SH_TAILQ_FIRST(&region->lockers, __db_locker);
  81.     lk != NULL;
  82.     lk = SH_TAILQ_NEXT(lk, ulinks, __db_locker))
  83. ids[nids++] = lk->id;
  84. region->stat.st_id = DB_LOCK_INVALIDID;
  85. region->stat.st_cur_maxid = DB_LOCK_MAXID;
  86. if (nids != 0)
  87. __db_idspace(ids, nids,
  88.     &region->stat.st_id, &region->stat.st_cur_maxid);
  89. __os_free(dbenv, ids);
  90. }
  91. *idp = ++region->stat.st_id;
  92. /* Allocate a locker for this id. */
  93. LOCKER_LOCK(lt, region, *idp, locker_ndx);
  94. ret = __lock_getlocker(lt, *idp, locker_ndx, 1, &lk);
  95. err: UNLOCKREGION(dbenv, lt);
  96. return (ret);
  97. }
  98. /*
  99.  * __lock_id_free --
  100.  * Free a locker id.
  101.  *
  102.  * PUBLIC: int __lock_id_free __P((DB_ENV *, u_int32_t));
  103.  */
  104. int
  105. __lock_id_free(dbenv, id)
  106. DB_ENV *dbenv;
  107. u_int32_t id;
  108. {
  109. DB_LOCKER *sh_locker;
  110. DB_LOCKTAB *lt;
  111. DB_LOCKREGION *region;
  112. u_int32_t locker_ndx;
  113. int ret;
  114. PANIC_CHECK(dbenv);
  115. ENV_REQUIRES_CONFIG(dbenv,
  116.     dbenv->lk_handle, "DB_ENV->lock_id_free", DB_INIT_LOCK);
  117. lt = dbenv->lk_handle;
  118. region = lt->reginfo.primary;
  119. LOCKREGION(dbenv, lt);
  120. LOCKER_LOCK(lt, region, id, locker_ndx);
  121. if ((ret =
  122.     __lock_getlocker(lt, id, locker_ndx, 0, &sh_locker)) != 0)
  123. goto err;
  124. if (sh_locker == NULL) {
  125. ret = EINVAL;
  126. goto err;
  127. }
  128. if (sh_locker->nlocks != 0) {
  129. __db_err(dbenv, "Locker still has locks");
  130. ret = EINVAL;
  131. goto err;
  132. }
  133. __lock_freelocker(lt, region, sh_locker, locker_ndx);
  134. err: UNLOCKREGION(dbenv, lt);
  135. return (ret);
  136. }
  137. /*
  138.  * __lock_vec --
  139.  * Vector lock routine.  This function takes a set of operations
  140.  * and performs them all at once.  In addition, lock_vec provides
  141.  * functionality for lock inheritance, releasing all locks for a
  142.  * given locker (used during transaction commit/abort), releasing
  143.  * all locks on a given object, and generating debugging information.
  144.  *
  145.  * PUBLIC: int __lock_vec __P((DB_ENV *,
  146.  * PUBLIC:     u_int32_t, u_int32_t, DB_LOCKREQ *, int, DB_LOCKREQ **));
  147.  */
  148. int
  149. __lock_vec(dbenv, locker, flags, list, nlist, elistp)
  150. DB_ENV *dbenv;
  151. u_int32_t locker, flags;
  152. int nlist;
  153. DB_LOCKREQ *list, **elistp;
  154. {
  155. struct __db_lock *lp, *next_lock;
  156. DB_LOCK lock;
  157. DB_LOCKER *sh_locker, *sh_parent;
  158. DB_LOCKOBJ *obj, *sh_obj;
  159. DB_LOCKREGION *region;
  160. DB_LOCKTAB *lt;
  161. u_int32_t lndx, ndx;
  162. int did_abort, i, ret, run_dd, upgrade, writes;
  163. PANIC_CHECK(dbenv);
  164. ENV_REQUIRES_CONFIG(dbenv,
  165.     dbenv->lk_handle, "DB_ENV->lock_vec", DB_INIT_LOCK);
  166. /* Check if locks have been globally turned off. */
  167. if (F_ISSET(dbenv, DB_ENV_NOLOCKING))
  168. return (0);
  169. /* Validate arguments. */
  170. if ((ret = __db_fchk(dbenv, "DB_ENV->lock_vec",
  171.     flags, DB_LOCK_FREE_LOCKER | DB_LOCK_NOWAIT)) != 0)
  172. return (ret);
  173. lt = dbenv->lk_handle;
  174. region = lt->reginfo.primary;
  175. run_dd = 0;
  176. LOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle);
  177. for (i = 0, ret = 0; i < nlist && ret == 0; i++)
  178. switch (list[i].op) {
  179. case DB_LOCK_GET_TIMEOUT:
  180. LF_SET(DB_LOCK_SET_TIMEOUT);
  181. case DB_LOCK_GET:
  182. ret = __lock_get_internal(dbenv->lk_handle,
  183.     locker, flags, list[i].obj,
  184.     list[i].mode, list[i].timeout, &list[i].lock);
  185. break;
  186. case DB_LOCK_INHERIT:
  187. /*
  188.  * Get the committing locker and mark it as deleted.
  189.  * This allows us to traverse the locker links without
  190.  * worrying that someone else is deleting locks out
  191.  * from under us.  However, if the locker doesn't
  192.  * exist, that just means that the child holds no
  193.  * locks, so inheritance is easy!
  194.  */
  195. LOCKER_LOCK(lt, region, locker, ndx);
  196. if ((ret = __lock_getlocker(lt,
  197.     locker, ndx, 0, &sh_locker)) != 0 ||
  198.     sh_locker == NULL ||
  199.     F_ISSET(sh_locker, DB_LOCKER_DELETED)) {
  200. if (ret == 0 && sh_locker != NULL)
  201. ret = EINVAL;
  202. __db_err(dbenv, __db_locker_invalid);
  203. break;
  204. }
  205. /* Make sure we are a child transaction. */
  206. if (sh_locker->parent_locker == INVALID_ROFF) {
  207. __db_err(dbenv, "Not a child transaction");
  208. ret = EINVAL;
  209. break;
  210. }
  211. sh_parent = (DB_LOCKER *)
  212.     R_ADDR(&lt->reginfo, sh_locker->parent_locker);
  213. F_SET(sh_locker, DB_LOCKER_DELETED);
  214. /*
  215.  * Now, lock the parent locker; move locks from
  216.  * the committing list to the parent's list.
  217.  */
  218. LOCKER_LOCK(lt, region, locker, ndx);
  219. if (F_ISSET(sh_parent, DB_LOCKER_DELETED)) {
  220. if (ret == 0) {
  221. __db_err(dbenv,
  222.     "Parent locker is not valid");
  223. ret = EINVAL;
  224. }
  225. break;
  226. }
  227. for (lp = SH_LIST_FIRST(&sh_locker->heldby, __db_lock);
  228.     lp != NULL;
  229.     lp = SH_LIST_FIRST(&sh_locker->heldby, __db_lock)) {
  230. SH_LIST_REMOVE(lp, locker_links, __db_lock);
  231. SH_LIST_INSERT_HEAD(&sh_parent->heldby, lp,
  232.     locker_links, __db_lock);
  233. lp->holder = sh_parent->id;
  234. /* Get the object associated with this lock. */
  235. obj = (DB_LOCKOBJ *)((u_int8_t *)lp + lp->obj);
  236. (void)__lock_promote(lt, obj,
  237.     LF_ISSET(DB_LOCK_NOWAITERS));
  238. }
  239. /* Transfer child counts to parent. */
  240. sh_parent->nlocks += sh_locker->nlocks;
  241. sh_parent->nwrites += sh_locker->nwrites;
  242. /* Now free the original locker. */
  243. ret = __lock_checklocker(lt,
  244.     NULL, locker, DB_LOCK_IGNOREDEL);
  245. break;
  246. case DB_LOCK_PUT:
  247. ret = __lock_put_nolock(dbenv,
  248.     &list[i].lock, &run_dd, flags);
  249. break;
  250. case DB_LOCK_PUT_ALL:
  251. case DB_LOCK_PUT_READ:
  252. case DB_LOCK_UPGRADE_WRITE:
  253. /*
  254.  * Get the locker and mark it as deleted.  This
  255.  * allows us to traverse the locker links without
  256.  * worrying that someone else is deleting locks out
  257.  * from under us.  Since the locker may hold no
  258.  * locks (i.e., you could call abort before you've
  259.  * done any work), it's perfectly reasonable for there
  260.  * to be no locker; this is not an error.
  261.  */
  262. LOCKER_LOCK(lt, region, locker, ndx);
  263. if ((ret = __lock_getlocker(lt,
  264.     locker, ndx, 0, &sh_locker)) != 0 ||
  265.     sh_locker == NULL ||
  266.     F_ISSET(sh_locker, DB_LOCKER_DELETED))
  267. /*
  268.  * If ret is set, then we'll generate an
  269.  * error.  If it's not set, we have nothing
  270.  * to do.
  271.  */
  272. break;
  273. upgrade = 0;
  274. writes = 1;
  275. if (list[i].op == DB_LOCK_PUT_READ)
  276. writes = 0;
  277. else if (list[i].op == DB_LOCK_UPGRADE_WRITE) {
  278. if (F_ISSET(sh_locker, DB_LOCKER_DIRTY))
  279. upgrade = 1;
  280. writes = 0;
  281. }
  282. F_SET(sh_locker, DB_LOCKER_DELETED);
  283. /* Now traverse the locks, releasing each one. */
  284. for (lp = SH_LIST_FIRST(&sh_locker->heldby, __db_lock);
  285.     lp != NULL;) {
  286. sh_obj = (DB_LOCKOBJ *)
  287.     ((u_int8_t *)lp + lp->obj);
  288. if (writes == 1 || lp->mode == DB_LOCK_READ) {
  289. SH_LIST_REMOVE(lp,
  290.     locker_links, __db_lock);
  291. sh_obj = (DB_LOCKOBJ *)
  292.     ((u_int8_t *)lp + lp->obj);
  293. SHOBJECT_LOCK(lt, region, sh_obj, lndx);
  294. /*
  295.  * We are not letting lock_put_internal
  296.  * unlink the lock, so we'll have to
  297.  * update counts here.
  298.  */
  299. sh_locker->nlocks--;
  300. if (IS_WRITELOCK(lp->mode))
  301. sh_locker->nwrites--;
  302. ret = __lock_put_internal(lt, lp,
  303.     lndx, DB_LOCK_FREE | DB_LOCK_DOALL);
  304. if (ret != 0)
  305. break;
  306. lp = SH_LIST_FIRST(
  307.     &sh_locker->heldby, __db_lock);
  308. } else
  309. lp = SH_LIST_NEXT(lp,
  310.     locker_links, __db_lock);
  311. }
  312. switch (list[i].op) {
  313. case DB_LOCK_UPGRADE_WRITE:
  314. if (upgrade != 1)
  315. goto up_done;
  316. for (lp = SH_LIST_FIRST(
  317.     &sh_locker->heldby, __db_lock);
  318.     lp != NULL;
  319.     lp = SH_LIST_NEXT(lp,
  320.     locker_links, __db_lock)) {
  321. if (ret != 0)
  322. break;
  323. lock.off = R_OFFSET(&lt->reginfo, lp);
  324. lock.gen = lp->gen;
  325. F_SET(sh_locker, DB_LOCKER_INABORT);
  326. ret = __lock_get_internal(lt,
  327.     locker, DB_LOCK_UPGRADE,
  328.     NULL, DB_LOCK_WRITE, 0, &lock);
  329. }
  330. up_done:
  331. /* FALL THROUGH */
  332. case DB_LOCK_PUT_READ:
  333. F_CLR(sh_locker, DB_LOCKER_DELETED);
  334. break;
  335. case DB_LOCK_PUT_ALL:
  336. if (ret == 0)
  337. ret = __lock_checklocker(lt,
  338.     NULL, locker, DB_LOCK_IGNOREDEL);
  339. break;
  340. default:
  341. break;
  342. }
  343. break;
  344. case DB_LOCK_PUT_OBJ:
  345. /* Remove all the locks associated with an object. */
  346. OBJECT_LOCK(lt, region, list[i].obj, ndx);
  347. if ((ret = __lock_getobj(lt, list[i].obj,
  348.     ndx, 0, &sh_obj)) != 0 || sh_obj == NULL) {
  349. if (ret == 0)
  350. ret = EINVAL;
  351. break;
  352. }
  353. /*
  354.  * Go through both waiters and holders.  Don't bother
  355.  * to run promotion, because everyone is getting
  356.  * released.  The processes waiting will still get
  357.  * awakened as their waiters are released.
  358.  */
  359. for (lp = SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock);
  360.     ret == 0 && lp != NULL;
  361.     lp = SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock))
  362. ret = __lock_put_internal(lt, lp, ndx,
  363.     DB_LOCK_UNLINK |
  364.     DB_LOCK_NOPROMOTE | DB_LOCK_DOALL);
  365. /*
  366.  * On the last time around, the object will get
  367.  * reclaimed by __lock_put_internal, structure the
  368.  * loop carefully so we do not get bitten.
  369.  */
  370. for (lp = SH_TAILQ_FIRST(&sh_obj->holders, __db_lock);
  371.     ret == 0 && lp != NULL;
  372.     lp = next_lock) {
  373. next_lock = SH_TAILQ_NEXT(lp, links, __db_lock);
  374. ret = __lock_put_internal(lt, lp, ndx,
  375.     DB_LOCK_UNLINK |
  376.     DB_LOCK_NOPROMOTE | DB_LOCK_DOALL);
  377. }
  378. break;
  379. case DB_LOCK_TIMEOUT:
  380. ret = __lock_set_timeout(dbenv,
  381.     locker, 0, DB_SET_TXN_NOW);
  382. region->need_dd = 1;
  383. break;
  384. case DB_LOCK_TRADE:
  385. /*
  386.  * INTERNAL USE ONLY.
  387.  * Change the holder of the lock described in
  388.  * list[i].lock to the locker-id specified by
  389.  * the locker parameter.
  390.  */
  391. /*
  392.  * You had better know what you're doing here.
  393.  * We are trading locker-id's on a lock to
  394.  * facilitate file locking on open DB handles.
  395.  * We do not do any conflict checking on this,
  396.  * so heaven help you if you use this flag under
  397.  * any other circumstances.
  398.  */
  399. ret = __lock_trade(dbenv, &list[i].lock, locker);
  400. break;
  401. #ifdef DEBUG
  402. case DB_LOCK_DUMP:
  403. /* Find the locker. */
  404. LOCKER_LOCK(lt, region, locker, ndx);
  405. if ((ret = __lock_getlocker(lt,
  406.     locker, ndx, 0, &sh_locker)) != 0 ||
  407.     sh_locker == NULL ||
  408.     F_ISSET(sh_locker, DB_LOCKER_DELETED))
  409. break;
  410. for (lp = SH_LIST_FIRST(&sh_locker->heldby, __db_lock);
  411.     lp != NULL;
  412.     lp = SH_LIST_NEXT(lp, locker_links, __db_lock)) {
  413. __lock_printlock(lt, lp, 1);
  414. }
  415. break;
  416. #endif
  417. default:
  418. __db_err(dbenv,
  419.     "Invalid lock operation: %d", list[i].op);
  420. ret = EINVAL;
  421. break;
  422. }
  423. if (ret == 0 && region->need_dd && region->detect != DB_LOCK_NORUN)
  424. run_dd = 1;
  425. UNLOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle);
  426. if (run_dd)
  427. (void)dbenv->lock_detect(dbenv, 0, region->detect, &did_abort);
  428. if (ret != 0 && elistp != NULL)
  429. *elistp = &list[i - 1];
  430. return (ret);
  431. }
  432. /*
  433.  * Lock acquisition routines.  There are two library interfaces:
  434.  *
  435.  * __lock_get --
  436.  * original lock get interface that takes a locker id.
  437.  *
  438.  * All the work for lock_get (and for the GET option of lock_vec) is done
  439.  * inside of lock_get_internal.
  440.  *
  441.  * PUBLIC: int __lock_get __P((DB_ENV *,
  442.  * PUBLIC:     u_int32_t, u_int32_t, const DBT *, db_lockmode_t, DB_LOCK *));
  443.  */
  444. int
  445. __lock_get(dbenv, locker, flags, obj, lock_mode, lock)
  446. DB_ENV *dbenv;
  447. u_int32_t locker, flags;
  448. const DBT *obj;
  449. db_lockmode_t lock_mode;
  450. DB_LOCK *lock;
  451. {
  452. int ret;
  453. PANIC_CHECK(dbenv);
  454. ENV_REQUIRES_CONFIG(dbenv,
  455.     dbenv->lk_handle, "DB_ENV->lock_get", DB_INIT_LOCK);
  456. if (IS_RECOVERING(dbenv)) {
  457. LOCK_INIT(*lock);
  458. return (0);
  459. }
  460. /* Validate arguments. */
  461. if ((ret = __db_fchk(dbenv, "DB_ENV->lock_get", flags,
  462.     DB_LOCK_NOWAIT | DB_LOCK_UPGRADE | DB_LOCK_SWITCH)) != 0)
  463. return (ret);
  464. LOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle);
  465. ret = __lock_get_internal(dbenv->lk_handle,
  466.     locker, flags, obj, lock_mode, 0, lock);
  467. UNLOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle);
  468. return (ret);
  469. }
  470. static int
  471. __lock_get_internal(lt, locker, flags, obj, lock_mode, timeout, lock)
  472. DB_LOCKTAB *lt;
  473. u_int32_t locker, flags;
  474. const DBT *obj;
  475. db_lockmode_t lock_mode;
  476. db_timeout_t timeout;
  477. DB_LOCK *lock;
  478. {
  479. struct __db_lock *newl, *lp, *wwrite;
  480. DB_ENV *dbenv;
  481. DB_LOCKER *sh_locker;
  482. DB_LOCKOBJ *sh_obj;
  483. DB_LOCKREGION *region;
  484. u_int32_t locker_ndx, obj_ndx;
  485. int did_abort, ihold, on_locker_list, no_dd, ret;
  486. dbenv = lt->dbenv;
  487. region = lt->reginfo.primary;
  488. on_locker_list = no_dd = ret = 0;
  489. /* Check if locks have been globally turned off. */
  490. if (F_ISSET(dbenv, DB_ENV_NOLOCKING))
  491. return (0);
  492. /*
  493.  * If we are not going to reuse this lock, initialize the offset to
  494.  * invalid so that if we fail it will not look like a valid lock.
  495.  */
  496. if (!LF_ISSET(DB_LOCK_UPGRADE | DB_LOCK_SWITCH))
  497. LOCK_INIT(*lock);
  498. /* Check that the lock mode is valid.  */
  499. if ((u_int32_t)lock_mode >= region->stat.st_nmodes) {
  500. __db_err(dbenv, "DB_ENV->lock_get: invalid lock mode %lu",
  501.     (u_long)lock_mode);
  502. return (EINVAL);
  503. }
  504. /* Allocate a new lock.  Optimize for the common case of a grant. */
  505. region->stat.st_nrequests++;
  506. if ((newl = SH_TAILQ_FIRST(&region->free_locks, __db_lock)) != NULL)
  507. SH_TAILQ_REMOVE(&region->free_locks, newl, links, __db_lock);
  508. if (newl == NULL) {
  509. __db_err(dbenv, __db_lock_err, "locks");
  510. return (ENOMEM);
  511. }
  512. if (++region->stat.st_nlocks > region->stat.st_maxnlocks)
  513. region->stat.st_maxnlocks = region->stat.st_nlocks;
  514. if (obj == NULL) {
  515. DB_ASSERT(LOCK_ISSET(*lock));
  516. lp = (struct __db_lock *)R_ADDR(&lt->reginfo, lock->off);
  517. sh_obj = (DB_LOCKOBJ *) ((u_int8_t *)lp + lp->obj);
  518. } else {
  519. /* Allocate a shared memory new object. */
  520. OBJECT_LOCK(lt, region, obj, lock->ndx);
  521. if ((ret = __lock_getobj(lt, obj, lock->ndx, 1, &sh_obj)) != 0)
  522. goto err;
  523. }
  524. /* Get the locker, we may need it to find our parent. */
  525. LOCKER_LOCK(lt, region, locker, locker_ndx);
  526. if ((ret = __lock_getlocker(lt, locker,
  527.     locker_ndx, locker > DB_LOCK_MAXID ? 1 : 0, &sh_locker)) != 0) {
  528. /*
  529.  * XXX We cannot tell if we created the object or not,
  530.  * so we don't kow if we should free it or not.
  531.  */
  532. goto err;
  533. }
  534. if (sh_locker == NULL) {
  535. __db_err(dbenv, "Locker does not exist");
  536. ret = EINVAL;
  537. goto err;
  538. }
  539. /*
  540.  * Now we have a lock and an object and we need to see if we should
  541.  * grant the lock.  We use a FIFO ordering so we can only grant a
  542.  * new lock if it does not conflict with anyone on the holders list
  543.  * OR anyone on the waiters list.  The reason that we don't grant if
  544.  * there's a conflict is that this can lead to starvation (a writer
  545.  * waiting on a popularly read item will never be granted).  The
  546.  * downside of this is that a waiting reader can prevent an upgrade
  547.  * from reader to writer, which is not uncommon.
  548.  *
  549.  * There is one exception to the no-conflict rule.  If a lock is held
  550.  * by the requesting locker AND the new lock does not conflict with
  551.  * any other holders, then we grant the lock.  The most common place
  552.  * this happens is when the holder has a WRITE lock and a READ lock
  553.  * request comes in for the same locker.  If we do not grant the read
  554.  * lock, then we guarantee deadlock.
  555.  *
  556.  * In case of conflict, we put the new lock on the end of the waiters
  557.  * list, unless we are upgrading in which case the locker goes on the
  558.  * front of the list.
  559.  */
  560. ihold = 0;
  561. lp = NULL;
  562. if (LF_ISSET(DB_LOCK_SWITCH))
  563. goto put_lock;
  564. wwrite = NULL;
  565. for (lp = SH_TAILQ_FIRST(&sh_obj->holders, __db_lock);
  566.     lp != NULL;
  567.     lp = SH_TAILQ_NEXT(lp, links, __db_lock)) {
  568. if (locker == lp->holder) {
  569. if (lp->mode == lock_mode &&
  570.     lp->status == DB_LSTAT_HELD) {
  571. if (LF_ISSET(DB_LOCK_UPGRADE))
  572. goto upgrade;
  573. /*
  574.  * Lock is held, so we can increment the
  575.  * reference count and return this lock.
  576.  * We do not count reference increments
  577.  * towards the locks held by the locker.
  578.  */
  579. lp->refcount++;
  580. lock->off = R_OFFSET(&lt->reginfo, lp);
  581. lock->gen = lp->gen;
  582. lock->mode = lp->mode;
  583. ret = 0;
  584. goto done;
  585. } else {
  586. ihold = 1;
  587. if (lock_mode == DB_LOCK_WRITE &&
  588.     lp->mode == DB_LOCK_WWRITE)
  589. wwrite = lp;
  590. }
  591. } else if (__lock_is_parent(lt, lp->holder, sh_locker))
  592. ihold = 1;
  593. else if (CONFLICTS(lt, region, lp->mode, lock_mode))
  594. break;
  595. }
  596. /*
  597.  * If we are looking to upgrade a WWRITE to a WRITE lock
  598.  * and there were no conflicting locks then we can just
  599.  * upgrade this lock to the one we want.
  600.  */
  601. if (wwrite != NULL && lp == NULL) {
  602. lp = wwrite;
  603. lp->mode = lock_mode;
  604. lp->refcount++;
  605. lock->off = R_OFFSET(&lt->reginfo, lp);
  606. lock->gen = lp->gen;
  607. lock->mode = lp->mode;
  608. ret = 0;
  609. goto done;
  610. }
  611. /*
  612.  * Make the new lock point to the new object, initialize fields.
  613.  *
  614.  * This lock is not linked in anywhere, so we can muck with it
  615.  * without holding any mutexes.
  616.  */
  617. put_lock:
  618. newl->holder = locker;
  619. newl->refcount = 1;
  620. newl->mode = lock_mode;
  621. newl->obj = SH_PTR_TO_OFF(newl, sh_obj);
  622. newl->status = DB_LSTAT_HELD;
  623. /*
  624.  * If we are upgrading, then there are two scenarios.  Either
  625.  * we had no conflicts, so we can do the upgrade.  Or, there
  626.  * is a conflict and we should wait at the HEAD of the waiters
  627.  * list.
  628.  */
  629. if (LF_ISSET(DB_LOCK_UPGRADE)) {
  630. if (lp == NULL)
  631. goto upgrade;
  632. /*
  633.  * There was a conflict, wait.  If this is the first waiter,
  634.  * add the object to the deadlock detector's list.
  635.  */
  636. if (SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock) == NULL)
  637. SH_TAILQ_INSERT_HEAD(&region->dd_objs,
  638.     sh_obj, dd_links, __db_lockobj);
  639. SH_TAILQ_INSERT_HEAD(&sh_obj->waiters, newl, links, __db_lock);
  640. goto llist;
  641. }
  642. if (lp == NULL && !ihold)
  643. for (lp = SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock);
  644.     lp != NULL;
  645.     lp = SH_TAILQ_NEXT(lp, links, __db_lock)) {
  646. if (CONFLICTS(lt, region, lp->mode, lock_mode) &&
  647.     locker != lp->holder)
  648. break;
  649. }
  650. if (!LF_ISSET(DB_LOCK_SWITCH) && lp == NULL)
  651. SH_TAILQ_INSERT_TAIL(&sh_obj->holders, newl, links);
  652. else if (!LF_ISSET(DB_LOCK_NOWAIT)) {
  653. /*
  654.  * If this is the first waiter, add the object to the
  655.  * deadlock detector's list.
  656.  */
  657. if (SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock) == NULL)
  658. SH_TAILQ_INSERT_HEAD(&region->dd_objs,
  659.     sh_obj, dd_links, __db_lockobj);
  660. SH_TAILQ_INSERT_TAIL(&sh_obj->waiters, newl, links);
  661. } else {
  662. ret = DB_LOCK_NOTGRANTED;
  663. if (SH_LIST_FIRST(&sh_locker->heldby, __db_lock) == NULL &&
  664.     LF_ISSET(DB_LOCK_FREE_LOCKER))
  665. __lock_freelocker(lt, region, sh_locker, locker_ndx);
  666. region->stat.st_nnowaits++;
  667. goto err;
  668. }
  669. llist:
  670. /*
  671.  * Now, insert the lock onto its locker's list.  If the locker does
  672.  * not currently hold any locks, there's no reason to run a deadlock
  673.  * detector, save that information.
  674.  */
  675. on_locker_list = 1;
  676. no_dd = sh_locker->master_locker == INVALID_ROFF &&
  677.     SH_LIST_FIRST(&sh_locker->child_locker, __db_locker) == NULL &&
  678.     SH_LIST_FIRST(&sh_locker->heldby, __db_lock) == NULL;
  679. SH_LIST_INSERT_HEAD(&sh_locker->heldby, newl, locker_links, __db_lock);
  680. if (LF_ISSET(DB_LOCK_SWITCH) || lp != NULL) {
  681. if (LF_ISSET(DB_LOCK_SWITCH) &&
  682.     (ret = __lock_put_nolock(dbenv,
  683.     lock, &ihold, DB_LOCK_NOWAITERS)) != 0)
  684. goto err;
  685. /*
  686.  * This is really a blocker for the thread.  It should be
  687.  * initialized locked, so that when we try to acquire it, we
  688.  * block.
  689.  */
  690. newl->status = DB_LSTAT_WAITING;
  691. region->stat.st_nconflicts++;
  692. region->need_dd = 1;
  693. /*
  694.  * First check to see if this txn has expired.
  695.  * If not then see if the lock timeout is past
  696.  * the expiration of the txn, if it is, use
  697.  * the txn expiration time.  lk_expire is passed
  698.  * to avoid an extra call to get the time.
  699.  */
  700. if (__lock_expired(dbenv,
  701.     &sh_locker->lk_expire, &sh_locker->tx_expire)) {
  702. newl->status = DB_LSTAT_ABORTED;
  703. region->stat.st_ndeadlocks++;
  704. region->stat.st_ntxntimeouts++;
  705. /*
  706.  * Remove the lock from the wait queue and if
  707.  * this was the only lock on the wait queue remove
  708.  * this object from the deadlock detector object
  709.  * list.
  710.  */
  711. SH_LIST_REMOVE(newl, locker_links, __db_lock);
  712. SH_TAILQ_REMOVE(
  713.     &sh_obj->waiters, newl, links, __db_lock);
  714. if (SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock) == NULL)
  715. SH_TAILQ_REMOVE(&region->dd_objs,
  716.     sh_obj, dd_links, __db_lockobj);
  717. /* Clear the timeout, we are done. */
  718. LOCK_SET_TIME_INVALID(&sh_locker->tx_expire);
  719. goto expired;
  720. }
  721. /*
  722.  * If a timeout was specified in this call then it
  723.  * takes priority.  If a lock timeout has been specified
  724.  * for this transaction then use that, otherwise use
  725.  * the global timeout value.
  726.  */
  727. if (!LF_ISSET(DB_LOCK_SET_TIMEOUT)) {
  728. if (F_ISSET(sh_locker, DB_LOCKER_TIMEOUT))
  729. timeout = sh_locker->lk_timeout;
  730. else
  731. timeout = region->lk_timeout;
  732. }
  733. if (timeout != 0)
  734. __lock_expires(dbenv, &sh_locker->lk_expire, timeout);
  735. else
  736. LOCK_SET_TIME_INVALID(&sh_locker->lk_expire);
  737. if (LOCK_TIME_ISVALID(&sh_locker->tx_expire) &&
  738. (timeout == 0 || __lock_expired(dbenv,
  739.     &sh_locker->lk_expire, &sh_locker->tx_expire)))
  740. sh_locker->lk_expire = sh_locker->tx_expire;
  741. UNLOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle);
  742. /*
  743.  * We are about to wait; before waiting, see if the deadlock
  744.  * detector should be run.
  745.  */
  746. if (region->detect != DB_LOCK_NORUN && !no_dd)
  747. (void)dbenv->lock_detect(
  748.     dbenv, 0, region->detect, &did_abort);
  749. MUTEX_LOCK(dbenv, &newl->mutex);
  750. LOCKREGION(dbenv, (DB_LOCKTAB *)dbenv->lk_handle);
  751. expired: /* Turn off lock timeout. */
  752. LOCK_SET_TIME_INVALID(&sh_locker->lk_expire);
  753. if (newl->status != DB_LSTAT_PENDING) {
  754. (void)__lock_checklocker(lt, newl, newl->holder, 0);
  755. switch (newl->status) {
  756. case DB_LSTAT_ABORTED:
  757. on_locker_list = 0;
  758. ret = DB_LOCK_DEADLOCK;
  759. break;
  760. case DB_LSTAT_NOTEXIST:
  761. ret = DB_LOCK_NOTEXIST;
  762. break;
  763. case DB_LSTAT_EXPIRED:
  764. SHOBJECT_LOCK(lt,
  765.     region, sh_obj, obj_ndx);
  766. if ((ret = __lock_put_internal(
  767.     lt, newl, obj_ndx, 0) != 0))
  768. goto err;
  769. if (LOCK_TIME_EQUAL(
  770.     &sh_locker->lk_expire,
  771.     &sh_locker->tx_expire)) {
  772. region->stat.st_ndeadlocks++;
  773. region->stat.st_ntxntimeouts++;
  774. return (DB_LOCK_DEADLOCK);
  775. } else {
  776. region->stat.st_nlocktimeouts++;
  777. return (DB_LOCK_NOTGRANTED);
  778. }
  779. default:
  780. ret = EINVAL;
  781. break;
  782. }
  783. goto err;
  784. } else if (LF_ISSET(DB_LOCK_UPGRADE)) {
  785. /*
  786.  * The lock that was just granted got put on the
  787.  * holders list.  Since we're upgrading some other
  788.  * lock, we've got to remove it here.
  789.  */
  790. SH_TAILQ_REMOVE(
  791.     &sh_obj->holders, newl, links, __db_lock);
  792. /*
  793.  * Ensure that the object is not believed to be on
  794.  * the object's lists, if we're traversing by locker.
  795.  */
  796. newl->links.stqe_prev = -1;
  797. goto upgrade;
  798. } else
  799. newl->status = DB_LSTAT_HELD;
  800. }
  801. lock->off = R_OFFSET(&lt->reginfo, newl);
  802. lock->gen = newl->gen;
  803. lock->mode = newl->mode;
  804. sh_locker->nlocks++;
  805. if (IS_WRITELOCK(newl->mode))
  806. sh_locker->nwrites++;
  807. return (0);
  808. upgrade:/*
  809.  * This was an upgrade, so return the new lock to the free list and
  810.  * upgrade the mode of the original lock.
  811.  */
  812. lp = (struct __db_lock *)R_ADDR(&lt->reginfo, lock->off);
  813. if (IS_WRITELOCK(lock_mode) && !IS_WRITELOCK(lp->mode))
  814. sh_locker->nwrites++;
  815. lp->mode = lock_mode;
  816. ret = 0;
  817. /* FALLTHROUGH */
  818. done:
  819. err: newl->status = DB_LSTAT_FREE;
  820. region->stat.st_nlocks--;
  821. if (on_locker_list) {
  822. SH_LIST_REMOVE(newl, locker_links, __db_lock);
  823. }
  824. SH_TAILQ_INSERT_HEAD(&region->free_locks, newl, links, __db_lock);
  825. return (ret);
  826. }
  827. /*
  828.  * Lock release routines.
  829.  *
  830.  * The user callable one is lock_put and the three we use internally are
  831.  * __lock_put_nolock, __lock_put_internal and __lock_downgrade.
  832.  *
  833.  * PUBLIC: int  __lock_put __P((DB_ENV *, DB_LOCK *));
  834.  */
  835. int
  836. __lock_put(dbenv, lock)
  837. DB_ENV *dbenv;
  838. DB_LOCK *lock;
  839. {
  840. DB_LOCKTAB *lt;
  841. int ret, run_dd;
  842. PANIC_CHECK(dbenv);
  843. ENV_REQUIRES_CONFIG(dbenv,
  844.     dbenv->lk_handle, "DB_LOCK->lock_put", DB_INIT_LOCK);
  845. if (IS_RECOVERING(dbenv))
  846. return (0);
  847. lt = dbenv->lk_handle;
  848. LOCKREGION(dbenv, lt);
  849. ret = __lock_put_nolock(dbenv, lock, &run_dd, 0);
  850. UNLOCKREGION(dbenv, lt);
  851. /*
  852.  * Only run the lock detector if put told us to AND we are running
  853.  * in auto-detect mode.  If we are not running in auto-detect, then
  854.  * a call to lock_detect here will 0 the need_dd bit, but will not
  855.  * actually abort anything.
  856.  */
  857. if (ret == 0 && run_dd)
  858. (void)dbenv->lock_detect(dbenv, 0,
  859.     ((DB_LOCKREGION *)lt->reginfo.primary)->detect, NULL);
  860. return (ret);
  861. }
  862. static int
  863. __lock_put_nolock(dbenv, lock, runp, flags)
  864. DB_ENV *dbenv;
  865. DB_LOCK *lock;
  866. int *runp;
  867. u_int32_t flags;
  868. {
  869. struct __db_lock *lockp;
  870. DB_LOCKREGION *region;
  871. DB_LOCKTAB *lt;
  872. int ret;
  873. /* Check if locks have been globally turned off. */
  874. if (F_ISSET(dbenv, DB_ENV_NOLOCKING))
  875. return (0);
  876. lt = dbenv->lk_handle;
  877. region = lt->reginfo.primary;
  878. lockp = (struct __db_lock *)R_ADDR(&lt->reginfo, lock->off);
  879. LOCK_INIT(*lock);
  880. if (lock->gen != lockp->gen) {
  881. __db_err(dbenv, __db_lock_invalid, "DB_LOCK->lock_put");
  882. return (EINVAL);
  883. }
  884. ret = __lock_put_internal(lt,
  885.     lockp, lock->ndx, flags | DB_LOCK_UNLINK | DB_LOCK_FREE);
  886. *runp = 0;
  887. if (ret == 0 && region->need_dd && region->detect != DB_LOCK_NORUN)
  888. *runp = 1;
  889. return (ret);
  890. }
  891. /*
  892.  * __lock_downgrade --
  893.  * Used to downgrade locks.  Currently this is used in two places,
  894.  * 1) by the concurrent access product to downgrade write locks
  895.  * back to iwrite locks and 2) to downgrade write-handle locks to read-handle
  896.  * locks at the end of an open/create.
  897.  *
  898.  * PUBLIC: int __lock_downgrade __P((DB_ENV *,
  899.  * PUBLIC:     DB_LOCK *, db_lockmode_t, u_int32_t));
  900.  */
  901. int
  902. __lock_downgrade(dbenv, lock, new_mode, flags)
  903. DB_ENV *dbenv;
  904. DB_LOCK *lock;
  905. db_lockmode_t new_mode;
  906. u_int32_t flags;
  907. {
  908. struct __db_lock *lockp;
  909. DB_LOCKER *sh_locker;
  910. DB_LOCKOBJ *obj;
  911. DB_LOCKREGION *region;
  912. DB_LOCKTAB *lt;
  913. u_int32_t indx;
  914. int ret;
  915. COMPQUIET(flags, 0);
  916. PANIC_CHECK(dbenv);
  917. ret = 0;
  918. /* Check if locks have been globally turned off. */
  919. if (F_ISSET(dbenv, DB_ENV_NOLOCKING))
  920. return (0);
  921. lt = dbenv->lk_handle;
  922. region = lt->reginfo.primary;
  923. LOCKREGION(dbenv, lt);
  924. lockp = (struct __db_lock *)R_ADDR(&lt->reginfo, lock->off);
  925. if (lock->gen != lockp->gen) {
  926. __db_err(dbenv, __db_lock_invalid, "lock_downgrade");
  927. ret = EINVAL;
  928. goto out;
  929. }
  930. LOCKER_LOCK(lt, region, lockp->holder, indx);
  931. if ((ret = __lock_getlocker(lt, lockp->holder,
  932.     indx, 0, &sh_locker)) != 0 || sh_locker == NULL) {
  933. if (ret == 0)
  934. ret = EINVAL;
  935. __db_err(dbenv, __db_locker_invalid);
  936. goto out;
  937. }
  938. if (IS_WRITELOCK(lockp->mode) && !IS_WRITELOCK(new_mode))
  939. sh_locker->nwrites--;
  940. if (new_mode == DB_LOCK_WWRITE)
  941. F_SET(sh_locker, DB_LOCKER_DIRTY);
  942. lockp->mode = new_mode;
  943. /* Get the object associated with this lock. */
  944. obj = (DB_LOCKOBJ *)((u_int8_t *)lockp + lockp->obj);
  945. (void)__lock_promote(lt, obj, LF_ISSET(DB_LOCK_NOWAITERS));
  946. out: UNLOCKREGION(dbenv, lt);
  947. return (ret);
  948. }
  949. static int
  950. __lock_put_internal(lt, lockp, obj_ndx, flags)
  951. DB_LOCKTAB *lt;
  952. struct __db_lock *lockp;
  953. u_int32_t obj_ndx, flags;
  954. {
  955. DB_LOCKOBJ *sh_obj;
  956. DB_LOCKREGION *region;
  957. int ret, state_changed;
  958. region = lt->reginfo.primary;
  959. ret = state_changed = 0;
  960. if (!OBJ_LINKS_VALID(lockp)) {
  961. /*
  962.  * Someone removed this lock while we were doing a release
  963.  * by locker id.  We are trying to free this lock, but it's
  964.  * already been done; all we need to do is return it to the
  965.  * free list.
  966.  */
  967. lockp->status = DB_LSTAT_FREE;
  968. SH_TAILQ_INSERT_HEAD(
  969.     &region->free_locks, lockp, links, __db_lock);
  970. region->stat.st_nlocks--;
  971. return (0);
  972. }
  973. if (LF_ISSET(DB_LOCK_DOALL))
  974. region->stat.st_nreleases += lockp->refcount;
  975. else
  976. region->stat.st_nreleases++;
  977. if (!LF_ISSET(DB_LOCK_DOALL) && lockp->refcount > 1) {
  978. lockp->refcount--;
  979. return (0);
  980. }
  981. /* Increment generation number. */
  982. lockp->gen++;
  983. /* Get the object associated with this lock. */
  984. sh_obj = (DB_LOCKOBJ *)((u_int8_t *)lockp + lockp->obj);
  985. /* Remove this lock from its holders/waitlist. */
  986. if (lockp->status != DB_LSTAT_HELD && lockp->status != DB_LSTAT_PENDING)
  987. __lock_remove_waiter(lt, sh_obj, lockp, DB_LSTAT_FREE);
  988. else {
  989. SH_TAILQ_REMOVE(&sh_obj->holders, lockp, links, __db_lock);
  990. lockp->links.stqe_prev = -1;
  991. }
  992. if (LF_ISSET(DB_LOCK_NOPROMOTE))
  993. state_changed = 0;
  994. else
  995. state_changed = __lock_promote(lt,
  996.     sh_obj, LF_ISSET(DB_LOCK_REMOVE | DB_LOCK_NOWAITERS));
  997. if (LF_ISSET(DB_LOCK_UNLINK))
  998. ret = __lock_checklocker(lt, lockp, lockp->holder, flags);
  999. /* Check if object should be reclaimed. */
  1000. if (SH_TAILQ_FIRST(&sh_obj->holders, __db_lock) == NULL &&
  1001.     SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock) == NULL) {
  1002. HASHREMOVE_EL(lt->obj_tab,
  1003.     obj_ndx, __db_lockobj, links, sh_obj);
  1004. if (sh_obj->lockobj.size > sizeof(sh_obj->objdata))
  1005. __db_shalloc_free(lt->reginfo.addr,
  1006.     SH_DBT_PTR(&sh_obj->lockobj));
  1007. SH_TAILQ_INSERT_HEAD(
  1008.     &region->free_objs, sh_obj, links, __db_lockobj);
  1009. region->stat.st_nobjects--;
  1010. state_changed = 1;
  1011. }
  1012. /* Free lock. */
  1013. if (!LF_ISSET(DB_LOCK_UNLINK) && LF_ISSET(DB_LOCK_FREE)) {
  1014. lockp->status = DB_LSTAT_FREE;
  1015. SH_TAILQ_INSERT_HEAD(
  1016.     &region->free_locks, lockp, links, __db_lock);
  1017. region->stat.st_nlocks--;
  1018. }
  1019. /*
  1020.  * If we did not promote anyone; we need to run the deadlock
  1021.  * detector again.
  1022.  */
  1023. if (state_changed == 0)
  1024. region->need_dd = 1;
  1025. return (ret);
  1026. }
  1027. /*
  1028.  * Utility functions; listed alphabetically.
  1029.  */
  1030. /*
  1031.  * __lock_checklocker --
  1032.  * If a locker has no more locks, then we can free the object.
  1033.  * Return a boolean indicating whether we freed the object or not.
  1034.  *
  1035.  * Must be called without the locker's lock set.
  1036.  */
  1037. static int
  1038. __lock_checklocker(lt, lockp, locker, flags)
  1039. DB_LOCKTAB *lt;
  1040. struct __db_lock *lockp;
  1041. u_int32_t locker, flags;
  1042. {
  1043. DB_ENV *dbenv;
  1044. DB_LOCKER *sh_locker;
  1045. DB_LOCKREGION *region;
  1046. u_int32_t indx;
  1047. int ret;
  1048. dbenv = lt->dbenv;
  1049. region = lt->reginfo.primary;
  1050. ret = 0;
  1051. LOCKER_LOCK(lt, region, locker, indx);
  1052. /* If the locker's list is NULL, free up the locker. */
  1053. if ((ret = __lock_getlocker(lt,
  1054.     locker, indx, 0, &sh_locker)) != 0 || sh_locker == NULL) {
  1055. if (ret == 0)
  1056. ret = EINVAL;
  1057. __db_err(dbenv, __db_locker_invalid);
  1058. goto freelock;
  1059. }
  1060. if (F_ISSET(sh_locker, DB_LOCKER_DELETED)) {
  1061. LF_CLR(DB_LOCK_FREE);
  1062. if (!LF_ISSET(DB_LOCK_IGNOREDEL))
  1063. goto freelock;
  1064. }
  1065. if (LF_ISSET(DB_LOCK_UNLINK)) {
  1066. SH_LIST_REMOVE(lockp, locker_links, __db_lock);
  1067. if (lockp->status == DB_LSTAT_HELD) {
  1068. sh_locker->nlocks--;
  1069. if (IS_WRITELOCK(lockp->mode))
  1070. sh_locker->nwrites--;
  1071. }
  1072. }
  1073. if (SH_LIST_FIRST(&sh_locker->heldby, __db_lock) == NULL &&
  1074.     LF_ISSET(DB_LOCK_FREE_LOCKER))
  1075. __lock_freelocker( lt, region, sh_locker, indx);
  1076. freelock:
  1077. if (LF_ISSET(DB_LOCK_FREE)) {
  1078. lockp->status = DB_LSTAT_FREE;
  1079. SH_TAILQ_INSERT_HEAD(
  1080.     &region->free_locks, lockp, links, __db_lock);
  1081. region->stat.st_nlocks--;
  1082. }
  1083. return (ret);
  1084. }
  1085. /*
  1086.  * __lock_addfamilylocker
  1087.  * Put a locker entry in for a child transaction.
  1088.  *
  1089.  * PUBLIC: int __lock_addfamilylocker __P((DB_ENV *, u_int32_t, u_int32_t));
  1090.  */
  1091. int
  1092. __lock_addfamilylocker(dbenv, pid, id)
  1093. DB_ENV *dbenv;
  1094. u_int32_t pid, id;
  1095. {
  1096. DB_LOCKER *lockerp, *mlockerp;
  1097. DB_LOCKREGION *region;
  1098. DB_LOCKTAB *lt;
  1099. u_int32_t ndx;
  1100. int ret;
  1101. lt = dbenv->lk_handle;
  1102. region = lt->reginfo.primary;
  1103. LOCKREGION(dbenv, lt);
  1104. /* get/create the  parent locker info */
  1105. LOCKER_LOCK(lt, region, pid, ndx);
  1106. if ((ret = __lock_getlocker(dbenv->lk_handle,
  1107.     pid, ndx, 1, &mlockerp)) != 0)
  1108. goto err;
  1109. /*
  1110.  * We assume that only one thread can manipulate
  1111.  * a single transaction family.
  1112.  * Therefore the master locker cannot go away while
  1113.  * we manipulate it, nor can another child in the
  1114.  * family be created at the same time.
  1115.  */
  1116. LOCKER_LOCK(lt, region, id, ndx);
  1117. if ((ret = __lock_getlocker(dbenv->lk_handle,
  1118.     id, ndx, 1, &lockerp)) != 0)
  1119. goto err;
  1120. /* Point to our parent. */
  1121. lockerp->parent_locker = R_OFFSET(&lt->reginfo, mlockerp);
  1122. /* See if this locker is the family master. */
  1123. if (mlockerp->master_locker == INVALID_ROFF)
  1124. lockerp->master_locker = R_OFFSET(&lt->reginfo, mlockerp);
  1125. else {
  1126. lockerp->master_locker = mlockerp->master_locker;
  1127. mlockerp = R_ADDR(&lt->reginfo, mlockerp->master_locker);
  1128. }
  1129. /*
  1130.  * Link the child at the head of the master's list.
  1131.  * The guess is when looking for deadlock that
  1132.  * the most recent child is the one thats blocked.
  1133.  */
  1134. SH_LIST_INSERT_HEAD(
  1135.     &mlockerp->child_locker, lockerp, child_link, __db_locker);
  1136. err:
  1137. UNLOCKREGION(dbenv, lt);
  1138. return (ret);
  1139. }
  1140. /*
  1141.  * __lock_freefamilylocker
  1142.  * Remove a locker from the hash table and its family.
  1143.  *
  1144.  * This must be called without the locker bucket locked.
  1145.  *
  1146.  * PUBLIC: int __lock_freefamilylocker  __P((DB_LOCKTAB *, u_int32_t));
  1147.  */
  1148. int
  1149. __lock_freefamilylocker(lt, locker)
  1150. DB_LOCKTAB *lt;
  1151. u_int32_t locker;
  1152. {
  1153. DB_ENV *dbenv;
  1154. DB_LOCKER *sh_locker;
  1155. DB_LOCKREGION *region;
  1156. u_int32_t indx;
  1157. int ret;
  1158. dbenv = lt->dbenv;
  1159. region = lt->reginfo.primary;
  1160. LOCKREGION(dbenv, lt);
  1161. LOCKER_LOCK(lt, region, locker, indx);
  1162. if ((ret = __lock_getlocker(lt,
  1163.     locker, indx, 0, &sh_locker)) != 0 || sh_locker == NULL)
  1164. goto freelock;
  1165. if (SH_LIST_FIRST(&sh_locker->heldby, __db_lock) != NULL) {
  1166. ret = EINVAL;
  1167. __db_err(dbenv, "Freeing locker with locks");
  1168. goto freelock;
  1169. }
  1170. /* If this is part of a family, we must fix up its links. */
  1171. if (sh_locker->master_locker != INVALID_ROFF)
  1172. SH_LIST_REMOVE(sh_locker, child_link, __db_locker);
  1173. __lock_freelocker(lt, region, sh_locker, indx);
  1174. freelock:
  1175. UNLOCKREGION(dbenv, lt);
  1176. return (ret);
  1177. }
  1178. /*
  1179.  * __lock_freelocker
  1180.  * common code for deleting a locker.
  1181.  *
  1182.  * This must be called with the locker bucket locked.
  1183.  */
  1184. static void
  1185. __lock_freelocker(lt, region, sh_locker, indx)
  1186. DB_LOCKTAB *lt;
  1187. DB_LOCKREGION *region;
  1188. DB_LOCKER *sh_locker;
  1189. u_int32_t indx;
  1190. {
  1191. HASHREMOVE_EL(
  1192.     lt->locker_tab, indx, __db_locker, links, sh_locker);
  1193. SH_TAILQ_INSERT_HEAD(
  1194.     &region->free_lockers, sh_locker, links, __db_locker);
  1195. SH_TAILQ_REMOVE(&region->lockers, sh_locker, ulinks, __db_locker);
  1196. region->stat.st_nlockers--;
  1197. }
  1198. /*
  1199.  * __lock_set_timeout
  1200.  * -- set timeout values in shared memory.
  1201.  * This is called from the transaction system.
  1202.  * We either set the time that this tranaction expires or the
  1203.  * amount of time that a lock for this transaction is permitted
  1204.  * to wait.
  1205.  *
  1206.  * PUBLIC: int __lock_set_timeout __P(( DB_ENV *,
  1207.  * PUBLIC:      u_int32_t, db_timeout_t, u_int32_t));
  1208.  */
  1209. int
  1210. __lock_set_timeout(dbenv, locker, timeout, op)
  1211. DB_ENV *dbenv;
  1212. u_int32_t locker;
  1213. db_timeout_t timeout;
  1214. u_int32_t op;
  1215. {
  1216. DB_LOCKER *sh_locker;
  1217. DB_LOCKREGION *region;
  1218. DB_LOCKTAB *lt;
  1219. u_int32_t locker_ndx;
  1220. int ret;
  1221. lt = dbenv->lk_handle;
  1222. region = lt->reginfo.primary;
  1223. LOCKREGION(dbenv, lt);
  1224. LOCKER_LOCK(lt, region, locker, locker_ndx);
  1225. ret = __lock_getlocker(lt, locker, locker_ndx, 1, &sh_locker);
  1226. UNLOCKREGION(dbenv, lt);
  1227. if (ret != 0)
  1228. return (ret);
  1229. if (op == DB_SET_TXN_TIMEOUT) {
  1230. if (timeout == 0)
  1231. LOCK_SET_TIME_INVALID(&sh_locker->tx_expire);
  1232. else
  1233. __lock_expires(dbenv, &sh_locker->tx_expire, timeout);
  1234. } else if (op == DB_SET_LOCK_TIMEOUT) {
  1235. sh_locker->lk_timeout = timeout;
  1236. F_SET(sh_locker, DB_LOCKER_TIMEOUT);
  1237. } else if (op == DB_SET_TXN_NOW) {
  1238. LOCK_SET_TIME_INVALID(&sh_locker->tx_expire);
  1239. __lock_expires(dbenv, &sh_locker->tx_expire, 0);
  1240. sh_locker->lk_expire = sh_locker->tx_expire;
  1241. } else
  1242. return (EINVAL);
  1243. return (0);
  1244. }
  1245. /*
  1246.  * __lock_inherit_timeout
  1247.  * -- inherit timeout values from parent locker.
  1248.  * This is called from the transaction system.  This will
  1249.  * return EINVAL if the parent does not exist or did not
  1250.  * have a current txn timeout set.
  1251.  *
  1252.  * PUBLIC: int __lock_inherit_timeout __P(( DB_ENV *, u_int32_t, u_int32_t));
  1253.  */
  1254. int
  1255. __lock_inherit_timeout(dbenv, parent, locker)
  1256. DB_ENV *dbenv;
  1257. u_int32_t parent, locker;
  1258. {
  1259. DB_LOCKER *parent_locker, *sh_locker;
  1260. DB_LOCKREGION *region;
  1261. DB_LOCKTAB *lt;
  1262. u_int32_t locker_ndx;
  1263. int ret;
  1264. lt = dbenv->lk_handle;
  1265. region = lt->reginfo.primary;
  1266. ret = 0;
  1267. LOCKREGION(dbenv, lt);
  1268. /* If the parent does not exist, we are done. */
  1269. LOCKER_LOCK(lt, region, parent, locker_ndx);
  1270. if ((ret = __lock_getlocker(lt,
  1271.     parent, locker_ndx, 0, &parent_locker)) != 0)
  1272. goto err;
  1273. /*
  1274.  * If the parent is not there yet, thats ok.  If it
  1275.  * does not have any timouts set, then avoid creating
  1276.  * the child locker at this point.
  1277.  */
  1278. if (parent_locker == NULL ||
  1279.     (LOCK_TIME_ISVALID(&parent_locker->tx_expire) &&
  1280.     !F_ISSET(parent_locker, DB_LOCKER_TIMEOUT))) {
  1281. ret = EINVAL;
  1282. goto done;
  1283. }
  1284. LOCKER_LOCK(lt, region, locker, locker_ndx);
  1285. if ((ret = __lock_getlocker(lt,
  1286.     locker, locker_ndx, 1, &sh_locker)) != 0)
  1287. goto err;
  1288. sh_locker->tx_expire = parent_locker->tx_expire;
  1289. if (F_ISSET(parent_locker, DB_LOCKER_TIMEOUT)) {
  1290. sh_locker->lk_timeout = parent_locker->lk_timeout;
  1291. F_SET(sh_locker, DB_LOCKER_TIMEOUT);
  1292. if (!LOCK_TIME_ISVALID(&parent_locker->tx_expire))
  1293. ret = EINVAL;
  1294. }
  1295. done:
  1296. err:
  1297. UNLOCKREGION(dbenv, lt);
  1298. return (ret);
  1299. }
  1300. /*
  1301.  * __lock_getlocker --
  1302.  * Get a locker in the locker hash table.  The create parameter
  1303.  * indicates if the locker should be created if it doesn't exist in
  1304.  * the table.
  1305.  *
  1306.  * This must be called with the locker bucket locked.
  1307.  *
  1308.  * PUBLIC: int __lock_getlocker __P((DB_LOCKTAB *,
  1309.  * PUBLIC:     u_int32_t, u_int32_t, int, DB_LOCKER **));
  1310.  */
  1311. int
  1312. __lock_getlocker(lt, locker, indx, create, retp)
  1313. DB_LOCKTAB *lt;
  1314. u_int32_t locker, indx;
  1315. int create;
  1316. DB_LOCKER **retp;
  1317. {
  1318. DB_ENV *dbenv;
  1319. DB_LOCKER *sh_locker;
  1320. DB_LOCKREGION *region;
  1321. dbenv = lt->dbenv;
  1322. region = lt->reginfo.primary;
  1323. HASHLOOKUP(lt->locker_tab,
  1324.     indx, __db_locker, links, locker, sh_locker, __lock_locker_cmp);
  1325. /*
  1326.  * If we found the locker, then we can just return it.  If
  1327.  * we didn't find the locker, then we need to create it.
  1328.  */
  1329. if (sh_locker == NULL && create) {
  1330. /* Create new locker and then insert it into hash table. */
  1331. if ((sh_locker = SH_TAILQ_FIRST(
  1332.     &region->free_lockers, __db_locker)) == NULL) {
  1333. __db_err(dbenv, __db_lock_err, "locker entries");
  1334. return (ENOMEM);
  1335. }
  1336. SH_TAILQ_REMOVE(
  1337.     &region->free_lockers, sh_locker, links, __db_locker);
  1338. if (++region->stat.st_nlockers > region->stat.st_maxnlockers)
  1339. region->stat.st_maxnlockers = region->stat.st_nlockers;
  1340. sh_locker->id = locker;
  1341. sh_locker->dd_id = 0;
  1342. sh_locker->master_locker = INVALID_ROFF;
  1343. sh_locker->parent_locker = INVALID_ROFF;
  1344. SH_LIST_INIT(&sh_locker->child_locker);
  1345. sh_locker->flags = 0;
  1346. SH_LIST_INIT(&sh_locker->heldby);
  1347. sh_locker->nlocks = 0;
  1348. sh_locker->nwrites = 0;
  1349. sh_locker->lk_timeout = 0;
  1350. LOCK_SET_TIME_INVALID(&sh_locker->tx_expire);
  1351. if (locker < TXN_MINIMUM && region->tx_timeout != 0)
  1352. __lock_expires(dbenv,
  1353.     &sh_locker->tx_expire, region->tx_timeout);
  1354. LOCK_SET_TIME_INVALID(&sh_locker->lk_expire);
  1355. HASHINSERT(lt->locker_tab, indx, __db_locker, links, sh_locker);
  1356. SH_TAILQ_INSERT_HEAD(&region->lockers,
  1357.     sh_locker, ulinks, __db_locker);
  1358. }
  1359. *retp = sh_locker;
  1360. return (0);
  1361. }
  1362. /*
  1363.  * __lock_getobj --
  1364.  * Get an object in the object hash table.  The create parameter
  1365.  * indicates if the object should be created if it doesn't exist in
  1366.  * the table.
  1367.  *
  1368.  * This must be called with the object bucket locked.
  1369.  */
  1370. static int
  1371. __lock_getobj(lt, obj, ndx, create, retp)
  1372. DB_LOCKTAB *lt;
  1373. const DBT *obj;
  1374. u_int32_t ndx;
  1375. int create;
  1376. DB_LOCKOBJ **retp;
  1377. {
  1378. DB_ENV *dbenv;
  1379. DB_LOCKOBJ *sh_obj;
  1380. DB_LOCKREGION *region;
  1381. int ret;
  1382. void *p;
  1383. dbenv = lt->dbenv;
  1384. region = lt->reginfo.primary;
  1385. /* Look up the object in the hash table. */
  1386. HASHLOOKUP(lt->obj_tab,
  1387.     ndx, __db_lockobj, links, obj, sh_obj, __lock_cmp);
  1388. /*
  1389.  * If we found the object, then we can just return it.  If
  1390.  * we didn't find the object, then we need to create it.
  1391.  */
  1392. if (sh_obj == NULL && create) {
  1393. /* Create new object and then insert it into hash table. */
  1394. if ((sh_obj =
  1395.     SH_TAILQ_FIRST(&region->free_objs, __db_lockobj)) == NULL) {
  1396. __db_err(lt->dbenv, __db_lock_err, "object entries");
  1397. ret = ENOMEM;
  1398. goto err;
  1399. }
  1400. /*
  1401.  * If we can fit this object in the structure, do so instead
  1402.  * of shalloc-ing space for it.
  1403.  */
  1404. if (obj->size <= sizeof(sh_obj->objdata))
  1405. p = sh_obj->objdata;
  1406. else if ((ret = __db_shalloc(
  1407.     lt->reginfo.addr, obj->size, 0, &p)) != 0) {
  1408. __db_err(dbenv, "No space for lock object storage");
  1409. goto err;
  1410. }
  1411. memcpy(p, obj->data, obj->size);
  1412. SH_TAILQ_REMOVE(
  1413.     &region->free_objs, sh_obj, links, __db_lockobj);
  1414. if (++region->stat.st_nobjects > region->stat.st_maxnobjects)
  1415. region->stat.st_maxnobjects = region->stat.st_nobjects;
  1416. SH_TAILQ_INIT(&sh_obj->waiters);
  1417. SH_TAILQ_INIT(&sh_obj->holders);
  1418. sh_obj->lockobj.size = obj->size;
  1419. sh_obj->lockobj.off = SH_PTR_TO_OFF(&sh_obj->lockobj, p);
  1420. HASHINSERT(lt->obj_tab, ndx, __db_lockobj, links, sh_obj);
  1421. }
  1422. *retp = sh_obj;
  1423. return (0);
  1424. err: return (ret);
  1425. }
  1426. /*
  1427.  * __lock_is_parent --
  1428.  * Given a locker and a transaction, return 1 if the locker is
  1429.  * an ancestor of the designcated transaction.  This is used to determine
  1430.  * if we should grant locks that appear to conflict, but don't because
  1431.  * the lock is already held by an ancestor.
  1432.  */
  1433. static int
  1434. __lock_is_parent(lt, locker, sh_locker)
  1435. DB_LOCKTAB *lt;
  1436. u_int32_t locker;
  1437. DB_LOCKER *sh_locker;
  1438. {
  1439. DB_LOCKER *parent;
  1440. parent = sh_locker;
  1441. while (parent->parent_locker != INVALID_ROFF) {
  1442. parent = (DB_LOCKER *)
  1443.     R_ADDR(&lt->reginfo, parent->parent_locker);
  1444. if (parent->id == locker)
  1445. return (1);
  1446. }
  1447. return (0);
  1448. }
  1449. /*
  1450.  * __lock_promote --
  1451.  *
  1452.  * Look through the waiters and holders lists and decide which (if any)
  1453.  * locks can be promoted.   Promote any that are eligible.
  1454.  *
  1455.  * PUBLIC: int __lock_promote __P((DB_LOCKTAB *, DB_LOCKOBJ *, u_int32_t));
  1456.  */
  1457. int
  1458. __lock_promote(lt, obj, flags)
  1459. DB_LOCKTAB *lt;
  1460. DB_LOCKOBJ *obj;
  1461. u_int32_t flags;
  1462. {
  1463. struct __db_lock *lp_w, *lp_h, *next_waiter;
  1464. DB_LOCKER *sh_locker;
  1465. DB_LOCKREGION *region;
  1466. u_int32_t locker_ndx;
  1467. int had_waiters, state_changed;
  1468. region = lt->reginfo.primary;
  1469. had_waiters = 0;
  1470. /*
  1471.  * We need to do lock promotion.  We also need to determine if we're
  1472.  * going to need to run the deadlock detector again.  If we release
  1473.  * locks, and there are waiters, but no one gets promoted, then we
  1474.  * haven't fundamentally changed the lockmgr state, so we may still
  1475.  * have a deadlock and we have to run again.  However, if there were
  1476.  * no waiters, or we actually promoted someone, then we are OK and we
  1477.  * don't have to run it immediately.
  1478.  *
  1479.  * During promotion, we look for state changes so we can return this
  1480.  * information to the caller.
  1481.  */
  1482. for (lp_w = SH_TAILQ_FIRST(&obj->waiters, __db_lock),
  1483.     state_changed = lp_w == NULL;
  1484.     lp_w != NULL;
  1485.     lp_w = next_waiter) {
  1486. had_waiters = 1;
  1487. next_waiter = SH_TAILQ_NEXT(lp_w, links, __db_lock);
  1488. /* Waiter may have aborted or expired. */
  1489. if (lp_w->status != DB_LSTAT_WAITING)
  1490. continue;
  1491. /* Are we switching locks? */
  1492. if (LF_ISSET(DB_LOCK_NOWAITERS) && lp_w->mode == DB_LOCK_WAIT)
  1493. continue;
  1494. if (LF_ISSET(DB_LOCK_REMOVE)) {
  1495. __lock_remove_waiter(lt, obj, lp_w, DB_LSTAT_NOTEXIST);
  1496. continue;
  1497. }
  1498. for (lp_h = SH_TAILQ_FIRST(&obj->holders, __db_lock);
  1499.     lp_h != NULL;
  1500.     lp_h = SH_TAILQ_NEXT(lp_h, links, __db_lock)) {
  1501. if (lp_h->holder != lp_w->holder &&
  1502.     CONFLICTS(lt, region, lp_h->mode, lp_w->mode)) {
  1503. LOCKER_LOCK(lt,
  1504.     region, lp_w->holder, locker_ndx);
  1505. if ((__lock_getlocker(lt, lp_w->holder,
  1506.     locker_ndx, 0, &sh_locker)) != 0) {
  1507. DB_ASSERT(0);
  1508. break;
  1509. }
  1510. if (!__lock_is_parent(lt,
  1511.     lp_h->holder, sh_locker))
  1512. break;
  1513. }
  1514. }
  1515. if (lp_h != NULL) /* Found a conflict. */
  1516. break;
  1517. /* No conflict, promote the waiting lock. */
  1518. SH_TAILQ_REMOVE(&obj->waiters, lp_w, links, __db_lock);
  1519. lp_w->status = DB_LSTAT_PENDING;
  1520. SH_TAILQ_INSERT_TAIL(&obj->holders, lp_w, links);
  1521. /* Wake up waiter. */
  1522. MUTEX_UNLOCK(lt->dbenv, &lp_w->mutex);
  1523. state_changed = 1;
  1524. }
  1525. /*
  1526.  * If this object had waiters and doesn't any more, then we need
  1527.  * to remove it from the dd_obj list.
  1528.  */
  1529. if (had_waiters && SH_TAILQ_FIRST(&obj->waiters, __db_lock) == NULL)
  1530. SH_TAILQ_REMOVE(&region->dd_objs, obj, dd_links, __db_lockobj);
  1531. return (state_changed);
  1532. }
  1533. /*
  1534.  * __lock_remove_waiter --
  1535.  * Any lock on the waitlist has a process waiting for it.  Therefore,
  1536.  * we can't return the lock to the freelist immediately.  Instead, we can
  1537.  * remove the lock from the list of waiters, set the status field of the
  1538.  * lock, and then let the process waking up return the lock to the
  1539.  * free list.
  1540.  *
  1541.  * This must be called with the Object bucket locked.
  1542.  */
  1543. static void
  1544. __lock_remove_waiter(lt, sh_obj, lockp, status)
  1545. DB_LOCKTAB *lt;
  1546. DB_LOCKOBJ *sh_obj;
  1547. struct __db_lock *lockp;
  1548. db_status_t status;
  1549. {
  1550. DB_LOCKREGION *region;
  1551. int do_wakeup;
  1552. region = lt->reginfo.primary;
  1553. do_wakeup = lockp->status == DB_LSTAT_WAITING;
  1554. SH_TAILQ_REMOVE(&sh_obj->waiters, lockp, links, __db_lock);
  1555. lockp->links.stqe_prev = -1;
  1556. lockp->status = status;
  1557. if (SH_TAILQ_FIRST(&sh_obj->waiters, __db_lock) == NULL)
  1558. SH_TAILQ_REMOVE(
  1559.     &region->dd_objs,
  1560.     sh_obj, dd_links, __db_lockobj);
  1561. /*
  1562.  * Wake whoever is waiting on this lock.
  1563.  *
  1564.  * The MUTEX_UNLOCK macro normally resolves to a single argument,
  1565.  * keep the compiler quiet.
  1566.  */
  1567. if (do_wakeup)
  1568. MUTEX_UNLOCK(lt->dbenv, &lockp->mutex);
  1569. }
  1570. /*
  1571.  * __lock_expires -- set the expire time given the time to live.
  1572.  * We assume that if timevalp is set then it contains "now".
  1573.  * This avoids repeated system calls to get the time.
  1574.  */
  1575. static void
  1576. __lock_expires(dbenv, timevalp, timeout)
  1577. DB_ENV *dbenv;
  1578. db_timeval_t *timevalp;
  1579. db_timeout_t timeout;
  1580. {
  1581. if (!LOCK_TIME_ISVALID(timevalp))
  1582. __os_clock(dbenv, &timevalp->tv_sec, &timevalp->tv_usec);
  1583. if (timeout > 1000000) {
  1584. timevalp->tv_sec += timeout / 1000000;
  1585. timevalp->tv_usec += timeout % 1000000;
  1586. } else
  1587. timevalp->tv_usec += timeout;
  1588. if (timevalp->tv_usec > 1000000) {
  1589. timevalp->tv_sec++;
  1590. timevalp->tv_usec -= 1000000;
  1591. }
  1592. }
  1593. /*
  1594.  * __lock_expired -- determine if a lock has expired.
  1595.  *
  1596.  * PUBLIC: int __lock_expired __P((DB_ENV *, db_timeval_t *, db_timeval_t *));
  1597.  */
  1598. int
  1599. __lock_expired(dbenv, now, timevalp)
  1600. DB_ENV *dbenv;
  1601. db_timeval_t *now, *timevalp;
  1602. {
  1603. if (!LOCK_TIME_ISVALID(timevalp))
  1604. return (0);
  1605. if (!LOCK_TIME_ISVALID(now))
  1606. __os_clock(dbenv, &now->tv_sec, &now->tv_usec);
  1607. return (now->tv_sec > timevalp->tv_sec ||
  1608.     (now->tv_sec == timevalp->tv_sec &&
  1609.     now->tv_usec >= timevalp->tv_usec));
  1610. }
  1611. /*
  1612.  * __lock_trade --
  1613.  *
  1614.  * Trade locker ids on a lock.  This is used to reassign file locks from
  1615.  * a transactional locker id to a long-lived locker id.  This should be
  1616.  * called with the region mutex held.
  1617.  */
  1618. static int
  1619. __lock_trade(dbenv, lock, new_locker)
  1620. DB_ENV *dbenv;
  1621. DB_LOCK *lock;
  1622. u_int32_t new_locker;
  1623. {
  1624. struct __db_lock *lp;
  1625. DB_LOCKREGION *region;
  1626. DB_LOCKTAB *lt;
  1627. DB_LOCKER *sh_locker;
  1628. int ret;
  1629. u_int32_t locker_ndx;
  1630. lt = dbenv->lk_handle;
  1631. region = lt->reginfo.primary;
  1632. lp = (struct __db_lock *)R_ADDR(&lt->reginfo, lock->off);
  1633. /* If the lock is already released, simply return. */
  1634. if (lp->gen != lock->gen)
  1635. return (DB_NOTFOUND);
  1636. /* Make sure that we can get new locker and add this lock to it. */
  1637. LOCKER_LOCK(lt, region, new_locker, locker_ndx);
  1638. if ((ret =
  1639.     __lock_getlocker(lt, new_locker, locker_ndx, 0, &sh_locker)) != 0)
  1640. return (ret);
  1641. if (sh_locker == NULL) {
  1642. __db_err(dbenv, "Locker does not exist");
  1643. return (EINVAL);
  1644. }
  1645. /* Remove the lock from its current locker. */
  1646. if ((ret = __lock_checklocker(lt, lp, lp->holder, DB_LOCK_UNLINK)) != 0)
  1647. return (ret);
  1648. /* Add lock to its new locker. */
  1649. SH_LIST_INSERT_HEAD(&sh_locker->heldby, lp, locker_links, __db_lock);
  1650. sh_locker->nlocks++;
  1651. if (IS_WRITELOCK(lp->mode))
  1652. sh_locker->nwrites++;
  1653. lp->holder = new_locker;
  1654. return (0);
  1655. }