int DbEnv::set_shm_key(long shm_key)
{
int ret;
DB_ENV *dbenv = unwrap(this);
if ((ret = dbenv->set_shm_key(dbenv, shm_key)) != 0)
DB_ERROR("DbEnv::set_shm_key", ret, error_policy());
return (ret);
}
int
cache_init(cache_t *c, void (*freevalue)(void *value))
{
memset(c, '\0', sizeof(*c));
int ret;
DB_ENV *dbenv;
ret = db_env_create(&dbenv, 0);
dbenv->err(dbenv,ret,"err db_env_create ");
dbenv->set_errfile(dbenv, stderr);
dbenv->err(dbenv,ret,"err set_errfile ");
if ((ret = dbenv->set_shm_key(dbenv, 664)) != 0) {
dbenv->err(dbenv,ret,"err set_shm_key ");
return 0;
}
ret = dbenv->open(dbenv,bfile(_temp_path),DB_CREATE | DB_INIT_MPOOL | DB_INIT_CDB ,0);
dbenv->err(dbenv,ret,"err db_env_open ");
/* Create and initialize database object */
if ((ret = db_create(&c->c_data, dbenv, 0)) != 0) {
fprintf(stderr,
"%s: db_create: %s\n", "bbdocument", db_strerror(ret));
return 0;
}
#ifdef DEBUG
dbenv->stat_print(dbenv, DB_STAT_ALL);
#endif
/* open the database. */
if ((ret = c->c_data->open(c->c_data, NULL, "libcachedb", NULL, DB_BTREE, DB_CREATE, 0)) != 0) {
c->c_data->err(c->c_data, ret, "db open");
//goto err1;
//dette skjer nor collection mappen ikke er opprettet enda, typisk forde vi ikke har lagret et dokument der enda
#ifdef DEBUG
printf("can't dbp->open(), but db_create() was sucessful!\n");
#endif
return 0;
}
#ifdef DEBUG
c->c_data->stat_print(c->c_data, DB_STAT_ALL);
#endif
pthread_mutex_init(&c->c_lock, NULL);
c->c_freevalue = freevalue;
return 1;
}
static int db_init(dbiIndex dbi, const char * dbhome,
const char * dbfile,
const char * dbsubfile,
DB_ENV ** dbenvp)
{
rpmdb rpmdb = dbi->dbi_rpmdb;
DB_ENV *dbenv = NULL;
int eflags;
int rc;
if (dbenvp == NULL)
return 1;
/* XXX HACK */
if (rpmdb->db_errfile == NULL)
rpmdb->db_errfile = stderr;
eflags = (dbi->dbi_oeflags | dbi->dbi_eflags);
if (eflags & DB_JOINENV) eflags &= DB_JOINENV;
if (dbfile) {
char *dbiflags = prDbiOpenFlags(eflags, 1);
rpmlog(RPMLOG_DEBUG, "opening db environment %s/%s %s\n",
dbhome, dbfile, dbiflags);
free(dbiflags);
}
/* XXX Can't do RPC w/o host. */
if (dbi->dbi_host == NULL)
dbi->dbi_ecflags &= ~DB_CLIENT;
/* XXX Set a default shm_key. */
if ((dbi->dbi_eflags & DB_SYSTEM_MEM) && dbi->dbi_shmkey == 0) {
#if defined(HAVE_FTOK)
dbi->dbi_shmkey = ftok(dbhome, 0);
#else
dbi->dbi_shmkey = 0x44631380;
#endif
}
rc = db_env_create(&dbenv, dbi->dbi_ecflags);
rc = cvtdberr(dbi, "db_env_create", rc, _debug);
if (dbenv == NULL || rc)
goto errxit;
{ int xx;
/* 4.1: dbenv->set_app_dispatch(???) */
/* 4.1: dbenv->set_alloc(???) */
/* 4.1: dbenv->set_data_dir(???) */
/* 4.1: dbenv->set_encrypt(???) */
dbenv->set_errcall(dbenv, (void *) rpmdb->db_errcall);
dbenv->set_errfile(dbenv, rpmdb->db_errfile);
dbenv->set_errpfx(dbenv, rpmdb->db_errpfx);
/* 4.1: dbenv->set_feedback(???) */
/* 4.1: dbenv->set_flags(???) */
/* dbenv->set_paniccall(???) */
#if (DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR >= 5)
/*
* These enable automatic stale lock removal.
* thread_count 8 is some kind of "magic minimum" value...
*/
dbenv->set_thread_count(dbenv, 8);
dbenv->set_isalive(dbenv, db3isalive);
#endif
if ((dbi->dbi_ecflags & DB_CLIENT) && dbi->dbi_host) {
const char * home;
int retry = 0;
if ((home = strrchr(dbhome, '/')) != NULL)
dbhome = ++home;
while (retry++ < 5) {
xx = dbenv->set_rpc_server(dbenv, NULL, dbi->dbi_host,
dbi->dbi_cl_timeout, dbi->dbi_sv_timeout, 0);
xx = cvtdberr(dbi, "dbenv->set_server", xx, _debug);
if (!xx)
break;
(void) sleep(15);
}
} else {
#if !(DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)
xx = dbenv->set_verbose(dbenv, DB_VERB_CHKPOINT,
(dbi->dbi_verbose & DB_VERB_CHKPOINT));
#endif
xx = dbenv->set_verbose(dbenv, DB_VERB_DEADLOCK,
(dbi->dbi_verbose & DB_VERB_DEADLOCK));
xx = dbenv->set_verbose(dbenv, DB_VERB_RECOVERY,
(dbi->dbi_verbose & DB_VERB_RECOVERY));
xx = dbenv->set_verbose(dbenv, DB_VERB_WAITSFOR,
(dbi->dbi_verbose & DB_VERB_WAITSFOR));
if (dbi->dbi_mmapsize) {
xx = dbenv->set_mp_mmapsize(dbenv, dbi->dbi_mmapsize);
xx = cvtdberr(dbi, "dbenv->set_mp_mmapsize", xx, _debug);
}
if (dbi->dbi_tmpdir) {
const char * root;
char * tmpdir;
root = (dbi->dbi_root ? dbi->dbi_root : rpmdb->db_root);
if ((root[0] == '/' && root[1] == '\0') || rpmdb->db_chrootDone)
root = NULL;
tmpdir = rpmGenPath(root, dbi->dbi_tmpdir, NULL);
xx = dbenv->set_tmp_dir(dbenv, tmpdir);
xx = cvtdberr(dbi, "dbenv->set_tmp_dir", xx, _debug);
tmpdir = _free(tmpdir);
}
}
/* dbenv->set_lk_conflicts(???) */
/* dbenv->set_lk_detect(???) */
/* 4.1: dbenv->set_lk_max_lockers(???) */
/* 4.1: dbenv->set_lk_max_locks(???) */
/* 4.1: dbenv->set_lk_max_objects(???) */
/* 4.1: dbenv->set_lg_bsize(???) */
/* 4.1: dbenv->set_lg_dir(???) */
/* 4.1: dbenv->set_lg_max(???) */
/* 4.1: dbenv->set_lg_regionmax(???) */
if (dbi->dbi_cachesize) {
xx = dbenv->set_cachesize(dbenv, 0, dbi->dbi_cachesize, 0);
xx = cvtdberr(dbi, "dbenv->set_cachesize", xx, _debug);
}
/* 4.1 dbenv->set_timeout(???) */
/* dbenv->set_tx_max(???) */
/* 4.1: dbenv->set_tx_timestamp(???) */
/* dbenv->set_tx_recover(???) */
/* dbenv->set_rep_transport(???) */
/* dbenv->set_rep_limit(???) */
if (dbi->dbi_no_fsync) {
xx = db_env_set_func_fsync(db3_fsync_disable);
xx = cvtdberr(dbi, "db_env_set_func_fsync", xx, _debug);
}
if (dbi->dbi_shmkey) {
xx = dbenv->set_shm_key(dbenv, dbi->dbi_shmkey);
xx = cvtdberr(dbi, "dbenv->set_shm_key", xx, _debug);
}
}
rc = (dbenv->open)(dbenv, dbhome, eflags, dbi->dbi_perms);
rc = cvtdberr(dbi, "dbenv->open", rc, _debug);
if (rc)
goto errxit;
#if (DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR >= 5)
/* stale lock removal */
rc = dbenv->failchk(dbenv, 0);
rc = cvtdberr(dbi, "dbenv->failchk", rc, _debug);
if (rc)
goto errxit;
#endif
*dbenvp = dbenv;
return 0;
errxit:
if (dbenv) {
int xx;
xx = dbenv->close(dbenv, 0);
xx = cvtdberr(dbi, "dbenv->close", xx, _debug);
}
return rc;
}
/*
* This should be done before the program is open for business.
* As such, it does not need to be reentrant.
*/
int
open_db_env(char *topdir)
{
DB_ENV *tmpenv = NULL;
int st;
struct stat64 sbuf;
char logdir[MAXPATHLEN+1];
char tmpdir[MAXPATHLEN+1];
char *dirarr[3];
int i;
if (topdir == NULL) {
return (-1);
}
snprintf(logdir, sizeof (tmpdir), "%s/.logs", topdir);
snprintf(tmpdir, sizeof (tmpdir), "%s/.tmp", topdir);
dirarr[0] = topdir;
dirarr[1] = logdir;
dirarr[2] = tmpdir;
/* first, set up the environment */
st = db_env_create(&tmpenv, 0);
if (st != 0) {
return (st);
}
/* make sure the directories exist */
for (i = 0; i < 3; i++) {
st = stat64(dirarr[i], &sbuf);
if ((st != 0) && (errno == ENOENT)) {
st = mkdirp(dirarr[i], 0744);
if (st == 0) {
st = stat64(dirarr[i], &sbuf);
}
}
if ((st == 0) && (!S_ISDIR(sbuf.st_mode))) {
st = -1;
break;
}
}
if (st != 0) {
return (st);
}
st = tmpenv->set_data_dir(tmpenv, topdir);
if (st != 0) {
return (st);
}
st = tmpenv->set_lg_dir(tmpenv, logdir);
if (st != 0) {
return (st);
}
st = tmpenv->set_tmp_dir(tmpenv, tmpdir);
if (st != 0) {
return (st);
}
st = tmpenv->set_flags(tmpenv, env_fl, 1);
if (st != 0) {
return (st);
}
/* overall database cache size */
st = tmpenv->set_cachesize(tmpenv, 0, (60 * MEGA), 1);
st = tmpenv->set_shm_key(tmpenv, FSM_SHM_MASTER_KEY);
if (st != 0) {
return (st);
}
/* log buffer in memory */
st = tmpenv->set_lg_bsize(tmpenv, (30 * MEGA));
if (st != 0) {
return (st);
}
/* set up additional error logging */
tmpenv->set_errcall(tmpenv, fsmdb_log_err);
/* Increase the number of locks available */
tmpenv->set_lk_max_locks(tmpenv, 10000);
tmpenv->set_lk_max_lockers(tmpenv, 10000);
tmpenv->set_lk_max_objects(tmpenv, 10000);
/* Increase the number of concurrent transactions available */
/* Note: Default in 4.4-20 is '20'. In later versions it's 100 */
tmpenv->set_tx_max(tmpenv, 100);
st = tmpenv->open(tmpenv, topdir, env_ofl, 0644);
if (st != 0) {
/* check for a major failure */
if (st == DB_RUNRECOVERY) {
st = tmpenv->open(tmpenv, topdir, env_ffl, 0644);
}
/* log catastrophic failure and remove all db files. */
if (st == DB_RUNRECOVERY) {
fsmdb_log_err(dbEnv, NULL,
"Database files corrupt, cannot recover. "
"Files will be removed. Please re-index any "
"recovery points to regenerate the database.");
fsmdb_remove_all(topdir);
}
}
if (st != 0) {
return (st);
}
/* clear out unneeded log files */
tmpenv->log_archive(tmpenv, NULL, DB_ARCH_REMOVE);
/* all set, ready to use */
dbEnv = tmpenv;
return (st);
}
