#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: fop_util.c,v 1.2 2003/06/04 01:20:09 zarzycki 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/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 = (ENV)->lock_get((ENV), (ID), \
0, &__dbt, DB_LOCK_WRITE, (L))) != 0) \
goto err; \
} \
} while (0)
#define REL_ENVLOCK(ENV, L) \
(!LOCK_ISSET(*(L)) ? 0 : (ENV)->lock_put((ENV), (L)))
#define CLOSE_HANDLE(D, F) { \
if (F_ISSET((F), DB_FH_VALID)) { \
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; \
} \
} \
}
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))
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 = dbenv->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 fh, *fhp;
DB_LOCK elock, tmp_lock;
DB_TXN *stxn;
char *real_name, *real_tmpname, *tmpname;
db_lockmode_t lmode;
int created_fhp, created_locker, ret, tmp_created, t_ret, truncating;
size_t len;
u_int32_t locker, oflags;
u_int8_t mbuf[DBMETASIZE];
DB_ASSERT(name != NULL);
*retidp = TXN_INVALID;
dbenv = dbp->dbenv;
LOCK_INIT(elock);
LOCK_INIT(tmp_lock);
stxn = NULL;
created_fhp = created_locker = 0;
real_name = real_tmpname = tmpname = NULL;
tmp_created = truncating = 0;
if (LF_ISSET(DB_FCNTL_LOCKING)) {
if ((ret = __os_malloc(dbenv, sizeof(*fhp), &fhp)) != 0)
return (ret);
created_fhp = 1;
} else
fhp = &fh;
memset(fhp, 0, sizeof(*fhp));
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;
}
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;
retry: if (!F_ISSET(dbp, DB_AM_COMPENSATE))
GET_ENVLOCK(dbenv, locker, &elock);
if ((ret = __os_exists(real_name, NULL)) == 0) {
if (LF_ISSET(DB_EXCL)) {
ret = EEXIST;
goto err;
}
if (LF_ISSET(DB_FCNTL_LOCKING) && LF_ISSET(DB_TRUNCATE))
goto do_trunc;
reopen: ret = __fop_read_meta(dbenv, real_name,
mbuf, sizeof(mbuf), fhp,
LF_ISSET(DB_FCNTL_LOCKING) && txn == NULL ? 1 : 0,
&len, oflags);
if (ret != 0 &&
LF_ISSET(DB_FCNTL_LOCKING) && txn == NULL && len == 0) {
tmpname = (char *)real_name;
real_name = NULL;
goto creat2;
}
if (ret != 0)
goto err;
if ((ret = __db_meta_setup(dbenv,
dbp, real_name, (DBMETA *)mbuf, flags, 1)) != 0)
goto err;
lmode = LF_ISSET(DB_TRUNCATE) ? DB_LOCK_WRITE : DB_LOCK_READ;
if ((ret = __fop_lock_handle(dbenv,
dbp, locker, lmode, NULL, DB_LOCK_NOWAIT)) == 0) {
if ((ret = REL_ENVLOCK(dbenv, &elock)) != 0)
goto err;
} else {
DB_ASSERT(!LF_ISSET(DB_FCNTL_LOCKING));
if ((ret = __os_closehandle(dbenv, fhp)) != 0)
goto err;
ret = __fop_lock_handle(dbenv,
dbp, locker, lmode, &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;
}
if (LF_ISSET(DB_TRUNCATE)) {
if ((ret = __os_closehandle(dbenv, fhp)) != 0)
goto err;
do_trunc: if ((ret = __os_open(dbenv,
real_name, DB_OSO_TRUNC, 0, fhp)) != 0)
goto err;
tmp_lock = dbp->handle_lock;
truncating = 1;
tmpname = (char *)name;
goto creat2;
}
if (F_ISSET(dbp, DB_AM_IN_RENAME)) {
if (LF_ISSET(DB_CREATE)) {
F_CLR(dbp, DB_AM_IN_RENAME);
goto create;
} else {
ret = ENOENT;
goto err;
}
}
CLOSE_HANDLE(dbp, fhp);
goto done;
}
if (!LF_ISSET(DB_CREATE))
goto err;
ret = 0;
if ((ret = REL_ENVLOCK(dbenv, &elock)) != 0)
goto err;
create: if ((ret = __db_backup_name(dbenv, name, txn, &tmpname)) != 0)
goto err;
if (TXN_ON(dbenv) && txn != NULL &&
(ret = dbenv->txn_begin(dbenv, txn, &stxn, 0)) != 0)
goto err;
if ((ret = __fop_create(dbenv,
stxn, fhp, tmpname, DB_APP_DATA, mode)) != 0)
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 (!truncating && __os_exists(real_name, NULL) == 0) {
(void)__fop_remove(dbenv,
NULL, dbp->fileid, tmpname, DB_APP_DATA);
if (LOCKING_ON(dbenv))
dbenv->lock_put(dbenv, &dbp->handle_lock);
LOCK_INIT(dbp->handle_lock);
if (LF_ISSET(DB_FCNTL_LOCKING))
(void)__os_closehandle(dbenv, fhp);
if (stxn != NULL) {
ret = stxn->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 (!truncating && (ret = __fop_rename(dbenv,
stxn, tmpname, name, dbp->fileid, DB_APP_DATA)) != 0)
goto err;
if (LOCK_ISSET(tmp_lock) && (ret = __lock_put(dbenv, &tmp_lock)) != 0)
goto err;
if (stxn != NULL) {
*retidp = stxn->txnid;
ret = stxn->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: if (stxn != NULL)
(void)stxn->abort(stxn);
if (tmp_created && txn == NULL)
(void)__fop_remove(dbenv,
NULL, NULL, tmpname, DB_APP_DATA);
if (F_ISSET(fhp, DB_FH_VALID))
CLOSE_HANDLE(dbp, fhp);
if (LOCK_ISSET(tmp_lock))
__lock_put(dbenv, &tmp_lock);
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;
}
if (created_fhp && !F_ISSET(fhp, DB_FH_VALID))
__os_free(dbenv, fhp);
}
done:
if (!truncating && tmpname != NULL && tmpname != real_name)
__os_free(dbenv, tmpname);
if (real_name != NULL)
__os_free(dbenv, real_name);
if (real_tmpname != NULL)
__os_free(dbenv, real_tmpname);
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 do_remove, ret;
mdbp = NULL;
dbenv = dbp->dbenv;
if ((ret = __db_master_open(dbp, txn, mname, flags, mode, &mdbp)) != 0)
return (ret);
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)
goto err;
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 (!F_ISSET(dbp, DB_AM_RECOVER) && txn != NULL) {
__txn_remlock(dbenv,
txn, &mdbp->handle_lock, DB_LOCK_INVALIDID);
if ((ret = __txn_lockevent(dbenv,
txn, dbp, &mdbp->handle_lock, dbp->lid)) != 0)
goto err;
}
LOCK_INIT(mdbp->handle_lock);
return (__db_close_i(mdbp, txn, 0));
err:
DB_TEST_RECOVERY_LABEL
if (LOCK_ISSET(dbp->handle_lock) && txn == NULL)
__lock_put(dbenv, &dbp->handle_lock);
if (mdbp != NULL) {
do_remove = F_ISSET(mdbp, DB_AM_CREATED) ? 1 : 0;
if (do_remove)
F_SET(mdbp, DB_AM_DISCARD);
(void)__db_close_i(mdbp, txn, 0);
if (do_remove) {
(void)db_create(&mdbp, dbp->dbenv, 0);
(void)__db_remove_i(mdbp, txn, mname, NULL);
}
}
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);
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 || !F_ISSET(fhp, DB_FH_VALID));
GET_ENVLOCK(dbenv, dbp->lid, &elock);
if ((ret = __fop_read_meta(dbenv,
name, mbuf, sizeof(mbuf), fhp, 0, NULL, 0)) != 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, &elock, 0)) != 0)
goto err;
return (0);
err: (void)REL_ENVLOCK(dbenv, &elock);
return (ret);
}
int
__fop_read_meta(dbenv, name, buf, size, fhp, errok, nbytesp, flags)
DB_ENV *dbenv;
const char *name;
u_int8_t *buf;
size_t size;
DB_FH *fhp;
int errok;
size_t *nbytesp;
u_int32_t flags;
{
DB_FH fh, *lfhp;
size_t nr;
int myfhp, ret;
nr = 0;
myfhp = 0;
memset(&fh, 0, sizeof(fh));
lfhp = fhp == NULL ? &fh : fhp;
myfhp = F_ISSET(lfhp, DB_FH_VALID);
if (!myfhp && (ret = __os_open(dbenv, name, flags, 0, lfhp)) != 0)
goto err;
if ((ret = __os_read(dbenv, lfhp, buf, size, &nr)) != 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;
goto err;
}
err:
if (!myfhp && F_ISSET((lfhp), DB_FH_VALID) && (ret != 0 || fhp == NULL))
__os_closehandle(dbenv, lfhp);
if (nbytesp != NULL)
*nbytesp = nr;
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_LOCK elock;
DB_LSN lsn;
DBT fiddbt, namedbt, tmpdbt;
DB_TXN *stxn;
char *back;
char *realback, *realnew, *realold;
int ret, t_ret;
u_int8_t mbuf[DBMETASIZE];
u_int32_t locker, stxnid;
dbenv = dbp->dbenv;
LOCK_INIT(elock);
realback = NULL;
realnew = NULL;
realold = NULL;
back = NULL;
stxn = NULL;
tmpdbp = NULL;
DB_ASSERT(txn != NULL);
locker = txn->txnid;
if (TXN_ON(dbenv) &&
(ret = dbenv->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)) != 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, mbuf, DBMETASIZE, 1)) != 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) {
ret = EEXIST;
goto err;
}
if ((ret = __fop_rename(dbenv,
stxn, old, new, dbp->fileid, DB_APP_DATA)) != 0)
goto err;
if ((ret = __fop_rename(dbenv,
stxn, back, old, tmpdbp->fileid, DB_APP_DATA)) != 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 = stxn->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)stxn->abort(stxn);
if (tmpdbp != NULL &&
(t_ret = __db_close_i(tmpdbp, NULL, 0)) != 0 && ret == 0)
ret = t_ret;
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 = dbenv->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);
}