BDB锁共享区域

/*
* The lock table is the per-process cookie returned from a lock_open call.
*/
struct __db_locktab {
 DB_ENV *dbenv; /* Environment. */
 REGINFO reginfo; /* Region information. */
 DB_LOCKREGION *region; /* Address of shared memory region. */
 DB_HASHTAB *hashtab; /* Beginning of hash table. */
 void *mem; /* Beginning of string space. */
 u_int8_t *conflicts; /* Pointer to conflict matrix. */
};

/*
* The lock region consists of:
* The DB_LOCKREGION structure (sizeof(DB_LOCKREGION)).
* The conflict matrix of nmodes * nmodes bytes (nmodes * nmodes).
* The hash table for object lookup (hashsize * sizeof(DB_OBJ *)).
* The locks themselves (maxlocks * sizeof(struct __db_lock).
* The objects being locked (maxlocks * sizeof(DB_OBJ)).
* String space to represent the DBTs that are the objects being locked.
*/
struct __db_lockregion {
 RLAYOUT hdr; /* Shared region header. */
 u_int32_t magic; /* lock magic number */
 u_int32_t version; /* version number */
 u_int32_t id; /* unique id generator */
 u_int32_t need_dd; /* flag for deadlock detector */
 u_int32_t detect; /* run dd on every conflict */
 SH_TAILQ_HEAD(lock_header) free_locks; /* free lock header */
 SH_TAILQ_HEAD(obj_header) free_objs; /* free obj header */
 u_int32_t maxlocks; /* maximum number of locks in table */
 u_int32_t table_size; /* size of hash table */
 u_int32_t nmodes; /* number of lock modes */
 u_int32_t numobjs; /* number of objects */
 u_int32_t nlockers; /* number of lockers */
 size_t increment; /* how much to grow region */
 size_t hash_off; /* offset of hash table */
 size_t mem_off; /* offset of memory region */
 size_t mem_bytes; /* number of bytes in memory region */
 u_int32_t nconflicts; /* number of lock conflicts */
 u_int32_t nrequests; /* number of lock gets */
 u_int32_t nreleases; /* number of lock puts */
 u_int32_t ndeadlocks; /* number of deadlocks */
};

if (LF_ISSET(DB_INIT_LOCK) && (ret = lock_open(NULL,
 LF_ISSET(DB_CREATE | DB_THREAD),
 mode, dbenv, &dbenv->lk_info)) != 0)

int
lock_open(path, flags, mode, dbenv, ltp)
 const char *path;
 u_int32_t flags;
 int mode;
 DB_ENV *dbenv;
 DB_LOCKTAB **ltp;
{
 DB_LOCKTAB *lt;
 u_int32_t lock_modes, maxlocks, regflags;
 int ret;
/* 首先验证参数的合法性 */
 /* Validate arguments. */
......
 /* 然后使用malloc创建每个进程都有的锁表数据结构 */
 /* Create the lock table structure. */
 if ((ret = __os_calloc(1, sizeof(DB_LOCKTAB), <)) != 0)
 return (ret);
 lt->dbenv = dbenv;
 /* Grab the values that we need to compute the region size. */
 lock_modes = DB_LOCK_RW_N;
 maxlocks = DB_LOCK_DEFAULT_N;
 regflags = REGION_SIZEDEF;
 if (dbenv != NULL) {
 if (dbenv->lk_modes != 0) {
 lock_modes = dbenv->lk_modes;
 regflags = 0;
 }
 if (dbenv->lk_max != 0) {
 maxlocks = dbenv->lk_max;
 regflags = 0;
 }
 }
 /* 现在可以创建或链接到一个共享锁区域 */
 /* Join/create the lock region. */
 /* 填充reginfo信息以调用底层的__db_rattach()函数 */
 lt->reginfo.dbenv = dbenv;
 lt->reginfo.appname = DB_APP_NONE;
 if (path == NULL)
 lt->reginfo.path = NULL;
 else
 if ((ret = __os_strdup(path, <->reginfo.path)) != 0)
 goto err;
 lt->reginfo.file = DB_DEFAULT_LOCK_FILE;
 lt->reginfo.mode = mode;
 lt->reginfo.size =
 LOCK_REGION_SIZE(lock_modes, maxlocks, __db_tablesize(maxlocks));
 lt->reginfo.dbflags = flags;
 lt->reginfo.addr = NULL;
 lt->reginfo.fd = -1;
 lt->reginfo.flags = regflags;
 /* 调用__db_rattach()函数创建或打开一个共享区域 */
 if ((ret = __db_rattach(<->reginfo)) != 0)
 goto err;
 /* Now set up the pointer to the region. */
 lt->region = lt->reginfo.addr;
 /* 如果是该共享区域是新创建的，初始化之 */
 /* Initialize the region if we created it. */
 if (F_ISSET(<->reginfo, REGION_CREATED)) {
 lt->region->maxlocks = maxlocks;
 lt->region->nmodes = lock_modes;
 if ((ret = __lock_tabinit(dbenv, lt->region)) != 0)
 goto err;
 } else {
 /* Check for an unexpected region. */
 if (lt->region->magic != DB_LOCKMAGIC) {
 __db_err(dbenv,
 "lock_open: %s: bad magic number", path);
 ret = EINVAL;
 goto err;
 }
 }
 /* Check for automatic deadlock detection. */
 if (dbenv != NULL && dbenv->lk_detect != DB_LOCK_NORUN) {
 if (lt->region->detect != DB_LOCK_NORUN &&
 dbenv->lk_detect != DB_LOCK_DEFAULT &&
 lt->region->detect != dbenv->lk_detect) {
 __db_err(dbenv,
 "lock_open: incompatible deadlock detector mode");
 ret = EINVAL;
 goto err;
 }
 if (lt->region->detect == DB_LOCK_NORUN)
 lt->region->detect = dbenv->lk_detect;
 }
 /* 填充区域的指针字段：注意我们前面说过的映射问题。这里进程利用公共DB_LOCKREGION类型字段region的相对地址在自己的锁表中填写绝对地址 */
 /* Set up remaining pointers into region. */
 lt->conflicts = (u_int8_t *)lt->region + sizeof(DB_LOCKREGION);
 lt->hashtab =
 (DB_HASHTAB *)((u_int8_t *)lt->region + lt->region->hash_off);
 lt->mem = (void *)((u_int8_t *)lt->region + lt->region->mem_off);
 UNLOCK_LOCKREGION(lt);
 *ltp = lt;
 return (0);
err: if (lt->reginfo.addr != NULL) {
 UNLOCK_LOCKREGION(lt);
 (void)__db_rdetach(<->reginfo);
 if (F_ISSET(<->reginfo, REGION_CREATED))
 (void)lock_unlink(path, 1, dbenv);
 }
 if (lt->reginfo.path != NULL)
 __os_freestr(lt->reginfo.path);
 __os_free(lt, sizeof(*lt));
 return (ret);
}
/*
* __lock_panic --
* Panic a lock region.
*
* PUBLIC: void __lock_panic __P((DB_ENV *));
*/
void
__lock_panic(dbenv)
 DB_ENV *dbenv;
{
 if (dbenv->lk_info != NULL)
 dbenv->lk_info->region->hdr.panic = 1;
}

/*
* __lock_tabinit --
* Initialize the lock region.
*/
static int
__lock_tabinit(dbenv, lrp)
 DB_ENV *dbenv;
 DB_LOCKREGION *lrp;
{
 struct __db_lock *lp;
 struct lock_header *tq_head;
 struct obj_header *obj_head;
 DB_LOCKOBJ *op;
 u_int32_t i, nelements;
 const u_int8_t *conflicts;
 u_int8_t *curaddr;
 conflicts = dbenv == NULL || dbenv->lk_conflicts == NULL ?
 db_rw_conflicts : dbenv->lk_conflicts;
 lrp->table_size = __db_tablesize(lrp->maxlocks);
 lrp->magic = DB_LOCKMAGIC;
 lrp->version = DB_LOCKVERSION;
 lrp->id = 0;
 /*
 * These fields (lrp->maxlocks, lrp->nmodes) are initialized
 * in the caller, since we had to grab those values to size
 * the region.
 */
 lrp->need_dd = 0;
 lrp->detect = DB_LOCK_NORUN;
 lrp->numobjs = lrp->maxlocks;
 lrp->nlockers = 0;
 lrp->mem_bytes = ALIGN(STRING_SIZE(lrp->maxlocks), sizeof(size_t));
 lrp->increment = lrp->hdr.size / 2;
 lrp->nconflicts = 0;
 lrp->nrequests = 0;
 lrp->nreleases = 0;
 lrp->ndeadlocks = 0;
 /*
 * As we write the region, we've got to maintain the alignment
 * for the structures that follow each chunk. This information
 * ends up being encapsulated both in here as well as in the
 * lock.h file for the XXX_SIZE macros.
 */
 /* Initialize conflict matrix. */
 curaddr = (u_int8_t *)lrp + sizeof(DB_LOCKREGION);
 memcpy(curaddr, conflicts, lrp->nmodes * lrp->nmodes);
 curaddr += lrp->nmodes * lrp->nmodes;
 /*
 * Initialize hash table.
 */
 curaddr = (u_int8_t *)ALIGNP(curaddr, LOCK_HASH_ALIGN);
 lrp->hash_off = curaddr - (u_int8_t *)lrp;
 nelements = lrp->table_size;
 __db_hashinit(curaddr, nelements);
 curaddr += nelements * sizeof(DB_HASHTAB);
 /*
 * Initialize locks onto a free list. Since locks contains mutexes,
 * we need to make sure that each lock is aligned on a MUTEX_ALIGNMENT
 * boundary.
 */
 curaddr = (u_int8_t *)ALIGNP(curaddr, MUTEX_ALIGNMENT);
 tq_head = &lrp->free_locks;
 SH_TAILQ_INIT(tq_head);
 for (i = 0; i++ < lrp->maxlocks;
 curaddr += ALIGN(sizeof(struct __db_lock), MUTEX_ALIGNMENT)) {
 lp = (struct __db_lock *)curaddr;
 lp->status = DB_LSTAT_FREE;
 SH_TAILQ_INSERT_HEAD(tq_head, lp, links, __db_lock);
 }
 /* Initialize objects onto a free list. */
 obj_head = &lrp->free_objs;
 SH_TAILQ_INIT(obj_head);
 for (i = 0; i++ < lrp->maxlocks; curaddr += sizeof(DB_LOCKOBJ)) {
 op = (DB_LOCKOBJ *)curaddr;
 SH_TAILQ_INSERT_HEAD(obj_head, op, links, __db_lockobj);
 }
 /*
 * Initialize the string space; as for all shared memory allocation
 * regions, this requires size_t alignment, since we store the
 * lengths of malloc'd areas in the area.
 */
 curaddr = (u_int8_t *)ALIGNP(curaddr, sizeof(size_t));
 lrp->mem_off = curaddr - (u_int8_t *)lrp;
 __db_shalloc_init(curaddr, lrp->mem_bytes);
 return (0);
}