#include "db_config.h"
#include "db_int.h"
#include "dbinc/log.h"
#include "dbinc/mp.h"
#include "dbinc/db_page.h"
#include "dbinc/hash.h"
static int __memp_mpf_alloc __P((DB_MPOOL *,
DB_MPOOLFILE *, const char *, u_int32_t, u_int32_t, MPOOLFILE **));
static int __memp_mpf_find __P((ENV *,
DB_MPOOLFILE *, DB_MPOOL_HASH *, const char *, u_int32_t, MPOOLFILE **));
int
__memp_fopen_pp(dbmfp, path, flags, mode, pagesize)
DB_MPOOLFILE *dbmfp;
const char *path;
u_int32_t flags;
int mode;
size_t pagesize;
{
DB_THREAD_INFO *ip;
ENV *env;
int ret;
env = dbmfp->env;
if ((ret = __db_fchk(env, "DB_MPOOLFILE->open", flags,
DB_CREATE | DB_DIRECT | DB_EXTENT | DB_MULTIVERSION |
DB_NOMMAP | DB_ODDFILESIZE | DB_RDONLY | DB_TRUNCATE)) != 0)
return (ret);
if (pagesize == 0 || !POWER_OF_TWO(pagesize)) {
__db_errx(env,
"DB_MPOOLFILE->open: page sizes must be a power-of-2");
return (EINVAL);
}
if (dbmfp->clear_len > pagesize) {
__db_errx(env,
"DB_MPOOLFILE->open: clear length larger than page size");
return (EINVAL);
}
if (LF_ISSET(DB_RDONLY) && path == NULL) {
__db_errx(env,
"DB_MPOOLFILE->open: temporary files can't be readonly");
return (EINVAL);
}
if (LF_ISSET(DB_MULTIVERSION) && !TXN_ON(env)) {
__db_errx(env,
"DB_MPOOLFILE->open: DB_MULTIVERSION requires transactions");
return (EINVAL);
}
ENV_ENTER(env, ip);
REPLICATION_WRAP(env,
(__memp_fopen(dbmfp, NULL, path, flags, mode, pagesize)), 0, ret);
ENV_LEAVE(env, ip);
return (ret);
}
int
__memp_fopen(dbmfp, mfp, path, flags, mode, pgsize)
DB_MPOOLFILE *dbmfp;
MPOOLFILE *mfp;
const char *path;
u_int32_t flags;
int mode;
size_t pgsize;
{
DB_ENV *dbenv;
DB_MPOOL *dbmp;
DB_MPOOLFILE *tmp_dbmfp;
DB_MPOOL_HASH *hp;
ENV *env;
MPOOL *mp;
MPOOLFILE *alloc_mfp;
size_t maxmap;
db_pgno_t last_pgno;
u_int32_t bucket, mbytes, bytes, oflags, pagesize;
int refinc, ret;
char *rpath;
if (F_ISSET(dbmfp, MP_OPEN_CALLED))
return (0);
env = dbmfp->env;
dbmp = env->mp_handle;
dbenv = env->dbenv;
mp = dbmp->reginfo[0].primary;
alloc_mfp = NULL;
mbytes = bytes = 0;
refinc = ret = 0;
rpath = NULL;
pagesize = (u_int32_t)pgsize;
DB_ASSERT(env, mfp == NULL || path == NULL);
bucket = 0;
hp = R_ADDR(dbmp->reginfo, mp->ftab);
if (mfp == NULL) {
if (path == NULL)
goto alloc;
if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE))
bucket = FNBUCKET(path, strlen(path));
else
bucket = FNBUCKET(dbmfp->fileid, DB_FILE_ID_LEN);
hp += bucket;
if (F_ISSET(dbmfp, MP_FILEID_SET)) {
MUTEX_LOCK(env, hp->mtx_hash);
ret =
__memp_mpf_find(env, dbmfp, hp, path, flags,&mfp);
MUTEX_UNLOCK(env, hp->mtx_hash);
if (ret != 0)
goto err;
if (mfp != NULL)
refinc = 1;
}
} else {
MUTEX_LOCK(env, mfp->mutex);
if (!mfp->deadfile) {
++mfp->mpf_cnt;
refinc = 1;
}
MUTEX_UNLOCK(env, mfp->mutex);
if (mfp->deadfile)
return (EINVAL);
}
if (!FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE)) {
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 (F_ISSET(env->dbenv, DB_ENV_DSYNC_DB))
oflags |= DB_OSO_DSYNC;
if (mfp != NULL) {
MPOOL_SYSTEM_LOCK(env);
path = R_ADDR(dbmp->reginfo, mfp->path_off);
}
if ((ret = __db_appname(env,
DB_APP_DATA, path, 0, NULL, &rpath)) == 0)
ret = __os_open(env, rpath,
(u_int32_t)pagesize, oflags, mode, &dbmfp->fhp);
if (mfp != NULL)
MPOOL_SYSTEM_UNLOCK(env);
if (ret != 0)
goto err;
dbmfp->fhp->ref = 1;
if ((ret = __mutex_alloc(env, MTX_MPOOL_FH,
DB_MUTEX_PROCESS_ONLY, &dbmfp->fhp->mtx_fh)) != 0)
goto err;
if ((ret = __os_ioinfo(
env, rpath, dbmfp->fhp, &mbytes, &bytes, NULL)) != 0) {
__db_err(env, ret, "%s", rpath);
goto err;
}
DB_ASSERT(env, pagesize != 0);
if (bytes % pagesize != 0) {
if (LF_ISSET(DB_ODDFILESIZE))
bytes -= (u_int32_t)(bytes % pagesize);
else {
__db_errx(env,
"%s: file size not a multiple of the pagesize", rpath);
ret = EINVAL;
goto err;
}
}
if (mfp == NULL && !F_ISSET(dbmfp, MP_FILEID_SET)) {
if ((ret =
__os_fileid(env, rpath, 0, dbmfp->fileid)) != 0)
goto err;
F_SET(dbmfp, MP_FILEID_SET);
goto alloc;
}
}
if (mfp != NULL)
goto have_mfp;
check: MUTEX_LOCK(env, hp->mtx_hash);
if ((ret = __memp_mpf_find(env, dbmfp, hp, path, flags, &mfp) != 0))
goto err;
if (alloc_mfp != NULL && mfp == NULL) {
mfp = alloc_mfp;
alloc_mfp = NULL;
SH_TAILQ_INSERT_HEAD(&hp->hash_bucket, mfp, q, __mpoolfile);
} else if (mfp != NULL) {
if ((dbmfp->clear_len != DB_CLEARLEN_NOTSET &&
mfp->clear_len != DB_CLEARLEN_NOTSET &&
dbmfp->clear_len != mfp->clear_len) ||
(pagesize != 0 && pagesize != mfp->stat.st_pagesize) ||
(dbmfp->lsn_offset != DB_LSN_OFF_NOTSET &&
mfp->lsn_off != DB_LSN_OFF_NOTSET &&
dbmfp->lsn_offset != mfp->lsn_off)) {
__db_errx(env,
"%s: clear length, page size or LSN location changed",
path);
MUTEX_UNLOCK(env, hp->mtx_hash);
ret = EINVAL;
goto err;
}
}
MUTEX_UNLOCK(env, hp->mtx_hash);
if (alloc_mfp != NULL) {
MUTEX_LOCK(env, alloc_mfp->mutex);
if ((ret = __memp_mf_discard(dbmp, alloc_mfp)) != 0)
goto err;
}
if (mfp == NULL) {
if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE) &&
!LF_ISSET(DB_CREATE)) {
ret = ENOENT;
goto err;
}
alloc:
if (path != NULL &&
!FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE) &&
!F_ISSET(dbmfp, MP_FILEID_SET) && (ret =
__os_fileid(env, rpath, 0, dbmfp->fileid)) != 0)
goto err;
if ((ret = __memp_mpf_alloc(dbmp,
dbmfp, path, pagesize, flags, &alloc_mfp)) != 0)
goto err;
DB_ASSERT(env, pagesize != 0);
last_pgno = (db_pgno_t)(mbytes * (MEGABYTE / pagesize));
last_pgno += (db_pgno_t)(bytes / pagesize);
if (last_pgno != 0)
--last_pgno;
alloc_mfp->last_flushed_pgno = alloc_mfp->orig_last_pgno =
alloc_mfp->last_pgno = last_pgno;
alloc_mfp->bucket = bucket;
if (path != NULL)
goto check;
mfp = alloc_mfp;
MUTEX_LOCK(env, hp->mtx_hash);
SH_TAILQ_INSERT_TAIL(&hp->hash_bucket, mfp, q);
MUTEX_UNLOCK(env, hp->mtx_hash);
}
have_mfp:
if (!LF_ISSET(DB_DURABLE_UNKNOWN | DB_RDONLY)) {
if (F_ISSET(mfp, MP_DURABLE_UNKNOWN)) {
if (LF_ISSET(MP_NOT_DURABLE))
F_SET(mfp, MP_NOT_DURABLE);
F_CLR(mfp, MP_DURABLE_UNKNOWN);
} else if (!LF_ISSET(DB_TXN_NOT_DURABLE) !=
!F_ISSET(mfp, MP_NOT_DURABLE)) {
__db_errx(env,
"Cannot open DURABLE and NOT DURABLE handles in the same file");
ret = EINVAL;
goto err;
}
}
if (LF_ISSET(DB_MULTIVERSION)) {
++mfp->multiversion;
F_SET(dbmfp, MP_MULTIVERSION);
}
dbmfp->mfp = mfp;
#define DB_MAXMMAPSIZE (10 * 1024 * 1024)
if (F_ISSET(mfp, MP_CAN_MMAP)) {
maxmap = dbenv->mp_mmapsize == 0 ?
DB_MAXMMAPSIZE : dbenv->mp_mmapsize;
if (path == NULL ||
FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE))
F_CLR(mfp, MP_CAN_MMAP);
else if (!F_ISSET(dbmfp, MP_READONLY))
F_CLR(mfp, MP_CAN_MMAP);
else if (dbmfp->ftype != 0)
F_CLR(mfp, MP_CAN_MMAP);
else if (LF_ISSET(DB_NOMMAP) || F_ISSET(dbenv, DB_ENV_NOMMAP))
F_CLR(mfp, MP_CAN_MMAP);
else {
MPOOL_SYSTEM_LOCK(env);
maxmap = mp->mp_mmapsize == 0 ?
DB_MAXMMAPSIZE : mp->mp_mmapsize;
MPOOL_SYSTEM_UNLOCK(env);
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(env, rpath,
dbmfp->fhp, dbmfp->len, 1, &dbmfp->addr) != 0) {
dbmfp->addr = NULL;
F_CLR(mfp, MP_CAN_MMAP);
}
}
}
F_SET(dbmfp, MP_OPEN_CALLED);
MUTEX_LOCK(env, dbmp->mutex);
if (dbmfp->fhp != NULL)
TAILQ_FOREACH(tmp_dbmfp, &dbmp->dbmfq, q)
if (dbmfp->mfp == tmp_dbmfp->mfp &&
(F_ISSET(dbmfp, MP_READONLY) ||
!F_ISSET(tmp_dbmfp, MP_READONLY))) {
(void)__mutex_free(env, &dbmfp->fhp->mtx_fh);
(void)__os_closehandle(env, dbmfp->fhp);
++tmp_dbmfp->fhp->ref;
dbmfp->fhp = tmp_dbmfp->fhp;
break;
}
TAILQ_INSERT_TAIL(&dbmp->dbmfq, dbmfp, q);
MUTEX_UNLOCK(env, dbmp->mutex);
if (0) {
err: if (refinc) {
MUTEX_LOCK(env, mfp->mutex);
--mfp->mpf_cnt;
MUTEX_UNLOCK(env, mfp->mutex);
}
}
if (rpath != NULL)
__os_free(env, rpath);
return (ret);
}
static int
__memp_mpf_find(env, dbmfp, hp, path, flags, mfpp)
ENV *env;
DB_MPOOLFILE *dbmfp;
DB_MPOOL_HASH *hp;
const char *path;
u_int32_t flags;
MPOOLFILE **mfpp;
{
DB_MPOOL *dbmp;
MPOOLFILE *mfp;
dbmp = env->mp_handle;
SH_TAILQ_FOREACH(mfp, &hp->hash_bucket, q, __mpoolfile) {
if (mfp->deadfile || F_ISSET(mfp, MP_TEMP))
continue;
if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE)) {
if (!mfp->no_backing_file)
continue;
if (strcmp(path, R_ADDR(dbmp->reginfo, mfp->path_off)))
continue;
if (!F_ISSET(dbmfp, MP_FILEID_SET))
(void)__memp_set_fileid(dbmfp,
R_ADDR(dbmp->reginfo, mfp->fileid_off));
} else
if (memcmp(dbmfp->fileid, R_ADDR(dbmp->reginfo,
mfp->fileid_off), DB_FILE_ID_LEN) != 0)
continue;
if (LF_ISSET(DB_TRUNCATE)) {
MUTEX_LOCK(env, mfp->mutex);
mfp->deadfile = 1;
MUTEX_UNLOCK(env, mfp->mutex);
continue;
}
MUTEX_LOCK(env, mfp->mutex);
if (mfp->deadfile) {
MUTEX_UNLOCK(env, mfp->mutex);
continue;
}
++mfp->mpf_cnt;
MUTEX_UNLOCK(env, mfp->mutex);
if (dbmfp->ftype != 0)
mfp->ftype = dbmfp->ftype;
if (dbmfp->clear_len != DB_CLEARLEN_NOTSET)
mfp->clear_len = dbmfp->clear_len;
if (dbmfp->lsn_offset != -1)
mfp->lsn_off = dbmfp->lsn_offset;
break;
}
*mfpp = mfp;
return (0);
}
static int
__memp_mpf_alloc(dbmp, dbmfp, path, pagesize, flags, retmfp)
DB_MPOOL *dbmp;
DB_MPOOLFILE *dbmfp;
const char *path;
u_int32_t pagesize;
u_int32_t flags;
MPOOLFILE **retmfp;
{
ENV *env;
MPOOLFILE *mfp;
int ret;
void *p;
env = dbmp->env;
ret = 0;
if ((ret = __memp_alloc(dbmp,
dbmp->reginfo, NULL, sizeof(MPOOLFILE), NULL, &mfp)) != 0)
goto err;
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;
mfp->priority = dbmfp->priority;
if (dbmfp->gbytes != 0 || dbmfp->bytes != 0) {
mfp->maxpgno = (db_pgno_t)
(dbmfp->gbytes * (GIGABYTE / mfp->stat.st_pagesize));
mfp->maxpgno += (db_pgno_t)
((dbmfp->bytes + mfp->stat.st_pagesize - 1) /
mfp->stat.st_pagesize);
}
if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE))
mfp->no_backing_file = 1;
if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_UNLINK))
mfp->unlink_on_close = 1;
if (LF_ISSET(DB_DURABLE_UNKNOWN | DB_RDONLY))
F_SET(mfp, MP_DURABLE_UNKNOWN);
if (LF_ISSET(DB_DIRECT))
F_SET(mfp, MP_DIRECT);
if (LF_ISSET(DB_EXTENT))
F_SET(mfp, MP_EXTENT);
if (LF_ISSET(DB_TXN_NOT_DURABLE))
F_SET(mfp, MP_NOT_DURABLE);
F_SET(mfp, MP_CAN_MMAP);
if (path == NULL)
F_SET(mfp, MP_TEMP);
else if (FLD_ISSET(dbmfp->config_flags, DB_MPOOL_NOFILE))
mfp->mpf_cnt++;
if (F_ISSET(dbmfp, MP_FILEID_SET)) {
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 (path != NULL) {
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 (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;
}
if ((ret = __mutex_alloc(env,
MTX_MPOOLFILE_HANDLE, 0, &mfp->mutex)) != 0)
goto err;
*retmfp = mfp;
err: return (ret);
}
int
__memp_fclose_pp(dbmfp, flags)
DB_MPOOLFILE *dbmfp;
u_int32_t flags;
{
DB_THREAD_INFO *ip;
ENV *env;
int ret;
env = dbmfp->env;
if (flags != 0)
(void)__db_ferr(env, "DB_MPOOLFILE->close", 0);
ENV_ENTER(env, ip);
REPLICATION_WRAP(env, (__memp_fclose(dbmfp, 0)), 0, ret);
ENV_LEAVE(env, ip);
return (ret);
}
int
__memp_fclose(dbmfp, flags)
DB_MPOOLFILE *dbmfp;
u_int32_t flags;
{
DB_MPOOL *dbmp;
ENV *env;
MPOOLFILE *mfp;
char *rpath;
u_int32_t ref;
int deleted, ret, t_ret;
env = dbmfp->env;
dbmp = env->mp_handle;
ret = 0;
if (dbmp == NULL)
goto done;
MUTEX_LOCK(env, dbmp->mutex);
DB_ASSERT(env, dbmfp->ref >= 1);
if ((ref = --dbmfp->ref) == 0 && F_ISSET(dbmfp, MP_OPEN_CALLED))
TAILQ_REMOVE(&dbmp->dbmfq, dbmfp, q);
if (ref == 0 && dbmfp->fhp != NULL && --dbmfp->fhp->ref > 0)
dbmfp->fhp = NULL;
MUTEX_UNLOCK(env, dbmp->mutex);
if (ref != 0)
return (0);
if (dbmfp->pinref != 0) {
__db_errx(env, "%s: close: %lu blocks left pinned",
__memp_fn(dbmfp), (u_long)dbmfp->pinref);
ret = __env_panic(env, DB_RUNRECOVERY);
}
if (dbmfp->addr != NULL &&
(ret = __os_unmapfile(env, dbmfp->addr, dbmfp->len)) != 0)
__db_err(env, ret, "%s", __memp_fn(dbmfp));
if (dbmfp->fhp != NULL) {
if ((t_ret =
__mutex_free(env, &dbmfp->fhp->mtx_fh)) != 0 && ret == 0)
ret = t_ret;
if ((t_ret = __os_closehandle(env, dbmfp->fhp)) != 0) {
__db_err(env, t_ret, "%s", __memp_fn(dbmfp));
if (ret == 0)
ret = t_ret;
}
dbmfp->fhp = NULL;
}
mfp = dbmfp->mfp;
DB_ASSERT(env,
(F_ISSET(dbmfp, MP_OPEN_CALLED) && mfp != NULL) ||
(!F_ISSET(dbmfp, MP_OPEN_CALLED) && mfp == NULL));
if (!F_ISSET(dbmfp, MP_OPEN_CALLED))
goto done;
deleted = 0;
if (!LF_ISSET(DB_MPOOL_NOLOCK))
MUTEX_LOCK(env, mfp->mutex);
if (F_ISSET(dbmfp, MP_MULTIVERSION))
--mfp->multiversion;
if (--mfp->mpf_cnt == 0 || LF_ISSET(DB_MPOOL_DISCARD)) {
if (LF_ISSET(DB_MPOOL_DISCARD) ||
F_ISSET(mfp, MP_TEMP) || mfp->unlink_on_close) {
mfp->deadfile = 1;
}
if (mfp->unlink_on_close) {
if ((t_ret = __db_appname(dbmp->env,
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->env, rpath, 0)) != 0 && ret == 0)
ret = t_ret;
__os_free(env, rpath);
}
}
if (mfp->block_cnt == 0) {
DB_ASSERT(env, !LF_ISSET(DB_MPOOL_NOLOCK));
if ((t_ret =
__memp_mf_discard(dbmp, mfp)) != 0 && ret == 0)
ret = t_ret;
deleted = 1;
}
}
if (!deleted && !LF_ISSET(DB_MPOOL_NOLOCK))
MUTEX_UNLOCK(env, mfp->mutex);
done:
if (dbmfp->pgcookie != NULL) {
__os_free(env, dbmfp->pgcookie->data);
__os_free(env, dbmfp->pgcookie);
}
__os_free(env, dbmfp);
return (ret);
}
int
__memp_mf_discard(dbmp, mfp)
DB_MPOOL *dbmp;
MPOOLFILE *mfp;
{
DB_MPOOL_HASH *hp;
ENV *env;
#ifdef HAVE_STATISTICS
DB_MPOOL_STAT *sp;
#endif
MPOOL *mp;
int need_sync, ret, t_ret;
env = dbmp->env;
mp = dbmp->reginfo[0].primary;
hp = R_ADDR(dbmp->reginfo, mp->ftab);
hp += mfp->bucket;
ret = 0;
need_sync =
mfp->file_written && !mfp->deadfile && !F_ISSET(mfp, MP_TEMP);
mfp->deadfile = 1;
MUTEX_UNLOCK(env, mfp->mutex);
if ((t_ret = __mutex_free(env, &mfp->mutex)) != 0 && ret == 0)
ret = t_ret;
MUTEX_LOCK(env, hp->mtx_hash);
SH_TAILQ_REMOVE(&hp->hash_bucket, mfp, q, __mpoolfile);
MUTEX_UNLOCK(env, hp->mtx_hash);
MPOOL_SYSTEM_LOCK(env);
if (need_sync &&
(t_ret = __memp_mf_sync(dbmp, mfp, 0)) != 0 && ret == 0)
ret = t_ret;
#ifdef HAVE_STATISTICS
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;
#endif
if (mfp->path_off != 0)
__memp_free(&dbmp->reginfo[0], NULL,
R_ADDR(dbmp->reginfo, mfp->path_off));
if (mfp->fileid_off != 0)
__memp_free(&dbmp->reginfo[0], NULL,
R_ADDR(dbmp->reginfo, mfp->fileid_off));
if (mfp->pgcookie_off != 0)
__memp_free(&dbmp->reginfo[0], NULL,
R_ADDR(dbmp->reginfo, mfp->pgcookie_off));
__memp_free(&dbmp->reginfo[0], NULL, mfp);
MPOOL_SYSTEM_UNLOCK(env);
return (ret);
}
int
__memp_inmemlist(env, namesp, cntp)
ENV *env;
char ***namesp;
int *cntp;
{
DB_MPOOL *dbmp;
DB_MPOOL_HASH *hp;
MPOOL *mp;
MPOOLFILE *mfp;
int arraysz, cnt, i, ret;
char **names;
names = NULL;
dbmp = env->mp_handle;
mp = dbmp->reginfo[0].primary;
hp = R_ADDR(dbmp->reginfo, mp->ftab);
arraysz = cnt = 0;
for (i = 0; i < MPOOL_FILE_BUCKETS; i++, hp++) {
MUTEX_LOCK(env, hp->mtx_hash);
SH_TAILQ_FOREACH(mfp, &hp->hash_bucket, q, __mpoolfile) {
if (mfp->deadfile || F_ISSET(mfp, MP_TEMP))
continue;
if (!mfp->no_backing_file)
continue;
if (cnt >= arraysz) {
arraysz += 100;
if ((ret = __os_realloc(env,
(u_int)arraysz * sizeof(names[0]),
&names)) != 0)
goto nomem;
}
if ((ret = __os_strdup(env,
R_ADDR(dbmp->reginfo, mfp->path_off),
&names[cnt])) != 0)
goto nomem;
cnt++;
}
MUTEX_UNLOCK(env, hp->mtx_hash);
}
*namesp = names;
*cntp = cnt;
return (0);
nomem: MUTEX_UNLOCK(env, hp->mtx_hash);
if (names != NULL) {
while (--cnt >= 0)
__os_free(env, names[cnt]);
__os_free(env, names);
}
*cntp = 0;
*namesp = NULL;
return (ret);
}