#include "db_config.h"
#include "db_int.h"
#include "dbinc/lock.h"
static int __lock_region_init __P((DB_ENV *, DB_LOCKTAB *));
static size_t
__lock_region_size __P((DB_ENV *));
#define DB_LOCK_RIW_N 9
static const u_int8_t db_riw_conflicts[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 1, 0, 1, 0, 1,
0, 1, 1, 1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 0, 0, 0, 0, 1, 1,
0, 0, 1, 0, 0, 0, 0, 0, 1,
0, 1, 1, 0, 0, 0, 0, 1, 1,
0, 0, 1, 0, 1, 0, 1, 0, 0,
0, 1, 1, 0, 1, 1, 1, 0, 1
};
#define DB_LOCK_CDB_N 5
static const u_int8_t db_cdb_conflicts[] = {
0, 0, 0, 0, 0,
0, 0, 1, 0, 0,
0, 1, 1, 1, 1,
0, 0, 0, 0, 0,
0, 0, 1, 0, 1
};
int
__lock_open(dbenv, create_ok)
DB_ENV *dbenv;
int create_ok;
{
DB_LOCKREGION *region;
DB_LOCKTAB *lt;
size_t size;
int region_locked, ret;
region_locked = 0;
if ((ret = __os_calloc(dbenv, 1, sizeof(DB_LOCKTAB), <)) != 0)
return (ret);
lt->dbenv = dbenv;
lt->reginfo.dbenv = dbenv;
lt->reginfo.type = REGION_TYPE_LOCK;
lt->reginfo.id = INVALID_REGION_ID;
lt->reginfo.flags = REGION_JOIN_OK;
if (create_ok)
F_SET(<->reginfo, REGION_CREATE_OK);
size = __lock_region_size(dbenv);
if ((ret = __env_region_attach(dbenv, <->reginfo, size)) != 0)
goto err;
if (F_ISSET(<->reginfo, REGION_CREATE))
if ((ret = __lock_region_init(dbenv, lt)) != 0)
goto err;
region = lt->reginfo.primary =
R_ADDR(<->reginfo, lt->reginfo.rp->primary);
lt->conflicts = R_ADDR(<->reginfo, region->conf_off);
lt->obj_tab = R_ADDR(<->reginfo, region->obj_off);
lt->obj_stat = R_ADDR(<->reginfo, region->stat_off);
#ifdef HAVE_FINE_GRAINED_LOCK_MANAGER
lt->obj_mtx = R_ADDR(<->reginfo, region->mtx_off);
#endif
lt->locker_tab = R_ADDR(<->reginfo, region->locker_off);
dbenv->lk_handle = lt;
LOCK_SYSTEM_LOCK(dbenv);
region_locked = 1;
if (dbenv->lk_detect != DB_LOCK_NORUN) {
if (region->detect != DB_LOCK_NORUN &&
dbenv->lk_detect != DB_LOCK_DEFAULT &&
region->detect != dbenv->lk_detect) {
__db_errx(dbenv,
"lock_open: incompatible deadlock detector mode");
ret = EINVAL;
goto err;
}
if (region->detect == DB_LOCK_NORUN)
region->detect = dbenv->lk_detect;
}
if (dbenv->lk_timeout != 0)
region->lk_timeout = dbenv->lk_timeout;
if (dbenv->tx_timeout != 0)
region->tx_timeout = dbenv->tx_timeout;
LOCK_SYSTEM_UNLOCK(dbenv);
region_locked = 0;
return (0);
err: dbenv->lk_handle = NULL;
if (lt->reginfo.addr != NULL) {
if (region_locked) {
LOCK_SYSTEM_UNLOCK(dbenv);
}
(void)__env_region_detach(dbenv, <->reginfo, 0);
}
__os_free(dbenv, lt);
return (ret);
}
static int
__lock_region_init(dbenv, lt)
DB_ENV *dbenv;
DB_LOCKTAB *lt;
{
const u_int8_t *lk_conflicts;
struct __db_lock *lp;
DB_LOCKER *lidp;
DB_LOCKOBJ *op;
DB_LOCKREGION *region;
#ifdef HAVE_FINE_GRAINED_LOCK_MANAGER
db_mutex_t *mtxp;
#endif
u_int32_t i;
u_int8_t *addr;
int lk_modes, ret;
if ((ret = __env_alloc(<->reginfo,
sizeof(DB_LOCKREGION), <->reginfo.primary)) != 0)
goto mem_err;
lt->reginfo.rp->primary = R_OFFSET(<->reginfo, lt->reginfo.primary);
region = lt->reginfo.primary;
memset(region, 0, sizeof(*region));
if ((ret = __mutex_alloc(
dbenv, MTX_LOCK_REGION, 0, ®ion->mtx_region)) != 0)
return (ret);
if (dbenv->lk_modes == 0)
if (CDB_LOCKING(dbenv)) {
lk_modes = DB_LOCK_CDB_N;
lk_conflicts = db_cdb_conflicts;
} else {
lk_modes = DB_LOCK_RIW_N;
lk_conflicts = db_riw_conflicts;
}
else {
lk_modes = dbenv->lk_modes;
lk_conflicts = dbenv->lk_conflicts;
}
region->need_dd = 0;
timespecclear(®ion->next_timeout);
region->detect = DB_LOCK_NORUN;
region->lk_timeout = dbenv->lk_timeout;
region->tx_timeout = dbenv->tx_timeout;
region->locker_t_size = __db_tablesize(dbenv->lk_max_lockers);
region->object_t_size = __db_tablesize(dbenv->lk_max_objects);
memset(®ion->stat, 0, sizeof(region->stat));
region->stat.st_id = 0;
region->stat.st_cur_maxid = DB_LOCK_MAXID;
region->stat.st_maxlocks = dbenv->lk_max;
region->stat.st_maxlockers = dbenv->lk_max_lockers;
region->stat.st_maxobjects = dbenv->lk_max_objects;
region->stat.st_nmodes = lk_modes;
if ((ret = __env_alloc(
<->reginfo, (size_t)(lk_modes * lk_modes), &addr)) != 0)
goto mem_err;
memcpy(addr, lk_conflicts, (size_t)(lk_modes * lk_modes));
region->conf_off = R_OFFSET(<->reginfo, addr);
if ((ret = __env_alloc(<->reginfo,
region->object_t_size * sizeof(DB_HASHTAB), &addr)) != 0)
goto mem_err;
__db_hashinit(addr, region->object_t_size);
region->obj_off = R_OFFSET(<->reginfo, addr);
if ((ret = __env_alloc(<->reginfo,
region->object_t_size * sizeof(DB_LOCK_HSTAT), &addr)) != 0)
goto mem_err;
memset(addr, 0, region->object_t_size * sizeof(DB_LOCK_HSTAT));
region->stat_off = R_OFFSET(<->reginfo, addr);
#ifdef HAVE_FINE_GRAINED_LOCK_MANAGER
if ((ret = __env_alloc(<->reginfo,
region->object_t_size * sizeof(db_mutex_t), &mtxp)) != 0)
goto mem_err;
region->mtx_off = R_OFFSET(<->reginfo, mtxp);
for (i = 0; i < region->object_t_size; i++) {
if ((ret = __mutex_alloc(
dbenv, MTX_LOCK_REGION, 0, &mtxp[i])) != 0)
return (ret);
}
if ((ret = __mutex_alloc(
dbenv, MTX_LOCK_REGION, 0, ®ion->mtx_objs)) != 0)
return (ret);
if ((ret = __mutex_alloc(
dbenv, MTX_LOCK_REGION, 0, ®ion->mtx_locks)) != 0)
return (ret);
if ((ret = __mutex_alloc(
dbenv, MTX_LOCK_REGION, 0, ®ion->mtx_lockers)) != 0)
return (ret);
#endif
if ((ret = __env_alloc(<->reginfo,
region->locker_t_size * sizeof(DB_HASHTAB), &addr)) != 0)
goto mem_err;
__db_hashinit(addr, region->locker_t_size);
region->locker_off = R_OFFSET(<->reginfo, addr);
SH_TAILQ_INIT(®ion->free_locks);
for (i = 0; i < region->stat.st_maxlocks; ++i) {
if ((ret = __env_alloc(<->reginfo,
sizeof(struct __db_lock), &lp)) != 0)
goto mem_err;
lp->mtx_lock = MUTEX_INVALID;
lp->gen = 0;
lp->status = DB_LSTAT_FREE;
SH_TAILQ_INSERT_HEAD(®ion->free_locks, lp, links, __db_lock);
}
SH_TAILQ_INIT(®ion->dd_objs);
SH_TAILQ_INIT(®ion->free_objs);
for (i = 0; i < region->stat.st_maxobjects; ++i) {
if ((ret = __env_alloc(<->reginfo,
sizeof(DB_LOCKOBJ), &op)) != 0)
goto mem_err;
SH_TAILQ_INSERT_HEAD(
®ion->free_objs, op, links, __db_lockobj);
op->generation = 0;
}
SH_TAILQ_INIT(®ion->lockers);
SH_TAILQ_INIT(®ion->free_lockers);
for (i = 0; i < region->stat.st_maxlockers; ++i) {
if ((ret =
__env_alloc(<->reginfo, sizeof(DB_LOCKER), &lidp)) != 0) {
mem_err: __db_errx(dbenv,
"unable to allocate memory for the lock table");
return (ret);
}
SH_TAILQ_INSERT_HEAD(
®ion->free_lockers, lidp, links, __db_locker);
}
return (0);
}
int
__lock_env_refresh(dbenv)
DB_ENV *dbenv;
{
struct __db_lock *lp;
DB_LOCKER *locker;
DB_LOCKOBJ *lockobj;
DB_LOCKREGION *lr;
DB_LOCKTAB *lt;
REGINFO *reginfo;
int ret;
lt = dbenv->lk_handle;
reginfo = <->reginfo;
lr = reginfo->primary;
if (F_ISSET(dbenv, DB_ENV_PRIVATE)) {
__env_alloc_free(reginfo, R_ADDR(reginfo, lr->conf_off));
__env_alloc_free(reginfo, R_ADDR(reginfo, lr->obj_off));
__env_alloc_free(reginfo, R_ADDR(reginfo, lr->locker_off));
while ((lp =
SH_TAILQ_FIRST(&lr->free_locks, __db_lock)) != NULL) {
SH_TAILQ_REMOVE(&lr->free_locks, lp, links, __db_lock);
__env_alloc_free(reginfo, lp);
}
while ((lockobj =
SH_TAILQ_FIRST(&lr->free_objs, __db_lockobj)) != NULL) {
SH_TAILQ_REMOVE(
&lr->free_objs, lockobj, links, __db_lockobj);
__env_alloc_free(reginfo, lockobj);
}
while ((locker =
SH_TAILQ_FIRST(&lr->free_lockers, __db_locker)) != NULL) {
SH_TAILQ_REMOVE(
&lr->free_lockers, locker, links, __db_locker);
__env_alloc_free(reginfo, locker);
}
}
ret = __env_region_detach(dbenv, reginfo, 0);
__os_free(dbenv, lt);
dbenv->lk_handle = NULL;
return (ret);
}
u_int32_t
__lock_region_mutex_count(dbenv)
DB_ENV *dbenv;
{
#ifdef HAVE_FINE_GRAINED_LOCK_MANAGER
return (dbenv->lk_max + __db_tablesize(dbenv->lk_max_objects) + 3);
#else
return (dbenv->lk_max);
#endif
}
static size_t
__lock_region_size(dbenv)
DB_ENV *dbenv;
{
size_t retval;
retval = 0;
retval += __env_alloc_size(sizeof(DB_LOCKREGION));
retval += __env_alloc_size((size_t)(dbenv->lk_modes * dbenv->lk_modes));
retval += __env_alloc_size(
__db_tablesize(dbenv->lk_max_objects) * (sizeof(DB_HASHTAB)));
retval += __env_alloc_size(
__db_tablesize(dbenv->lk_max_objects) * (sizeof(DB_LOCK_HSTAT)));
retval += __env_alloc_size(
__db_tablesize(dbenv->lk_max_lockers) * (sizeof(DB_HASHTAB)));
retval += __env_alloc_size(sizeof(struct __db_lock)) * dbenv->lk_max;
retval += __env_alloc_size(sizeof(DB_LOCKOBJ)) * dbenv->lk_max_objects;
retval += __env_alloc_size(sizeof(DB_LOCKER)) * dbenv->lk_max_lockers;
retval += __env_alloc_size(dbenv->lk_max * 16);
retval += retval / 4;
return (retval);
}