#include "db_config.h"
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/log.h"
#include "dbinc/txn.h"
#include "dbinc/db_am.h"
static int __dbreg_push_id __P((ENV *, int32_t));
static int __dbreg_pop_id __P((ENV *, int32_t *));
static int __dbreg_pluck_id __P((ENV *, int32_t));
int
__dbreg_setup(dbp, fname, dname, create_txnid)
DB *dbp;
const char *fname, *dname;
u_int32_t create_txnid;
{
DB_LOG *dblp;
ENV *env;
FNAME *fnp;
REGINFO *infop;
int ret;
size_t len;
void *p;
env = dbp->env;
dblp = env->lg_handle;
infop = &dblp->reginfo;
fnp = NULL;
p = NULL;
LOG_SYSTEM_LOCK(env);
if ((ret = __env_alloc(infop, sizeof(FNAME), &fnp)) != 0)
goto err;
memset(fnp, 0, sizeof(FNAME));
if (fname == NULL)
fnp->fname_off = INVALID_ROFF;
else {
len = strlen(fname) + 1;
if ((ret = __env_alloc(infop, len, &p)) != 0)
goto err;
fnp->fname_off = R_OFFSET(infop, p);
memcpy(p, fname, len);
}
if (dname == NULL)
fnp->dname_off = INVALID_ROFF;
else {
len = strlen(dname) + 1;
if ((ret = __env_alloc(infop, len, &p)) != 0)
goto err;
fnp->dname_off = R_OFFSET(infop, p);
memcpy(p, dname, len);
}
LOG_SYSTEM_UNLOCK(env);
fnp->id = fnp->old_id = DB_LOGFILEID_INVALID;
fnp->s_type = dbp->type;
memcpy(fnp->ufid, dbp->fileid, DB_FILE_ID_LEN);
fnp->meta_pgno = dbp->meta_pgno;
fnp->create_txnid = create_txnid;
dbp->dbenv->thread_id(dbp->dbenv, &fnp->pid, NULL);
if (F_ISSET(dbp, DB_AM_INMEM))
F_SET(fnp, DB_FNAME_INMEM);
if (F_ISSET(dbp, DB_AM_RECOVER))
F_SET(fnp, DB_FNAME_RECOVER);
fnp->txn_ref = 1;
fnp->mutex = dbp->mutex;
dbp->log_filename = fnp;
return (0);
err: LOG_SYSTEM_UNLOCK(env);
if (ret == ENOMEM)
__db_errx(env,
"Logging region out of memory; you may need to increase its size");
return (ret);
}
int
__dbreg_teardown(dbp)
DB *dbp;
{
int ret;
if (dbp->log_filename == NULL)
return (0);
ret = __dbreg_teardown_int(dbp->env, dbp->log_filename);
dbp->log_filename = NULL;
dbp->mutex = MUTEX_INVALID;
return (ret);
}
int
__dbreg_teardown_int(env, fnp)
ENV *env;
FNAME *fnp;
{
DB_LOG *dblp;
REGINFO *infop;
int ret;
if (F_ISSET(fnp, DB_FNAME_NOTLOGGED))
return (0);
dblp = env->lg_handle;
infop = &dblp->reginfo;
DB_ASSERT(env, fnp->id == DB_LOGFILEID_INVALID);
ret = __mutex_free(env, &fnp->mutex);
LOG_SYSTEM_LOCK(env);
if (fnp->fname_off != INVALID_ROFF)
__env_alloc_free(infop, R_ADDR(infop, fnp->fname_off));
if (fnp->dname_off != INVALID_ROFF)
__env_alloc_free(infop, R_ADDR(infop, fnp->dname_off));
__env_alloc_free(infop, fnp);
LOG_SYSTEM_UNLOCK(env);
return (ret);
}
int
__dbreg_new_id(dbp, txn)
DB *dbp;
DB_TXN *txn;
{
DB_LOG *dblp;
ENV *env;
FNAME *fnp;
LOG *lp;
int32_t id;
int ret;
env = dbp->env;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
fnp = dbp->log_filename;
MUTEX_LOCK(env, lp->mtx_filelist);
if (fnp->id != DB_LOGFILEID_INVALID) {
MUTEX_UNLOCK(env, lp->mtx_filelist);
return (0);
}
if ((ret = __dbreg_get_id(dbp, txn, &id)) == 0)
fnp->id = id;
MUTEX_UNLOCK(env, lp->mtx_filelist);
return (ret);
}
int
__dbreg_get_id(dbp, txn, idp)
DB *dbp;
DB_TXN *txn;
int32_t *idp;
{
DB_LOG *dblp;
ENV *env;
FNAME *fnp;
LOG *lp;
int32_t id;
int ret;
env = dbp->env;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
fnp = dbp->log_filename;
if ((ret = __dbreg_pop_id(env, &id)) != 0)
goto err;
if (id == DB_LOGFILEID_INVALID)
id = lp->fid_max++;
if (!F_ISSET(dbp, DB_AM_NOT_DURABLE))
F_SET(fnp, DB_FNAME_DURABLE);
SH_TAILQ_INSERT_HEAD(&lp->fq, fnp, q, __fname);
DB_ASSERT(env, !F_ISSET(dbp, DB_AM_RECOVER));
if ((ret = __dbreg_log_id(dbp, txn, id, 0)) != 0)
goto err;
fnp->create_txnid = TXN_INVALID;
DB_ASSERT(env, dbp->type == fnp->s_type);
DB_ASSERT(env, dbp->meta_pgno == fnp->meta_pgno);
if ((ret = __dbreg_add_dbentry(env, dblp, dbp, id)) != 0)
goto err;
err:
if (ret != 0 && id != DB_LOGFILEID_INVALID) {
(void)__dbreg_revoke_id(dbp, 1, id);
id = DB_LOGFILEID_INVALID;
}
*idp = id;
return (ret);
}
int
__dbreg_assign_id(dbp, id)
DB *dbp;
int32_t id;
{
DB *close_dbp;
DB_LOG *dblp;
ENV *env;
FNAME *close_fnp, *fnp;
LOG *lp;
int ret;
env = dbp->env;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
fnp = dbp->log_filename;
close_dbp = NULL;
close_fnp = NULL;
MUTEX_LOCK(env, lp->mtx_filelist);
DB_ASSERT(env, fnp->id == DB_LOGFILEID_INVALID);
if (__dbreg_id_to_fname(dblp, id, 1, &close_fnp) == 0) {
ret = __dbreg_id_to_db(env, NULL, &close_dbp, id, 0);
if (ret == ENOENT) {
ret = 0;
goto cont;
} else if (ret != 0)
goto err;
if ((ret = __dbreg_revoke_id(close_dbp, 1,
DB_LOGFILEID_INVALID)) != 0)
goto err;
}
cont: if ((ret = __dbreg_pluck_id(env, id)) != 0)
goto err;
if (id >= lp->fid_max)
lp->fid_max = id + 1;
fnp->id = id;
if (!F_ISSET(dbp, DB_AM_NOT_DURABLE))
F_SET(fnp, DB_FNAME_DURABLE);
SH_TAILQ_INSERT_HEAD(&lp->fq, fnp, q, __fname);
if ((ret = __dbreg_add_dbentry(env, dblp, dbp, id)) != 0)
(void)__dbreg_revoke_id(dbp, 1, id);
err: MUTEX_UNLOCK(env, lp->mtx_filelist);
if (close_dbp != NULL)
(void)__db_close(close_dbp, NULL, DB_NOSYNC);
return (ret);
}
int
__dbreg_revoke_id(dbp, have_lock, force_id)
DB *dbp;
int have_lock;
int32_t force_id;
{
DB_REP *db_rep;
ENV *env;
int push;
env = dbp->env;
db_rep = env->rep_handle;
push = (!F_ISSET(dbp, DB_AM_RECOVER) || IS_RECOVERING(env)) &&
(!REP_ON(env) || ((REP *)db_rep->region)->gen == dbp->fid_gen);
return (__dbreg_revoke_id_int(dbp->env,
dbp->log_filename, have_lock, push, force_id));
}
int
__dbreg_revoke_id_int(env, fnp, have_lock, push, force_id)
ENV *env;
FNAME *fnp;
int have_lock, push;
int32_t force_id;
{
DB_LOG *dblp;
LOG *lp;
int32_t id;
int ret;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
ret = 0;
if (fnp == NULL)
return (0);
if (force_id != DB_LOGFILEID_INVALID)
id = force_id;
else if (fnp->id == DB_LOGFILEID_INVALID) {
if (fnp->old_id == DB_LOGFILEID_INVALID)
return (0);
id = fnp->old_id;
} else
id = fnp->id;
if (!have_lock)
MUTEX_LOCK(env, lp->mtx_filelist);
fnp->id = DB_LOGFILEID_INVALID;
fnp->old_id = DB_LOGFILEID_INVALID;
SH_TAILQ_REMOVE(&lp->fq, fnp, q, __fname);
if (!F_ISSET(fnp, DB_FNAME_CLOSED) &&
(ret = __dbreg_rem_dbentry(dblp, id)) == 0 && push)
ret = __dbreg_push_id(env, id);
if (!have_lock)
MUTEX_UNLOCK(env, lp->mtx_filelist);
return (ret);
}
int
__dbreg_close_id(dbp, txn, op)
DB *dbp;
DB_TXN *txn;
u_int32_t op;
{
DB_LOG *dblp;
ENV *env;
FNAME *fnp;
LOG *lp;
int ret, t_ret;
env = dbp->env;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
fnp = dbp->log_filename;
if (fnp == NULL)
return (0);
if (fnp->id == DB_LOGFILEID_INVALID) {
ret = __dbreg_revoke_id(dbp, 0, DB_LOGFILEID_INVALID);
goto done;
}
ret = 0;
DB_ASSERT(env, fnp->txn_ref > 0);
if (fnp->txn_ref > 1) {
MUTEX_LOCK(env, dbp->mutex);
if (fnp->txn_ref > 1) {
if (!F_ISSET(fnp, DB_FNAME_CLOSED) &&
(t_ret = __dbreg_rem_dbentry(
env->lg_handle, fnp->id)) != 0 && ret == 0)
ret = t_ret;
F_SET(fnp, DB_FNAME_CLOSED);
fnp->txn_ref--;
MUTEX_UNLOCK(env, dbp->mutex);
dbp->mutex = MUTEX_INVALID;
dbp->log_filename = NULL;
goto no_log;
}
}
MUTEX_LOCK(env, lp->mtx_filelist);
if ((ret = __dbreg_log_close(env, fnp, txn, op)) != 0)
goto err;
ret = __dbreg_revoke_id(dbp, 1, DB_LOGFILEID_INVALID);
err: MUTEX_UNLOCK(env, lp->mtx_filelist);
done: if ((t_ret = __dbreg_teardown(dbp)) != 0 && ret == 0)
ret = t_ret;
no_log:
return (ret);
}
int
__dbreg_close_id_int(env, fnp, op, locked)
ENV *env;
FNAME *fnp;
u_int32_t op;
int locked;
{
DB_LOG *dblp;
LOG *lp;
int ret, t_ret;
DB_ASSERT(env, fnp->txn_ref == 1);
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
if (fnp->id == DB_LOGFILEID_INVALID)
return (__dbreg_revoke_id_int(env,
fnp, locked, 1, DB_LOGFILEID_INVALID));
if (F_ISSET(fnp, DB_FNAME_RECOVER))
return (__dbreg_close_file(env, fnp));
if (!locked)
MUTEX_LOCK(env, lp->mtx_filelist);
if ((ret = __dbreg_log_close(env, fnp, NULL, op)) != 0)
goto err;
ret = __dbreg_revoke_id_int(env, fnp, 1, 1, DB_LOGFILEID_INVALID);
err: if (!locked)
MUTEX_UNLOCK(env, lp->mtx_filelist);
if ((t_ret = __dbreg_teardown_int(env, fnp)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
int
__dbreg_failchk(env)
ENV *env;
{
DB_ENV *dbenv;
DB_LOG *dblp;
FNAME *fnp, *nnp;
LOG *lp;
int ret, t_ret;
char buf[DB_THREADID_STRLEN];
if ((dblp = env->lg_handle) == NULL)
return (0);
lp = dblp->reginfo.primary;
dbenv = env->dbenv;
ret = 0;
MUTEX_LOCK(env, lp->mtx_filelist);
for (fnp = SH_TAILQ_FIRST(&lp->fq, __fname); fnp != NULL; fnp = nnp) {
nnp = SH_TAILQ_NEXT(fnp, q, __fname);
if (dbenv->is_alive(dbenv, fnp->pid, 0, DB_MUTEX_PROCESS_ONLY))
continue;
MUTEX_LOCK(env, fnp->mutex);
__db_msg(env,
"Freeing log information for process: %s, (ref %lu)",
dbenv->thread_id_string(dbenv, fnp->pid, 0, buf),
(u_long)fnp->txn_ref);
if (fnp->txn_ref > 1 || F_ISSET(fnp, DB_FNAME_CLOSED)) {
if (!F_ISSET(fnp, DB_FNAME_CLOSED)) {
fnp->txn_ref--;
F_SET(fnp, DB_FNAME_CLOSED);
}
MUTEX_UNLOCK(env, fnp->mutex);
fnp->mutex = MUTEX_INVALID;
fnp->pid = 0;
} else {
F_SET(fnp, DB_FNAME_CLOSED);
if ((t_ret = __dbreg_close_id_int(env,
fnp, DBREG_CLOSE, 1)) && ret == 0)
ret = t_ret;
}
}
MUTEX_UNLOCK(env, lp->mtx_filelist);
return (ret);
}
int
__dbreg_log_close(env, fnp, txn, op)
ENV *env;
FNAME *fnp;
DB_TXN *txn;
u_int32_t op;
{
DBT fid_dbt, r_name, *dbtp;
DB_LOG *dblp;
DB_LSN r_unused;
int ret;
dblp = env->lg_handle;
ret = 0;
if (fnp->fname_off == INVALID_ROFF)
dbtp = NULL;
else {
memset(&r_name, 0, sizeof(r_name));
r_name.data = R_ADDR(&dblp->reginfo, fnp->fname_off);
r_name.size = (u_int32_t)strlen((char *)r_name.data) + 1;
dbtp = &r_name;
}
memset(&fid_dbt, 0, sizeof(fid_dbt));
fid_dbt.data = fnp->ufid;
fid_dbt.size = DB_FILE_ID_LEN;
if ((ret = __dbreg_register_log(env, txn, &r_unused,
F_ISSET(fnp, DB_FNAME_DURABLE) ? 0 : DB_LOG_NOT_DURABLE,
op, dbtp, &fid_dbt, fnp->id,
fnp->s_type, fnp->meta_pgno, TXN_INVALID)) != 0) {
F_SET(fnp, DB_FNAME_NOTLOGGED);
(void)__dbreg_rem_dbentry(dblp, fnp->id);
}
return (ret);
}
static int
__dbreg_push_id(env, id)
ENV *env;
int32_t id;
{
DB_LOG *dblp;
LOG *lp;
REGINFO *infop;
int32_t *stack, *newstack;
int ret;
dblp = env->lg_handle;
infop = &dblp->reginfo;
lp = infop->primary;
if (id == lp->fid_max - 1) {
lp->fid_max--;
return (0);
}
if (lp->free_fid_stack == INVALID_ROFF ||
lp->free_fids_alloced <= lp->free_fids + 1) {
LOG_SYSTEM_LOCK(env);
if ((ret = __env_alloc(infop,
(lp->free_fids_alloced + 20) * sizeof(u_int32_t),
&newstack)) != 0) {
LOG_SYSTEM_UNLOCK(env);
return (ret);
}
if (lp->free_fid_stack != INVALID_ROFF) {
stack = R_ADDR(infop, lp->free_fid_stack);
memcpy(newstack, stack,
lp->free_fids_alloced * sizeof(u_int32_t));
__env_alloc_free(infop, stack);
}
lp->free_fid_stack = R_OFFSET(infop, newstack);
lp->free_fids_alloced += 20;
LOG_SYSTEM_UNLOCK(env);
}
stack = R_ADDR(infop, lp->free_fid_stack);
stack[lp->free_fids++] = id;
return (0);
}
static int
__dbreg_pop_id(env, id)
ENV *env;
int32_t *id;
{
DB_LOG *dblp;
LOG *lp;
int32_t *stack;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
if (lp->free_fid_stack != INVALID_ROFF && lp->free_fids > 0) {
stack = R_ADDR(&dblp->reginfo, lp->free_fid_stack);
*id = stack[--lp->free_fids];
} else
*id = DB_LOGFILEID_INVALID;
return (0);
}
static int
__dbreg_pluck_id(env, id)
ENV *env;
int32_t id;
{
DB_LOG *dblp;
LOG *lp;
int32_t *stack;
u_int i;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
if (id >= lp->fid_max)
return (0);
if (lp->free_fid_stack != INVALID_ROFF) {
stack = R_ADDR(&dblp->reginfo, lp->free_fid_stack);
for (i = 0; i < lp->free_fids; i++)
if (id == stack[i]) {
stack[i] = stack[lp->free_fids - 1];
lp->free_fids--;
return (0);
}
}
return (0);
}
int
__dbreg_log_id(dbp, txn, id, needlock)
DB *dbp;
DB_TXN *txn;
int32_t id;
int needlock;
{
DBT fid_dbt, r_name;
DB_LOG *dblp;
DB_LSN unused;
ENV *env;
FNAME *fnp;
LOG *lp;
u_int32_t op;
int ret;
env = dbp->env;
dblp = env->lg_handle;
lp = dblp->reginfo.primary;
fnp = dbp->log_filename;
if (fnp->s_type == DB_UNKNOWN) {
memcpy(fnp->ufid, dbp->fileid, DB_FILE_ID_LEN);
fnp->s_type = dbp->type;
}
memset(&fid_dbt, 0, sizeof(fid_dbt));
memset(&r_name, 0, sizeof(r_name));
if (needlock)
MUTEX_LOCK(env, lp->mtx_filelist);
if (fnp->fname_off != INVALID_ROFF) {
r_name.data = R_ADDR(&dblp->reginfo, fnp->fname_off);
r_name.size = (u_int32_t)strlen((char *)r_name.data) + 1;
}
fid_dbt.data = dbp->fileid;
fid_dbt.size = DB_FILE_ID_LEN;
op = !F_ISSET(dbp, DB_AM_OPEN_CALLED) ? DBREG_PREOPEN :
(F_ISSET(dbp, DB_AM_INMEM) ? DBREG_REOPEN : DBREG_OPEN);
ret = __dbreg_register_log(env, txn, &unused,
F_ISSET(dbp, DB_AM_NOT_DURABLE) ? DB_LOG_NOT_DURABLE : 0,
op, r_name.size == 0 ? NULL : &r_name, &fid_dbt, id,
fnp->s_type, fnp->meta_pgno, fnp->create_txnid);
if (needlock)
MUTEX_UNLOCK(env, lp->mtx_filelist);
return (ret);
}