#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: lock_region.c,v 1.2 2004/03/30 01:23:43 jtownsen Exp $";
#endif
#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>
#include <string.h>
#endif
#include "db_int.h"
#include "dbinc/db_shash.h"
#include "dbinc/lock.h"
static int __lock_init __P((DB_ENV *, DB_LOCKTAB *));
static size_t
__lock_region_size __P((DB_ENV *));
#ifdef HAVE_MUTEX_SYSTEM_RESOURCES
static size_t __lock_region_maint __P((DB_ENV *));
#endif
#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)
DB_ENV *dbenv;
{
DB_LOCKREGION *region;
DB_LOCKTAB *lt;
size_t size;
int ret;
if ((ret = __os_calloc(dbenv, 1, sizeof(DB_LOCKTAB), <)) != 0)
return (ret);
lt->dbenv = dbenv;
lt->reginfo.type = REGION_TYPE_LOCK;
lt->reginfo.id = INVALID_REGION_ID;
lt->reginfo.mode = dbenv->db_mode;
lt->reginfo.flags = REGION_JOIN_OK;
if (F_ISSET(dbenv, DB_ENV_CREATE))
F_SET(<->reginfo, REGION_CREATE_OK);
size = __lock_region_size(dbenv);
if ((ret = __db_r_attach(dbenv, <->reginfo, size)) != 0)
goto err;
if (F_ISSET(<->reginfo, REGION_CREATE))
if ((ret = __lock_init(dbenv, lt)) != 0)
goto err;
region = lt->reginfo.primary =
R_ADDR(<->reginfo, lt->reginfo.rp->primary);
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_err(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;
lt->conflicts = (u_int8_t *)R_ADDR(<->reginfo, region->conf_off);
lt->obj_tab = (DB_HASHTAB *)R_ADDR(<->reginfo, region->obj_off);
lt->locker_tab = (DB_HASHTAB *)R_ADDR(<->reginfo, region->locker_off);
R_UNLOCK(dbenv, <->reginfo);
dbenv->lk_handle = lt;
return (0);
err: if (lt->reginfo.addr != NULL) {
if (F_ISSET(<->reginfo, REGION_CREATE))
ret = __db_panic(dbenv, ret);
R_UNLOCK(dbenv, <->reginfo);
(void)__db_r_detach(dbenv, <->reginfo, 0);
}
__os_free(dbenv, lt);
return (ret);
}
static int
__lock_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_MUTEX_SYSTEM_RESOURCES
size_t maint_size;
#endif
u_int32_t i, lk_modes;
u_int8_t *addr;
int ret;
if ((ret = __db_shalloc(lt->reginfo.addr,
sizeof(DB_LOCKREGION), 0, <->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 (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;
LOCK_SET_TIME_INVALID(®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 =
__db_shalloc(lt->reginfo.addr, lk_modes * lk_modes, 0, &addr)) != 0)
goto mem_err;
memcpy(addr, lk_conflicts, lk_modes * lk_modes);
region->conf_off = R_OFFSET(<->reginfo, addr);
if ((ret = __db_shalloc(lt->reginfo.addr,
region->object_t_size * sizeof(DB_HASHTAB), 0, &addr)) != 0)
goto mem_err;
__db_hashinit(addr, region->object_t_size);
region->obj_off = R_OFFSET(<->reginfo, addr);
if ((ret = __db_shalloc(lt->reginfo.addr,
region->locker_t_size * sizeof(DB_HASHTAB), 0, &addr)) != 0)
goto mem_err;
__db_hashinit(addr, region->locker_t_size);
region->locker_off = R_OFFSET(<->reginfo, addr);
#ifdef HAVE_MUTEX_SYSTEM_RESOURCES
maint_size = __lock_region_maint(dbenv);
if ((ret = __db_shalloc(lt->reginfo.addr,
sizeof(REGMAINT) + maint_size, 0, &addr)) != 0)
goto mem_err;
__db_maintinit(<->reginfo, addr, maint_size);
region->maint_off = R_OFFSET(<->reginfo, addr);
#endif
SH_TAILQ_INIT(®ion->free_locks);
for (i = 0; i < region->stat.st_maxlocks; ++i) {
if ((ret = __db_shalloc(lt->reginfo.addr,
sizeof(struct __db_lock), MUTEX_ALIGN, &lp)) != 0)
goto mem_err;
lp->status = DB_LSTAT_FREE;
lp->gen = 0;
if ((ret = __db_mutex_setup(dbenv, <->reginfo, &lp->mutex,
MUTEX_LOGICAL_LOCK | MUTEX_NO_RLOCK | MUTEX_SELF_BLOCK))
!= 0)
return (ret);
MUTEX_LOCK(dbenv, &lp->mutex);
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 = __db_shalloc(lt->reginfo.addr,
sizeof(DB_LOCKOBJ), 0, &op)) != 0)
goto mem_err;
SH_TAILQ_INSERT_HEAD(
®ion->free_objs, op, links, __db_lockobj);
}
SH_TAILQ_INIT(®ion->lockers);
SH_TAILQ_INIT(®ion->free_lockers);
for (i = 0; i < region->stat.st_maxlockers; ++i) {
if ((ret = __db_shalloc(lt->reginfo.addr,
sizeof(DB_LOCKER), 0, &lidp)) != 0) {
mem_err: __db_err(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_dbenv_refresh(dbenv)
DB_ENV *dbenv;
{
DB_LOCKTAB *lt;
int ret;
lt = dbenv->lk_handle;
ret = __db_r_detach(dbenv, <->reginfo, 0);
__os_free(dbenv, lt);
dbenv->lk_handle = NULL;
return (ret);
}
static size_t
__lock_region_size(dbenv)
DB_ENV *dbenv;
{
size_t retval;
retval = 0;
retval += __db_shalloc_size(sizeof(DB_LOCKREGION), 1);
retval += __db_shalloc_size(dbenv->lk_modes * dbenv->lk_modes, 1);
retval += __db_shalloc_size(
__db_tablesize(dbenv->lk_max_lockers) * (sizeof(DB_HASHTAB)), 1);
retval += __db_shalloc_size(
__db_tablesize(dbenv->lk_max_objects) * (sizeof(DB_HASHTAB)), 1);
#ifdef HAVE_MUTEX_SYSTEM_RESOURCES
retval +=
__db_shalloc_size(sizeof(REGMAINT) + __lock_region_maint(dbenv), 1);
#endif
retval += __db_shalloc_size(
sizeof(struct __db_lock), MUTEX_ALIGN) * dbenv->lk_max;
retval += __db_shalloc_size(
sizeof(DB_LOCKOBJ), 1) * dbenv->lk_max_objects;
retval += __db_shalloc_size(
sizeof(DB_LOCKER), 1) * dbenv->lk_max_lockers;
retval += __db_shalloc_size(dbenv->lk_max * 16, sizeof(size_t));
retval += retval / 4;
return (retval);
}
#ifdef HAVE_MUTEX_SYSTEM_RESOURCES
static size_t
__lock_region_maint(dbenv)
DB_ENV *dbenv;
{
size_t s;
s = sizeof(DB_MUTEX *) * dbenv->lk_max;
return (s);
}
#endif
void
__lock_region_destroy(dbenv, infop)
DB_ENV *dbenv;
REGINFO *infop;
{
__db_shlocks_destroy(infop, (REGMAINT *)R_ADDR(infop,
((DB_LOCKREGION *)R_ADDR(infop, infop->rp->primary))->maint_off));
COMPQUIET(dbenv, NULL);
COMPQUIET(infop, NULL);
}
int
__lock_id_set(dbenv, cur_id, max_id)
DB_ENV *dbenv;
u_int32_t cur_id, max_id;
{
DB_LOCKTAB *lt;
DB_LOCKREGION *region;
ENV_REQUIRES_CONFIG(dbenv,
dbenv->lk_handle, "lock_id_set", DB_INIT_LOCK);
lt = dbenv->lk_handle;
region = lt->reginfo.primary;
region->stat.st_id = cur_id;
region->stat.st_cur_maxid = max_id;
return (0);
}