#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: mp_fopen.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>
#endif
#include "db_int.h"
#include "dbinc/db_shash.h"
#include "dbinc/mp.h"
static int __memp_fclose __P((DB_MPOOLFILE *, u_int32_t));
static int __memp_fopen __P((DB_MPOOLFILE *,
const char *, u_int32_t, int, size_t));
static void __memp_get_fileid __P((DB_MPOOLFILE *, u_int8_t *));
static void __memp_last_pgno __P((DB_MPOOLFILE *, db_pgno_t *));
static void __memp_refcnt __P((DB_MPOOLFILE *, db_pgno_t *));
static int __memp_set_clear_len __P((DB_MPOOLFILE *, u_int32_t));
static int __memp_set_fileid __P((DB_MPOOLFILE *, u_int8_t *));
static int __memp_set_ftype __P((DB_MPOOLFILE *, int));
static int __memp_set_lsn_offset __P((DB_MPOOLFILE *, int32_t));
static int __memp_set_pgcookie __P((DB_MPOOLFILE *, DBT *));
static int __memp_set_priority __P((DB_MPOOLFILE *, DB_CACHE_PRIORITY));
static void __memp_set_unlink __P((DB_MPOOLFILE *, int));
#define MPF_ILLEGAL_AFTER_OPEN(dbmfp, name) \
if (F_ISSET(dbmfp, MP_OPEN_CALLED)) \
return (__db_mi_open((dbmfp)->dbmp->dbenv, name, 1));
int
__memp_fcreate(dbenv, retp, flags)
DB_ENV *dbenv;
DB_MPOOLFILE **retp;
u_int32_t flags;
{
DB_MPOOL *dbmp;
DB_MPOOLFILE *dbmfp;
int ret;
PANIC_CHECK(dbenv);
ENV_REQUIRES_CONFIG(dbenv,
dbenv->mp_handle, "memp_fcreate", DB_INIT_MPOOL);
dbmp = dbenv->mp_handle;
if ((ret = __db_fchk(dbenv, "memp_fcreate", flags, 0)) != 0)
return (ret);
if ((ret = __os_calloc(dbenv, 1, sizeof(DB_MPOOLFILE), &dbmfp)) != 0)
return (ret);
if ((ret = __os_calloc(dbenv, 1, sizeof(DB_FH), &dbmfp->fhp)) != 0)
goto err;
if (F_ISSET(dbenv, DB_ENV_THREAD) &&
(ret = __db_mutex_setup(dbenv, dbmp->reginfo, &dbmfp->mutexp,
MUTEX_ALLOC | MUTEX_THREAD)) != 0)
goto err;
dbmfp->ref = 1;
dbmfp->lsn_offset = -1;
dbmfp->dbmp = dbmp;
dbmfp->mfp = INVALID_ROFF;
dbmfp->close = __memp_fclose;
dbmfp->get = __memp_fget;
dbmfp->get_fileid = __memp_get_fileid;
dbmfp->last_pgno = __memp_last_pgno;
dbmfp->open = __memp_fopen;
dbmfp->put = __memp_fput;
dbmfp->refcnt = __memp_refcnt;
dbmfp->set = __memp_fset;
dbmfp->set_clear_len = __memp_set_clear_len;
dbmfp->set_fileid = __memp_set_fileid;
dbmfp->set_ftype = __memp_set_ftype;
dbmfp->set_lsn_offset = __memp_set_lsn_offset;
dbmfp->set_pgcookie = __memp_set_pgcookie;
dbmfp->set_priority = __memp_set_priority;
dbmfp->set_unlink = __memp_set_unlink;
dbmfp->sync = __memp_fsync;
*retp = dbmfp;
return (0);
err: if (dbmfp != NULL) {
if (dbmfp->fhp != NULL)
(void)__os_free(dbenv, dbmfp->fhp);
(void)__os_free(dbenv, dbmfp);
}
return (ret);
}
static int
__memp_set_clear_len(dbmfp, clear_len)
DB_MPOOLFILE *dbmfp;
u_int32_t clear_len;
{
MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_clear_len");
dbmfp->clear_len = clear_len;
return (0);
}
static int
__memp_set_fileid(dbmfp, fileid)
DB_MPOOLFILE *dbmfp;
u_int8_t *fileid;
{
MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_fileid");
dbmfp->fileid = fileid;
return (0);
}
static int
__memp_set_ftype(dbmfp, ftype)
DB_MPOOLFILE *dbmfp;
int ftype;
{
MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_ftype");
dbmfp->ftype = ftype;
return (0);
}
static int
__memp_set_lsn_offset(dbmfp, lsn_offset)
DB_MPOOLFILE *dbmfp;
int32_t lsn_offset;
{
MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_lsn_offset");
dbmfp->lsn_offset = lsn_offset;
return (0);
}
static int
__memp_set_pgcookie(dbmfp, pgcookie)
DB_MPOOLFILE *dbmfp;
DBT *pgcookie;
{
MPF_ILLEGAL_AFTER_OPEN(dbmfp, "set_pgcookie");
dbmfp->pgcookie = pgcookie;
return (0);
}
static int
__memp_set_priority(dbmfp, priority)
DB_MPOOLFILE *dbmfp;
DB_CACHE_PRIORITY priority;
{
switch (priority) {
case DB_PRIORITY_VERY_LOW:
dbmfp->mfp->priority = MPOOL_PRI_VERY_LOW;
break;
case DB_PRIORITY_LOW:
dbmfp->mfp->priority = MPOOL_PRI_LOW;
break;
case DB_PRIORITY_DEFAULT:
dbmfp->mfp->priority = MPOOL_PRI_DEFAULT;
break;
case DB_PRIORITY_HIGH:
dbmfp->mfp->priority = MPOOL_PRI_HIGH;
break;
case DB_PRIORITY_VERY_HIGH:
dbmfp->mfp->priority = MPOOL_PRI_VERY_HIGH;
break;
default:
__db_err(dbmfp->dbmp->dbenv,
"Unknown priority value: %d", priority);
return (EINVAL);
}
return (0);
}
static int
__memp_fopen(dbmfp, path, flags, mode, pagesize)
DB_MPOOLFILE *dbmfp;
const char *path;
u_int32_t flags;
int mode;
size_t pagesize;
{
DB_ENV *dbenv;
DB_MPOOL *dbmp;
int ret;
dbmp = dbmfp->dbmp;
dbenv = dbmp->dbenv;
PANIC_CHECK(dbenv);
if ((ret = __db_fchk(dbenv, "memp_fopen", flags,
DB_CREATE | DB_DIRECT | DB_EXTENT |
DB_NOMMAP | DB_ODDFILESIZE | DB_RDONLY | DB_TRUNCATE)) != 0)
return (ret);
if (pagesize == 0 || !POWER_OF_TWO(pagesize)) {
__db_err(dbenv,
"memp_fopen: page sizes must be a power-of-2");
return (EINVAL);
}
if (dbmfp->clear_len > pagesize) {
__db_err(dbenv,
"memp_fopen: clear length larger than page size");
return (EINVAL);
}
if (LF_ISSET(DB_RDONLY) && path == NULL) {
__db_err(dbenv,
"memp_fopen: temporary files can't be readonly");
return (EINVAL);
}
return (__memp_fopen_int(dbmfp, NULL, path, flags, mode, pagesize));
}
int
__memp_fopen_int(dbmfp, mfp, path, flags, mode, pagesize)
DB_MPOOLFILE *dbmfp;
MPOOLFILE *mfp;
const char *path;
u_int32_t flags;
int mode;
size_t pagesize;
{
DB_ENV *dbenv;
DB_MPOOL *dbmp;
MPOOL *mp;
db_pgno_t last_pgno;
size_t maxmap;
u_int32_t mbytes, bytes, oflags;
int mfp_alloc, ret;
u_int8_t idbuf[DB_FILE_ID_LEN];
char *rpath;
void *p;
dbmp = dbmfp->dbmp;
dbenv = dbmp->dbenv;
mp = dbmp->reginfo[0].primary;
mfp_alloc = ret = 0;
rpath = NULL;
dbmfp->fhp->pagesize = (u_int32_t)pagesize;
if (path == NULL)
goto alloc;
oflags = 0;
if (LF_ISSET(DB_CREATE))
oflags |= DB_OSO_CREATE;
if (LF_ISSET(DB_DIRECT))
oflags |= DB_OSO_DIRECT;
if (LF_ISSET(DB_RDONLY)) {
F_SET(dbmfp, MP_READONLY);
oflags |= DB_OSO_RDONLY;
}
if ((ret =
__db_appname(dbenv, DB_APP_DATA, path, 0, NULL, &rpath)) != 0)
goto err;
if ((ret = __os_open(dbenv, rpath, oflags, mode, dbmfp->fhp)) != 0) {
if (!LF_ISSET(DB_EXTENT))
__db_err(dbenv, "%s: %s", rpath, db_strerror(ret));
goto err;
}
if ((ret = __os_ioinfo(
dbenv, rpath, dbmfp->fhp, &mbytes, &bytes, NULL)) != 0) {
__db_err(dbenv, "%s: %s", rpath, db_strerror(ret));
goto err;
}
if (dbmfp->fileid == NULL) {
if ((ret = __os_fileid(dbenv, rpath, 0, idbuf)) != 0)
goto err;
dbmfp->fileid = idbuf;
}
if (mfp != NULL) {
MUTEX_LOCK(dbenv, &mfp->mutex);
++mfp->mpf_cnt;
MUTEX_UNLOCK(dbenv, &mfp->mutex);
goto check_map;
}
R_LOCK(dbenv, dbmp->reginfo);
for (mfp = SH_TAILQ_FIRST(&mp->mpfq, __mpoolfile);
mfp != NULL; mfp = SH_TAILQ_NEXT(mfp, q, __mpoolfile)) {
if (F_ISSET(mfp, MP_DEADFILE | MP_TEMP))
continue;
if (memcmp(dbmfp->fileid, R_ADDR(dbmp->reginfo,
mfp->fileid_off), DB_FILE_ID_LEN) != 0)
continue;
if (LF_ISSET(DB_TRUNCATE)) {
MUTEX_LOCK(dbenv, &mfp->mutex);
MPOOLFILE_IGNORE(mfp);
MUTEX_UNLOCK(dbenv, &mfp->mutex);
continue;
}
if (dbmfp->clear_len != mfp->clear_len ||
pagesize != mfp->stat.st_pagesize ||
dbmfp->lsn_offset != mfp->lsn_off) {
__db_err(dbenv,
"%s: clear length, page size or LSN location changed",
path);
R_UNLOCK(dbenv, dbmp->reginfo);
ret = EINVAL;
goto err;
}
if (dbmfp->ftype != 0)
mfp->ftype = dbmfp->ftype;
MUTEX_LOCK(dbenv, &mfp->mutex);
++mfp->mpf_cnt;
MUTEX_UNLOCK(dbenv, &mfp->mutex);
break;
}
R_UNLOCK(dbenv, dbmp->reginfo);
if (mfp != NULL)
goto check_map;
alloc:
if ((ret = __memp_alloc(
dbmp, dbmp->reginfo, NULL, sizeof(MPOOLFILE), NULL, &mfp)) != 0)
goto err;
mfp_alloc = 1;
memset(mfp, 0, sizeof(MPOOLFILE));
mfp->mpf_cnt = 1;
mfp->ftype = dbmfp->ftype;
mfp->stat.st_pagesize = pagesize;
mfp->lsn_off = dbmfp->lsn_offset;
mfp->clear_len = dbmfp->clear_len;
if (LF_ISSET(DB_DIRECT))
F_SET(mfp, MP_DIRECT);
if (LF_ISSET(DB_EXTENT))
F_SET(mfp, MP_EXTENT);
F_SET(mfp, MP_CAN_MMAP);
if (path == NULL)
F_SET(mfp, MP_TEMP);
else {
if (bytes % pagesize != 0) {
if (LF_ISSET(DB_ODDFILESIZE))
bytes -= (u_int32_t)(bytes % pagesize);
else {
__db_err(dbenv,
"%s: file size not a multiple of the pagesize", rpath);
ret = EINVAL;
goto err;
}
}
last_pgno = (db_pgno_t)(mbytes * (MEGABYTE / pagesize));
last_pgno += (db_pgno_t)(bytes / pagesize);
if (last_pgno != 0)
--last_pgno;
mfp->orig_last_pgno = mfp->last_pgno = last_pgno;
if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
NULL, strlen(path) + 1, &mfp->path_off, &p)) != 0)
goto err;
memcpy(p, path, strlen(path) + 1);
if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
NULL, DB_FILE_ID_LEN, &mfp->fileid_off, &p)) != 0)
goto err;
memcpy(p, dbmfp->fileid, DB_FILE_ID_LEN);
}
if (dbmfp->pgcookie == NULL || dbmfp->pgcookie->size == 0) {
mfp->pgcookie_len = 0;
mfp->pgcookie_off = 0;
} else {
if ((ret = __memp_alloc(dbmp, dbmp->reginfo,
NULL, dbmfp->pgcookie->size, &mfp->pgcookie_off, &p)) != 0)
goto err;
memcpy(p, dbmfp->pgcookie->data, dbmfp->pgcookie->size);
mfp->pgcookie_len = dbmfp->pgcookie->size;
}
R_LOCK(dbenv, dbmp->reginfo);
ret = __db_mutex_setup(dbenv, dbmp->reginfo, &mfp->mutex,
MUTEX_NO_RLOCK);
if (ret == 0)
SH_TAILQ_INSERT_HEAD(&mp->mpfq, mfp, q, __mpoolfile);
R_UNLOCK(dbenv, dbmp->reginfo);
if (ret != 0)
goto err;
check_map:
#define DB_MAXMMAPSIZE (10 * 1024 * 1024)
if (F_ISSET(mfp, MP_CAN_MMAP)) {
if (path == NULL)
F_CLR(mfp, MP_CAN_MMAP);
if (!F_ISSET(dbmfp, MP_READONLY))
F_CLR(mfp, MP_CAN_MMAP);
if (dbmfp->ftype != 0)
F_CLR(mfp, MP_CAN_MMAP);
if (LF_ISSET(DB_NOMMAP) || F_ISSET(dbenv, DB_ENV_NOMMAP))
F_CLR(mfp, MP_CAN_MMAP);
maxmap = dbenv->mp_mmapsize == 0 ?
DB_MAXMMAPSIZE : dbenv->mp_mmapsize;
if (mbytes > maxmap / MEGABYTE ||
(mbytes == maxmap / MEGABYTE && bytes >= maxmap % MEGABYTE))
F_CLR(mfp, MP_CAN_MMAP);
dbmfp->addr = NULL;
if (F_ISSET(mfp, MP_CAN_MMAP)) {
dbmfp->len = (size_t)mbytes * MEGABYTE + bytes;
if (__os_mapfile(dbenv, rpath,
dbmfp->fhp, dbmfp->len, 1, &dbmfp->addr) != 0) {
dbmfp->addr = NULL;
F_CLR(mfp, MP_CAN_MMAP);
}
}
}
dbmfp->mfp = mfp;
F_SET(dbmfp, MP_OPEN_CALLED);
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
TAILQ_INSERT_TAIL(&dbmp->dbmfq, dbmfp, q);
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
if (0) {
err: if (F_ISSET(dbmfp->fhp, DB_FH_VALID))
(void)__os_closehandle(dbenv, dbmfp->fhp);
if (mfp_alloc) {
R_LOCK(dbenv, dbmp->reginfo);
if (mfp->path_off != 0)
__db_shalloc_free(dbmp->reginfo[0].addr,
R_ADDR(dbmp->reginfo, mfp->path_off));
if (mfp->fileid_off != 0)
__db_shalloc_free(dbmp->reginfo[0].addr,
R_ADDR(dbmp->reginfo, mfp->fileid_off));
__db_shalloc_free(dbmp->reginfo[0].addr, mfp);
R_UNLOCK(dbenv, dbmp->reginfo);
}
}
if (rpath != NULL)
__os_free(dbenv, rpath);
return (ret);
}
static void
__memp_get_fileid(dbmfp, fidp)
DB_MPOOLFILE *dbmfp;
u_int8_t *fidp;
{
memcpy(fidp, R_ADDR(
dbmfp->dbmp->reginfo, dbmfp->mfp->fileid_off), DB_FILE_ID_LEN);
}
static void
__memp_last_pgno(dbmfp, pgnoaddr)
DB_MPOOLFILE *dbmfp;
db_pgno_t *pgnoaddr;
{
DB_ENV *dbenv;
DB_MPOOL *dbmp;
dbmp = dbmfp->dbmp;
dbenv = dbmp->dbenv;
R_LOCK(dbenv, dbmp->reginfo);
*pgnoaddr = dbmfp->mfp->last_pgno;
R_UNLOCK(dbenv, dbmp->reginfo);
}
static void
__memp_refcnt(dbmfp, cntp)
DB_MPOOLFILE *dbmfp;
db_pgno_t *cntp;
{
DB_ENV *dbenv;
dbenv = dbmfp->dbmp->dbenv;
MUTEX_LOCK(dbenv, &dbmfp->mfp->mutex);
*cntp = dbmfp->mfp->mpf_cnt;
MUTEX_UNLOCK(dbenv, &dbmfp->mfp->mutex);
}
static void
__memp_set_unlink(dbmpf, set)
DB_MPOOLFILE *dbmpf;
int set;
{
DB_ENV *dbenv;
dbenv = dbmpf->dbmp->dbenv;
MUTEX_LOCK(dbenv, &dbmpf->mfp->mutex);
if (set)
F_SET(dbmpf->mfp, MP_UNLINK);
else
F_CLR(dbmpf->mfp, MP_UNLINK);
MUTEX_UNLOCK(dbenv, &dbmpf->mfp->mutex);
}
static int
__memp_fclose(dbmfp, flags)
DB_MPOOLFILE *dbmfp;
u_int32_t flags;
{
DB_ENV *dbenv;
int ret, t_ret;
dbenv = dbmfp->dbmp->dbenv;
PANIC_CHECK(dbenv);
ret = __db_fchk(dbenv, "DB_MPOOLFILE->close", flags, DB_MPOOL_DISCARD);
if ((t_ret = __memp_fclose_int(dbmfp, flags)) != 0 && ret == 0)
ret = t_ret;
return (ret);
}
int
__memp_fclose_int(dbmfp, flags)
DB_MPOOLFILE *dbmfp;
u_int32_t flags;
{
DB_ENV *dbenv;
DB_MPOOL *dbmp;
MPOOLFILE *mfp;
char *rpath;
int deleted, ret, t_ret;
dbmp = dbmfp->dbmp;
dbenv = dbmp->dbenv;
ret = 0;
for (deleted = 0;;) {
MUTEX_THREAD_LOCK(dbenv, dbmp->mutexp);
if (dbmfp->ref == 1) {
if (F_ISSET(dbmfp, MP_OPEN_CALLED))
TAILQ_REMOVE(&dbmp->dbmfq, dbmfp, q);
deleted = 1;
}
MUTEX_THREAD_UNLOCK(dbenv, dbmp->mutexp);
if (deleted)
break;
__os_sleep(dbenv, 1, 0);
}
if (dbmfp->pinref != 0) {
__db_err(dbenv, "%s: close: %lu blocks left pinned",
__memp_fn(dbmfp), (u_long)dbmfp->pinref);
ret = __db_panic(dbenv, DB_RUNRECOVERY);
}
if (dbmfp->addr != NULL &&
(ret = __os_unmapfile(dbenv, dbmfp->addr, dbmfp->len)) != 0)
__db_err(dbenv, "%s: %s", __memp_fn(dbmfp), db_strerror(ret));
if (F_ISSET(dbmfp->fhp, DB_FH_VALID) &&
(t_ret = __os_closehandle(dbenv, dbmfp->fhp)) != 0) {
__db_err(dbenv, "%s: %s", __memp_fn(dbmfp), db_strerror(t_ret));
if (ret == 0)
ret = t_ret;
}
if (dbmfp->mutexp != NULL)
__db_mutex_free(dbenv, dbmp->reginfo, dbmfp->mutexp);
if ((mfp = dbmfp->mfp) == NULL)
goto done;
deleted = 0;
MUTEX_LOCK(dbenv, &mfp->mutex);
if (--mfp->mpf_cnt == 0 || LF_ISSET(DB_MPOOL_DISCARD)) {
if (LF_ISSET(DB_MPOOL_DISCARD) ||
F_ISSET(mfp, MP_TEMP | MP_UNLINK))
MPOOLFILE_IGNORE(mfp);
if (F_ISSET(mfp, MP_UNLINK)) {
if ((t_ret = __db_appname(dbmp->dbenv,
DB_APP_DATA, R_ADDR(dbmp->reginfo,
mfp->path_off), 0, NULL, &rpath)) != 0 && ret == 0)
ret = t_ret;
if (t_ret == 0) {
if ((t_ret = __os_unlink(
dbmp->dbenv, rpath) != 0) && ret == 0)
ret = t_ret;
__os_free(dbenv, rpath);
}
}
if (mfp->block_cnt == 0) {
if ((t_ret =
__memp_mf_discard(dbmp, mfp)) != 0 && ret == 0)
ret = t_ret;
deleted = 1;
}
}
if (deleted == 0)
MUTEX_UNLOCK(dbenv, &mfp->mutex);
done: __os_free(dbenv, dbmfp->fhp);
__os_free(dbenv, dbmfp);
return (ret);
}
int
__memp_mf_discard(dbmp, mfp)
DB_MPOOL *dbmp;
MPOOLFILE *mfp;
{
DB_ENV *dbenv;
DB_FH fh;
DB_MPOOL_STAT *sp;
MPOOL *mp;
char *rpath;
int ret;
dbenv = dbmp->dbenv;
mp = dbmp->reginfo[0].primary;
ret = 0;
if (!F_ISSET(mfp, MP_DEADFILE) &&
(ret = __db_appname(dbenv, DB_APP_DATA,
R_ADDR(dbmp->reginfo, mfp->path_off), 0, NULL, &rpath)) == 0) {
if ((ret = __os_open(dbenv, rpath, 0, 0, &fh)) == 0) {
ret = __os_fsync(dbenv, &fh);
(void)__os_closehandle(dbenv, &fh);
}
__os_free(dbenv, rpath);
}
MPOOLFILE_IGNORE(mfp);
MUTEX_UNLOCK(dbenv, &mfp->mutex);
R_LOCK(dbenv, dbmp->reginfo);
SH_TAILQ_REMOVE(&mp->mpfq, mfp, q, __mpoolfile);
sp = &mp->stat;
sp->st_cache_hit += mfp->stat.st_cache_hit;
sp->st_cache_miss += mfp->stat.st_cache_miss;
sp->st_map += mfp->stat.st_map;
sp->st_page_create += mfp->stat.st_page_create;
sp->st_page_in += mfp->stat.st_page_in;
sp->st_page_out += mfp->stat.st_page_out;
__db_shlocks_clear(&mfp->mutex, dbmp->reginfo,
(REGMAINT *)R_ADDR(dbmp->reginfo, mp->maint_off));
if (mfp->path_off != 0)
__db_shalloc_free(dbmp->reginfo[0].addr,
R_ADDR(dbmp->reginfo, mfp->path_off));
if (mfp->fileid_off != 0)
__db_shalloc_free(dbmp->reginfo[0].addr,
R_ADDR(dbmp->reginfo, mfp->fileid_off));
if (mfp->pgcookie_off != 0)
__db_shalloc_free(dbmp->reginfo[0].addr,
R_ADDR(dbmp->reginfo, mfp->pgcookie_off));
__db_shalloc_free(dbmp->reginfo[0].addr, mfp);
R_UNLOCK(dbenv, dbmp->reginfo);
return (ret);
}
char *
__memp_fn(dbmfp)
DB_MPOOLFILE *dbmfp;
{
return (__memp_fns(dbmfp->dbmp, dbmfp->mfp));
}
char *
__memp_fns(dbmp, mfp)
DB_MPOOL *dbmp;
MPOOLFILE *mfp;
{
if (mfp->path_off == 0)
return ((char *)"temporary");
return ((char *)R_ADDR(dbmp->reginfo, mfp->path_off));
}