#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: mp_bh.c,v 1.1.1.1 2003/02/15 04:56:08 zarzycki Exp $";
#endif
#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>
#include <string.h>
#include <unistd.h>
#endif
#include "db_int.h"
#include "dbinc/db_shash.h"
#include "dbinc/mp.h"
#include "dbinc/log.h"
#include "dbinc/db_page.h"
static int __memp_pgwrite
__P((DB_MPOOL *, DB_MPOOLFILE *, DB_MPOOL_HASH *, BH *));
static int __memp_upgrade __P((DB_MPOOL *, DB_MPOOLFILE *, MPOOLFILE *));
int
__memp_bhwrite(dbmp, hp, mfp, bhp, open_extents)
DB_MPOOL *dbmp;
DB_MPOOL_HASH *hp;
MPOOLFILE *mfp;
BH *bhp;
int open_extents;
{
DB_ENV *dbenv;
DB_MPOOLFILE *dbmfp;
DB_MPREG *mpreg;
int local_open, incremented, ret;
dbenv = dbmp->dbenv;
local_open = incremented = 0;
if (F_ISSET(mfp, MP_DEADFILE)) {
dbmfp = NULL;
goto found;
}
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
for (dbmfp = TAILQ_FIRST(&dbmp->dbmfq);
dbmfp != NULL; dbmfp = TAILQ_NEXT(dbmfp, q))
if (dbmfp->mfp == mfp) {
if (F_ISSET(dbmfp, MP_READONLY) &&
!F_ISSET(dbmfp, MP_UPGRADE) &&
(F_ISSET(dbmfp, MP_UPGRADE_FAIL) ||
__memp_upgrade(dbmp, dbmfp, mfp))) {
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
return (EPERM);
}
++dbmfp->ref;
incremented = 1;
break;
}
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
if (dbmfp != NULL)
goto found;
if (!open_extents && F_ISSET(mfp, MP_EXTENT))
return (EPERM);
if (F_ISSET(mfp, MP_TEMP))
return (EPERM);
if (mfp->ftype != 0) {
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
for (mpreg = LIST_FIRST(&dbmp->dbregq);
mpreg != NULL; mpreg = LIST_NEXT(mpreg, q))
if (mpreg->ftype == mfp->ftype)
break;
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
if (mpreg == NULL)
return (EPERM);
}
if ((ret = dbenv->memp_fcreate(dbenv, &dbmfp, 0)) != 0)
return (ret);
if ((ret = __memp_fopen_int(dbmfp, mfp,
R_ADDR(dbmp->reginfo, mfp->path_off),
0, 0, mfp->stat.st_pagesize)) != 0) {
(void)dbmfp->close(dbmfp, 0);
return (ret);
}
local_open = 1;
found: ret = __memp_pgwrite(dbmp, dbmfp, hp, bhp);
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
if (incremented)
--dbmfp->ref;
else if (local_open)
F_SET(dbmfp, MP_FLUSH);
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
return (ret);
}
int
__memp_pgread(dbmfp, mutexp, bhp, can_create)
DB_MPOOLFILE *dbmfp;
DB_MUTEX *mutexp;
BH *bhp;
int can_create;
{
DB_IO db_io;
DB_ENV *dbenv;
DB_MPOOL *dbmp;
MPOOLFILE *mfp;
size_t len, nr, pagesize;
int ret;
dbmp = dbmfp->dbmp;
dbenv = dbmp->dbenv;
mfp = dbmfp->mfp;
pagesize = mfp->stat.st_pagesize;
DB_ASSERT(!F_ISSET(bhp, BH_DIRTY | BH_DIRTY_CREATE | BH_LOCKED));
F_SET(bhp, BH_LOCKED | BH_TRASH);
MUTEX_LOCK(dbenv, &bhp->mutex);
MUTEX_UNLOCK(dbenv, mutexp);
nr = 0;
if (F_ISSET(dbmfp->fhp, DB_FH_VALID)) {
db_io.fhp = dbmfp->fhp;
db_io.mutexp = dbmfp->mutexp;
db_io.pagesize = db_io.bytes = pagesize;
db_io.pgno = bhp->pgno;
db_io.buf = bhp->buf;
if ((ret = __os_io(dbenv, &db_io, DB_IO_READ, &nr)) != 0)
goto err;
}
if (nr < pagesize) {
if (can_create == 0) {
ret = DB_PAGE_NOTFOUND;
goto err;
}
len = mfp->clear_len == 0 ? pagesize : mfp->clear_len;
memset(bhp->buf, 0, len);
#if defined(DIAGNOSTIC) || defined(UMRW)
if (len < pagesize)
memset(bhp->buf + len, CLEAR_BYTE, pagesize - len);
#endif
++mfp->stat.st_page_create;
} else
++mfp->stat.st_page_in;
ret = mfp->ftype == 0 ? 0 : __memp_pg(dbmfp, bhp, 1);
err: MUTEX_UNLOCK(dbenv, &bhp->mutex);
MUTEX_LOCK(dbenv, mutexp);
F_CLR(bhp, BH_LOCKED);
if (ret == 0)
F_CLR(bhp, BH_TRASH);
return (ret);
}
static int
__memp_pgwrite(dbmp, dbmfp, hp, bhp)
DB_MPOOL *dbmp;
DB_MPOOLFILE *dbmfp;
DB_MPOOL_HASH *hp;
BH *bhp;
{
DB_ENV *dbenv;
DB_IO db_io;
DB_LSN lsn;
MPOOLFILE *mfp;
size_t nw;
int callpgin, ret;
dbenv = dbmp->dbenv;
mfp = dbmfp == NULL ? NULL : dbmfp->mfp;
callpgin = ret = 0;
DB_ASSERT(F_ISSET(bhp, BH_DIRTY));
DB_ASSERT(!F_ISSET(bhp, BH_TRASH));
if (!F_ISSET(bhp, BH_LOCKED)) {
F_SET(bhp, BH_LOCKED);
MUTEX_LOCK(dbenv, &bhp->mutex);
MUTEX_UNLOCK(dbenv, &hp->hash_mutex);
}
if (mfp == NULL || F_ISSET(mfp, MP_DEADFILE))
goto file_dead;
if (LOGGING_ON(dbenv) && mfp->lsn_off != -1) {
memcpy(&lsn, bhp->buf + mfp->lsn_off, sizeof(DB_LSN));
if ((ret = dbenv->log_flush(dbenv, &lsn)) != 0)
goto err;
}
#ifdef DIAGNOSTIC
if (LOGGING_ON(dbenv) && !IS_NOT_LOGGED_LSN(LSN(bhp->buf))) {
DB_LOG *dblp;
LOG *lp;
dblp = dbenv->lg_handle;
lp = dblp->reginfo.primary;
if (!IS_NOT_LOGGED_LSN(LSN(bhp->buf)) &&
log_compare(&lp->s_lsn, &LSN(bhp->buf)) <= 0) {
R_LOCK(dbenv, &dblp->reginfo);
DB_ASSERT(log_compare(&lp->s_lsn, &LSN(bhp->buf)) > 0);
R_UNLOCK(dbenv, &dblp->reginfo);
}
}
#endif
if (mfp->ftype != 0) {
callpgin = 1;
if ((ret = __memp_pg(dbmfp, bhp, 0)) != 0)
goto err;
}
if (!F_ISSET(dbmfp->fhp, DB_FH_VALID)) {
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
ret = F_ISSET(dbmfp->fhp, DB_FH_VALID) ? 0 :
__db_appname(dbenv, DB_APP_TMP, NULL,
F_ISSET(dbenv, DB_ENV_DIRECT_DB) ? DB_OSO_DIRECT : 0,
dbmfp->fhp, NULL);
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
if (ret != 0) {
__db_err(dbenv,
"unable to create temporary backing file");
goto err;
}
}
db_io.fhp = dbmfp->fhp;
db_io.mutexp = dbmfp->mutexp;
db_io.pagesize = db_io.bytes = mfp->stat.st_pagesize;
db_io.pgno = bhp->pgno;
db_io.buf = bhp->buf;
if ((ret = __os_io(dbenv, &db_io, DB_IO_WRITE, &nw)) != 0) {
__db_err(dbenv, "%s: write failed for page %lu",
__memp_fn(dbmfp), (u_long)bhp->pgno);
goto err;
}
++mfp->stat.st_page_out;
err:
file_dead:
MUTEX_UNLOCK(dbenv, &bhp->mutex);
MUTEX_LOCK(dbenv, &hp->hash_mutex);
if (callpgin)
F_SET(bhp, BH_CALLPGIN);
if (ret == 0) {
DB_ASSERT(hp->hash_page_dirty != 0);
--hp->hash_page_dirty;
F_CLR(bhp, BH_DIRTY | BH_DIRTY_CREATE);
}
bhp->ref_sync = 0;
F_CLR(bhp, BH_LOCKED);
return (ret);
}
int
__memp_pg(dbmfp, bhp, is_pgin)
DB_MPOOLFILE *dbmfp;
BH *bhp;
int is_pgin;
{
DBT dbt, *dbtp;
DB_ENV *dbenv;
DB_MPOOL *dbmp;
DB_MPREG *mpreg;
MPOOLFILE *mfp;
int ftype, ret;
dbmp = dbmfp->dbmp;
dbenv = dbmp->dbenv;
mfp = dbmfp->mfp;
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
ftype = mfp->ftype;
for (mpreg = LIST_FIRST(&dbmp->dbregq);
mpreg != NULL; mpreg = LIST_NEXT(mpreg, q)) {
if (ftype != mpreg->ftype)
continue;
if (mfp->pgcookie_len == 0)
dbtp = NULL;
else {
dbt.size = mfp->pgcookie_len;
dbt.data = R_ADDR(dbmp->reginfo, mfp->pgcookie_off);
dbtp = &dbt;
}
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
if (is_pgin) {
if (mpreg->pgin != NULL &&
(ret = mpreg->pgin(dbenv,
bhp->pgno, bhp->buf, dbtp)) != 0)
goto err;
} else
if (mpreg->pgout != NULL &&
(ret = mpreg->pgout(dbenv,
bhp->pgno, bhp->buf, dbtp)) != 0)
goto err;
break;
}
if (mpreg == NULL)
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
return (0);
err: MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
__db_err(dbenv, "%s: %s failed for page %lu",
__memp_fn(dbmfp), is_pgin ? "pgin" : "pgout", (u_long)bhp->pgno);
return (ret);
}
void
__memp_bhfree(dbmp, hp, bhp, free_mem)
DB_MPOOL *dbmp;
DB_MPOOL_HASH *hp;
BH *bhp;
int free_mem;
{
DB_ENV *dbenv;
MPOOL *c_mp, *mp;
MPOOLFILE *mfp;
u_int32_t n_cache;
dbenv = dbmp->dbenv;
mp = dbmp->reginfo[0].primary;
n_cache = NCACHE(mp, bhp->mf_offset, bhp->pgno);
SH_TAILQ_REMOVE(&hp->hash_bucket, bhp, hq, __bh);
if (bhp->priority == hp->hash_priority)
hp->hash_priority =
SH_TAILQ_FIRST(&hp->hash_bucket, __bh) == NULL ?
0 : SH_TAILQ_FIRST(&hp->hash_bucket, __bh)->priority;
MUTEX_UNLOCK(dbenv, &hp->hash_mutex);
mfp = R_ADDR(dbmp->reginfo, bhp->mf_offset);
MUTEX_LOCK(dbenv, &mfp->mutex);
if (--mfp->block_cnt == 0 && mfp->mpf_cnt == 0)
__memp_mf_discard(dbmp, mfp);
else
MUTEX_UNLOCK(dbenv, &mfp->mutex);
R_LOCK(dbenv, &dbmp->reginfo[n_cache]);
__db_shlocks_clear(&bhp->mutex, &dbmp->reginfo[n_cache],
(REGMAINT *)R_ADDR(&dbmp->reginfo[n_cache], mp->maint_off));
if (free_mem) {
__db_shalloc_free(dbmp->reginfo[n_cache].addr, bhp);
c_mp = dbmp->reginfo[n_cache].primary;
c_mp->stat.st_pages--;
}
R_UNLOCK(dbenv, &dbmp->reginfo[n_cache]);
}
static int
__memp_upgrade(dbmp, dbmfp, mfp)
DB_MPOOL *dbmp;
DB_MPOOLFILE *dbmfp;
MPOOLFILE *mfp;
{
DB_ENV *dbenv;
DB_FH *fhp, *tfhp;
int ret;
char *rpath;
dbenv = dbmp->dbenv;
fhp = NULL;
rpath = NULL;
if ((ret = __os_calloc(dbenv, 1, sizeof(DB_FH), &fhp)) != 0)
goto err;
if ((ret = __db_appname(dbenv, DB_APP_DATA,
R_ADDR(dbmp->reginfo, mfp->path_off), 0, NULL, &rpath)) != 0)
goto err;
if (__os_open(dbenv, rpath,
F_ISSET(mfp, MP_DIRECT) ? DB_OSO_DIRECT : 0, 0, fhp) != 0) {
F_SET(dbmfp, MP_UPGRADE_FAIL);
goto err;
}
tfhp = dbmfp->fhp;
dbmfp->fhp = fhp;
fhp = tfhp;
(void)__os_closehandle(dbenv, fhp);
F_SET(dbmfp, MP_UPGRADE);
ret = 0;
if (0) {
err: ret = 1;
}
if (fhp != NULL)
__os_free(dbenv, fhp);
if (rpath != NULL)
__os_free(dbenv, rpath);
return (ret);
}