#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: mutex.c,v 1.2 2004/03/30 01:23:45 jtownsen Exp $";
#endif
#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>
#include <string.h>
#endif
#include "db_int.h"
#if defined(MUTEX_NO_MALLOC_LOCKS) || defined(HAVE_MUTEX_SYSTEM_RESOURCES)
#include "dbinc/db_shash.h"
#include "dbinc/lock.h"
#include "dbinc/log.h"
#include "dbinc/mp.h"
#include "dbinc/txn.h"
#endif
static int __db_mutex_alloc_int __P((DB_ENV *, REGINFO *, DB_MUTEX **));
#ifdef HAVE_MUTEX_SYSTEM_RESOURCES
static REGMAINT * __db_mutex_maint __P((DB_ENV *, REGINFO *));
#endif
int
__db_mutex_setup(dbenv, infop, ptr, flags)
DB_ENV *dbenv;
REGINFO *infop;
void *ptr;
u_int32_t flags;
{
DB_MUTEX *mutex;
REGMAINT *maint;
u_int32_t iflags, offset;
int ret;
ret = 0;
#if defined(MUTEX_NO_MALLOC_LOCKS) || defined(HAVE_MUTEX_SYSTEM_RESOURCES)
if (!LF_ISSET(MUTEX_NO_RLOCK))
R_LOCK(dbenv, infop);
#endif
mutex = NULL;
if (LF_ISSET(MUTEX_ALLOC)) {
if ((ret = __db_mutex_alloc_int(dbenv, infop, ptr)) != 0)
goto err;
mutex = *(DB_MUTEX **)ptr;
} else
mutex = (DB_MUTEX *)ptr;
iflags = LF_ISSET(MUTEX_LOGICAL_LOCK | MUTEX_THREAD | MUTEX_SELF_BLOCK);
switch (infop->type) {
case REGION_TYPE_LOCK:
offset = P_TO_UINT32(mutex) + DB_FCNTL_OFF_LOCK;
break;
case REGION_TYPE_MPOOL:
offset = P_TO_UINT32(mutex) + DB_FCNTL_OFF_MPOOL;
break;
default:
offset = P_TO_UINT32(mutex) + DB_FCNTL_OFF_GEN;
break;
}
maint = NULL;
#ifdef HAVE_MUTEX_SYSTEM_RESOURCES
if (!LF_ISSET(MUTEX_NO_RECORD))
maint = (REGMAINT *)__db_mutex_maint(dbenv, infop);
#endif
ret = __db_mutex_init(dbenv, mutex, offset, iflags, infop, maint);
err:
#if defined(MUTEX_NO_MALLOC_LOCKS) || defined(HAVE_MUTEX_SYSTEM_RESOURCES)
if (!LF_ISSET(MUTEX_NO_RLOCK))
R_UNLOCK(dbenv, infop);
#endif
if (ret != 0 && LF_ISSET(MUTEX_ALLOC) && mutex != NULL) {
__db_mutex_free(dbenv, infop, mutex);
*(DB_MUTEX **)ptr = NULL;
}
return (ret);
}
static int
__db_mutex_alloc_int(dbenv, infop, storep)
DB_ENV *dbenv;
REGINFO *infop;
DB_MUTEX **storep;
{
int ret;
#if defined(MUTEX_NO_MALLOC_LOCKS) || defined(HAVE_MUTEX_SYSTEM_RESOURCES)
ret = __db_shalloc(infop->addr, sizeof(DB_MUTEX), MUTEX_ALIGN, storep);
if (ret == ENOMEM && MPOOL_ON(dbenv)) {
DB_MPOOL *dbmp;
dbmp = dbenv->mp_handle;
if ((ret = __memp_alloc(dbmp,
dbmp->reginfo, NULL, sizeof(DB_MUTEX), NULL, storep)) == 0)
(*storep)->flags = MUTEX_MPOOL;
} else
(*storep)->flags = 0;
#else
COMPQUIET(dbenv, NULL);
COMPQUIET(infop, NULL);
ret = __os_calloc(dbenv, 1, sizeof(DB_MUTEX), storep);
#endif
if (ret != 0)
__db_err(dbenv, "Unable to allocate memory for mutex");
return (ret);
}
void
__db_mutex_free(dbenv, infop, mutexp)
DB_ENV *dbenv;
REGINFO *infop;
DB_MUTEX *mutexp;
{
#if defined(MUTEX_NO_MALLOC_LOCKS) || defined(HAVE_MUTEX_SYSTEM_RESOURCES)
R_LOCK(dbenv, infop);
#if defined(HAVE_MUTEX_SYSTEM_RESOURCES)
if (F_ISSET(mutexp, MUTEX_INITED))
__db_shlocks_clear(mutexp, infop, NULL);
#endif
if (F_ISSET(mutexp, MUTEX_MPOOL)) {
DB_MPOOL *dbmp;
dbmp = dbenv->mp_handle;
R_LOCK(dbenv, dbmp->reginfo);
__db_shalloc_free(dbmp->reginfo[0].addr, mutexp);
R_UNLOCK(dbenv, dbmp->reginfo);
} else
__db_shalloc_free(infop->addr, mutexp);
R_UNLOCK(dbenv, infop);
#else
COMPQUIET(dbenv, NULL);
COMPQUIET(infop, NULL);
__os_free(dbenv, mutexp);
#endif
}
#ifdef HAVE_MUTEX_SYSTEM_RESOURCES
static int
__db_shreg_locks_record(dbenv, mutexp, infop, rp)
DB_ENV *dbenv;
DB_MUTEX *mutexp;
REGINFO *infop;
REGMAINT *rp;
{
u_int i;
if (!F_ISSET(mutexp, MUTEX_INITED))
return (0);
DB_ASSERT(mutexp->reg_off == INVALID_ROFF);
rp->stat.st_records++;
i = (roff_t *)R_ADDR(infop, rp->regmutex_hint) - &rp->regmutexes[0];
if (rp->regmutexes[i] != INVALID_ROFF) {
rp->stat.st_hint_miss++;
for (i = 0; i < rp->reglocks; i++)
if (rp->regmutexes[i] == INVALID_ROFF)
break;
if (i == rp->reglocks) {
rp->stat.st_max_locks++;
__db_err(dbenv,
"Region mutexes: Exceeded maximum lock slots %lu",
(u_long)rp->reglocks);
return (ENOMEM);
}
} else
rp->stat.st_hint_hit++;
rp->regmutexes[i] = R_OFFSET(infop, mutexp);
mutexp->reg_off = R_OFFSET(infop, &rp->regmutexes[i]);
rp->regmutex_hint = (i < rp->reglocks - 1) ?
R_OFFSET(infop, &rp->regmutexes[i+1]) :
R_OFFSET(infop, &rp->regmutexes[0]);
return (0);
}
void
__db_shreg_locks_clear(mutexp, infop, rp)
DB_MUTEX *mutexp;
REGINFO *infop;
REGMAINT *rp;
{
if (!F_ISSET(mutexp, MUTEX_INITED))
return;
DB_ASSERT(mutexp->reg_off != INVALID_ROFF);
DB_ASSERT(*(roff_t *)R_ADDR(infop, mutexp->reg_off) == \
R_OFFSET(infop, mutexp));
*(roff_t *)R_ADDR(infop, mutexp->reg_off) = 0;
if (rp != NULL) {
rp->regmutex_hint = mutexp->reg_off;
rp->stat.st_clears++;
}
mutexp->reg_off = INVALID_ROFF;
__db_mutex_destroy(mutexp);
}
void
__db_shreg_locks_destroy(infop, rp)
REGINFO *infop;
REGMAINT *rp;
{
u_int32_t i;
for (i = 0; i < rp->reglocks; i++)
if (rp->regmutexes[i] != 0) {
rp->stat.st_destroys++;
__db_mutex_destroy((DB_MUTEX *)R_ADDR(infop,
rp->regmutexes[i]));
}
}
int
__db_shreg_mutex_init(dbenv, mutexp, offset, flags, infop, rp)
DB_ENV *dbenv;
DB_MUTEX *mutexp;
u_int32_t offset;
u_int32_t flags;
REGINFO *infop;
REGMAINT *rp;
{
int ret;
if ((ret = __db_mutex_init_int(dbenv, mutexp, offset, flags)) != 0)
return (ret);
if (rp == NULL)
return (ret);
COMPQUIET(offset, 0);
ret = __db_shreg_locks_record(dbenv, mutexp, infop, rp);
if (ret)
__db_mutex_destroy(mutexp);
return (ret);
}
void
__db_shreg_maintinit(infop, addr, size)
REGINFO *infop;
void *addr;
size_t size;
{
REGMAINT *rp;
u_int32_t i;
rp = (REGMAINT *)addr;
memset(addr, 0, sizeof(REGMAINT));
rp->reglocks = size / sizeof(roff_t);
rp->regmutex_hint = R_OFFSET(infop, &rp->regmutexes[0]);
for (i = 0; i < rp->reglocks; i++)
rp->regmutexes[i] = INVALID_ROFF;
}
static REGMAINT *
__db_mutex_maint(dbenv, infop)
DB_ENV *dbenv;
REGINFO *infop;
{
roff_t moff;
switch (infop->type) {
case REGION_TYPE_LOCK:
moff = ((DB_LOCKREGION *)R_ADDR(infop,
infop->rp->primary))->maint_off;
break;
case REGION_TYPE_LOG:
moff = ((LOG *)R_ADDR(infop, infop->rp->primary))->maint_off;
break;
case REGION_TYPE_MPOOL:
moff = ((MPOOL *)R_ADDR(infop, infop->rp->primary))->maint_off;
break;
case REGION_TYPE_TXN:
moff = ((DB_TXNREGION *)R_ADDR(infop,
infop->rp->primary))->maint_off;
break;
default:
__db_err(dbenv,
"Attempting to record mutex in a region not set up to do so");
return (NULL);
}
return ((REGMAINT *)R_ADDR(infop, moff));
}
#endif