#include "db_config.h"
#include "db_int.h"
#include "dbinc/crypto.h"
#include "dbinc/hmac.h"
#include "dbinc/log.h"
#include "dbinc/txn.h"
static int __log_init __P((DB_ENV *, DB_LOG *));
static int __log_recover __P((DB_LOG *));
static size_t __log_region_size __P((DB_ENV *));
int
__log_open(dbenv, create_ok)
DB_ENV *dbenv;
int create_ok;
{
DB_LOG *dblp;
LOG *lp;
u_int8_t *bulk;
int region_locked, ret;
region_locked = 0;
if ((ret = __os_calloc(dbenv, 1, sizeof(DB_LOG), &dblp)) != 0)
return (ret);
dblp->dbenv = dbenv;
if (dbenv->lg_bsize == 0)
dbenv->lg_bsize = F_ISSET(dbenv, DB_ENV_LOG_INMEMORY) ?
LG_BSIZE_INMEM : LG_BSIZE_DEFAULT;
dblp->reginfo.dbenv = dbenv;
dblp->reginfo.type = REGION_TYPE_LOG;
dblp->reginfo.id = INVALID_REGION_ID;
dblp->reginfo.flags = REGION_JOIN_OK;
if (create_ok)
F_SET(&dblp->reginfo, REGION_CREATE_OK);
if ((ret = __env_region_attach(
dbenv, &dblp->reginfo, __log_region_size(dbenv))) != 0)
goto err;
if (F_ISSET(&dblp->reginfo, REGION_CREATE))
if ((ret = __log_init(dbenv, dblp)) != 0)
goto err;
lp = dblp->reginfo.primary =
R_ADDR(&dblp->reginfo, dblp->reginfo.rp->primary);
dblp->bufp = R_ADDR(&dblp->reginfo, lp->buffer_off);
if ((ret = __mutex_alloc(dbenv,
MTX_LOG_REGION, DB_MUTEX_PROCESS_ONLY, &dblp->mtx_dbreg)) != 0)
goto err;
dbenv->lg_handle = dblp;
if (F_ISSET(&dblp->reginfo, REGION_CREATE)) {
if (lp->log_size == 0)
lp->log_size = F_ISSET(dbenv, DB_ENV_LOG_INMEMORY) ?
LG_MAX_INMEM : LG_MAX_DEFAULT;
if ((ret = __log_recover(dblp)) != 0)
goto err;
if (lp->log_nsize == 0)
lp->log_nsize = lp->log_size;
if (IS_INIT_LSN(lp->lsn) &&
(ret = __log_newfile(dblp, NULL, 0, 0)) != 0)
goto err;
lp->ready_lsn = lp->lsn;
if (IS_ENV_REPLICATED(dbenv)) {
if ((ret =
__env_alloc(&dblp->reginfo, MEGABYTE, &bulk)) != 0)
goto err;
lp->bulk_buf = R_OFFSET(&dblp->reginfo, bulk);
lp->bulk_len = MEGABYTE;
lp->bulk_off = 0;
} else {
lp->bulk_buf = INVALID_ROFF;
lp->bulk_len = 0;
lp->bulk_off = 0;
}
} else {
LOG_SYSTEM_LOCK(dbenv);
region_locked = 1;
if (dbenv->lg_size != 0) {
if ((ret =
__log_check_sizes(dbenv, dbenv->lg_size, 0)) != 0)
goto err;
lp->log_nsize = dbenv->lg_size;
}
if (lp->db_log_autoremove)
F_SET(dbenv, DB_ENV_LOG_AUTOREMOVE);
if (lp->db_log_inmemory)
F_SET(dbenv, DB_ENV_LOG_INMEMORY);
LOG_SYSTEM_UNLOCK(dbenv);
region_locked = 0;
}
return (0);
err: dbenv->lg_handle = NULL;
if (dblp->reginfo.addr != NULL) {
if (region_locked)
LOG_SYSTEM_UNLOCK(dbenv);
(void)__env_region_detach(dbenv, &dblp->reginfo, 0);
}
(void)__mutex_free(dbenv, &dblp->mtx_dbreg);
__os_free(dbenv, dblp);
return (ret);
}
static int
__log_init(dbenv, dblp)
DB_ENV *dbenv;
DB_LOG *dblp;
{
LOG *lp;
int ret;
void *p;
if ((ret =
__log_check_sizes(dbenv, dbenv->lg_size, dbenv->lg_bsize)) != 0)
return (ret);
if ((ret = __env_alloc(&dblp->reginfo,
sizeof(*lp), &dblp->reginfo.primary)) != 0)
goto mem_err;
dblp->reginfo.rp->primary =
R_OFFSET(&dblp->reginfo, dblp->reginfo.primary);
lp = dblp->reginfo.primary;
memset(lp, 0, sizeof(*lp));
if ((ret =
__mutex_alloc(dbenv, MTX_LOG_REGION, 0, &lp->mtx_region)) != 0)
return (ret);
lp->fid_max = 0;
SH_TAILQ_INIT(&lp->fq);
lp->free_fid_stack = INVALID_ROFF;
lp->free_fids = lp->free_fids_alloced = 0;
INIT_LSN(lp->lsn);
INIT_LSN(lp->t_lsn);
ZERO_LSN(lp->waiting_lsn);
ZERO_LSN(lp->cached_ckp_lsn);
if ((ret =
__mutex_alloc(dbenv, MTX_LOG_FILENAME, 0, &lp->mtx_filelist)) != 0)
return (ret);
if ((ret = __mutex_alloc(dbenv, MTX_LOG_FLUSH, 0, &lp->mtx_flush)) != 0)
return (ret);
if ((ret = __env_alloc(&dblp->reginfo, dbenv->lg_bsize, &p)) != 0) {
mem_err: __db_errx( dbenv, "unable to allocate log region memory");
return (ret);
}
lp->regionmax = dbenv->lg_regionmax;
lp->buffer_off = R_OFFSET(&dblp->reginfo, p);
lp->buffer_size = dbenv->lg_bsize;
lp->filemode = dbenv->lg_filemode;
lp->log_size = lp->log_nsize = dbenv->lg_size;
SH_TAILQ_INIT(&lp->free_commits);
SH_TAILQ_INIT(&lp->commits);
lp->ncommit = 0;
SH_TAILQ_INIT(&lp->logfiles);
SH_TAILQ_INIT(&lp->free_logfiles);
lp->persist.magic = DB_LOGMAGIC;
lp->persist.version = DB_LOGVERSION;
lp->persist.notused = 0;
if (F_ISSET(dbenv, DB_ENV_LOG_AUTOREMOVE))
lp->db_log_autoremove = 1;
if (F_ISSET(dbenv, DB_ENV_LOG_INMEMORY))
lp->db_log_inmemory = 1;
(void)time(&lp->timestamp);
return (0);
}
static int
__log_recover(dblp)
DB_LOG *dblp;
{
DBT dbt;
DB_ENV *dbenv;
DB_LOGC *logc;
DB_LSN lsn;
LOG *lp;
u_int32_t cnt, rectype;
int ret;
logfile_validity status;
logc = NULL;
dbenv = dblp->dbenv;
lp = dblp->reginfo.primary;
if ((ret = __log_find(dblp, 0, &cnt, &status)) != 0)
return (ret);
if (cnt == 0)
return (0);
if (status == DB_LV_OLD_UNREADABLE) {
lp->lsn.file = lp->s_lsn.file = cnt + 1;
lp->lsn.offset = lp->s_lsn.offset = 0;
goto skipsearch;
}
DB_ASSERT(dbenv,
(status == DB_LV_NORMAL || status == DB_LV_OLD_READABLE));
lp->lsn.file = cnt + 1;
lp->lsn.offset = 0;
lsn.file = cnt;
lsn.offset = 0;
if ((ret = __log_cursor(dbenv, &logc)) != 0)
return (ret);
F_SET(logc, DB_LOG_LOCKED);
memset(&dbt, 0, sizeof(dbt));
if ((ret = __logc_get(logc, &lsn, &dbt, DB_SET)) != 0)
goto err;
F_SET(logc, DB_LOG_SILENT_ERR);
while (__logc_get(logc, &lsn, &dbt, DB_NEXT) == 0) {
if (dbt.size < sizeof(u_int32_t))
continue;
memcpy(&rectype, dbt.data, sizeof(u_int32_t));
if (rectype == DB___txn_ckp)
lp->cached_ckp_lsn = lsn;
}
F_CLR(logc, DB_LOG_SILENT_ERR);
lp->lsn = lsn;
lp->s_lsn = lsn;
lp->lsn.offset += logc->len;
lp->s_lsn.offset += logc->len;
lp->len = logc->len;
lp->a_off = 0;
lp->b_off = 0;
lp->w_off = lp->lsn.offset;
skipsearch:
if (FLD_ISSET(dbenv->verbose, DB_VERB_RECOVERY))
__db_msg(dbenv,
"Finding last valid log LSN: file: %lu offset %lu",
(u_long)lp->lsn.file, (u_long)lp->lsn.offset);
err: if (logc != NULL)
(void)__logc_close(logc);
return (ret);
}
int
__log_find(dblp, find_first, valp, statusp)
DB_LOG *dblp;
int find_first;
u_int32_t *valp;
logfile_validity *statusp;
{
DB_ENV *dbenv;
LOG *lp;
logfile_validity logval_status, status;
struct __db_filestart *filestart;
u_int32_t clv, logval;
int cnt, fcnt, ret;
const char *dir;
char *c, **names, *p, *q;
dbenv = dblp->dbenv;
lp = dblp->reginfo.primary;
logval_status = status = DB_LV_NONEXISTENT;
*valp = 0;
if (lp->db_log_inmemory) {
filestart = find_first ?
SH_TAILQ_FIRST(&lp->logfiles, __db_filestart) :
SH_TAILQ_LAST(&lp->logfiles, links, __db_filestart);
if (filestart != NULL) {
*valp = filestart->file;
logval_status = DB_LV_NORMAL;
}
*statusp = logval_status;
return (0);
}
if ((ret = __log_name(dblp, 1, &p, NULL, 0)) != 0)
return (ret);
if ((q = __db_rpath(p)) == NULL)
dir = PATH_DOT;
else {
*q = '\0';
dir = p;
}
if ((ret = __os_dirlist(dbenv, dir, &names, &fcnt)) != 0) {
__db_err(dbenv, ret, "%s", dir);
__os_free(dbenv, p);
return (ret);
}
for (cnt = fcnt, clv = logval = 0; --cnt >= 0;) {
if (strncmp(names[cnt], LFPREFIX, sizeof(LFPREFIX) - 1) != 0)
continue;
for (c = names[cnt] + sizeof(LFPREFIX) - 1; *c != '\0'; c++)
if (!isdigit((int)*c))
break;
if (*c != '\0')
continue;
clv = (u_int32_t)atol(names[cnt] + (sizeof(LFPREFIX) - 1));
if (find_first) {
if (logval != 0 &&
status != DB_LV_OLD_UNREADABLE && clv > logval)
continue;
} else
if (logval != 0 && clv < logval)
continue;
if ((ret = __log_valid(dblp, clv, 1, NULL, 0,
&status, NULL)) != 0) {
__db_err(
dbenv, ret, "Invalid log file: %s", names[cnt]);
goto err;
}
switch (status) {
case DB_LV_NONEXISTENT:
DB_ASSERT(dbenv, 0);
break;
case DB_LV_INCOMPLETE:
if (find_first)
goto found;
break;
case DB_LV_OLD_UNREADABLE:
if (!find_first || logval == 0 ||
(status == DB_LV_OLD_UNREADABLE && clv > logval))
goto found;
break;
case DB_LV_NORMAL:
case DB_LV_OLD_READABLE:
found: logval = clv;
logval_status = status;
break;
}
}
*valp = logval;
err: __os_dirfree(dbenv, names, fcnt);
__os_free(dbenv, p);
*statusp = logval_status;
return (ret);
}
int
__log_valid(dblp, number, set_persist, fhpp, flags, statusp, versionp)
DB_LOG *dblp;
u_int32_t number;
int set_persist;
DB_FH **fhpp;
u_int32_t flags;
logfile_validity *statusp;
u_int32_t *versionp;
{
DB_CIPHER *db_cipher;
DB_ENV *dbenv;
DB_FH *fhp;
HDR *hdr;
LOG *lp;
LOGP *persist;
logfile_validity status;
size_t hdrsize, nr, recsize;
int is_hmac, ret;
u_int8_t *tmp;
char *fname;
dbenv = dblp->dbenv;
db_cipher = dbenv->crypto_handle;
fhp = NULL;
persist = NULL;
status = DB_LV_NORMAL;
tmp = NULL;
if (fhpp != NULL)
*fhpp = NULL;
if (flags == 0)
flags = DB_OSO_RDONLY | DB_OSO_SEQ;
if ((ret = __log_name(dblp, number, &fname, &fhp, flags)) != 0) {
__os_free(dbenv, fname);
return (ret);
}
hdrsize = HDR_NORMAL_SZ;
is_hmac = 0;
recsize = sizeof(LOGP);
if (CRYPTO_ON(dbenv)) {
hdrsize = HDR_CRYPTO_SZ;
recsize = sizeof(LOGP);
recsize += db_cipher->adj_size(recsize);
is_hmac = 1;
}
if ((ret = __os_calloc(dbenv, 1, recsize + hdrsize, &tmp)) != 0)
goto err;
hdr = (HDR *)tmp;
persist = (LOGP *)(tmp + hdrsize);
if ((ret = __os_read(dbenv, fhp, tmp, recsize + hdrsize, &nr)) != 0 ||
nr != recsize + hdrsize ||
(hdr->len == 0 && persist->magic == 0 && persist->log_size == 0)) {
if (ret == 0)
status = DB_LV_INCOMPLETE;
else
__db_err(dbenv, ret, "ignoring log file: %s", fname);
goto err;
}
if (CRYPTO_ON(dbenv)) {
if ((hdr->len - hdrsize) != sizeof(LOGP)) {
__db_errx(dbenv, "log record size mismatch");
goto err;
}
if ((ret = __db_check_chksum(dbenv, hdr, db_cipher,
&hdr->chksum[0], (u_int8_t *)persist,
hdr->len - hdrsize, is_hmac)) != 0) {
__db_errx(dbenv, "log record checksum mismatch");
goto err;
}
if ((ret = db_cipher->decrypt(dbenv, db_cipher->data,
&hdr->iv[0], (u_int8_t *)persist, hdr->len - hdrsize)) != 0)
goto err;
}
if (persist->magic != DB_LOGMAGIC) {
__db_errx(dbenv,
"Ignoring log file: %s: magic number %lx, not %lx",
fname, (u_long)persist->magic, (u_long)DB_LOGMAGIC);
ret = EINVAL;
goto err;
}
if (persist->version > DB_LOGVERSION) {
__db_errx(dbenv,
"Unacceptable log file %s: unsupported log version %lu",
fname, (u_long)persist->version);
ret = EINVAL;
goto err;
} else if (persist->version < DB_LOGOLDVER) {
status = DB_LV_OLD_UNREADABLE;
__db_errx(dbenv,
"Skipping log file %s: historic log version %lu",
fname, (u_long)persist->version);
goto err;
} else if (persist->version < DB_LOGVERSION)
status = DB_LV_OLD_READABLE;
if (!CRYPTO_ON(dbenv) && ((ret = __db_check_chksum(dbenv,
hdr, db_cipher, &hdr->chksum[0], (u_int8_t *)persist,
hdr->len - hdrsize, is_hmac)) != 0)) {
__db_errx(dbenv, "log record checksum mismatch");
goto err;
}
if (set_persist) {
lp = dblp->reginfo.primary;
lp->log_size = persist->log_size;
lp->persist.version = persist->version;
}
if (versionp != NULL)
*versionp = persist->version;
err: if (fname != NULL)
__os_free(dbenv, fname);
if (ret == 0 && fhpp != NULL)
*fhpp = fhp;
else
(void)__os_closehandle(dbenv, fhp);
if (tmp != NULL)
__os_free(dbenv, tmp);
if (statusp != NULL)
*statusp = status;
return (ret);
}
int
__log_env_refresh(dbenv)
DB_ENV *dbenv;
{
DB_LOG *dblp;
LOG *lp;
REGINFO *reginfo;
struct __fname *fnp;
struct __db_filestart *filestart;
int ret, t_ret;
dblp = dbenv->lg_handle;
reginfo = &dblp->reginfo;
lp = reginfo->primary;
ret = 0;
if (F_ISSET(dbenv, DB_ENV_PRIVATE) &&
(t_ret = __log_flush(dbenv, NULL)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __dbreg_close_files(dbenv, 0)) != 0 && ret == 0)
ret = t_ret;
MUTEX_LOCK(dbenv, lp->mtx_filelist);
SH_TAILQ_FOREACH(fnp, &lp->fq, q, __fname)
if (F_ISSET(fnp, DB_FNAME_NOTLOGGED) &&
(t_ret = __dbreg_close_id_int(
dbenv, fnp, DBREG_CLOSE, 1)) != 0)
ret = t_ret;
MUTEX_UNLOCK(dbenv, lp->mtx_filelist);
if (F_ISSET(dbenv, DB_ENV_PRIVATE)) {
if ((t_ret =
__mutex_free(dbenv, &lp->mtx_flush)) != 0 && ret == 0)
ret = t_ret;
__env_alloc_free(reginfo, R_ADDR(reginfo, lp->buffer_off));
if (lp->free_fid_stack != INVALID_ROFF)
__env_alloc_free(reginfo,
R_ADDR(reginfo, lp->free_fid_stack));
while ((filestart = SH_TAILQ_FIRST(&lp->logfiles,
__db_filestart)) != NULL) {
SH_TAILQ_REMOVE(&lp->logfiles, filestart, links,
__db_filestart);
__env_alloc_free(reginfo, filestart);
}
while ((filestart = SH_TAILQ_FIRST(&lp->free_logfiles,
__db_filestart)) != NULL) {
SH_TAILQ_REMOVE(&lp->free_logfiles, filestart, links,
__db_filestart);
__env_alloc_free(reginfo, filestart);
}
if (lp->bulk_buf != INVALID_ROFF) {
__env_alloc_free(reginfo,
R_ADDR(reginfo, lp->bulk_buf));
lp->bulk_buf = INVALID_ROFF;
}
}
if ((t_ret = __mutex_free(dbenv, &dblp->mtx_dbreg)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __env_region_detach(dbenv, reginfo, 0)) != 0 && ret == 0)
ret = t_ret;
if (dblp->lfhp != NULL) {
if ((t_ret =
__os_closehandle(dbenv, dblp->lfhp)) != 0 && ret == 0)
ret = t_ret;
dblp->lfhp = NULL;
}
if (dblp->dbentry != NULL)
__os_free(dbenv, dblp->dbentry);
__os_free(dbenv, dblp);
dbenv->lg_handle = NULL;
return (ret);
}
int
__log_get_cached_ckp_lsn(dbenv, ckp_lsnp)
DB_ENV *dbenv;
DB_LSN *ckp_lsnp;
{
DB_LOG *dblp;
LOG *lp;
dblp = dbenv->lg_handle;
lp = (LOG *)dblp->reginfo.primary;
LOG_SYSTEM_LOCK(dbenv);
*ckp_lsnp = lp->cached_ckp_lsn;
LOG_SYSTEM_UNLOCK(dbenv);
return (0);
}
u_int32_t
__log_region_mutex_count(dbenv)
DB_ENV *dbenv;
{
return (dbenv->tx_max + 5);
}
static size_t
__log_region_size(dbenv)
DB_ENV *dbenv;
{
size_t s;
s = dbenv->lg_regionmax + dbenv->lg_bsize;
if (IS_ENV_REPLICATED(dbenv))
s += MEGABYTE;
return (s);
}
int
__log_vtruncate(dbenv, lsn, ckplsn, trunclsn)
DB_ENV *dbenv;
DB_LSN *lsn, *ckplsn, *trunclsn;
{
DBT log_dbt;
DB_LOG *dblp;
DB_LOGC *logc;
LOG *lp;
u_int32_t bytes, len;
int ret, t_ret;
if ((ret = __log_cursor(dbenv, &logc)) != 0)
return (ret);
memset(&log_dbt, 0, sizeof(log_dbt));
ret = __logc_get(logc, lsn, &log_dbt, DB_SET);
len = logc->len;
if ((t_ret = __logc_close(logc)) != 0 && ret == 0)
ret = t_ret;
if (ret != 0)
return (ret);
dblp = dbenv->lg_handle;
lp = (LOG *)dblp->reginfo.primary;
LOG_SYSTEM_LOCK(dbenv);
if ((ret = __log_flush_int(dblp, NULL, 0)) != 0)
goto err;
lp->lsn = *lsn;
lp->len = len;
lp->lsn.offset += lp->len;
if (lp->db_log_inmemory &&
(ret = __log_inmem_lsnoff(dblp, &lp->lsn, &lp->b_off)) != 0)
goto err;
DB_ASSERT(dbenv, lp->lsn.file >= ckplsn->file);
bytes = 0;
if (ckplsn->file != lp->lsn.file) {
bytes = lp->log_size - ckplsn->offset;
if (lp->lsn.file > ckplsn->file + 1)
bytes += lp->log_size *
((lp->lsn.file - ckplsn->file) - 1);
bytes += lp->lsn.offset;
} else
bytes = lp->lsn.offset - ckplsn->offset;
lp->stat.st_wc_mbytes += bytes / MEGABYTE;
lp->stat.st_wc_bytes += bytes % MEGABYTE;
MUTEX_LOCK(dbenv, lp->mtx_flush);
if (LOG_COMPARE(&lp->s_lsn, lsn) > 0)
lp->s_lsn = lp->lsn;
MUTEX_UNLOCK(dbenv, lp->mtx_flush);
ZERO_LSN(lp->f_lsn);
lp->w_off = lp->lsn.offset;
if (trunclsn != NULL)
*trunclsn = lp->lsn;
if ((ret = __log_zero(dbenv, &lp->lsn)) != 0)
goto err;
err: LOG_SYSTEM_UNLOCK(dbenv);
return (ret);
}
int
__log_is_outdated(dbenv, fnum, outdatedp)
DB_ENV *dbenv;
u_int32_t fnum;
int *outdatedp;
{
DB_LOG *dblp;
LOG *lp;
char *name;
int ret;
u_int32_t cfile;
struct __db_filestart *filestart;
dblp = dbenv->lg_handle;
if (F_ISSET(dbenv, DB_ENV_LOG_INMEMORY)) {
LOG_SYSTEM_LOCK(dbenv);
lp = (LOG *)dblp->reginfo.primary;
filestart = SH_TAILQ_FIRST(&lp->logfiles, __db_filestart);
*outdatedp = filestart == NULL ? 0 : (fnum < filestart->file);
LOG_SYSTEM_UNLOCK(dbenv);
return (0);
}
*outdatedp = 0;
if ((ret = __log_name(dblp, fnum, &name, NULL, 0)) != 0)
return (ret);
if (__os_exists(dbenv, name, NULL) == 0)
goto out;
LOG_SYSTEM_LOCK(dbenv);
lp = (LOG *)dblp->reginfo.primary;
cfile = lp->lsn.file;
LOG_SYSTEM_UNLOCK(dbenv);
if (cfile > fnum)
*outdatedp = 1;
out: __os_free(dbenv, name);
return (ret);
}
int
__log_zero(dbenv, from_lsn)
DB_ENV *dbenv;
DB_LSN *from_lsn;
{
DB_FH *fhp;
DB_LOG *dblp;
LOG *lp;
struct __db_filestart *filestart, *nextstart;
size_t nbytes, len, nw;
u_int32_t fn, mbytes, bytes;
u_int8_t buf[4096];
int ret;
char *fname;
dblp = dbenv->lg_handle;
lp = (LOG *)dblp->reginfo.primary;
DB_ASSERT(dbenv, LOG_COMPARE(from_lsn, &lp->lsn) <= 0);
if (LOG_COMPARE(from_lsn, &lp->lsn) > 0) {
__db_errx(dbenv,
"Warning: truncating to point beyond end of log");
return (0);
}
if (lp->db_log_inmemory) {
for (filestart = SH_TAILQ_FIRST(&lp->logfiles, __db_filestart);
filestart != NULL; filestart = nextstart) {
nextstart = SH_TAILQ_NEXT(filestart,
links, __db_filestart);
if (filestart->file > from_lsn->file) {
SH_TAILQ_REMOVE(&lp->logfiles,
filestart, links, __db_filestart);
SH_TAILQ_INSERT_HEAD(&lp->free_logfiles,
filestart, links, __db_filestart);
}
}
return (0);
}
if (dblp->lfhp != NULL) {
(void)__os_closehandle(dbenv, dblp->lfhp);
dblp->lfhp = NULL;
}
for (fn = from_lsn->file + 1;; fn++) {
if (__log_name(dblp, fn, &fname, &fhp, DB_OSO_RDONLY) != 0) {
__os_free(dbenv, fname);
break;
}
(void)__os_closehandle(dbenv, fhp);
(void)time(&lp->timestamp);
ret = __os_unlink(dbenv, fname);
__os_free(dbenv, fname);
if (ret != 0)
return (ret);
}
if ((ret =
__log_name(dblp, from_lsn->file, &fname, &dblp->lfhp, 0)) != 0)
return (ret);
__os_free(dbenv, fname);
if ((ret = __os_ioinfo(dbenv,
NULL, dblp->lfhp, &mbytes, &bytes, NULL)) != 0)
goto err;
DB_ASSERT(dbenv, (mbytes * MEGABYTE + bytes) >= from_lsn->offset);
len = (mbytes * MEGABYTE + bytes) - from_lsn->offset;
memset(buf, 0, sizeof(buf));
if ((ret = __os_seek(dbenv, dblp->lfhp, 0, 0, from_lsn->offset)) != 0)
goto err;
while (len > 0) {
nbytes = len > sizeof(buf) ? sizeof(buf) : len;
if ((ret =
__os_write(dbenv, dblp->lfhp, buf, nbytes, &nw)) != 0)
goto err;
len -= nbytes;
}
err: (void)__os_closehandle(dbenv, dblp->lfhp);
dblp->lfhp = NULL;
return (ret);
}
int
__log_inmem_lsnoff(dblp, lsnp, offsetp)
DB_LOG *dblp;
DB_LSN *lsnp;
size_t *offsetp;
{
LOG *lp;
struct __db_filestart *filestart;
lp = (LOG *)dblp->reginfo.primary;
SH_TAILQ_FOREACH(filestart, &lp->logfiles, links, __db_filestart)
if (filestart->file == lsnp->file) {
*offsetp =
(filestart->b_off + lsnp->offset) % lp->buffer_size;
return (0);
}
return (DB_NOTFOUND);
}
int
__log_inmem_newfile(dblp, file)
DB_LOG *dblp;
u_int32_t file;
{
HDR hdr;
LOG *lp;
struct __db_filestart *filestart;
int ret;
#ifdef DIAGNOSTIC
struct __db_filestart *first, *last;
#endif
lp = (LOG *)dblp->reginfo.primary;
filestart = SH_TAILQ_FIRST(&lp->logfiles, __db_filestart);
if (filestart != NULL &&
RINGBUF_LEN(lp, filestart->b_off, lp->b_off) <=
sizeof(HDR) + sizeof(LOGP)) {
filestart->file = file;
filestart->b_off = lp->b_off;
return (0);
}
if (file > 1) {
memset(&hdr, 0, sizeof(HDR));
__log_inmem_copyin(dblp, lp->b_off, &hdr, sizeof(HDR));
lp->b_off = (lp->b_off + sizeof(HDR)) % lp->buffer_size;
}
filestart = SH_TAILQ_FIRST(&lp->free_logfiles, __db_filestart);
if (filestart == NULL) {
if ((ret = __env_alloc(&dblp->reginfo,
sizeof(struct __db_filestart), &filestart)) != 0)
return (ret);
memset(filestart, 0, sizeof(*filestart));
} else
SH_TAILQ_REMOVE(&lp->free_logfiles, filestart,
links, __db_filestart);
filestart->file = file;
filestart->b_off = lp->b_off;
#ifdef DIAGNOSTIC
first = SH_TAILQ_FIRST(&lp->logfiles, __db_filestart);
last = SH_TAILQ_LAST(&(lp)->logfiles, links, __db_filestart);
DB_ASSERT(dblp->dbenv, !first || first == last ||
RINGBUF_LEN(lp, first->b_off, lp->b_off) ==
RINGBUF_LEN(lp, first->b_off, last->b_off) +
RINGBUF_LEN(lp, last->b_off, lp->b_off));
#endif
SH_TAILQ_INSERT_TAIL(&lp->logfiles, filestart, links);
return (0);
}
int
__log_inmem_chkspace(dblp, len)
DB_LOG *dblp;
size_t len;
{
DB_ENV *dbenv;
LOG *lp;
DB_LSN active_lsn, old_active_lsn;
struct __db_filestart *filestart;
int ret;
dbenv = dblp->dbenv;
lp = dblp->reginfo.primary;
DB_ASSERT(dbenv, lp->db_log_inmemory);
len += sizeof(HDR);
while (TXN_ON(dbenv) &&
RINGBUF_LEN(lp, lp->b_off, lp->a_off) <= len) {
old_active_lsn = lp->active_lsn;
active_lsn = lp->lsn;
LOG_SYSTEM_UNLOCK(dbenv);
if ((ret = __txn_getactive(dbenv, &active_lsn)) != 0)
return (ret);
LOG_SYSTEM_LOCK(dbenv);
active_lsn.offset = 0;
if (LOG_COMPARE(&active_lsn, &old_active_lsn) == 0) {
__db_errx(dbenv,
"In-memory log buffer is full (an active transaction spans the buffer)");
return (DB_LOG_BUFFER_FULL);
}
if (LOG_COMPARE(&active_lsn, &lp->active_lsn) > 0) {
lp->active_lsn = active_lsn;
(void)__log_inmem_lsnoff(dblp, &active_lsn,
&lp->a_off);
}
}
filestart = SH_TAILQ_FIRST(&lp->logfiles, __db_filestart);
if (filestart != NULL &&
RINGBUF_LEN(lp, lp->b_off, filestart->b_off) <= len) {
SH_TAILQ_REMOVE(&lp->logfiles, filestart,
links, __db_filestart);
SH_TAILQ_INSERT_HEAD(&lp->free_logfiles, filestart,
links, __db_filestart);
lp->f_lsn.file = filestart->file + 1;
}
return (0);
}
void
__log_inmem_copyout(dblp, offset, buf, size)
DB_LOG *dblp;
size_t offset;
void *buf;
size_t size;
{
LOG *lp;
size_t nbytes;
lp = (LOG *)dblp->reginfo.primary;
nbytes = (offset + size < lp->buffer_size) ?
size : lp->buffer_size - offset;
memcpy(buf, dblp->bufp + offset, nbytes);
if (nbytes < size)
memcpy((u_int8_t *)buf + nbytes, dblp->bufp, size - nbytes);
}
void
__log_inmem_copyin(dblp, offset, buf, size)
DB_LOG *dblp;
size_t offset;
void *buf;
size_t size;
{
LOG *lp;
size_t nbytes;
lp = (LOG *)dblp->reginfo.primary;
nbytes = (offset + size < lp->buffer_size) ?
size : lp->buffer_size - offset;
memcpy(dblp->bufp + offset, buf, nbytes);
if (nbytes < size)
memcpy(dblp->bufp, (u_int8_t *)buf + nbytes, size - nbytes);
}
void
__log_set_version(dbenv, newver)
DB_ENV *dbenv;
u_int32_t newver;
{
DB_LOG *dblp;
LOG *lp;
dblp = dbenv->lg_handle;
lp = (LOG *)dblp->reginfo.primary;
lp->persist.version = newver;
}
int
__log_get_oldversion(dbenv, ver)
DB_ENV *dbenv;
u_int32_t *ver;
{
DBT rec;
DB_LOG *dblp;
DB_LOGC *logc;
DB_LSN lsn;
LOG *lp;
u_int32_t firstfnum, fnum, lastver, oldver;
int ret, t_ret;
dblp = dbenv->lg_handle;
lp = dblp->reginfo.primary;
logc = NULL;
ret = 0;
oldver = DB_LOGVERSION;
if (lp->db_log_inmemory) {
*ver = oldver;
return (0);
}
memset(&rec, 0, sizeof(rec));
if ((ret = __log_cursor(dbenv, &logc)) != 0)
goto err;
if ((ret = __logc_get(logc, &lsn, &rec, DB_FIRST)) != 0) {
if (ret == DB_NOTFOUND)
ret = 0;
goto err;
}
firstfnum = lsn.file;
if ((ret = __logc_get(logc, &lsn, &rec, DB_LAST)) != 0)
goto err;
if ((ret = __log_valid(dblp, firstfnum, 0, NULL, 0,
NULL, &oldver)) != 0)
goto err;
if (firstfnum == lsn.file)
goto err;
if ((ret = __log_valid(dblp, lsn.file, 0, NULL, 0,
NULL, &lastver)) != 0)
goto err;
if (oldver != lastver) {
for (fnum = lsn.file - 1; fnum >= firstfnum; fnum--) {
if ((ret = __log_valid(dblp, fnum, 0, NULL, 0,
NULL, &oldver)) != 0)
goto err;
if (oldver != lastver)
break;
}
}
err: if (logc != NULL && ((t_ret = __logc_close(logc)) != 0) && ret == 0)
ret = t_ret;
if (ret == 0 && ver != NULL)
*ver = oldver;
return (ret);
}