#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: fop_util.c,v 1.3 2004/03/30 01:23:27 jtownsen Exp $";
#endif
#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#endif
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_shash.h"
#include "dbinc/db_am.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 *));
#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)
#define REL_ENVLOCK(ENV, L) \
(!LOCK_ISSET(*(L)) ? 0 : __lock_put((ENV), (L)))
#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, elock, flags)
DB_ENV *dbenv;
DB *dbp;
u_int32_t locker;
db_lockmode_t mode;
DB_LOCK *elock;
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)) {
if (elock != NULL)
REL_ENVLOCK(dbenv, elock);
return (0);
}
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 (elock == NULL)
ret = __lock_get(dbenv, locker,
flags, &fileobj, mode, &dbp->handle_lock);
else {
reqs[0].op = DB_LOCK_PUT;
reqs[0].lock = *elock;
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(*elock);
} else if (ereq != reqs)
LOCK_INIT(*elock);
}
dbp->cur_lid = 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_TXN *stxn;
size_t len;
u_int32_t dflags, locker, oflags;
u_int8_t mbuf[DBMETASIZE];
int created_locker, ret, t_ret, tmp_created, truncating;
char *real_name, *real_tmpname, *tmpname;
DB_ASSERT(name != NULL);
*retidp = TXN_INVALID;
dbenv = dbp->dbenv;
fhp = NULL;
LOCK_INIT(elock);
stxn = NULL;
created_locker = tmp_created = truncating = 0;
real_name = real_tmpname = tmpname = NULL;
dflags = F_ISSET(dbp, DB_AM_NOT_DURABLE) ? DB_LOG_NOT_DURABLE : 0;
if (LOCKING_ON(dbenv) &&
!F_ISSET(dbp, DB_AM_COMPENSATE) && dbp->lid == DB_LOCK_INVALIDID) {
if ((ret = __lock_id(dbenv, &dbp->lid)) != 0)
goto err;
created_locker = 1;
}
LOCK_INIT(dbp->handle_lock);
locker = txn == NULL ? dbp->lid : txn->txnid;
if ((ret = __db_appname(dbenv,
DB_APP_DATA, name, 0, NULL, &real_name)) != 0)
goto err;
if (mode == 0)
mode = __db_omode("rwrw--");
oflags = 0;
if (LF_ISSET(DB_RDONLY))
oflags |= DB_OSO_RDONLY;
if (LF_ISSET(DB_TRUNCATE))
oflags |= DB_OSO_TRUNC;
retry: if (!F_ISSET(dbp, DB_AM_COMPENSATE))
GET_ENVLOCK(dbenv, locker, &elock);
if ((ret = __os_exists(real_name, NULL)) == 0) {
reopen: if ((ret = __os_open(dbenv, real_name, 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;
}
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)
goto err;
if ((ret = __db_meta_setup(dbenv,
dbp, real_name, (DBMETA *)mbuf, flags, 1)) != 0)
goto err;
if ((ret = __fop_lock_handle(dbenv,
dbp, locker, DB_LOCK_READ, NULL, DB_LOCK_NOWAIT)) == 0) {
if ((ret = REL_ENVLOCK(dbenv, &elock)) != 0)
goto err;
} else if (ret == DB_LOCK_NOTGRANTED) {
DB_ASSERT(!LF_ISSET(DB_FCNTL_LOCKING));
if ((ret = __os_closehandle(dbenv, fhp)) != 0)
goto err;
fhp = NULL;
ret = __fop_lock_handle(dbenv,
dbp, locker, DB_LOCK_READ, &elock, 0);
if (ret == DB_LOCK_NOTEXIST)
goto retry;
if (ret != 0)
goto err;
if ((ret =
__os_open(dbenv, real_name, 0, 0, &fhp)) != 0)
goto err;
} else
goto err;
if (F_ISSET(dbp, DB_AM_IN_RENAME)) {
if (LF_ISSET(DB_CREATE)) {
if ((ret = __os_closehandle(dbenv, fhp)) != 0)
goto err;
goto create;
} else {
ret = ENOENT;
goto err;
}
}
if (LF_ISSET(DB_EXCL)) {
if (LOCK_ISSET(dbp->handle_lock))
__lock_put(dbenv, &dbp->handle_lock);
LOCK_INIT(dbp->handle_lock);
ret = EEXIST;
goto err;
}
goto done;
}
if (!LF_ISSET(DB_CREATE))
goto err;
ret = 0;
if ((ret = REL_ENVLOCK(dbenv, &elock)) != 0)
goto err;
create: if (txn != NULL && IS_REP_CLIENT(dbenv)) {
__db_err(dbenv,
"Transactional create on replication client disallowed");
ret = EINVAL;
goto err;
}
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;
goto retry;
}
goto err;
}
tmp_created = 1;
creat2: 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, stxn, fhp, tmpname)) != 0)
goto err;
CLOSE_HANDLE(dbp, fhp);
if (!F_ISSET(dbp, DB_AM_COMPENSATE))
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 (__os_exists(real_name, NULL) == 0) {
(void)__fop_remove(dbenv,
NULL, dbp->fileid, tmpname, DB_APP_DATA, dflags);
if (LOCK_ISSET(dbp->handle_lock))
__lock_put(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 ((ret = __fop_lock_handle(dbenv,
dbp, locker, DB_LOCK_WRITE, &elock, 0)) != 0)
goto err;
if (tmpname != name && (ret = __fop_rename(dbenv,
stxn, tmpname, name, dbp->fileid, DB_APP_DATA, 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, "%s: %s", name, db_strerror(ret));
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 (LOCK_ISSET(dbp->handle_lock) && txn == NULL)
__lock_put(dbenv, &dbp->handle_lock);
if (LOCK_ISSET(elock))
(void)REL_ENVLOCK(dbenv, &elock);
if (created_locker) {
(void)__lock_id_free(dbenv, dbp->lid);
dbp->lid = DB_LOCK_INVALIDID;
}
}
done:
if (!truncating && tmpname != NULL && tmpname != name)
__os_free(dbenv, tmpname);
if (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, "%s: %s", name, db_strerror(ret));
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;
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->lid = mdbp->lid;
mdbp->lid = DB_LOCK_INVALIDID;
DB_TEST_RECOVERY(dbp, DB_TEST_POSTLOG, ret, mname);
memcpy(dbp->fileid, mdbp->fileid, DB_FILE_ID_LEN);
if ((ret = __fop_lock_handle(dbenv, dbp,
txn == NULL ? dbp->lid : txn->txnid,
F_ISSET(dbp, DB_AM_CREATED) || LF_ISSET(DB_WRITEOPEN) ?
DB_LOCK_WRITE : DB_LOCK_READ, NULL, 0)) != 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 (LOCK_ISSET(dbp->handle_lock) && txn == NULL)
__lock_put(dbenv, &dbp->handle_lock);
}
if (!F_ISSET(dbp, DB_AM_RECOVER) && txn != NULL) {
__txn_remlock(dbenv,
txn, &mdbp->handle_lock, DB_LOCK_INVALIDID);
if ((t_ret = __txn_lockevent(dbenv, txn, dbp,
&mdbp->handle_lock, dbp->lid == DB_LOCK_INVALIDID ?
mdbp->lid : dbp->lid)) != 0 && ret == 0)
ret = t_ret;
}
LOCK_INIT(mdbp->handle_lock);
if ((t_ret =__db_close(mdbp, txn, 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 cnt, ret;
COMPQUIET(flags, 0);
dbenv = dbp->dbenv;
PANIC_CHECK(dbenv);
LOCK_INIT(elock);
retry: if (LOCKING_ON(dbenv)) {
if (txn != NULL)
dbp->lid = txn->txnid;
else if (dbp->lid == DB_LOCK_INVALIDID) {
if ((ret = __lock_id(dbenv, &dbp->lid)) != 0)
goto err;
}
}
fhp = dbp->saved_open_fhp;
DB_ASSERT(LF_ISSET(DB_FCNTL_LOCKING) || fhp == NULL);
GET_ENVLOCK(dbenv, dbp->lid, &elock);
if (fhp == NULL &&
(ret = __os_open(dbenv, name, DB_OSO_RDONLY, 0, &fhp)) != 0)
goto err;
if ((ret = __fop_read_meta(dbenv,
name, mbuf, sizeof(mbuf), fhp, 0, NULL)) != 0)
goto err;
if ((ret =
__db_meta_setup(dbenv, dbp, name, (DBMETA *)mbuf, flags, 1)) != 0)
goto err;
if ((ret = __fop_lock_handle(dbenv,
dbp, dbp->lid, DB_LOCK_WRITE, NULL, DB_LOCK_NOWAIT)) != 0) {
if (!LF_ISSET(DB_FCNTL_LOCKING)) {
(void)__os_closehandle(dbenv, fhp);
fhp = NULL;
}
if (ret == DB_LOCK_NOTEXIST) {
if ((ret = REL_ENVLOCK(dbenv, &elock)) != 0)
goto err;
} else if (ret != DB_LOCK_NOTGRANTED)
goto err;
else if ((ret = __fop_lock_handle(dbenv,
dbp, dbp->lid, DB_LOCK_WRITE, &elock, 0)) != 0 &&
ret != DB_LOCK_NOTEXIST)
goto err;
if (txn != NULL)
dbp->lid = DB_LOCK_INVALIDID;
(void)__db_refresh(dbp, txn, DB_NOSYNC, NULL);
goto retry;
} else if ((ret = REL_ENVLOCK(dbenv, &elock)) != 0)
goto err;
if ((ret = __memp_get_refcnt(dbenv, dbp->fileid, &cnt)) != 0)
goto err;
if (cnt != 0)
ret = DB_FILEOPEN;
else if (F_ISSET(dbp, DB_AM_IN_RENAME))
ret = ENOENT;
if (0) {
err: (void)REL_ENVLOCK(dbenv, &elock);
}
if (fhp != NULL && !LF_ISSET(DB_FCNTL_LOCKING))
(void)__os_closehandle(dbenv, fhp);
if (ret == 0)
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, "%s: %s", name, db_strerror(ret));
goto err;
}
if (nr != size) {
if (!errok)
__db_err(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, *t2dbp;
DB_ENV *dbenv;
DB_FH *fhp;
DB_LOCK elock;
DB_LSN lsn;
DBT fiddbt, namedbt, tmpdbt;
DB_TXN *stxn;
char *back;
char *realback, *realnew, *realold;
int ret, t_ret;
size_t len;
u_int8_t mbuf[DBMETASIZE];
u_int32_t dflags, locker, stxnid;
dbenv = dbp->dbenv;
LOCK_INIT(elock);
realback = NULL;
realnew = NULL;
realold = NULL;
back = NULL;
stxn = NULL;
tmpdbp = t2dbp = NULL;
fhp = NULL;
dflags = F_ISSET(dbp, DB_AM_NOT_DURABLE) ? DB_LOG_NOT_DURABLE : 0;
DB_ASSERT(txn != NULL);
locker = txn->txnid;
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_appname(dbenv,
DB_APP_DATA, back, flags, NULL, &realback)) != 0)
goto err;
if ((ret = __fop_create(dbenv,
stxn, NULL, back, DB_APP_DATA, 0, dflags)) != 0)
goto err;
memset(mbuf, 0, sizeof(mbuf));
if ((ret =
__os_fileid(dbenv, realback, 1, ((DBMETA *)mbuf)->uid)) != 0)
goto err;
((DBMETA *)mbuf)->magic = DB_RENAMEMAGIC;
if ((ret = __fop_write(dbenv, stxn, back,
DB_APP_DATA, NULL, 0, 0, 0, mbuf, DBMETASIZE, 1, dflags)) != 0)
goto err;
if ((ret = db_create(&tmpdbp, dbenv, 0)) != 0)
goto err;
memcpy(&tmpdbp->fileid, ((DBMETA *)mbuf)->uid, DB_FILE_ID_LEN);
if ((ret = __db_appname(dbenv,
DB_APP_DATA, new, 0, NULL, &realnew)) != 0)
goto err;
GET_ENVLOCK(dbenv, locker, &elock);
if (__os_exists(realnew, NULL) == 0) {
if ((ret = db_create(&t2dbp, dbenv, 0)) != 0)
goto err;
if ((ret = __os_open(dbenv, realnew, 0, 0, &fhp)) != 0)
goto err;
if ((ret = __fop_read_meta(dbenv,
realnew, mbuf, sizeof(mbuf), fhp, 0, &len)) != 0 ||
(ret = __db_meta_setup(dbenv,
t2dbp, realnew, (DBMETA *)mbuf, 0, 1)) != 0) {
ret = EEXIST;
goto err;
}
if ((ret = __fop_lock_handle(dbenv,
t2dbp, locker, DB_LOCK_WRITE, NULL, DB_LOCK_NOWAIT)) != 0)
ret = EEXIST;
else {
(void)__lock_put(dbenv, &t2dbp->handle_lock);
if (!F_ISSET(t2dbp, DB_AM_IN_RENAME))
ret = EEXIST;
}
if ((t_ret = __os_closehandle(dbenv, fhp)) != 0 && ret == 0)
ret = t_ret;
fhp = NULL;
if (ret != 0)
goto err;
}
if ((ret = __fop_rename(dbenv,
stxn, old, new, dbp->fileid, DB_APP_DATA, dflags)) != 0)
goto err;
if ((ret = __fop_rename(dbenv,
stxn, back, old, tmpdbp->fileid, DB_APP_DATA, dflags)) != 0)
goto err;
if ((ret = __fop_lock_handle(dbenv,
tmpdbp, locker, DB_LOCK_WRITE, &elock, 0)) != 0)
goto err;
LOCK_INIT(tmpdbp->handle_lock);
if (stxn != NULL) {
stxnid = stxn->txnid;
ret = __txn_commit(stxn, 0);
stxn = NULL;
memset(&fiddbt, 0, sizeof(fiddbt));
memset(&tmpdbt, 0, sizeof(fiddbt));
memset(&namedbt, 0, sizeof(namedbt));
fiddbt.data = dbp->fileid;
fiddbt.size = DB_FILE_ID_LEN;
tmpdbt.data = tmpdbp->fileid;
tmpdbt.size = DB_FILE_ID_LEN;
namedbt.data = (void *)old;
namedbt.size = (u_int32_t)strlen(old) + 1;
if ((t_ret =
__fop_file_remove_log(dbenv, txn, &lsn, 0, &fiddbt,
&tmpdbt, &namedbt, DB_APP_DATA, stxnid)) != 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, txn, realold, NULL)) != 0)
goto err;
err: (void)REL_ENVLOCK(dbenv, &elock);
if (stxn != NULL)
(void)__txn_abort(stxn);
if (tmpdbp != NULL &&
(t_ret = __db_close(tmpdbp, NULL, 0)) != 0 && ret == 0)
ret = t_ret;
if (t2dbp != NULL &&
(t_ret = __db_close(t2dbp, NULL, 0)) != 0 && ret == 0)
ret = t_ret;
if (fhp != NULL)
(void)__os_closehandle(dbenv, fhp);
if (realold != NULL)
__os_free(dbenv, realold);
if (realnew != NULL)
__os_free(dbenv, realnew);
if (realback != NULL)
__os_free(dbenv, realback);
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, tret;
dbenv = dbp->dbenv;
real_new = NULL;
real_old = NULL;
LOCK_INIT(elock);
if ((ret = __db_appname(dbenv,
DB_APP_DATA, new, 0, NULL, &real_new)) != 0)
goto err;
GET_ENVLOCK(dbenv, dbp->lid, &elock);
if (__os_exists(real_new, NULL) == 0) {
ret = EEXIST;
__db_err(dbenv, "rename: file %s exists", real_new);
goto err;
}
if ((ret = __db_appname(dbenv,
DB_APP_DATA, old, 0, NULL, &real_old)) != 0)
goto err;
ret = __memp_nameop(dbenv, dbp->fileid, new, real_old, real_new);
err: if ((tret = REL_ENVLOCK(dbenv, &elock)) != 0 && ret == 0)
ret = tret;
if (real_old != NULL)
__os_free(dbenv, real_old);
if (real_new != NULL)
__os_free(dbenv, real_new);
return (ret);
}