#include "db_config.h"
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_am.h"
#include "dbinc/hash.h"
#include "dbinc/fop.h"
#include "dbinc/lock.h"
#include "dbinc/mp.h"
#include "dbinc/log.h"
#include "dbinc/txn.h"
static int __fop_set_pgsize __P((DB *, DB_FH *, const char *));
static int __fop_inmem_create __P((DB *, const char *, DB_TXN *, u_int32_t));
static int __fop_inmem_dummy __P((DB *, DB_TXN *, const char *, u_int8_t *));
static int __fop_inmem_read_meta __P((DB *, DB_TXN *, const char *, u_int32_t));
static int __fop_inmem_swap __P((DB *, DB *, DB_TXN *,
const char *, const char *, const char *, DB_LOCKER *));
static int __fop_ondisk_dummy __P((DB *,
DB_TXN *, const char *, u_int8_t *, u_int32_t));
static int __fop_ondisk_swap __P((DB *, DB *, DB_TXN *,
const char *, const char *, const char *, DB_LOCKER *, u_int32_t));
#ifdef CRITICALPATH_10266
#define GET_ENVLOCK(ENV, ID, L) (0)
#else
#define GET_ENVLOCK(ENV, ID, L) do { \
DBT __dbt; \
u_int32_t __lockval; \
\
if (LOCKING_ON((ENV))) { \
__lockval = 1; \
__dbt.data = &__lockval; \
__dbt.size = sizeof(__lockval); \
if ((ret = __lock_get((ENV), (ID), \
0, &__dbt, DB_LOCK_WRITE, (L))) != 0) \
goto err; \
} \
} while (0)
#endif
#define RESET_MPF(D, F) do { \
(void)__memp_fclose((D)->mpf, (F)); \
(D)->mpf = NULL; \
F_CLR((D), DB_AM_OPEN_CALLED); \
if ((ret = __memp_fcreate((D)->dbenv, &(D)->mpf)) != 0) \
goto err; \
} while (0)
#define CLOSE_HANDLE(D, F) { \
if ((F) != NULL) { \
if (LF_ISSET(DB_FCNTL_LOCKING)) \
(D)->saved_open_fhp = (F); \
else if ((t_ret = \
__os_closehandle((D)->dbenv, (F))) != 0) { \
if (ret == 0) \
ret = t_ret; \
goto err; \
} \
(F) = NULL; \
} \
}
int
__fop_lock_handle(dbenv, dbp, locker, mode, elockp, flags)
DB_ENV *dbenv;
DB *dbp;
DB_LOCKER *locker;
db_lockmode_t mode;
DB_LOCK *elockp;
u_int32_t flags;
{
DBT fileobj;
DB_LOCKREQ reqs[2], *ereq;
DB_LOCK_ILOCK lock_desc;
int ret;
if (!LOCKING_ON(dbenv) ||
F_ISSET(dbp, DB_AM_COMPENSATE | DB_AM_RECOVER))
return (0);
if (IS_RECOVERING(dbenv))
return (elockp == NULL ? 0 : __ENV_LPUT(dbenv, *elockp));
memcpy(lock_desc.fileid, dbp->fileid, DB_FILE_ID_LEN);
lock_desc.pgno = dbp->meta_pgno;
lock_desc.type = DB_HANDLE_LOCK;
memset(&fileobj, 0, sizeof(fileobj));
fileobj.data = &lock_desc;
fileobj.size = sizeof(lock_desc);
DB_TEST_SUBLOCKS(dbenv, flags);
if (elockp == NULL)
ret = __lock_get(dbenv, locker,
flags, &fileobj, mode, &dbp->handle_lock);
else {
reqs[0].op = DB_LOCK_PUT;
reqs[0].lock = *elockp;
reqs[1].op = DB_LOCK_GET;
reqs[1].mode = mode;
reqs[1].obj = &fileobj;
reqs[1].timeout = 0;
if ((ret = __lock_vec(dbenv,
locker, flags, reqs, 2, &ereq)) == 0) {
dbp->handle_lock = reqs[1].lock;
LOCK_INIT(*elockp);
} else if (ereq != reqs)
LOCK_INIT(*elockp);
}
dbp->cur_locker = locker;
return (ret);
}
int
__fop_file_setup(dbp, txn, name, mode, flags, retidp)
DB *dbp;
DB_TXN *txn;
const char *name;
int mode;
u_int32_t flags, *retidp;
{
DB_ENV *dbenv;
DB_FH *fhp;
DB_LOCK elock;
DB_LOCKER *locker;
DB_TXN *stxn;
DBTYPE save_type;
size_t len;
u_int32_t dflags, oflags;
u_int8_t mbuf[DBMETASIZE];
int created_locker, create_ok, ret, retries, t_ret, tmp_created;
int truncating, was_inval;
char *real_name, *real_tmpname, *tmpname;
*retidp = TXN_INVALID;
dbenv = dbp->dbenv;
fhp = NULL;
LOCK_INIT(elock);
stxn = NULL;
created_locker = tmp_created = truncating = was_inval = 0;
real_name = real_tmpname = tmpname = NULL;
dflags = F_ISSET(dbp, DB_AM_NOT_DURABLE) ? DB_LOG_NOT_DURABLE : 0;
ret = 0;
retries = 0;
save_type = dbp->type;
if (LOCKING_ON(dbenv) &&
!F_ISSET(dbp, DB_AM_COMPENSATE) &&
!F_ISSET(dbp, DB_AM_RECOVER) &&
dbp->locker == DB_LOCK_INVALIDID) {
if ((ret = __lock_id(dbenv, NULL, &dbp->locker)) != 0)
goto err;
created_locker = 1;
}
LOCK_INIT(dbp->handle_lock);
locker = txn == NULL ? dbp->locker : txn->locker;
oflags = 0;
if (F_ISSET(dbp, DB_AM_INMEM))
real_name = (char *)name;
else {
if ((ret = __db_appname(dbenv,
DB_APP_DATA, name, 0, NULL, &real_name)) != 0)
goto err;
if (mode == 0)
mode = __db_omode("rw-rw----");
if (LF_ISSET(DB_RDONLY))
oflags |= DB_OSO_RDONLY;
if (LF_ISSET(DB_TRUNCATE))
oflags |= DB_OSO_TRUNC;
}
retries = 0;
create_ok = LF_ISSET(DB_CREATE);
LF_CLR(DB_CREATE);
retry:
if (++retries > DB_RETRY) {
__db_errx(dbenv, "__fop_file_setup: Retry limit (%d) exceeded",
DB_RETRY);
goto err;
}
if (!F_ISSET(dbp, DB_AM_COMPENSATE) && !F_ISSET(dbp, DB_AM_RECOVER))
GET_ENVLOCK(dbenv, locker, &elock);
if (name == NULL)
ret = ENOENT;
else if (F_ISSET(dbp, DB_AM_INMEM)) {
ret = __db_env_mpool(dbp, name, flags);
if (ret == EINVAL) {
was_inval = 1;
save_type = dbp->type;
dbp->type = DB_UNKNOWN;
ret = __db_env_mpool(dbp, name, flags);
dbp->type = save_type;
}
} else
ret = __os_exists(dbenv, real_name, NULL);
if (ret == 0) {
reopen: if (!F_ISSET(dbp, DB_AM_INMEM) && (ret =
__os_open(dbenv, real_name, 0, oflags, 0, &fhp)) != 0)
goto err;
if (LF_ISSET(DB_TRUNCATE)) {
if (LF_ISSET(DB_EXCL)) {
ret = EEXIST;
goto err;
}
tmpname = (char *)name;
goto creat2;
}
if (F_ISSET(dbp, DB_AM_INMEM))
ret = __fop_inmem_read_meta(dbp, txn, name, flags);
else {
ret = __fop_read_meta(dbenv, real_name, mbuf,
sizeof(mbuf), fhp,
LF_ISSET(DB_FCNTL_LOCKING) && txn == NULL ? 1 : 0,
&len);
if (ret != 0 && len == 0 && txn == NULL) {
if (LF_ISSET(DB_EXCL)) {
ret = EEXIST;
goto err;
}
tmpname = (char *)name;
goto creat2;
}
if (ret == 0)
ret = __db_meta_setup(dbenv, dbp,
real_name, (DBMETA *)mbuf, flags, 1);
}
if (ret != 0)
goto err;
if ((ret = __fop_lock_handle(dbenv,
dbp, locker, DB_LOCK_READ, NULL, DB_LOCK_NOWAIT)) == 0) {
if ((ret = __ENV_LPUT(dbenv, elock)) != 0)
goto err;
} else if (ret != DB_LOCK_NOTGRANTED ||
(txn != NULL && F_ISSET(txn, TXN_NOWAIT)))
goto err;
else {
DB_ASSERT(dbenv, !LF_ISSET(DB_FCNTL_LOCKING));
if (!F_ISSET(dbp, DB_AM_INMEM)) {
if ((ret = __os_closehandle(dbenv, fhp)) != 0)
goto err;
fhp = NULL;
}
if ((ret = __fop_lock_handle(dbenv,
dbp, locker, DB_LOCK_READ, &elock, 0)) != 0) {
if (F_ISSET(dbp, DB_AM_INMEM))
RESET_MPF(dbp, 0);
goto err;
}
if (F_ISSET(dbp, DB_AM_INMEM)) {
if ((ret = __db_refresh(dbp,
txn, DB_NOSYNC, NULL, 1)) != 0)
goto err;
ret = __db_env_mpool(dbp, name, flags);
} else
ret =
__os_open(dbenv, real_name, 0, 0, 0, &fhp);
if (ret != 0) {
if ((ret =
__ENV_LPUT(dbenv, dbp->handle_lock)) != 0) {
LOCK_INIT(dbp->handle_lock);
goto err;
}
goto retry;
}
dbp->type = save_type;
if (F_ISSET(dbp, DB_AM_INMEM))
ret = __fop_inmem_read_meta(dbp,
txn, name, flags);
else if ((ret =
__fop_read_meta(dbenv, real_name, mbuf,
sizeof(mbuf), fhp,
LF_ISSET(DB_FCNTL_LOCKING) && txn == NULL ? 1 : 0,
&len)) != 0 ||
(ret = __db_meta_setup(dbenv, dbp, real_name,
(DBMETA *)mbuf, flags, DB_CHK_META)) != 0)
goto err;
}
if (F_ISSET(dbp, DB_AM_IN_RENAME)) {
was_inval = 0;
if (create_ok) {
if (F_ISSET(dbp, DB_AM_INMEM)) {
RESET_MPF(dbp, DB_MPOOL_DISCARD);
} else if ((ret =
__os_closehandle(dbenv, fhp)) != 0)
goto err;
LF_SET(DB_CREATE);
goto create;
} else {
ret = ENOENT;
goto err;
}
}
if (was_inval) {
ret = EINVAL;
goto err;
}
if (LF_ISSET(DB_EXCL)) {
ret = __ENV_LPUT(dbenv, dbp->handle_lock);
LOCK_INIT(dbp->handle_lock);
if (ret == 0)
ret = EEXIST;
goto err;
}
goto done;
}
#ifdef HAVE_VXWORKS
if (!create_ok)
#else
if (!create_ok || ret != ENOENT)
#endif
goto err;
LF_SET(DB_CREATE);
ret = 0;
if (!F_ISSET(dbp, DB_AM_INMEM) &&
(ret = __ENV_LPUT(dbenv, elock)) != 0)
goto err;
create: if (txn != NULL && IS_REP_CLIENT(dbenv) &&
!F_ISSET(dbp, DB_AM_NOT_DURABLE)) {
__db_errx(dbenv,
"Transactional create on replication client disallowed");
ret = EINVAL;
goto err;
}
if (F_ISSET(dbp, DB_AM_INMEM))
ret = __fop_inmem_create(dbp, name, txn, flags);
else {
if ((ret = __db_backup_name(dbenv, name, txn, &tmpname)) != 0)
goto err;
if (TXN_ON(dbenv) && txn != NULL &&
(ret = __txn_begin(dbenv, txn, &stxn, 0)) != 0)
goto err;
if ((ret = __fop_create(dbenv,
stxn, &fhp, tmpname, DB_APP_DATA, mode, dflags)) != 0) {
if (!TXN_ON(dbenv) && ret == EEXIST) {
__os_free(dbenv, tmpname);
tmpname = NULL;
__os_sleep(dbenv, 1, 0);
goto retry;
}
goto err;
}
tmp_created = 1;
}
creat2: if (!F_ISSET(dbp, DB_AM_INMEM)) {
if ((ret = __db_appname(dbenv,
DB_APP_DATA, tmpname, 0, NULL, &real_tmpname)) != 0)
goto err;
if (dbp->pgsize == 0 &&
(ret = __fop_set_pgsize(dbp, fhp, real_tmpname)) != 0)
goto errmsg;
if ((ret =
__os_fileid(dbenv, real_tmpname, 1, dbp->fileid)) != 0)
goto errmsg;
}
if ((ret = __db_new_file(dbp,
F_ISSET(dbp, DB_AM_INMEM) ? txn : stxn, fhp, tmpname)) != 0)
goto err;
CLOSE_HANDLE(dbp, fhp);
if (!F_ISSET(dbp, DB_AM_COMPENSATE) &&
!F_ISSET(dbp, DB_AM_RECOVER) && !LOCK_ISSET(elock))
GET_ENVLOCK(dbenv, locker, &elock);
if (F_ISSET(dbp, DB_AM_IN_RENAME)) {
F_CLR(dbp, DB_AM_IN_RENAME);
__txn_remrem(dbenv, txn, real_name);
} else if (name == tmpname) {
} else if (!F_ISSET(dbp, DB_AM_INMEM) &&
__os_exists(dbenv, real_name, NULL) == 0) {
(void)__fop_remove(dbenv,
NULL, dbp->fileid, tmpname, DB_APP_DATA, dflags);
(void)__ENV_LPUT(dbenv, dbp->handle_lock);
LOCK_INIT(dbp->handle_lock);
if (stxn != NULL) {
ret = __txn_abort(stxn);
stxn = NULL;
}
if (ret != 0)
goto err;
goto reopen;
}
if (name != NULL && (ret = __fop_lock_handle(dbenv,
dbp, locker, DB_LOCK_WRITE, &elock, NOWAIT_FLAG(txn))) != 0)
goto err;
if (tmpname != NULL && tmpname != name && (ret = __fop_rename(dbenv,
stxn, tmpname, name, dbp->fileid, DB_APP_DATA, 1, dflags)) != 0)
goto err;
if (stxn != NULL) {
*retidp = stxn->txnid;
ret = __txn_commit(stxn, 0);
stxn = NULL;
} else
*retidp = TXN_INVALID;
if (ret != 0)
goto err;
F_SET(dbp, DB_AM_CREATED);
if (0) {
errmsg: __db_err(dbenv, ret, "%s", name);
err: CLOSE_HANDLE(dbp, fhp);
if (stxn != NULL)
(void)__txn_abort(stxn);
if (tmp_created && txn == NULL)
(void)__fop_remove(dbenv,
NULL, NULL, tmpname, DB_APP_DATA, dflags);
if (txn == NULL)
(void)__ENV_LPUT(dbenv, dbp->handle_lock);
(void)__ENV_LPUT(dbenv, elock);
if (created_locker) {
(void)__lock_id_free(dbenv, dbp->locker);
dbp->locker = NULL;
}
}
done:
if (!truncating && tmpname != NULL && tmpname != name)
__os_free(dbenv, tmpname);
if (real_name != name && real_name != NULL)
__os_free(dbenv, real_name);
if (real_tmpname != NULL)
__os_free(dbenv, real_tmpname);
CLOSE_HANDLE(dbp, fhp);
return (ret);
}
static int
__fop_set_pgsize(dbp, fhp, name)
DB *dbp;
DB_FH *fhp;
const char *name;
{
DB_ENV *dbenv;
u_int32_t iopsize;
int ret;
dbenv = dbp->dbenv;
if ((ret = __os_ioinfo(dbenv, name, fhp, NULL, NULL, &iopsize)) != 0) {
__db_err(dbenv, ret, "%s", name);
return (ret);
}
if (iopsize < 512)
iopsize = 512;
if (iopsize > 16 * 1024)
iopsize = 16 * 1024;
if (!IS_VALID_PAGESIZE(iopsize))
iopsize = DB_DEF_IOSIZE;
dbp->pgsize = iopsize;
F_SET(dbp, DB_AM_PGDEF);
return (0);
}
int
__fop_subdb_setup(dbp, txn, mname, name, mode, flags)
DB *dbp;
DB_TXN *txn;
const char *mname, *name;
int mode;
u_int32_t flags;
{
DB *mdbp;
DB_ENV *dbenv;
db_lockmode_t lkmode;
int ret, t_ret;
mdbp = NULL;
dbenv = dbp->dbenv;
if ((ret = __db_master_open(dbp, txn, mname, flags, mode, &mdbp)) != 0)
return (ret);
if (F_ISSET(mdbp, DB_AM_CREATED))
F_SET(mdbp, DB_AM_DISCARD);
if (LF_ISSET(DB_FCNTL_LOCKING)) {
dbp->saved_open_fhp = mdbp->saved_open_fhp;
mdbp->saved_open_fhp = NULL;
}
dbp->pgsize = mdbp->pgsize;
F_SET(dbp, DB_AM_SUBDB);
if (name != NULL && (ret = __db_master_update(mdbp, dbp, txn,
name, dbp->type, MU_OPEN, NULL, flags)) != 0)
goto err;
dbp->locker = mdbp->locker;
mdbp->locker = NULL;
DB_TEST_RECOVERY(dbp, DB_TEST_POSTLOG, ret, mname);
memcpy(dbp->fileid, mdbp->fileid, DB_FILE_ID_LEN);
lkmode = F_ISSET(dbp, DB_AM_CREATED) || LF_ISSET(DB_WRITEOPEN) ?
DB_LOCK_WRITE : DB_LOCK_READ;
if ((ret = __fop_lock_handle(dbenv, dbp,
txn == NULL ? dbp->locker : txn->locker, lkmode, NULL,
NOWAIT_FLAG(txn))) != 0)
goto err;
if ((ret = __db_init_subdb(mdbp, dbp, name, txn)) != 0) {
if (F_ISSET(dbp, DB_AM_CREATED) && txn == NULL)
(void)__db_master_update(mdbp, dbp, txn,
name, dbp->type, MU_REMOVE, NULL, 0);
F_CLR(dbp, DB_AM_CREATED);
goto err;
}
F_CLR(dbp, DB_AM_SWAP);
F_SET(dbp, F_ISSET(mdbp, DB_AM_SWAP));
DB_TEST_RECOVERY(dbp, DB_TEST_POSTLOGMETA, ret, mname);
DB_TEST_RECOVERY(dbp, DB_TEST_POSTSYNC, ret, mname);
if (F_ISSET(mdbp, DB_AM_CREATED)) {
F_SET(dbp, DB_AM_CREATED_MSTR);
F_CLR(mdbp, DB_AM_DISCARD);
}
if (0) {
err:
DB_TEST_RECOVERY_LABEL
if (txn == NULL)
(void)__ENV_LPUT(dbenv, dbp->handle_lock);
}
if (!F_ISSET(dbp, DB_AM_RECOVER) && IS_REAL_TXN(txn)) {
__txn_remlock(dbenv,
txn, &mdbp->handle_lock, DB_LOCK_INVALIDID);
if ((t_ret = __txn_lockevent(dbenv, txn, dbp,
&mdbp->handle_lock, dbp->locker == NULL ?
mdbp->locker : dbp->locker)) != 0 && ret == 0)
ret = t_ret;
}
LOCK_INIT(mdbp->handle_lock);
if (txn == NULL || F_ISSET(txn, TXN_CDSGROUP) ||
F_ISSET(mdbp, DB_AM_RECOVER)) {
if ((t_ret = __db_close(mdbp, txn,
F_ISSET(dbp, DB_AM_CREATED_MSTR) ? 0 : DB_NOSYNC)) != 0 &&
ret == 0)
ret = t_ret;
} else {
if (F_ISSET(dbp, DB_AM_CREATED_MSTR) &&
(t_ret = __memp_fsync(mdbp->mpf)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret =
__txn_closeevent(dbenv, txn, mdbp)) != 0 && ret == 0)
ret = t_ret;
}
return (ret);
}
int
__fop_remove_setup(dbp, txn, name, flags)
DB *dbp;
DB_TXN *txn;
const char *name;
u_int32_t flags;
{
DB_ENV *dbenv;
DB_FH *fhp;
DB_LOCK elock;
u_int8_t mbuf[DBMETASIZE];
int ret;
COMPQUIET(flags, 0);
dbenv = dbp->dbenv;
PANIC_CHECK(dbenv);
LOCK_INIT(elock);
fhp = NULL;
ret = 0;
retry: if (LOCKING_ON(dbenv)) {
if (txn != NULL)
dbp->locker = txn->locker;
else if (dbp->locker == DB_LOCK_INVALIDID) {
if ((ret = __lock_id(dbenv, NULL, &dbp->locker)) != 0)
goto err;
}
}
fhp = dbp->saved_open_fhp;
DB_ASSERT(dbenv, LF_ISSET(DB_FCNTL_LOCKING) || fhp == NULL);
GET_ENVLOCK(dbenv, dbp->locker, &elock);
if (F_ISSET(dbp, DB_AM_INMEM)) {
if ((ret = __db_env_mpool(dbp, name, flags)) == 0)
ret = __os_strdup(dbenv, name, &dbp->dname);
} else if (fhp == NULL)
ret = __os_open(dbenv, name, 0, DB_OSO_RDONLY, 0, &fhp);
if (ret != 0)
goto err;
if (F_ISSET(dbp, DB_AM_INMEM))
ret = __fop_inmem_read_meta(dbp, txn, name, flags);
else if ((ret = __fop_read_meta(dbenv,
name, mbuf, sizeof(mbuf), fhp, 0, NULL)) == 0)
ret = __db_meta_setup(dbenv, dbp,
name, (DBMETA *)mbuf, flags, DB_CHK_META | DB_CHK_NOLSN);
if (ret != 0)
goto err;
if ((ret = __fop_lock_handle(dbenv,
dbp, dbp->locker, DB_LOCK_WRITE, NULL, DB_LOCK_NOWAIT)) != 0) {
if (!F_ISSET(dbp, DB_AM_INMEM) && !LF_ISSET(DB_FCNTL_LOCKING)) {
(void)__os_closehandle(dbenv, fhp);
fhp = NULL;
}
if (ret != DB_LOCK_NOTGRANTED ||
(txn != NULL && F_ISSET(txn, TXN_NOWAIT)))
goto err;
else if ((ret = __fop_lock_handle(dbenv,
dbp, dbp->locker, DB_LOCK_WRITE, &elock, 0)) != 0)
goto err;
if (F_ISSET(dbp, DB_AM_INMEM)) {
(void)__lock_put(dbenv, &dbp->handle_lock);
(void)__db_refresh(dbp, txn, DB_NOSYNC, NULL, 1);
} else {
if (txn != NULL)
dbp->locker = NULL;
(void)__db_refresh(dbp, txn, DB_NOSYNC, NULL, 0);
}
goto retry;
} else if ((ret = __ENV_LPUT(dbenv, elock)) != 0)
goto err;
else if (F_ISSET(dbp, DB_AM_IN_RENAME))
ret = ENOENT;
if (0) {
err: (void)__ENV_LPUT(dbenv, elock);
}
if (fhp != NULL && !LF_ISSET(DB_FCNTL_LOCKING))
(void)__os_closehandle(dbenv, fhp);
if (ret == 0 && !F_ISSET(dbp, DB_AM_INMEM))
F_SET(dbp, DB_AM_DISCARD);
return (ret);
}
int
__fop_read_meta(dbenv, name, buf, size, fhp, errok, nbytesp)
DB_ENV *dbenv;
const char *name;
u_int8_t *buf;
size_t size;
DB_FH *fhp;
int errok;
size_t *nbytesp;
{
size_t nr;
int ret;
if (nbytesp != NULL)
*nbytesp = 0;
nr = 0;
ret = __os_read(dbenv, fhp, buf, size, &nr);
if (nbytesp != NULL)
*nbytesp = nr;
if (ret != 0) {
if (!errok)
__db_err(dbenv, ret, "%s", name);
goto err;
}
if (nr != size) {
if (!errok)
__db_errx(dbenv,
"%s: unexpected file type or format", name);
ret = EINVAL;
}
err:
return (ret);
}
int
__fop_dummy(dbp, txn, old, new, flags)
DB *dbp;
DB_TXN *txn;
const char *old, *new;
u_int32_t flags;
{
DB *tmpdbp;
DB_ENV *dbenv;
DB_TXN *stxn;
char *back;
int ret, t_ret;
u_int8_t mbuf[DBMETASIZE];
dbenv = dbp->dbenv;
back = NULL;
stxn = NULL;
tmpdbp = NULL;
DB_ASSERT(dbenv, txn != NULL);
if (TXN_ON(dbenv) && (ret = __txn_begin(dbenv, txn, &stxn, 0)) != 0)
goto err;
if ((ret = __db_backup_name(dbenv, new, stxn, &back)) != 0)
goto err;
if ((ret = __db_create_internal(&tmpdbp, dbenv, 0)) != 0)
goto err;
memset(mbuf, 0, sizeof(mbuf));
ret = F_ISSET(dbp, DB_AM_INMEM) ?
__fop_inmem_dummy(tmpdbp, stxn, back, mbuf) :
__fop_ondisk_dummy(tmpdbp, stxn, back, mbuf, flags);
if (ret != 0)
goto err;
ret = F_ISSET(dbp, DB_AM_INMEM) ?
__fop_inmem_swap(dbp, tmpdbp, stxn, old, new, back, txn->locker) :
__fop_ondisk_swap(dbp,
tmpdbp, stxn, old, new, back, txn->locker, flags);
stxn = NULL;
if (ret != 0)
goto err;
err: if (stxn != NULL)
(void)__txn_abort(stxn);
if (tmpdbp != NULL &&
(t_ret = __db_close(tmpdbp, NULL, 0)) != 0 && ret == 0)
ret = t_ret;
if (back != NULL)
__os_free(dbenv, back);
return (ret);
}
int
__fop_dbrename(dbp, old, new)
DB *dbp;
const char *old, *new;
{
DB_ENV *dbenv;
DB_LOCK elock;
char *real_new, *real_old;
int ret, t_ret;
dbenv = dbp->dbenv;
real_new = NULL;
real_old = NULL;
LOCK_INIT(elock);
if (F_ISSET(dbp, DB_AM_INMEM)) {
real_new = (char *)new;
real_old = (char *)old;
} else {
if ((ret = __db_appname(dbenv,
DB_APP_DATA, new, 0, NULL, &real_new)) != 0)
goto err;
if ((ret = __db_appname(dbenv,
DB_APP_DATA, old, 0, NULL, &real_old)) != 0)
goto err;
}
GET_ENVLOCK(dbenv, dbp->locker, &elock);
ret = F_ISSET(dbp, DB_AM_INMEM) ? ENOENT :
__os_exists(dbenv, real_new, NULL);
if (ret == 0) {
ret = EEXIST;
__db_errx(dbenv, "rename: file %s exists", real_new);
goto err;
}
ret = __memp_nameop(dbenv,
dbp->fileid, new, real_old, real_new, F_ISSET(dbp, DB_AM_INMEM));
err: if ((t_ret = __ENV_LPUT(dbenv, elock)) != 0 && ret == 0)
ret = t_ret;
if (!F_ISSET(dbp, DB_AM_INMEM) && real_old != NULL)
__os_free(dbenv, real_old);
if (!F_ISSET(dbp, DB_AM_INMEM) && real_new != NULL)
__os_free(dbenv, real_new);
return (ret);
}
static int
__fop_inmem_create(dbp, name, txn, flags)
DB *dbp;
const char *name;
DB_TXN *txn;
u_int32_t flags;
{
DB_ENV *dbenv;
DB_LSN lsn;
DBT fid_dbt, name_dbt;
int ret;
int32_t lfid;
u_int32_t *p32;
dbenv = dbp->dbenv;
MAKE_INMEM(dbp);
if (dbp->pgsize == 0)
dbp->pgsize = DB_DEF_IOSIZE;
if (name == NULL) {
if (LOCKING_ON(dbenv) && (ret =
__lock_id(dbenv, (u_int32_t *)dbp->fileid, NULL)) != 0)
goto err;
} else {
p32 = (u_int32_t *)(&dbp->fileid[0]);
__os_unique_id(dbenv, p32);
p32++;
(void)strncpy(
(char *)p32, name, DB_FILE_ID_LEN - sizeof(u_int32_t));
dbp->preserve_fid = 1;
if (DBENV_LOGGING(dbenv) &&
#if !defined(DEBUG_WOP) && !defined(DIAGNOSTIC)
txn != NULL &&
#endif
dbp->log_filename != NULL)
memcpy(dbp->log_filename->ufid,
dbp->fileid, DB_FILE_ID_LEN);
}
if ((ret = __memp_set_fileid(dbp->mpf, dbp->fileid)) != 0)
goto err;
if ((ret = __db_env_mpool(dbp, name, flags)) != 0)
goto err;
if (DBENV_LOGGING(dbenv) &&
#if !defined(DEBUG_WOP)
txn != NULL &&
#endif
name != NULL) {
DB_INIT_DBT(name_dbt, name, strlen(name) + 1);
memset(&fid_dbt, 0, sizeof(fid_dbt));
fid_dbt.data = dbp->fileid;
fid_dbt.size = DB_FILE_ID_LEN;
lfid = dbp->log_filename == NULL ?
DB_LOGFILEID_INVALID : dbp->log_filename->id;
if ((ret = __crdel_inmem_create_log(dbenv, txn,
&lsn, 0, lfid, &name_dbt, &fid_dbt, dbp->pgsize)) != 0)
goto err;
}
F_SET(dbp, DB_AM_CREATED);
err:
return (ret);
}
static int
__fop_inmem_read_meta(dbp, txn, name, flags)
DB *dbp;
DB_TXN *txn;
const char *name;
u_int32_t flags;
{
DBMETA *metap;
db_pgno_t pgno;
int ret, t_ret;
pgno = PGNO_BASE_MD;
if ((ret = __memp_fget(dbp->mpf, &pgno, txn, 0, &metap)) != 0)
return (ret);
ret = __db_meta_setup(dbp->dbenv, dbp, name, metap, flags, 1);
if ((t_ret =
__memp_fput(dbp->mpf, metap, dbp->priority)) && ret == 0)
ret = t_ret;
return (ret);
}
static int
__fop_ondisk_dummy(dbp, txn, name, mbuf, flags)
DB *dbp;
DB_TXN *txn;
const char *name;
u_int8_t *mbuf;
u_int32_t flags;
{
DB_ENV *dbenv;
int ret;
char *realname;
u_int32_t dflags;
realname = NULL;
dbenv = dbp->dbenv;
dflags = F_ISSET(dbp, DB_AM_NOT_DURABLE) ? DB_LOG_NOT_DURABLE : 0;
if ((ret = __db_appname(dbenv,
DB_APP_DATA, name, flags, NULL, &realname)) != 0)
goto err;
if ((ret = __fop_create(dbenv,
txn, NULL, name, DB_APP_DATA, 0, dflags)) != 0)
goto err;
if ((ret =
__os_fileid(dbenv, realname, 1, ((DBMETA *)mbuf)->uid)) != 0)
goto err;
((DBMETA *)mbuf)->magic = DB_RENAMEMAGIC;
if ((ret = __fop_write(dbenv, txn, name,
DB_APP_DATA, NULL, 0, 0, 0, mbuf, DBMETASIZE, 1, dflags)) != 0)
goto err;
memcpy(dbp->fileid, ((DBMETA *)mbuf)->uid, DB_FILE_ID_LEN);
err: if (realname != NULL)
__os_free(dbenv, realname);
return (ret);
}
static int
__fop_inmem_dummy(dbp, txn, name, mbuf)
DB *dbp;
DB_TXN *txn;
const char *name;
u_int8_t *mbuf;
{
DBMETA *metap;
db_pgno_t pgno;
int ret, t_ret;
if ((ret = __fop_inmem_create(dbp, name, txn, DB_CREATE)) != 0)
return (ret);
pgno = PGNO_BASE_MD;
if ((ret = __memp_fget(dbp->mpf, &pgno, txn,
DB_MPOOL_CREATE | DB_MPOOL_DIRTY, &metap)) != 0)
return (ret);
if (metap->magic != 0)
ret = EEXIST;
else
metap->magic = DB_RENAMEMAGIC;
memcpy(metap->uid, dbp->fileid, DB_FILE_ID_LEN);
if ((t_ret = __memp_fput(dbp->mpf, metap,
ret == 0 ? dbp->priority : DB_PRIORITY_VERY_LOW)) != 0 && ret == 0)
ret = t_ret;
if (ret != 0)
goto err;
((DBMETA *)mbuf)->magic = DB_RENAMEMAGIC;
err: return (ret);
}
static int
__fop_ondisk_swap(dbp, tmpdbp, txn, old, new, back, locker, flags)
DB *dbp, *tmpdbp;
DB_TXN *txn;
const char *old, *new, *back;
DB_LOCKER *locker;
u_int32_t flags;
{
DB_ENV *dbenv;
DB_FH *fhp;
DB_LOCK elock;
DB_LSN lsn;
DBT fiddbt, namedbt, tmpdbt;
DB_TXN *parent;
char *realold, *realnew;
int ret, t_ret;
u_int8_t mbuf[DBMETASIZE];
u_int32_t child_txnid, dflags;
dbenv = dbp->dbenv;
DB_ASSERT(dbenv, txn != NULL);
DB_ASSERT(dbenv, old != NULL);
realold = realnew = NULL;
LOCK_INIT(elock);
fhp = NULL;
dflags = F_ISSET(dbp, DB_AM_NOT_DURABLE) ? DB_LOG_NOT_DURABLE : 0;
if ((ret =
__db_appname(dbenv, DB_APP_DATA, new, 0, NULL, &realnew)) != 0)
goto err;
retry: GET_ENVLOCK(dbenv, locker, &elock);
if (__os_exists(dbenv, realnew, NULL) == 0) {
if ((ret = __os_open(dbenv, realnew, 0, 0, 0, &fhp)) != 0)
goto err;
if ((ret = __fop_read_meta(dbenv,
realnew, mbuf, sizeof(mbuf), fhp, 0, NULL)) != 0 ||
(ret = __db_meta_setup(dbenv,
tmpdbp, realnew, (DBMETA *)mbuf, 0, 1)) != 0) {
ret = EEXIST;
goto err;
}
ret = __os_closehandle(dbenv, fhp);
fhp = NULL;
if (ret != 0)
goto err;
if ((ret = __fop_lock_handle(dbenv,
tmpdbp, locker, DB_LOCK_READ, NULL, DB_LOCK_NOWAIT)) != 0) {
if ((ret = __fop_lock_handle(dbenv, tmpdbp,
locker, DB_LOCK_WRITE, &elock, 0)) != 0)
goto err;
if ((ret =
__lock_put(dbenv, &tmpdbp->handle_lock)) != 0)
goto err;
if ((ret = __db_refresh(tmpdbp, NULL, 0, NULL, 0)) != 0)
goto err;
goto retry;
}
ret = __fop_lock_handle(dbenv,
tmpdbp, locker, DB_LOCK_WRITE,
NULL, DB_LOCK_UPGRADE | DB_LOCK_NOWAIT);
if (ret != 0) {
(void)__lock_put(dbenv, &tmpdbp->handle_lock);
ret = EEXIST;
} else if (F_ISSET(tmpdbp, DB_AM_IN_RENAME))
ret = 0;
else {
(void)__lock_put(dbenv, &tmpdbp->handle_lock);
ret = EEXIST;
}
if (ret != 0)
goto err;
}
if ((ret = __fop_rename(dbenv,
txn, old, new, dbp->fileid, DB_APP_DATA, 1, dflags)) != 0)
goto err;
if ((ret = __fop_rename(dbenv,
txn, back, old, tmpdbp->fileid, DB_APP_DATA, 0, dflags)) != 0)
goto err;
if ((ret = __fop_lock_handle(dbenv,
tmpdbp, locker, DB_LOCK_WRITE, &elock, NOWAIT_FLAG(txn))) != 0)
goto err;
LOCK_INIT(tmpdbp->handle_lock);
child_txnid = txn->txnid;
parent = txn->parent;
ret = __txn_commit(txn, 0);
txn = NULL;
memset(&fiddbt, 0, sizeof(fiddbt));
fiddbt.data = dbp->fileid;
fiddbt.size = DB_FILE_ID_LEN;
memset(&tmpdbt, 0, sizeof(fiddbt));
tmpdbt.data = tmpdbp->fileid;
tmpdbt.size = DB_FILE_ID_LEN;
DB_INIT_DBT(namedbt, old, strlen(old) + 1);
if ((t_ret = __fop_file_remove_log(dbenv,
parent, &lsn, 0, &fiddbt, &tmpdbt, &namedbt,
(u_int32_t)DB_APP_DATA, child_txnid)) != 0 && ret == 0)
ret = t_ret;
if ((ret = __db_appname(dbenv,
DB_APP_DATA, old, flags, NULL, &realold)) != 0)
goto err;
if ((ret = __txn_remevent(dbenv, parent, realold, NULL, 0)) != 0)
goto err;
err: if (txn != NULL)
(void)__txn_abort(txn);
(void)__ENV_LPUT(dbenv, elock);
if (fhp != NULL &&
(t_ret = __os_closehandle(dbenv, fhp)) != 0 && ret == 0)
ret = t_ret;
if (realnew != NULL)
__os_free(dbenv, realnew);
if (realold != NULL)
__os_free(dbenv, realold);
return (ret);
}
static int
__fop_inmem_swap(olddbp, backdbp, txn, old, new, back, locker)
DB *olddbp, *backdbp;
DB_TXN *txn;
const char *old, *new, *back;
DB_LOCKER *locker;
{
DB_ENV *dbenv;
DB_LOCK elock;
DB_LSN lsn;
DB_TXN *parent;
DBT fid_dbt, n1_dbt, n2_dbt;
DB *tmpdbp;
int ret, t_ret;
dbenv = olddbp->dbenv;
parent = txn->parent;
retry: LOCK_INIT(elock);
if ((ret = __db_create_internal(&tmpdbp, dbenv, 0)) != 0)
return (ret);
MAKE_INMEM(tmpdbp);
GET_ENVLOCK(dbenv, locker, &elock);
if ((ret = __db_env_mpool(tmpdbp, new, 0)) == 0) {
if ((ret = __fop_inmem_read_meta(tmpdbp, txn, new, 0)) != 0) {
ret = EEXIST;
goto err;
}
if ((ret = __fop_lock_handle(dbenv,
tmpdbp, locker, DB_LOCK_READ, NULL, DB_LOCK_NOWAIT)) != 0) {
if ((ret = __fop_lock_handle(dbenv, tmpdbp,
locker, DB_LOCK_WRITE, &elock, 0)) != 0)
goto err;
(void)__lock_put(dbenv, &tmpdbp->handle_lock);
(void)__db_close(tmpdbp, NULL, DB_NOSYNC);
(void)__ENV_LPUT(dbenv, elock);
goto retry;
} else {
(void)__lock_put(dbenv, &tmpdbp->handle_lock);
if (!F_ISSET(tmpdbp, DB_AM_IN_RENAME))
ret = EEXIST;
}
if (ret != 0)
goto err;
}
if (LOGGING_ON(dbenv)
#ifndef DEBUG_WOP
&& txn != NULL
#endif
) {
DB_INIT_DBT(fid_dbt, olddbp->fileid, DB_FILE_ID_LEN);
DB_INIT_DBT(n1_dbt, old, strlen(old) + 1);
DB_INIT_DBT(n2_dbt, new, strlen(new) + 1);
if ((ret = __crdel_inmem_rename_log(dbenv, txn, &lsn, 0,
&n1_dbt, &n2_dbt, &fid_dbt)) != 0)
goto err;
fid_dbt.data = backdbp->fileid;
DB_SET_DBT(n2_dbt, back, strlen(back) + 1);
if ((ret = __crdel_inmem_rename_log(dbenv, txn, &lsn, 0,
&n2_dbt, &n1_dbt, &fid_dbt)) != 0)
goto err;
}
if (F_ISSET(tmpdbp, DB_AM_IN_RENAME)) {
if ((ret = __memp_nameop(dbenv,
tmpdbp->fileid, NULL, new, NULL, 1)) != 0)
goto err;
__txn_remrem(dbenv, parent, new);
}
if ((ret = __memp_nameop(dbenv, olddbp->fileid, new, old, new, 1)) != 0)
goto err;
if ((ret =
__memp_nameop(dbenv, backdbp->fileid, old, back, old, 1)) != 0)
goto err;
if ((ret = __fop_lock_handle(dbenv,
tmpdbp, locker, DB_LOCK_WRITE, &elock, 0)) != 0)
goto err;
LOCK_INIT(tmpdbp->handle_lock);
DB_ASSERT(dbenv, txn != NULL);
ret = __txn_commit(txn, 0);
txn = NULL;
if ((ret = __db_inmem_remove(backdbp, parent, old)) != 0)
goto err;
err: (void)__ENV_LPUT(dbenv, elock);
if (txn != NULL)
(void)__txn_abort(txn);
if ((t_ret = __db_close(tmpdbp, NULL, 0)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}