#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: mp_bh.c,v 1.2 2004/03/30 01:23:44 jtownsen Exp $";
#endif
#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>
#include <string.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_ENV *, DB_MPOOLFILE *, DB_MPOOL_HASH *, BH *));
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 ret;
dbenv = dbmp->dbenv;
if (mfp->deadfile)
return (__memp_pgwrite(dbenv, NULL, hp, bhp));
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
for (dbmfp = TAILQ_FIRST(&dbmp->dbmfq);
dbmfp != NULL; dbmfp = TAILQ_NEXT(dbmfp, q))
if (dbmfp->mfp == mfp && !F_ISSET(dbmfp, MP_READONLY)) {
++dbmfp->ref;
break;
}
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
if (dbmfp != NULL) {
if (dbmfp->fhp == NULL) {
if (mfp->no_backing_file)
return (EPERM);
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
if (dbmfp->fhp == NULL)
ret = __db_appname(dbenv, DB_APP_TMP, NULL,
F_ISSET(dbenv, DB_ENV_DIRECT_DB) ?
DB_OSO_DIRECT : 0, &dbmfp->fhp, NULL);
else
ret = 0;
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
if (ret != 0) {
__db_err(dbenv,
"unable to create temporary backing file");
return (ret);
}
}
goto pgwrite;
}
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 = __memp_fcreate(dbenv, &dbmfp)) != 0)
return (ret);
if ((ret = __memp_fopen(dbmfp, mfp,
R_ADDR(dbmp->reginfo, mfp->path_off),
0, 0, mfp->stat.st_pagesize)) != 0) {
(void)__memp_fclose(dbmfp, 0);
return (ret);
}
pgwrite:
ret = __memp_pgwrite(dbenv, dbmfp, hp, bhp);
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
if (dbmfp->ref == 1)
F_SET(dbmfp, MP_FLUSH);
else
--dbmfp->ref;
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_ENV *dbenv;
MPOOLFILE *mfp;
size_t len, nr, pagesize;
int ret;
dbenv = dbmfp->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 (dbmfp->fhp != NULL)
if ((ret = __os_io(dbenv, DB_IO_READ,
dbmfp->fhp, bhp->pgno, pagesize, bhp->buf, &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(dbenv, dbmfp, hp, bhp)
DB_ENV *dbenv;
DB_MPOOLFILE *dbmfp;
DB_MPOOL_HASH *hp;
BH *bhp;
{
DB_LSN lsn;
MPOOLFILE *mfp;
size_t nw;
int callpgin, ret;
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 || mfp->deadfile)
goto file_dead;
if (LOGGING_ON(dbenv) && mfp->lsn_off != -1) {
memcpy(&lsn, bhp->buf + mfp->lsn_off, sizeof(DB_LSN));
if ((ret = __log_flush(dbenv, &lsn)) != 0)
goto err;
}
#ifdef DIAGNOSTIC
if (LOGGING_ON(dbenv) && !IS_NOT_LOGGED_LSN(LSN(bhp->buf))) {
DB_LOG *dblp;
DB_MUTEX *mtx;
LOG *lp;
dblp = dbenv->lg_handle;
lp = dblp->reginfo.primary;
if (log_compare(&lp->s_lsn, &LSN(bhp->buf)) <= 0) {
mtx = R_ADDR(&dblp->reginfo, lp->flush_mutex_off);
MUTEX_LOCK(dbenv, mtx);
DB_ASSERT(log_compare(&lp->s_lsn, &LSN(bhp->buf)) > 0);
MUTEX_UNLOCK(dbenv, mtx);
}
}
#endif
if (mfp->ftype != 0 && !F_ISSET(bhp, BH_CALLPGIN)) {
callpgin = 1;
if ((ret = __memp_pg(dbmfp, bhp, 0)) != 0)
goto err;
}
if ((ret = __os_io(dbenv, DB_IO_WRITE, dbmfp->fhp,
bhp->pgno, mfp->stat.st_pagesize, bhp->buf, &nw)) != 0) {
__db_err(dbenv, "%s: write failed for page %lu",
__memp_fn(dbmfp), (u_long)bhp->pgno);
goto err;
}
mfp->file_written = 1;
++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;
dbenv = dbmfp->dbenv;
dbmp = dbenv->mp_handle;
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)
(void)__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]);
}