#include "db_config.h"
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_swap.h"
#include "dbinc/btree.h"
#include "dbinc/fop.h"
#include "dbinc/hash.h"
#include "dbinc/lock.h"
#include "dbinc/log.h"
#include "dbinc/mp.h"
#include "dbinc/qam.h"
#include "dbinc/txn.h"
static int __db_disassociate __P((DB *));
#ifdef CONFIG_TEST
static int __db_makecopy __P((DB_ENV *, const char *, const char *));
static int __db_testdocopy __P((DB_ENV *, const char *));
static int __qam_testdocopy __P((DB *, const char *));
#endif
int
__db_master_open(subdbp, txn, name, flags, mode, dbpp)
DB *subdbp;
DB_TXN *txn;
const char *name;
u_int32_t flags;
int mode;
DB **dbpp;
{
DB *dbp;
int ret;
*dbpp = NULL;
if ((ret = __db_create_internal(&dbp, subdbp->dbenv, 0)) != 0)
return (ret);
dbp->pgsize = subdbp->pgsize;
F_SET(dbp, DB_AM_SUBDB);
F_SET(dbp, F_ISSET(subdbp,
DB_AM_RECOVER | DB_AM_SWAP |
DB_AM_ENCRYPT | DB_AM_CHKSUM | DB_AM_NOT_DURABLE));
LF_CLR(DB_EXCL);
LF_SET(DB_RDWRMASTER);
if ((ret = __db_open(dbp,
txn, name, NULL, DB_BTREE, flags, mode, PGNO_BASE_MD)) != 0)
goto err;
if (F_ISSET(dbp, DB_AM_CHKSUM))
F_SET(subdbp, DB_AM_CHKSUM);
subdbp->pgsize = dbp->pgsize;
*dbpp = dbp;
if (0) {
err: if (!F_ISSET(dbp, DB_AM_DISCARD))
(void)__db_close(dbp, txn, 0);
}
return (ret);
}
int
__db_master_update(mdbp, sdbp, txn, subdb, type, action, newname, flags)
DB *mdbp, *sdbp;
DB_TXN *txn;
const char *subdb;
DBTYPE type;
mu_action action;
const char *newname;
u_int32_t flags;
{
DB_ENV *dbenv;
DBC *dbc, *ndbc;
DBT key, data, ndata;
PAGE *p, *r;
db_pgno_t t_pgno;
int modify, ret, t_ret;
dbenv = mdbp->dbenv;
dbc = ndbc = NULL;
p = NULL;
modify = (action != MU_OPEN || LF_ISSET(DB_CREATE)) ? 1 : 0;
if ((ret = __db_cursor(mdbp, txn, &dbc,
(CDB_LOCKING(dbenv) && modify) ? DB_WRITECURSOR : 0)) != 0)
return (ret);
DB_INIT_DBT(key, subdb, strlen(subdb));
memset(&data, 0, sizeof(data));
F_SET(&data, DB_DBT_MALLOC);
ret = __dbc_get(dbc, &key, &data,
DB_SET | ((STD_LOCKING(dbc) && modify) ? DB_RMW : 0));
switch (action) {
case MU_REMOVE:
if (ret != 0)
goto err;
if ((ret = __dbc_del(dbc, 0)) != 0)
goto err;
memcpy(&sdbp->meta_pgno, data.data, sizeof(db_pgno_t));
DB_NTOHL(&sdbp->meta_pgno);
if ((ret = __memp_fget(mdbp->mpf, &sdbp->meta_pgno,
dbc->txn, DB_MPOOL_DIRTY, &p)) != 0)
goto err;
if (TYPE(p) == P_BTREEMETA &&
((BTMETA *)p)->root != PGNO_INVALID) {
if ((ret = __memp_fget(mdbp->mpf,
&((BTMETA *)p)->root, dbc->txn,
DB_MPOOL_DIRTY, &r)) != 0)
goto err;
if ((ret = __db_free(dbc, r)) != 0) {
r = NULL;
goto err;
}
}
if ((ret = __db_free(dbc, p)) != 0) {
p = NULL;
goto err;
}
p = NULL;
break;
case MU_RENAME:
if (ret != 0)
goto err;
if ((ret = __db_cursor(mdbp, txn, &ndbc,
CDB_LOCKING(dbenv) ? DB_WRITECURSOR : 0)) != 0)
goto err;
DB_SET_DBT(key, newname, strlen(newname));
memset(&ndata, 0, sizeof(ndata));
F_SET(&ndata, DB_DBT_USERMEM | DB_DBT_PARTIAL);
if ((ret = __dbc_get(ndbc, &key, &ndata, DB_SET)) == 0) {
ret = EEXIST;
__db_errx(dbenv, "rename: database %s exists", newname);
goto err;
} else if (ret != DB_NOTFOUND)
goto err;
if ((ret = __dbc_put(ndbc, &key, &data, DB_KEYFIRST)) != 0)
goto err;
if ((ret = __dbc_del(dbc, 0)) != 0) {
(void)__dbc_del(ndbc, 0);
goto err;
}
break;
case MU_OPEN:
switch (ret) {
case 0:
if (LF_ISSET(DB_CREATE) && LF_ISSET(DB_EXCL)) {
ret = EEXIST;
goto err;
}
memcpy(&sdbp->meta_pgno, data.data, sizeof(db_pgno_t));
DB_NTOHL(&sdbp->meta_pgno);
goto done;
case DB_NOTFOUND:
if (LF_ISSET(DB_CREATE))
break;
ret = ENOENT;
goto err;
default:
goto err;
}
if ((ret = __db_new(dbc,
type == DB_HASH ? P_HASHMETA : P_BTREEMETA, &p)) != 0)
goto err;
sdbp->meta_pgno = PGNO(p);
t_pgno = PGNO(p);
DB_HTONL(&t_pgno);
memset(&ndata, 0, sizeof(ndata));
ndata.data = &t_pgno;
ndata.size = sizeof(db_pgno_t);
if ((ret = __dbc_put(dbc, &key, &ndata, DB_KEYLAST)) != 0)
goto err;
F_SET(sdbp, DB_AM_CREATED);
break;
}
err:
done:
if (p != NULL && (t_ret =
__memp_fput(mdbp->mpf, p, dbc->priority)) != 0 && ret == 0)
ret = t_ret;
if (data.data != NULL)
__os_ufree(dbenv, data.data);
if (dbc != NULL && (t_ret = __dbc_close(dbc)) != 0 && ret == 0)
ret = t_ret;
if (ndbc != NULL && (t_ret = __dbc_close(ndbc)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
int
__db_env_setup(dbp, txn, fname, dname, id, flags)
DB *dbp;
DB_TXN *txn;
const char *fname, *dname;
u_int32_t id, flags;
{
DB *ldbp;
DB_ENV *dbenv;
u_int32_t maxid;
int ret;
dbenv = dbp->dbenv;
if (!F_ISSET(dbenv, DB_ENV_OPEN_CALLED)) {
if (dbenv->mp_gbytes == 0 &&
dbenv->mp_bytes < dbp->pgsize * DB_MINPAGECACHE &&
(ret = __memp_set_cachesize(
dbenv, 0, dbp->pgsize * DB_MINPAGECACHE, 0)) != 0)
return (ret);
if ((ret = __env_open(dbenv, NULL, DB_CREATE |
DB_INIT_MPOOL | DB_PRIVATE | LF_ISSET(DB_THREAD), 0)) != 0)
return (ret);
}
if ((!F_ISSET(dbp, DB_AM_INMEM) || dname == NULL) &&
(ret = __db_env_mpool(dbp, fname, flags)) != 0)
return (ret);
if (LF_ISSET(DB_THREAD) && (ret = __mutex_alloc(
dbenv, MTX_DB_HANDLE, DB_MUTEX_PROCESS_ONLY, &dbp->mutex)) != 0)
return (ret);
if (LOGGING_ON(dbenv) && dbp->log_filename == NULL &&
#if !defined(DEBUG_ROP) && !defined(DEBUG_WOP) && !defined(DIAGNOSTIC)
(txn != NULL || F_ISSET(dbp, DB_AM_RECOVER)) &&
#endif
(ret = __dbreg_setup(dbp,
F_ISSET(dbp, DB_AM_INMEM) ? dname : fname, id)) != 0)
return (ret);
if (DBENV_LOGGING(dbenv) && !F_ISSET(dbp, DB_AM_RECOVER) &&
#if !defined(DEBUG_ROP) && !defined(DEBUG_WOP) && !defined(DIAGNOSTIC)
txn != NULL &&
#endif
#if !defined(DEBUG_ROP)
!F_ISSET(dbp, DB_AM_RDONLY) &&
#endif
(ret = __dbreg_new_id(dbp, txn)) != 0)
return (ret);
MUTEX_LOCK(dbenv, dbenv->mtx_dblist);
maxid = 0;
TAILQ_FOREACH(ldbp, &dbenv->dblist, dblistlinks) {
if (!F_ISSET(dbp, DB_AM_INMEM)) {
if (memcmp(ldbp->fileid, dbp->fileid, DB_FILE_ID_LEN)
== 0 && ldbp->meta_pgno == dbp->meta_pgno)
break;
} else if (dname != NULL) {
if (F_ISSET(ldbp, DB_AM_INMEM) &&
ldbp->dname != NULL &&
strcmp(ldbp->dname, dname) == 0)
break;
}
if (ldbp->adj_fileid > maxid)
maxid = ldbp->adj_fileid;
}
if (ldbp == NULL) {
dbp->adj_fileid = maxid + 1;
TAILQ_INSERT_HEAD(&dbenv->dblist, dbp, dblistlinks);
} else {
dbp->adj_fileid = ldbp->adj_fileid;
TAILQ_INSERT_AFTER(&dbenv->dblist, ldbp, dbp, dblistlinks);
}
MUTEX_UNLOCK(dbenv, dbenv->mtx_dblist);
return (0);
}
int
__db_env_mpool(dbp, fname, flags)
DB *dbp;
const char *fname;
u_int32_t flags;
{
DB_ENV *dbenv;
DBT pgcookie;
DB_MPOOLFILE *mpf;
DB_PGINFO pginfo;
int fidset, ftype, ret;
int32_t lsn_off;
u_int8_t nullfid[DB_FILE_ID_LEN];
u_int32_t clear_len;
dbenv = dbp->dbenv;
lsn_off = F_ISSET(dbp, DB_AM_NOT_DURABLE) ? DB_LSN_OFF_NOTSET : 0;
if (F_ISSET(dbp, DB_AM_OPEN_CALLED))
return (0);
switch (dbp->type) {
case DB_BTREE:
case DB_RECNO:
ftype = F_ISSET(dbp, DB_AM_SWAP | DB_AM_ENCRYPT | DB_AM_CHKSUM)
? DB_FTYPE_SET : DB_FTYPE_NOTSET;
clear_len = CRYPTO_ON(dbenv) ?
(dbp->pgsize != 0 ? dbp->pgsize : DB_CLEARLEN_NOTSET) :
DB_PAGE_DB_LEN;
break;
case DB_HASH:
ftype = DB_FTYPE_SET;
clear_len = CRYPTO_ON(dbenv) ?
(dbp->pgsize != 0 ? dbp->pgsize : DB_CLEARLEN_NOTSET) :
DB_PAGE_DB_LEN;
break;
case DB_QUEUE:
ftype = F_ISSET(dbp,
DB_AM_SWAP | DB_AM_ENCRYPT | DB_AM_CHKSUM) ?
DB_FTYPE_SET : DB_FTYPE_NOTSET;
clear_len = dbp->pgsize != 0 ? dbp->pgsize : DB_CLEARLEN_NOTSET;
break;
case DB_UNKNOWN:
if (F_ISSET(dbp, DB_AM_VERIFYING)) {
ftype = DB_FTYPE_NOTSET;
clear_len = DB_PAGE_DB_LEN;
break;
}
if (F_ISSET(dbp, DB_AM_INMEM)) {
clear_len = DB_CLEARLEN_NOTSET;
ftype = DB_FTYPE_NOTSET;
lsn_off = DB_LSN_OFF_NOTSET;
break;
}
default:
return (__db_unknown_type(dbenv, "DB->open", dbp->type));
}
mpf = dbp->mpf;
memset(nullfid, 0, DB_FILE_ID_LEN);
fidset = memcmp(nullfid, dbp->fileid, DB_FILE_ID_LEN);
if (fidset)
(void)__memp_set_fileid(mpf, dbp->fileid);
(void)__memp_set_clear_len(mpf, clear_len);
(void)__memp_set_ftype(mpf, ftype);
(void)__memp_set_lsn_offset(mpf, lsn_off);
pginfo.db_pagesize = dbp->pgsize;
pginfo.flags =
F_ISSET(dbp, (DB_AM_CHKSUM | DB_AM_ENCRYPT | DB_AM_SWAP));
pginfo.type = dbp->type;
pgcookie.data = &pginfo;
pgcookie.size = sizeof(DB_PGINFO);
(void)__memp_set_pgcookie(mpf, &pgcookie);
#ifndef DIAG_MVCC
if (F_ISSET(dbenv, DB_ENV_MULTIVERSION))
#endif
if (F_ISSET(dbp, DB_AM_TXN) &&
dbp->type != DB_QUEUE && dbp->type != DB_UNKNOWN)
LF_SET(DB_MULTIVERSION);
if ((ret = __memp_fopen(mpf, NULL, fname,
LF_ISSET(DB_CREATE | DB_DURABLE_UNKNOWN | DB_MULTIVERSION |
DB_NOMMAP | DB_ODDFILESIZE | DB_RDONLY | DB_TRUNCATE) |
(F_ISSET(dbenv, DB_ENV_DIRECT_DB) ? DB_DIRECT : 0) |
(F_ISSET(dbp, DB_AM_NOT_DURABLE) ? DB_TXN_NOT_DURABLE : 0),
0, dbp->pgsize)) != 0) {
(void)__memp_fclose(dbp->mpf, 0);
(void)__memp_fcreate(dbenv, &dbp->mpf);
if (F_ISSET(dbp, DB_AM_INMEM))
MAKE_INMEM(dbp);
return (ret);
}
F_SET(dbp, DB_AM_OPEN_CALLED);
if (!fidset && fname != NULL) {
(void)__memp_get_fileid(dbp->mpf, dbp->fileid);
dbp->preserve_fid = 1;
}
return (0);
}
int
__db_close(dbp, txn, flags)
DB *dbp;
DB_TXN *txn;
u_int32_t flags;
{
DB_ENV *dbenv;
int db_ref, deferred_close, ret, t_ret;
dbenv = dbp->dbenv;
deferred_close = ret = 0;
if (txn != NULL)
(void)__db_check_txn(dbp, txn, DB_LOCK_INVALIDID, 0);
ret = __db_refresh(dbp, txn, flags, &deferred_close, 0);
if (deferred_close)
return (ret);
MUTEX_LOCK(dbenv, dbenv->mtx_dblist);
db_ref = --dbenv->db_ref;
MUTEX_UNLOCK(dbenv, dbenv->mtx_dblist);
if (F_ISSET(dbenv, DB_ENV_DBLOCAL) && db_ref == 0 &&
(t_ret = __env_close(dbenv, 0)) != 0 && ret == 0)
ret = t_ret;
memset(dbp, CLEAR_BYTE, sizeof(*dbp));
__os_free(dbenv, dbp);
return (ret);
}
int
__db_refresh(dbp, txn, flags, deferred_closep, reuse)
DB *dbp;
DB_TXN *txn;
u_int32_t flags;
int *deferred_closep, reuse;
{
DB *sdbp;
DBC *dbc;
DB_ENV *dbenv;
DB_LOCKREQ lreq;
DB_LOCKER *locker;
REGENV *renv;
REGINFO *infop;
u_int32_t save_flags;
int resync, ret, t_ret;
ret = 0;
dbenv = dbp->dbenv;
infop = dbenv->reginfo;
if (infop != NULL)
renv = infop->primary;
else
renv = NULL;
if (dbp->mpf == NULL)
LF_SET(DB_NOSYNC);
if (!F_ISSET(dbp, DB_AM_OPEN_CALLED))
goto never_opened;
LIST_FOREACH(sdbp, &dbp->s_secondaries, s_links) {
LIST_REMOVE(sdbp, s_links);
if ((t_ret = __db_disassociate(sdbp)) != 0 && ret == 0)
ret = t_ret;
}
if (!LF_ISSET(DB_NOSYNC) &&
!F_ISSET(dbp, DB_AM_DISCARD | DB_AM_RECOVER) &&
(t_ret = __db_sync(dbp)) != 0 && ret == 0)
ret = t_ret;
resync = TAILQ_FIRST(&dbp->active_queue) == NULL ? 0 : 1;
while ((dbc = TAILQ_FIRST(&dbp->active_queue)) != NULL)
if ((t_ret = __dbc_close(dbc)) != 0) {
if (ret == 0)
ret = t_ret;
break;
}
while ((dbc = TAILQ_FIRST(&dbp->free_queue)) != NULL)
if ((t_ret = __dbc_destroy(dbc)) != 0) {
if (ret == 0)
ret = t_ret;
break;
}
while ((dbc = TAILQ_FIRST(&dbp->join_queue)) != NULL)
if ((t_ret = __db_join_close(dbc)) != 0) {
if (ret == 0)
ret = t_ret;
break;
}
if (resync && !LF_ISSET(DB_NOSYNC) &&
!F_ISSET(dbp, DB_AM_DISCARD | DB_AM_RECOVER) &&
(t_ret = __memp_fsync(dbp->mpf)) != 0 && ret == 0)
ret = t_ret;
never_opened:
if (!reuse && LOGGING_ON(dbp->dbenv) && dbp->log_filename != NULL) {
DB_ASSERT(dbenv, renv != NULL);
if (F_ISSET(dbp, DB_AM_RECOVER) || IS_REP_CLIENT(dbenv) ||
dbp->timestamp != renv->rep_timestamp) {
if ((t_ret = __dbreg_revoke_id(dbp,
0, DB_LOGFILEID_INVALID)) == 0 && ret == 0)
ret = t_ret;
if ((t_ret = __dbreg_teardown(dbp)) != 0 && ret == 0)
ret = t_ret;
} else {
if ((t_ret = __dbreg_close_id(dbp,
txn, DBREG_CLOSE)) != 0 && txn != NULL) {
if ((ret =
__txn_closeevent(dbenv, txn, dbp)) != 0)
return (__db_panic(dbenv, ret));
if (deferred_closep != NULL)
*deferred_closep = 1;
return (t_ret);
}
}
}
if (dbp->saved_open_fhp != NULL &&
(t_ret = __os_closehandle(dbenv, dbp->saved_open_fhp)) != 0 &&
ret == 0)
ret = t_ret;
MUTEX_LOCK(dbenv, dbenv->mtx_dblist);
if (!reuse &&
(dbp->dblistlinks.tqe_next != NULL ||
dbp->dblistlinks.tqe_prev != NULL)) {
TAILQ_REMOVE(&dbenv->dblist, dbp, dblistlinks);
dbp->dblistlinks.tqe_next = NULL;
dbp->dblistlinks.tqe_prev = NULL;
}
if (dbp->mpf != NULL) {
if ((t_ret = __memp_fclose(dbp->mpf,
F_ISSET(dbp, DB_AM_DISCARD) ? DB_MPOOL_DISCARD : 0)) != 0 &&
ret == 0)
ret = t_ret;
dbp->mpf = NULL;
if (reuse &&
(t_ret = __memp_fcreate(dbenv, &dbp->mpf)) != 0 &&
ret == 0)
ret = t_ret;
}
MUTEX_UNLOCK(dbenv, dbenv->mtx_dblist);
if ((t_ret = __bam_db_close(dbp)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __ham_db_close(dbp)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __qam_db_close(dbp, dbp->flags)) != 0 && ret == 0)
ret = t_ret;
if (!reuse && dbp->locker != NULL) {
if (txn == NULL)
txn = dbp->cur_txn;
if (IS_REAL_TXN(txn))
__txn_remlock(dbenv,
txn, &dbp->handle_lock, dbp->locker);
lreq.op = DB_LOCK_PUT_ALL;
lreq.obj = NULL;
if ((t_ret = __lock_vec(dbenv,
dbp->locker, 0, &lreq, 1, NULL)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret =
__lock_id_free(dbenv, dbp->locker)) != 0 && ret == 0)
ret = t_ret;
dbp->locker = NULL;
LOCK_INIT(dbp->handle_lock);
}
if (LOCKING_ON(dbenv) &&
F_ISSET(dbp, DB_AM_INMEM) && !dbp->preserve_fid &&
*(u_int32_t *)dbp->fileid != DB_LOCK_INVALIDID) {
if ((t_ret = __lock_getlocker(dbenv->lk_handle,
*(u_int32_t *)dbp->fileid, 0, &locker)) == 0)
t_ret = __lock_id_free(dbenv, locker);
if (ret == 0)
ret = t_ret;
}
if (reuse) {
save_flags = F_ISSET(dbp, DB_AM_INMEM | DB_AM_TXN);
if ((ret = __bam_db_create(dbp)) != 0)
return (ret);
if ((ret = __ham_db_create(dbp)) != 0)
return (ret);
if ((ret = __qam_db_create(dbp)) != 0)
return (ret);
dbp->flags = dbp->orig_flags | save_flags;
if (FLD_ISSET(save_flags, DB_AM_INMEM)) {
memset(dbp->fileid, 0, sizeof(dbp->fileid));
MAKE_INMEM(dbp);
}
return (ret);
}
dbp->type = DB_UNKNOWN;
if ((t_ret = __mutex_free(dbenv, &dbp->mutex)) != 0 && ret == 0)
ret = t_ret;
if (dbp->fname != NULL) {
__os_free(dbp->dbenv, dbp->fname);
dbp->fname = NULL;
}
if (dbp->dname != NULL) {
__os_free(dbp->dbenv, dbp->dname);
dbp->dname = NULL;
}
if (dbp->my_rskey.data != NULL)
__os_free(dbp->dbenv, dbp->my_rskey.data);
if (dbp->my_rkey.data != NULL)
__os_free(dbp->dbenv, dbp->my_rkey.data);
if (dbp->my_rdata.data != NULL)
__os_free(dbp->dbenv, dbp->my_rdata.data);
memset(&dbp->my_rskey, 0, sizeof(DBT));
memset(&dbp->my_rkey, 0, sizeof(DBT));
memset(&dbp->my_rdata, 0, sizeof(DBT));
memset(dbp->fileid, 0, sizeof(dbp->fileid));
dbp->adj_fileid = 0;
dbp->meta_pgno = 0;
dbp->cur_locker = NULL;
dbp->cur_txn = NULL;
dbp->associate_locker = NULL;
dbp->cl_id = 0;
dbp->open_flags = 0;
if (txn != NULL)
LOCK_INIT(dbp->handle_lock);
dbp->flags = dbp->orig_flags;
return (ret);
}
static int
__db_disassociate(sdbp)
DB *sdbp;
{
DBC *dbc;
int ret, t_ret;
ret = 0;
sdbp->s_callback = NULL;
sdbp->s_primary = NULL;
sdbp->get = sdbp->stored_get;
sdbp->close = sdbp->stored_close;
if (sdbp->s_refcnt != 1 ||
TAILQ_FIRST(&sdbp->active_queue) != NULL ||
TAILQ_FIRST(&sdbp->join_queue) != NULL) {
__db_errx(sdbp->dbenv,
"Closing a primary DB while a secondary DB has active cursors is unsafe");
ret = EINVAL;
}
sdbp->s_refcnt = 0;
while ((dbc = TAILQ_FIRST(&sdbp->free_queue)) != NULL)
if ((t_ret = __dbc_destroy(dbc)) != 0 && ret == 0)
ret = t_ret;
F_CLR(sdbp, DB_AM_SECONDARY);
return (ret);
}
int
__db_log_page(dbp, txn, lsn, pgno, page)
DB *dbp;
DB_TXN *txn;
DB_LSN *lsn;
db_pgno_t pgno;
PAGE *page;
{
DBT page_dbt;
DB_LSN new_lsn;
int ret;
if (!LOGGING_ON(dbp->dbenv) || txn == NULL)
return (0);
memset(&page_dbt, 0, sizeof(page_dbt));
page_dbt.size = dbp->pgsize;
page_dbt.data = page;
ret = __crdel_metasub_log(dbp, txn, &new_lsn, 0, pgno, &page_dbt, lsn);
if (ret == 0)
page->lsn = new_lsn;
return (ret);
}
#undef BACKUP_PREFIX
#define BACKUP_PREFIX "__db."
#undef MAX_INT_TO_HEX
#define MAX_INT_TO_HEX 8
int
__db_backup_name(dbenv, name, txn, backup)
DB_ENV *dbenv;
const char *name;
DB_TXN *txn;
char **backup;
{
u_int32_t id;
size_t len;
int ret;
char *p, *retp;
*backup = NULL;
len = strlen(name) + strlen(BACKUP_PREFIX) + 2 * MAX_INT_TO_HEX + 1;
if ((ret = __os_malloc(dbenv, len, &retp)) != 0)
return (ret);
p = __db_rpath(name);
if (IS_REAL_TXN(txn)) {
__os_unique_id(dbenv, &id);
if (p == NULL)
snprintf(retp, len, "%s%x.%x",
BACKUP_PREFIX, txn->txnid, id);
else
snprintf(retp, len, "%.*s%x.%x",
(int)(p - name) + 1, name, txn->txnid, id);
} else {
if (p == NULL)
snprintf(retp, len, "%s%s", BACKUP_PREFIX, name);
else
snprintf(retp, len, "%.*s%s%s",
(int)(p - name) + 1, name, BACKUP_PREFIX, p + 1);
}
*backup = retp;
return (0);
}
#ifdef CONFIG_TEST
int
__db_testcopy(dbenv, dbp, name)
DB_ENV *dbenv;
DB *dbp;
const char *name;
{
DB_MPOOL *dbmp;
DB_MPOOLFILE *mpf;
DB_ASSERT(dbenv, dbp != NULL || name != NULL);
if (name == NULL) {
dbmp = dbenv->mp_handle;
mpf = dbp->mpf;
name = R_ADDR(dbmp->reginfo, mpf->mfp->path_off);
}
if (dbp != NULL && dbp->type == DB_QUEUE)
return (__qam_testdocopy(dbp, name));
else
return (__db_testdocopy(dbenv, name));
}
static int
__qam_testdocopy(dbp, name)
DB *dbp;
const char *name;
{
QUEUE_FILELIST *filelist, *fp;
int ret;
char buf[DB_MAXPATHLEN], *dir;
filelist = NULL;
if ((ret = __db_testdocopy(dbp->dbenv, name)) != 0)
return (ret);
if (dbp->mpf != NULL &&
(ret = __qam_gen_filelist(dbp, &filelist)) != 0)
return (ret);
if (filelist == NULL)
return (0);
dir = ((QUEUE *)dbp->q_internal)->dir;
for (fp = filelist; fp->mpf != NULL; fp++) {
snprintf(buf, sizeof(buf),
QUEUE_EXTENT, dir, PATH_SEPARATOR[0], name, fp->id);
if ((ret = __db_testdocopy(dbp->dbenv, buf)) != 0)
return (ret);
}
__os_free(dbp->dbenv, filelist);
return (0);
}
static int
__db_testdocopy(dbenv, name)
DB_ENV *dbenv;
const char *name;
{
size_t len;
int dircnt, i, ret;
char *copy, **namesp, *p, *real_name;
dircnt = 0;
copy = NULL;
namesp = NULL;
if ((ret = __db_appname(dbenv,
DB_APP_DATA, name, 0, NULL, &real_name)) != 0)
return (ret);
if (__os_exists(dbenv, real_name, NULL) != 0) {
__os_free(dbenv, real_name);
return (0);
}
len = strlen(real_name) + sizeof(".afterop");
if ((ret = __os_malloc(dbenv, len, ©)) != 0)
goto err;
snprintf(copy, len, "%s.afterop", real_name);
if ((ret = __db_makecopy(dbenv, real_name, copy)) != 0)
goto err;
if ((p = __db_rpath(real_name)) != NULL)
*p = '\0';
if ((ret = __os_dirlist(dbenv, real_name, &namesp, &dircnt)) != 0)
goto err;
for (i = 0; i < dircnt; i++) {
if (strncmp(
namesp[i], BACKUP_PREFIX, sizeof(BACKUP_PREFIX) - 1) != 0)
continue;
p = namesp[i] + sizeof(BACKUP_PREFIX);
p += strspn(p, "0123456789ABCDEFabcdef");
if (*p != '.')
continue;
++p;
p += strspn(p, "0123456789ABCDEFabcdef");
if (*p != '\0')
continue;
if (real_name != NULL) {
__os_free(dbenv, real_name);
real_name = NULL;
}
if ((ret = __db_appname(
dbenv, DB_APP_DATA, namesp[i], 0, NULL, &real_name)) != 0)
goto err;
if (copy != NULL) {
__os_free(dbenv, copy);
copy = NULL;
}
len = strlen(real_name) + sizeof(".afterop");
if ((ret = __os_malloc(dbenv, len, ©)) != 0)
goto err;
snprintf(copy, len, "%s.afterop", real_name);
if ((ret = __db_makecopy(dbenv, real_name, copy)) != 0)
goto err;
}
err: if (namesp != NULL)
__os_dirfree(dbenv, namesp, dircnt);
if (copy != NULL)
__os_free(dbenv, copy);
if (real_name != NULL)
__os_free(dbenv, real_name);
return (ret);
}
static int
__db_makecopy(dbenv, src, dest)
DB_ENV *dbenv;
const char *src, *dest;
{
DB_FH *rfhp, *wfhp;
size_t rcnt, wcnt;
int ret;
char *buf;
rfhp = wfhp = NULL;
if ((ret = __os_malloc(dbenv, 64 * 1024, &buf)) != 0)
goto err;
if ((ret = __os_open(dbenv, src, 0,
DB_OSO_RDONLY, __db_omode(OWNER_RW), &rfhp)) != 0)
goto err;
if ((ret = __os_open(dbenv, dest, 0,
DB_OSO_CREATE | DB_OSO_TRUNC, __db_omode(OWNER_RW), &wfhp)) != 0)
goto err;
for (;;) {
if ((ret =
__os_read(dbenv, rfhp, buf, sizeof(buf), &rcnt)) != 0)
goto err;
if (rcnt == 0)
break;
if ((ret =
__os_write(dbenv, wfhp, buf, sizeof(buf), &wcnt)) != 0)
goto err;
}
if (0) {
err: __db_err(dbenv, ret, "__db_makecopy: %s -> %s", src, dest);
}
if (buf != NULL)
__os_free(dbenv, buf);
if (rfhp != NULL)
(void)__os_closehandle(dbenv, rfhp);
if (wfhp != NULL)
(void)__os_closehandle(dbenv, wfhp);
return (ret);
}
#endif