#include "db_config.h"
#include "db_int.h"
#define LOAD_ACTUAL_MUTEX_CODE
#include "dbinc/mutex_int.h"
#ifdef HAVE_MUTEX_SOLARIS_LWP
#define pthread_cond_destroy(x) 0
#define pthread_cond_signal _lwp_cond_signal
#define pthread_cond_wait _lwp_cond_wait
#define pthread_mutex_destroy(x) 0
#define pthread_mutex_lock _lwp_mutex_lock
#define pthread_mutex_trylock _lwp_mutex_trylock
#define pthread_mutex_unlock _lwp_mutex_unlock
#endif
#ifdef HAVE_MUTEX_UI_THREADS
#define pthread_cond_destroy(x) cond_destroy
#define pthread_cond_signal cond_signal
#define pthread_cond_wait cond_wait
#define pthread_mutex_destroy mutex_destroy
#define pthread_mutex_lock mutex_lock
#define pthread_mutex_trylock mutex_trylock
#define pthread_mutex_unlock mutex_unlock
#endif
#define PTHREAD_UNLOCK_ATTEMPTS 5
#define RET_SET(f, ret) do { \
if (((ret) = (f)) == -1 && ((ret) = errno) == 0) \
(ret) = EAGAIN; \
} while (0)
int
__db_pthread_mutex_init(dbenv, mutex, flags)
DB_ENV *dbenv;
db_mutex_t mutex;
u_int32_t flags;
{
DB_MUTEX *mutexp;
DB_MUTEXMGR *mtxmgr;
DB_MUTEXREGION *mtxregion;
int ret;
mtxmgr = dbenv->mutex_handle;
mtxregion = mtxmgr->reginfo.primary;
mutexp = MUTEXP_SET(mutex);
ret = 0;
#ifdef HAVE_MUTEX_PTHREADS
{
pthread_condattr_t condattr, *condattrp = NULL;
pthread_mutexattr_t mutexattr, *mutexattrp = NULL;
if (!LF_ISSET(DB_MUTEX_PROCESS_ONLY)) {
RET_SET((pthread_mutexattr_init(&mutexattr)), ret);
#ifndef HAVE_MUTEX_THREAD_ONLY
if (ret == 0)
RET_SET((pthread_mutexattr_setpshared(
&mutexattr, PTHREAD_PROCESS_SHARED)), ret);
#endif
mutexattrp = &mutexattr;
}
if (ret == 0)
RET_SET((pthread_mutex_init(&mutexp->mutex, mutexattrp)), ret);
if (mutexattrp != NULL)
(void)pthread_mutexattr_destroy(mutexattrp);
if (ret == 0 && LF_ISSET(DB_MUTEX_SELF_BLOCK)) {
if (!LF_ISSET(DB_MUTEX_PROCESS_ONLY)) {
RET_SET((pthread_condattr_init(&condattr)), ret);
if (ret == 0) {
condattrp = &condattr;
#ifndef HAVE_MUTEX_THREAD_ONLY
RET_SET((pthread_condattr_setpshared(
&condattr, PTHREAD_PROCESS_SHARED)), ret);
#endif
}
}
if (ret == 0)
RET_SET(
(pthread_cond_init(&mutexp->cond, condattrp)), ret);
F_SET(mutexp, DB_MUTEX_SELF_BLOCK);
if (condattrp != NULL)
(void)pthread_condattr_destroy(condattrp);
}
}
#endif
#ifdef HAVE_MUTEX_SOLARIS_LWP
if (LF_ISSET(DB_MUTEX_PROCESS_ONLY)) {
static lwp_mutex_t mi = DEFAULTMUTEX;
mutexp->mutex = mi;
} else {
static lwp_mutex_t mi = SHAREDMUTEX;
mutexp->mutex = mi;
}
if (LF_ISSET(DB_MUTEX_SELF_BLOCK)) {
if (LF_ISSET(DB_MUTEX_PROCESS_ONLY)) {
static lwp_cond_t ci = DEFAULTCV;
mutexp->cond = ci;
} else {
static lwp_cond_t ci = SHAREDCV;
mutexp->cond = ci;
}
F_SET(mutexp, DB_MUTEX_SELF_BLOCK);
}
#endif
#ifdef HAVE_MUTEX_UI_THREADS
{
int type;
type = LF_ISSET(DB_MUTEX_PROCESS_ONLY) ? USYNC_THREAD : USYNC_PROCESS;
ret = mutex_init(&mutexp->mutex, type, NULL);
if (ret == 0 && LF_ISSET(DB_MUTEX_SELF_BLOCK)) {
ret = cond_init(&mutexp->cond, type, NULL);
F_SET(mutexp, DB_MUTEX_SELF_BLOCK);
}}
#endif
if (ret != 0) {
__db_err(dbenv, ret, "unable to initialize mutex");
}
return (ret);
}
int
__db_pthread_mutex_lock(dbenv, mutex)
DB_ENV *dbenv;
db_mutex_t mutex;
{
DB_MUTEX *mutexp;
DB_MUTEXMGR *mtxmgr;
DB_MUTEXREGION *mtxregion;
int i, ret;
if (!MUTEX_ON(dbenv) || F_ISSET(dbenv, DB_ENV_NOLOCKING))
return (0);
mtxmgr = dbenv->mutex_handle;
mtxregion = mtxmgr->reginfo.primary;
mutexp = MUTEXP_SET(mutex);
#if defined(HAVE_STATISTICS) && !defined(HAVE_MUTEX_HYBRID)
if (F_ISSET(mutexp, DB_MUTEX_LOCKED))
++mutexp->mutex_set_wait;
else
++mutexp->mutex_set_nowait;
#endif
RET_SET((pthread_mutex_lock(&mutexp->mutex)), ret);
if (ret != 0)
goto err;
if (F_ISSET(mutexp, DB_MUTEX_SELF_BLOCK)) {
#ifdef HAVE_MUTEX_HYBRID
mutexp->wait++;
MUTEX_MEMBAR(mutexp->wait);
#endif
while (F_ISSET(mutexp, DB_MUTEX_LOCKED)) {
RET_SET((pthread_cond_wait(
&mutexp->cond, &mutexp->mutex)), ret);
if (ret != 0 && ret != EINTR &&
#ifdef ETIME
ret != ETIME &&
#endif
ret != ETIMEDOUT) {
(void)pthread_mutex_unlock(&mutexp->mutex);
goto err;
}
}
#ifdef HAVE_MUTEX_HYBRID
mutexp->wait--;
#else
F_SET(mutexp, DB_MUTEX_LOCKED);
dbenv->thread_id(dbenv, &mutexp->pid, &mutexp->tid);
CHECK_MTX_THREAD(dbenv, mutexp);
#endif
i = PTHREAD_UNLOCK_ATTEMPTS;
do {
RET_SET((pthread_mutex_unlock(&mutexp->mutex)), ret);
} while (ret == EFAULT && --i > 0);
if (ret != 0)
goto err;
} else {
#ifdef DIAGNOSTIC
if (F_ISSET(mutexp, DB_MUTEX_LOCKED)) {
char buf[DB_THREADID_STRLEN];
(void)dbenv->thread_id_string(dbenv,
mutexp->pid, mutexp->tid, buf);
__db_errx(dbenv,
"pthread lock failed: lock currently in use: pid/tid: %s",
buf);
ret = EINVAL;
goto err;
}
#endif
F_SET(mutexp, DB_MUTEX_LOCKED);
dbenv->thread_id(dbenv, &mutexp->pid, &mutexp->tid);
CHECK_MTX_THREAD(dbenv, mutexp);
}
#ifdef DIAGNOSTIC
if (F_ISSET(dbenv, DB_ENV_YIELDCPU))
__os_yield(dbenv);
#endif
return (0);
err: __db_err(dbenv, ret, "pthread lock failed");
return (__db_panic(dbenv, ret));
}
int
__db_pthread_mutex_unlock(dbenv, mutex)
DB_ENV *dbenv;
db_mutex_t mutex;
{
DB_MUTEX *mutexp;
DB_MUTEXMGR *mtxmgr;
DB_MUTEXREGION *mtxregion;
int i, ret;
if (!MUTEX_ON(dbenv) || F_ISSET(dbenv, DB_ENV_NOLOCKING))
return (0);
mtxmgr = dbenv->mutex_handle;
mtxregion = mtxmgr->reginfo.primary;
mutexp = MUTEXP_SET(mutex);
#if !defined(HAVE_MUTEX_HYBRID) && defined(DIAGNOSTIC)
if (!F_ISSET(mutexp, DB_MUTEX_LOCKED)) {
__db_errx(
dbenv, "pthread unlock failed: lock already unlocked");
return (__db_panic(dbenv, EACCES));
}
#endif
if (F_ISSET(mutexp, DB_MUTEX_SELF_BLOCK)) {
RET_SET((pthread_mutex_lock(&mutexp->mutex)), ret);
if (ret != 0)
goto err;
F_CLR(mutexp, DB_MUTEX_LOCKED);
RET_SET((pthread_cond_signal(&mutexp->cond)), ret);
if (ret != 0)
goto err;
} else
F_CLR(mutexp, DB_MUTEX_LOCKED);
i = PTHREAD_UNLOCK_ATTEMPTS;
do {
RET_SET((pthread_mutex_unlock(&mutexp->mutex)), ret);
} while (ret == EFAULT && --i > 0);
err: if (ret != 0) {
__db_err(dbenv, ret, "pthread unlock failed");
return (__db_panic(dbenv, ret));
}
return (ret);
}
int
__db_pthread_mutex_destroy(dbenv, mutex)
DB_ENV *dbenv;
db_mutex_t mutex;
{
DB_MUTEX *mutexp;
DB_MUTEXMGR *mtxmgr;
DB_MUTEXREGION *mtxregion;
int ret, t_ret;
if (!MUTEX_ON(dbenv))
return (0);
mtxmgr = dbenv->mutex_handle;
mtxregion = mtxmgr->reginfo.primary;
mutexp = MUTEXP_SET(mutex);
ret = 0;
if (F_ISSET(mutexp, DB_MUTEX_SELF_BLOCK)) {
RET_SET((pthread_cond_destroy(&mutexp->cond)), ret);
if (ret != 0)
__db_err(dbenv, ret, "unable to destroy cond");
}
RET_SET((pthread_mutex_destroy(&mutexp->mutex)), t_ret);
if (t_ret != 0) {
__db_err(dbenv, t_ret, "unable to destroy mutex");
if (ret == 0)
ret = t_ret;
}
return (ret);
}