#include "db_config.h"
#include "db_int.h"
#include "dbinc/crypto.h"
#include "dbinc/db_page.h"
#include "dbinc/btree.h"
#include "dbinc/lock.h"
#include "dbinc/log.h"
#include "dbinc/mp.h"
#include "dbinc/txn.h"
static int __env_refresh __P((DB_ENV *, u_int32_t, int));
static int __file_handle_cleanup __P((ENV *));
char *
db_version(majverp, minverp, patchp)
int *majverp, *minverp, *patchp;
{
if (majverp != NULL)
*majverp = DB_VERSION_MAJOR;
if (minverp != NULL)
*minverp = DB_VERSION_MINOR;
if (patchp != NULL)
*patchp = DB_VERSION_PATCH;
return ((char *)DB_VERSION_STRING);
}
int
__env_open_pp(dbenv, db_home, flags, mode)
DB_ENV *dbenv;
const char *db_home;
u_int32_t flags;
int mode;
{
ENV *env;
int ret;
env = dbenv->env;
#undef OKFLAGS
#define OKFLAGS \
(DB_CREATE | DB_INIT_CDB | DB_INIT_LOCK | DB_INIT_LOG | \
DB_INIT_MPOOL | DB_INIT_REP | DB_INIT_TXN | DB_LOCKDOWN | \
DB_PRIVATE | DB_RECOVER | DB_RECOVER_FATAL | DB_REGISTER | \
DB_SYSTEM_MEM | DB_THREAD | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT)
#undef OKFLAGS_CDB
#define OKFLAGS_CDB \
(DB_CREATE | DB_INIT_CDB | DB_INIT_MPOOL | DB_LOCKDOWN | \
DB_PRIVATE | DB_SYSTEM_MEM | DB_THREAD | \
DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT)
if ((ret = __db_fchk(env, "DB_ENV->open", flags, OKFLAGS)) != 0)
return (ret);
if ((ret = __db_fcchk(
env, "DB_ENV->open", flags, DB_INIT_CDB, ~OKFLAGS_CDB)) != 0)
return (ret);
if (LF_ISSET(DB_REGISTER)) {
if (!__os_support_db_register()) {
__db_errx(env,
"Berkeley DB library does not support DB_REGISTER on this system");
return (EINVAL);
}
if ((ret = __db_fcchk(env, "DB_ENV->open", flags,
DB_PRIVATE, DB_REGISTER | DB_SYSTEM_MEM)) != 0)
return (ret);
if (!LF_ISSET(DB_INIT_TXN)) {
__db_errx(
env, "registration requires transaction support");
return (EINVAL);
}
}
if (LF_ISSET(DB_INIT_REP)) {
if (!__os_support_replication()) {
__db_errx(env,
"Berkeley DB library does not support replication on this system");
return (EINVAL);
}
if (!LF_ISSET(DB_INIT_LOCK)) {
__db_errx(env,
"replication requires locking support");
return (EINVAL);
}
if (!LF_ISSET(DB_INIT_TXN)) {
__db_errx(
env, "replication requires transaction support");
return (EINVAL);
}
}
if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL)) {
if ((ret = __db_fcchk(env,
"DB_ENV->open", flags, DB_RECOVER, DB_RECOVER_FATAL)) != 0)
return (ret);
if ((ret = __db_fcchk(env,
"DB_ENV->open", flags, DB_REGISTER, DB_RECOVER_FATAL)) != 0)
return (ret);
if (!LF_ISSET(DB_CREATE)) {
__db_errx(env, "recovery requires the create flag");
return (EINVAL);
}
if (!LF_ISSET(DB_INIT_TXN)) {
__db_errx(
env, "recovery requires transaction support");
return (EINVAL);
}
}
#ifdef HAVE_MUTEX_THREAD_ONLY
if (!LF_ISSET(DB_PRIVATE)) {
__db_errx(env,
"Berkeley DB library configured to support only private environments");
return (EINVAL);
}
#endif
#ifdef HAVE_MUTEX_FCNTL
if (F_ISSET(env, ENV_THREAD)) {
__db_errx(env,
"architecture lacks fast mutexes: applications cannot be threaded");
return (EINVAL);
}
#endif
return (__env_open(dbenv, db_home, flags, mode));
}
int
__env_open(dbenv, db_home, flags, mode)
DB_ENV *dbenv;
const char *db_home;
u_int32_t flags;
int mode;
{
DB_THREAD_INFO *ip;
ENV *env;
REGINFO *infop;
u_int32_t init_flags, orig_flags;
int create_ok, register_recovery, rep_check, ret, t_ret;
ip = NULL;
env = dbenv->env;
register_recovery = rep_check = 0;
if ((ret = __env_config(dbenv, db_home, flags, mode)) != 0)
return (ret);
orig_flags = dbenv->flags;
if (LF_ISSET(DB_REGISTER)) {
if ((ret = __envreg_register(env, ®ister_recovery)) != 0)
goto err;
if (register_recovery) {
if (!LF_ISSET(DB_RECOVER)) {
__db_errx(env,
"The DB_RECOVER flag was not specified, and recovery is needed");
ret = DB_RUNRECOVERY;
goto err;
}
} else
LF_CLR(DB_RECOVER);
}
if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL))
#ifdef HAVE_REPLICATION
if ((ret = __rep_reset_init(env)) != 0 ||
(ret = __env_remove_env(env)) != 0 ||
#else
if ((ret = __env_remove_env(env)) != 0 ||
#endif
(ret = __env_refresh(dbenv, orig_flags, 0)) != 0)
goto err;
create_ok = LF_ISSET(DB_CREATE) ? 1 : 0;
if (LF_ISSET(DB_LOCKDOWN))
F_SET(env, ENV_LOCKDOWN);
if (LF_ISSET(DB_PRIVATE))
F_SET(env, ENV_PRIVATE);
if (LF_ISSET(DB_RECOVER_FATAL))
F_SET(env, ENV_RECOVER_FATAL);
if (LF_ISSET(DB_SYSTEM_MEM))
F_SET(env, ENV_SYSTEM_MEM);
if (LF_ISSET(DB_THREAD))
F_SET(env, ENV_THREAD);
#define DB_INITENV_CDB 0x0001
#define DB_INITENV_CDB_ALLDB 0x0002
#define DB_INITENV_LOCK 0x0004
#define DB_INITENV_LOG 0x0008
#define DB_INITENV_MPOOL 0x0010
#define DB_INITENV_REP 0x0020
#define DB_INITENV_TXN 0x0040
init_flags = 0;
if (LF_ISSET(DB_INIT_CDB))
FLD_SET(init_flags, DB_INITENV_CDB);
if (F_ISSET(dbenv, DB_ENV_CDB_ALLDB))
FLD_SET(init_flags, DB_INITENV_CDB_ALLDB);
if (LF_ISSET(DB_INIT_LOCK))
FLD_SET(init_flags, DB_INITENV_LOCK);
if (LF_ISSET(DB_INIT_LOG))
FLD_SET(init_flags, DB_INITENV_LOG);
if (LF_ISSET(DB_INIT_MPOOL))
FLD_SET(init_flags, DB_INITENV_MPOOL);
if (LF_ISSET(DB_INIT_REP))
FLD_SET(init_flags, DB_INITENV_REP);
if (LF_ISSET(DB_INIT_TXN))
FLD_SET(init_flags, DB_INITENV_TXN);
if ((ret = __env_attach(env, &init_flags, create_ok, 1)) != 0)
goto err;
if (FLD_ISSET(init_flags, DB_INITENV_CDB))
LF_SET(DB_INIT_CDB);
if (FLD_ISSET(init_flags, DB_INITENV_LOCK))
LF_SET(DB_INIT_LOCK);
if (FLD_ISSET(init_flags, DB_INITENV_LOG))
LF_SET(DB_INIT_LOG);
if (FLD_ISSET(init_flags, DB_INITENV_MPOOL))
LF_SET(DB_INIT_MPOOL);
if (FLD_ISSET(init_flags, DB_INITENV_REP))
LF_SET(DB_INIT_REP);
if (FLD_ISSET(init_flags, DB_INITENV_TXN))
LF_SET(DB_INIT_TXN);
if (FLD_ISSET(init_flags, DB_INITENV_CDB_ALLDB) &&
(ret = __env_set_flags(dbenv, DB_CDB_ALLDB, 1)) != 0)
goto err;
if (LF_ISSET(DB_INIT_CDB)) {
LF_SET(DB_INIT_LOCK);
F_SET(env, ENV_CDB);
}
env->open_flags = flags;
F_SET(env, ENV_OPEN_CALLED);
infop = env->reginfo;
if ((ret =
__env_thread_init(env, F_ISSET(infop, REGION_CREATE) ? 1 : 0)) != 0)
goto err;
ENV_ENTER(env, ip);
#ifdef HAVE_MUTEX_SUPPORT
if ((ret = __mutex_open(env, create_ok)) != 0)
goto err;
#endif
if ((ret = __env_ref_increment(env)) != 0)
goto err;
if ((ret = __mutex_alloc(env,
MTX_ENV_HANDLE, DB_MUTEX_PROCESS_ONLY, &dbenv->mtx_db_env)) != 0 ||
(ret = __mutex_alloc(env,
MTX_ENV_HANDLE, DB_MUTEX_PROCESS_ONLY, &env->mtx_env)) != 0)
goto err;
if (LF_ISSET(DB_INIT_REP) && (ret = __rep_open(env)) != 0)
goto err;
rep_check = IS_ENV_REPLICATED(env) ? 1 : 0;
if (rep_check && (ret = __env_rep_enter(env, 0)) != 0)
goto err;
if (LF_ISSET(DB_INIT_MPOOL)) {
if ((ret = __memp_open(env, create_ok)) != 0)
goto err;
if (create_ok)
(void)__memp_set_config(
dbenv, DB_MEMP_SUPPRESS_WRITE, 1);
TAILQ_INIT(&env->dblist);
if ((ret = __mutex_alloc(env, MTX_ENV_DBLIST,
DB_MUTEX_PROCESS_ONLY, &env->mtx_dblist)) != 0)
goto err;
if ((ret = __memp_register(
env, DB_FTYPE_SET, __db_pgin, __db_pgout)) != 0)
goto err;
}
if (LF_ISSET(DB_INIT_MPOOL | DB_INIT_LOG | DB_INIT_TXN) &&
(ret = __crypto_region_init(env)) != 0)
goto err;
if ((ret = __mutex_alloc(
env, MTX_TWISTER, DB_MUTEX_PROCESS_ONLY, &env->mtx_mt)) != 0)
goto err;
if (LF_ISSET(DB_INIT_LOG | DB_INIT_TXN))
if ((ret = __log_open(env, create_ok)) != 0)
goto err;
if (LF_ISSET(DB_INIT_LOCK))
if ((ret = __lock_open(env, create_ok)) != 0)
goto err;
if (LF_ISSET(DB_INIT_TXN)) {
if ((ret = __txn_open(env, create_ok)) != 0)
goto err;
if ((ret = __env_init_rec(env, DB_LOGVERSION)) != 0)
goto err;
}
if (LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL) &&
(ret = __db_apprec(env, ip, NULL, NULL, 1,
LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL))) != 0)
goto err;
if (TXN_ON(env) &&
!FLD_ISSET(dbenv->lg_flags, DB_LOG_IN_MEMORY) &&
F_ISSET(infop, REGION_CREATE) &&
!LF_ISSET(DB_RECOVER | DB_RECOVER_FATAL) &&
(ret = __txn_reset(env)) != 0)
goto err;
if ((ret = __env_turn_on(env)) != 0)
goto err;
if (rep_check)
ret = __env_db_rep_exit(env);
if (LF_ISSET(DB_INIT_MPOOL))
(void)__memp_set_config(dbenv, DB_MEMP_SUPPRESS_WRITE, 0);
err: if (ret == 0)
ENV_LEAVE(env, ip);
else {
infop = env->reginfo;
if (infop != NULL && F_ISSET(infop, REGION_CREATE)) {
ret = __env_panic(env, ret);
(void)__env_refresh(dbenv, orig_flags, rep_check);
(void)__env_remove_env(env);
(void)__env_refresh(dbenv, orig_flags, 0);
} else
(void)__env_refresh(dbenv, orig_flags, rep_check);
}
if (register_recovery) {
if (ret == 0 && (t_ret = __envreg_xunlock(env)) != 0)
ret = t_ret;
if (ret != 0)
(void)__envreg_unregister(env, 1);
}
return (ret);
}
int
__env_remove(dbenv, db_home, flags)
DB_ENV *dbenv;
const char *db_home;
u_int32_t flags;
{
ENV *env;
int ret, t_ret;
env = dbenv->env;
#undef OKFLAGS
#define OKFLAGS \
(DB_FORCE | DB_USE_ENVIRON | DB_USE_ENVIRON_ROOT)
if ((ret = __db_fchk(env, "DB_ENV->remove", flags, OKFLAGS)) != 0)
return (ret);
ENV_ILLEGAL_AFTER_OPEN(env, "DB_ENV->remove");
if ((ret = __env_config(dbenv, db_home, flags, 0)) != 0)
return (ret);
if ((ret = __env_turn_off(env, flags)) == 0 || LF_ISSET(DB_FORCE))
ret = __env_remove_env(env);
if ((t_ret = __env_close(dbenv, 0)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
int
__env_config(dbenv, db_home, flags, mode)
DB_ENV *dbenv;
const char *db_home;
u_int32_t flags;
int mode;
{
ENV *env;
int ret;
char *home, home_buf[DB_MAXPATHLEN];
env = dbenv->env;
home = (char *)db_home;
if (home == NULL && (LF_ISSET(DB_USE_ENVIRON) ||
(LF_ISSET(DB_USE_ENVIRON_ROOT) && __os_isroot()))) {
home = home_buf;
if ((ret = __os_getenv(
env, "DB_HOME", &home, sizeof(home_buf))) != 0)
return (ret);
}
if (home != NULL && (ret = __os_strdup(env, home, &env->db_home)) != 0)
return (ret);
env->open_flags = flags;
env->db_mode = mode == 0 ? DB_MODE_660 : mode;
if ((ret = __env_read_db_config(env)) != 0)
return (ret);
if (dbenv->db_tmp_dir == NULL && (ret = __os_tmpdir(env, flags)) != 0)
return (ret);
return (0);
}
int
__env_close_pp(dbenv, flags)
DB_ENV *dbenv;
u_int32_t flags;
{
DB_THREAD_INFO *ip;
ENV *env;
int rep_check, ret, t_ret;
env = dbenv->env;
ret = 0;
if (flags != 0 &&
(t_ret = __db_ferr(env, "DB_ENV->close", 0)) != 0 && ret == 0)
ret = t_ret;
if (PANIC_ISSET(env)) {
(void)__file_handle_cleanup(env);
if (IS_ENV_REPLICATED(env))
(void)__repmgr_close(env);
PANIC_CHECK(env);
}
ENV_ENTER(env, ip);
rep_check = IS_ENV_REPLICATED(env) ? 1 : 0;
if (rep_check) {
#ifdef HAVE_REPLICATION_THREADS
if ((t_ret = __repmgr_close(env)) != 0 && ret == 0)
ret = t_ret;
#endif
if ((t_ret = __env_rep_enter(env, 0)) != 0 && ret == 0)
ret = t_ret;
}
if ((t_ret = __env_close(dbenv, rep_check)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
int
__env_close(dbenv, rep_check)
DB_ENV *dbenv;
int rep_check;
{
ENV *env;
int ret, t_ret;
char **p;
env = dbenv->env;
ret = 0;
if (TXN_ON(env) && (t_ret = __txn_preclose(env)) != 0 && ret == 0)
ret = t_ret;
#ifdef HAVE_REPLICATION
if ((t_ret = __rep_env_close(env)) != 0 && ret == 0)
ret = t_ret;
#endif
if ((t_ret = __env_refresh(dbenv, 0, rep_check)) != 0 && ret == 0)
ret = t_ret;
#ifdef HAVE_CRYPTO
if ((t_ret = __crypto_env_close(env)) != 0 && ret == 0)
ret = t_ret;
#endif
if (dbenv->registry != NULL) {
(void)__envreg_unregister(env, 0);
dbenv->registry = NULL;
}
if ((t_ret = __file_handle_cleanup(env)) != 0 && ret == 0)
ret = t_ret;
if (dbenv->db_log_dir != NULL)
__os_free(env, dbenv->db_log_dir);
dbenv->db_log_dir = NULL;
if (dbenv->db_tmp_dir != NULL)
__os_free(env, dbenv->db_tmp_dir);
dbenv->db_tmp_dir = NULL;
if (dbenv->db_data_dir != NULL) {
for (p = dbenv->db_data_dir; *p != NULL; ++p)
__os_free(env, *p);
__os_free(env, dbenv->db_data_dir);
dbenv->db_data_dir = NULL;
dbenv->data_next = 0;
}
if (dbenv->intermediate_dir_mode != NULL)
__os_free(env, dbenv->intermediate_dir_mode);
if (env->db_home != NULL) {
__os_free(env, env->db_home);
env->db_home = NULL;
}
__db_env_destroy(dbenv);
return (ret);
}
static int
__env_refresh(dbenv, orig_flags, rep_check)
DB_ENV *dbenv;
u_int32_t orig_flags;
int rep_check;
{
DB *ldbp;
DB_THREAD_INFO *ip;
ENV *env;
int ret, t_ret;
env = dbenv->env;
ret = 0;
if (TXN_ON(env) &&
(t_ret = __txn_env_refresh(env)) != 0 && ret == 0)
ret = t_ret;
if (LOGGING_ON(env) &&
(t_ret = __log_env_refresh(env)) != 0 && ret == 0)
ret = t_ret;
if (LOCKING_ON(env)) {
if (!F_ISSET(env, ENV_THREAD) &&
env->env_lref != NULL && (t_ret =
__lock_id_free(env, env->env_lref)) != 0 && ret == 0)
ret = t_ret;
env->env_lref = NULL;
if ((t_ret = __lock_env_refresh(env)) != 0 && ret == 0)
ret = t_ret;
}
if ((t_ret = __mutex_free(env, &dbenv->mtx_db_env)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __mutex_free(env, &env->mtx_env)) != 0 && ret == 0)
ret = t_ret;
if (env->db_ref != 0) {
__db_errx(env,
"Database handles still open at environment close");
TAILQ_FOREACH(ldbp, &env->dblist, dblistlinks)
__db_errx(env, "Open database handle: %s%s%s",
ldbp->fname == NULL ? "unnamed" : ldbp->fname,
ldbp->dname == NULL ? "" : "/",
ldbp->dname == NULL ? "" : ldbp->dname);
if (ret == 0)
ret = EINVAL;
}
TAILQ_INIT(&env->dblist);
if ((t_ret = __mutex_free(env, &env->mtx_dblist)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __mutex_free(env, &env->mtx_mt)) != 0 && ret == 0)
ret = t_ret;
if (env->mt != NULL) {
__os_free(env, env->mt);
env->mt = NULL;
}
if (MPOOL_ON(env)) {
if (F_ISSET(env, ENV_PRIVATE) &&
(t_ret = __memp_sync_int(env, NULL, 0,
DB_SYNC_CACHE | DB_SYNC_SUPPRESS_WRITE, NULL, NULL)) != 0 &&
ret == 0)
ret = t_ret;
if ((t_ret = __memp_env_refresh(env)) != 0 && ret == 0)
ret = t_ret;
}
if (rep_check && (t_ret = __env_db_rep_exit(env)) != 0 && ret == 0)
ret = t_ret;
if (REP_ON(env) && (t_ret = __rep_env_refresh(env)) != 0 && ret == 0)
ret = t_ret;
#ifdef HAVE_CRYPTO
if (env->reginfo != NULL &&
(t_ret = __crypto_env_refresh(env)) != 0 && ret == 0)
ret = t_ret;
#endif
if (env->thr_hashtab != NULL &&
(t_ret = __env_set_state(env, &ip, THREAD_OUT)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __env_ref_decrement(env)) != 0 && ret == 0)
ret = t_ret;
#ifdef HAVE_MUTEX_SUPPORT
if (MUTEX_ON(env) &&
(t_ret = __mutex_env_refresh(env)) != 0 && ret == 0)
ret = t_ret;
#endif
if (env->reginfo != NULL) {
if (F_ISSET(env, ENV_PRIVATE)) {
__env_thread_destroy(env);
t_ret = __env_detach(env, 1);
} else
t_ret = __env_detach(env, 0);
if (t_ret != 0 && ret == 0)
ret = t_ret;
}
if (env->mutex_iq != NULL) {
__os_free(env, env->mutex_iq);
env->mutex_iq = NULL;
}
if (env->recover_dtab.int_dispatch != NULL) {
__os_free(env, env->recover_dtab.int_dispatch);
env->recover_dtab.int_size = 0;
env->recover_dtab.int_dispatch = NULL;
}
if (env->recover_dtab.ext_dispatch != NULL) {
__os_free(env, env->recover_dtab.ext_dispatch);
env->recover_dtab.ext_size = 0;
env->recover_dtab.ext_dispatch = NULL;
}
dbenv->flags = orig_flags;
return (ret);
}
static int
__file_handle_cleanup(env)
ENV *env;
{
DB_FH *fhp;
if (TAILQ_FIRST(&env->fdlist) == NULL)
return (0);
__db_errx(env, "File handles still open at environment close");
while ((fhp = TAILQ_FIRST(&env->fdlist)) != NULL) {
__db_errx(env, "Open file handle: %s", fhp->name);
(void)__os_closehandle(env, fhp);
}
return (EINVAL);
}
int
__env_get_open_flags(dbenv, flagsp)
DB_ENV *dbenv;
u_int32_t *flagsp;
{
ENV *env;
env = dbenv->env;
ENV_ILLEGAL_BEFORE_OPEN(env, "DB_ENV->get_open_flags");
*flagsp = env->open_flags;
return (0);
}