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

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.  * $Id: lock.h,v 11.42 2002/05/18 01:34:13 bostic Exp $
  8.  */
  9. #ifndef _DB_LOCK_H_
  10. #define _DB_LOCK_H_
  11. #define DB_LOCK_DEFAULT_N 1000 /* Default # of locks in region. */
  12. /*
  13.  * The locker id space is divided between the transaction manager and the lock
  14.  * manager.  Lock IDs start at 1 and go to DB_LOCK_MAXID.  Txn IDs start at
  15.  * DB_LOCK_MAXID + 1 and go up to TXN_MAXIMUM.
  16.  */
  17. #define DB_LOCK_INVALIDID 0
  18. #define DB_LOCK_MAXID 0x7fffffff
  19. /*
  20.  * Out of band value for a lock.  Locks contain an offset into a lock region,
  21.  * so we use an invalid region offset to indicate an invalid or unset lock.
  22.  */
  23. #define LOCK_INVALID INVALID_ROFF
  24. #define LOCK_ISSET(lock) ((lock).off != LOCK_INVALID)
  25. #define LOCK_INIT(lock) ((lock).off = LOCK_INVALID)
  26. /*
  27.  * Macro to identify a write lock for the purpose of counting locks
  28.  * for the NUMWRITES option to deadlock detection.
  29.  */
  30. #define IS_WRITELOCK(m) 
  31. ((m) == DB_LOCK_WRITE || (m) == DB_LOCK_IWRITE || (m) == DB_LOCK_IWR)
  32. /*
  33.  * Lock timers.
  34.  */
  35. typedef struct {
  36. u_int32_t tv_sec; /* Seconds. */
  37. u_int32_t tv_usec; /* Microseconds. */
  38. } db_timeval_t;
  39. #define LOCK_TIME_ISVALID(time) ((time)->tv_sec != 0)
  40. #define LOCK_SET_TIME_INVALID(time) ((time)->tv_sec = 0)
  41. #define LOCK_TIME_EQUAL(t1, t2)
  42. ((t1)->tv_sec == (t2)->tv_sec && (t1)->tv_usec == (t2)->tv_usec)
  43. /*
  44.  * DB_LOCKREGION --
  45.  * The lock shared region.
  46.  */
  47. typedef struct __db_lockregion {
  48. u_int32_t need_dd; /* flag for deadlock detector */
  49. u_int32_t detect; /* run dd on every conflict */
  50. /* free lock header */
  51. SH_TAILQ_HEAD(__flock) free_locks;
  52. /* free obj header */
  53. SH_TAILQ_HEAD(__fobj) free_objs;
  54. /* free locker header */
  55. SH_TAILQ_HEAD(__flocker) free_lockers;
  56. SH_TAILQ_HEAD(__dobj) dd_objs; /* objects with waiters */
  57. SH_TAILQ_HEAD(__lkrs) lockers; /* list of lockers */
  58. db_timeout_t lk_timeout; /* timeout for locks. */
  59. db_timeout_t tx_timeout; /* timeout for txns. */
  60. u_int32_t locker_t_size; /* size of locker hash table */
  61. u_int32_t object_t_size; /* size of object hash table */
  62. roff_t conf_off; /* offset of conflicts array */
  63. roff_t obj_off; /* offset of object hash table */
  64. roff_t osynch_off; /* offset of the object mutex table */
  65. roff_t locker_off; /* offset of locker hash table */
  66. roff_t lsynch_off; /* offset of the locker mutex table */
  67. DB_LOCK_STAT stat; /* stats about locking. */
  68. #ifdef HAVE_MUTEX_SYSTEM_RESOURCES
  69. roff_t maint_off; /* offset of region maintenance info */
  70. #endif
  71. } DB_LOCKREGION;
  72. /*
  73.  * Since we will store DBTs in shared memory, we need the equivalent of a
  74.  * DBT that will work in shared memory.
  75.  */
  76. typedef struct __sh_dbt {
  77. u_int32_t size; /* Byte length. */
  78. ssize_t   off; /* Region offset. */
  79. } SH_DBT;
  80. #define SH_DBT_PTR(p) ((void *)(((u_int8_t *)(p)) + (p)->off))
  81. /*
  82.  * Object structures;  these live in the object hash table.
  83.  */
  84. typedef struct __db_lockobj {
  85. SH_DBT lockobj; /* Identifies object locked. */
  86. SH_TAILQ_ENTRY links; /* Links for free list or hash list. */
  87. SH_TAILQ_ENTRY dd_links; /* Links for dd list. */
  88. SH_TAILQ_HEAD(__wait) waiters; /* List of waiting locks. */
  89. SH_TAILQ_HEAD(__hold) holders; /* List of held locks. */
  90. /* Declare room in the object to hold
  91.  * typical DB lock structures so that
  92.  * we do not have to allocate them from
  93.  * shalloc at run-time. */
  94. u_int8_t objdata[sizeof(struct __db_ilock)];
  95. } DB_LOCKOBJ;
  96. /*
  97.  * Locker structures; these live in the locker hash table.
  98.  */
  99. typedef struct __db_locker {
  100. u_int32_t id; /* Locker id. */
  101. u_int32_t dd_id; /* Deadlock detector id. */
  102. u_int32_t nlocks; /* Number of locks held. */
  103. u_int32_t nwrites; /* Number of write locks held. */
  104. size_t master_locker; /* Locker of master transaction. */
  105. size_t parent_locker; /* Parent of this child. */
  106. SH_LIST_HEAD(_child) child_locker; /* List of descendant txns;
  107.    only used in a "master"
  108.    txn. */
  109. SH_LIST_ENTRY child_link; /* Links transactions in the family;
  110.    elements of the child_locker
  111.    list. */
  112. SH_TAILQ_ENTRY links; /* Links for free and hash list. */
  113. SH_TAILQ_ENTRY ulinks; /* Links in-use list. */
  114. SH_LIST_HEAD(_held) heldby; /* Locks held by this locker. */
  115. db_timeval_t lk_expire; /* When current lock expires. */
  116. db_timeval_t tx_expire; /* When this txn expires. */
  117. db_timeout_t lk_timeout; /* How long do we let locks live. */
  118. #define DB_LOCKER_DELETED 0x0001
  119. #define DB_LOCKER_DIRTY 0x0002
  120. #define DB_LOCKER_INABORT 0x0004
  121. #define DB_LOCKER_TIMEOUT 0x0008
  122. u_int32_t flags;
  123. } DB_LOCKER;
  124. /*
  125.  * DB_LOCKTAB --
  126.  * The primary library lock data structure (i.e., the one referenced
  127.  * by the environment, as opposed to the internal one laid out in the region.)
  128.  */
  129. typedef struct __db_locktab {
  130. DB_ENV *dbenv; /* Environment. */
  131. REGINFO  reginfo; /* Region information. */
  132. u_int8_t *conflicts; /* Pointer to conflict matrix. */
  133. DB_HASHTAB *obj_tab; /* Beginning of object hash table. */
  134. DB_HASHTAB *locker_tab; /* Beginning of locker hash table. */
  135. } DB_LOCKTAB;
  136. /* Test for conflicts. */
  137. #define CONFLICTS(T, R, HELD, WANTED) 
  138. (T)->conflicts[(HELD) * (R)->stat.st_nmodes + (WANTED)]
  139. #define OBJ_LINKS_VALID(L) ((L)->links.stqe_prev != -1)
  140. struct __db_lock {
  141. /*
  142.  * Wait on mutex to wait on lock.  You reference your own mutex with
  143.  * ID 0 and others reference your mutex with ID 1.
  144.  */
  145. DB_MUTEX mutex;
  146. u_int32_t holder; /* Who holds this lock. */
  147. u_int32_t gen; /* Generation count. */
  148. SH_TAILQ_ENTRY links; /* Free or holder/waiter list. */
  149. SH_LIST_ENTRY locker_links; /* List of locks held by a locker. */
  150. u_int32_t refcount; /* Reference count the lock. */
  151. db_lockmode_t mode; /* What sort of lock. */
  152. ssize_t obj; /* Relative offset of object struct. */
  153. db_status_t status; /* Status of this lock. */
  154. };
  155. /*
  156.  * Flag values for __lock_put_internal:
  157.  * DB_LOCK_DOALL:     Unlock all references in this lock (instead of only 1).
  158.  * DB_LOCK_FREE:      Free the lock (used in checklocker).
  159.  * DB_LOCK_IGNOREDEL: Remove from the locker hash table even if already
  160.       deleted (used in checklocker).
  161.  * DB_LOCK_NOPROMOTE: Don't bother running promotion when releasing locks
  162.  *       (used by __lock_put_internal).
  163.  * DB_LOCK_UNLINK:    Remove from the locker links (used in checklocker).
  164.  * Make sure that these do not conflict with the interface flags because
  165.  * we pass some of those around (i.e., DB_LOCK_REMOVE).
  166.  */
  167. #define DB_LOCK_DOALL 0x010000
  168. #define DB_LOCK_FREE 0x020000
  169. #define DB_LOCK_IGNOREDEL 0x040000
  170. #define DB_LOCK_NOPROMOTE 0x080000
  171. #define DB_LOCK_UNLINK 0x100000
  172. #define DB_LOCK_NOWAITERS 0x200000
  173. /*
  174.  * Macros to get/release different types of mutexes.
  175.  */
  176. #define OBJECT_LOCK(lt, reg, obj, ndx)
  177. ndx = __lock_ohash(obj) % (reg)->object_t_size
  178. #define SHOBJECT_LOCK(lt, reg, shobj, ndx)
  179. ndx = __lock_lhash(shobj) % (reg)->object_t_size
  180. #define LOCKER_LOCK(lt, reg, locker, ndx)
  181. ndx = __lock_locker_hash(locker) % (reg)->locker_t_size;
  182. #define LOCKREGION(dbenv, lt)  R_LOCK((dbenv), &(lt)->reginfo)
  183. #define UNLOCKREGION(dbenv, lt)  R_UNLOCK((dbenv), &(lt)->reginfo)
  184. #include "dbinc_auto/lock_ext.h"
  185. #endif /* !_DB_LOCK_H_ */