int
main(int argc, char *const* argv)
{
const char *progname = "dbxml_dump";
DB_ENV *dbenv;
XmlManager *xmlDb;
u_int32_t cache;
int ch, exitval, is_private, keyflag, nflag, ret, Rflag, rflag;
char *home, *passwd;
if ((ret = version_check(progname)) != 0)
return (ret);
dbenv = NULL;
xmlDb = NULL;
exitval = nflag = rflag = Rflag = 0;
keyflag = 0;
cache = MEGABYTE;
is_private = 0;
home = passwd = NULL;
while ((ch = getopt(argc, argv, "f:h:NP:rRV")) != EOF)
switch (ch) {
case 'f':
if (freopen(optarg, "wb", stdout) == NULL) {
fprintf(stderr, "%s: %s: reopen: %s\n",
progname, optarg, strerror(errno));
return (EXIT_FAILURE);
}
break;
case 'h':
home = optarg;
break;
case 'N':
nflag = 1;
break;
case 'P':
passwd = strdup(optarg);
memset(optarg, 0, strlen(optarg));
if (passwd == NULL) {
fprintf(stderr, "%s: strdup: %s\n",
progname, strerror(errno));
return (EXIT_FAILURE);
}
break;
case 'R':
Rflag = 1;
/* DB_AGGRESSIVE requires DB_SALVAGE */
/* FALLTHROUGH */
case 'r':
rflag = 1;
break;
case 'V':
printf("%s\n", DbXml::dbxml_version(NULL, NULL, NULL));
printf("%s\n", db_version(NULL, NULL, NULL));
return (EXIT_SUCCESS);
case '?':
default:
return (usage());
}
argc -= optind;
argv += optind;
if (argc != 1)
return (usage());
/* Handle possible interruptions. */
SigBlock sb;
/*
* Create an environment object and initialize it for error
* reporting.
*/
if ((ret = db_env_create(&dbenv, 0)) != 0) {
fprintf(stderr,
"%s: db_env_create: %s\n", progname, db_strerror(ret));
goto err;
}
dbenv->set_errfile(dbenv, stderr);
dbenv->set_errpfx(dbenv, progname);
if (nflag) {
if ((ret = dbenv->set_flags(dbenv, DB_NOLOCKING, 1)) != 0) {
dbenv->err(dbenv, ret, "set_flags: DB_NOLOCKING");
goto err;
}
if ((ret = dbenv->set_flags(dbenv, DB_NOPANIC, 1)) != 0) {
dbenv->err(dbenv, ret, "set_flags: DB_NOPANIC");
goto err;
}
}
if (passwd != NULL && (ret = dbenv->set_encrypt(dbenv,
passwd, DB_ENCRYPT_AES)) != 0) {
dbenv->err(dbenv, ret, "set_passwd");
goto err;
}
/* Initialize the environment. */
if ((ret = db_init(dbenv, home, rflag, cache, &is_private)) != 0) {
dbenv->err(dbenv, ret, "db_init");
goto err;
}
xmlDb = new XmlManager(dbenv);
if (rflag) {
try {
xmlDb->verifyContainer(argv[0], &cout, DB_SALVAGE | (Rflag ? DB_AGGRESSIVE : 0));
} catch (XmlException &e) {
dbenv->errx(dbenv, "verify %s: %s", argv[0], e.what());
goto err;
}
goto done;
}
try {
xmlDb->dumpContainer(argv[0], &cout);
} catch (XmlException &e) {
dbenv->errx(dbenv, "dump %s: %s", argv[0], e.what());
goto err;
}
if (0) {
err:
exitval = 1;
}
done:
if (xmlDb)
delete xmlDb;
if ((ret = dbenv->close(dbenv, 0)) != 0) {
exitval = 1;
fprintf(stderr,
"%s: dbenv->close: %s\n", progname, db_strerror(ret));
}
return (exitval == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
static void
b_inmem_op_tds(u_int ops, int update, u_int32_t env_flags, u_int32_t log_flags)
{
DB *dbp;
DBT key, data;
DB_ENV *dbenv;
DB_MPOOL_STAT *gsp;
DB_TXN *txn;
char *keybuf, *databuf;
DB_BENCH_ASSERT((keybuf = malloc(keysize)) != NULL);
DB_BENCH_ASSERT((databuf = malloc(datasize)) != NULL);
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
key.data = keybuf;
key.size = keysize;
memset(keybuf, 'a', keysize);
data.data = databuf;
data.size = datasize;
memset(databuf, 'b', datasize);
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
/* General environment configuration. */
#ifdef DB_AUTO_COMMIT
DB_BENCH_ASSERT(dbenv->set_flags(dbenv, DB_AUTO_COMMIT, 1) == 0);
#endif
if (env_flags != 0)
DB_BENCH_ASSERT(dbenv->set_flags(dbenv, env_flags, 1) == 0);
/* Logging configuration. */
if (log_flags != 0)
#if DB_VERSION_MINOR >= 7
DB_BENCH_ASSERT(
dbenv->log_set_config(dbenv, log_flags, 1) == 0);
#else
DB_BENCH_ASSERT(dbenv->set_flags(dbenv, log_flags, 1) == 0);
#endif
#ifdef DB_LOG_INMEMORY
if (!(log_flags & DB_LOG_INMEMORY))
#endif
#ifdef DB_LOG_IN_MEMORY
if (!(log_flags & DB_LOG_IN_MEMORY))
#endif
DB_BENCH_ASSERT(dbenv->set_lg_max(dbenv, logbufsize * 10) == 0);
DB_BENCH_ASSERT(dbenv->set_lg_bsize(dbenv, logbufsize) == 0);
DB_BENCH_ASSERT(dbenv->open(dbenv, "TESTDIR",
DB_CREATE | DB_PRIVATE | DB_INIT_LOCK |
DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN, 0666) == 0);
DB_BENCH_ASSERT(db_create(&dbp, dbenv, 0) == 0);
DB_BENCH_ASSERT(dbp->set_pagesize(dbp, pagesize) == 0);
DB_BENCH_ASSERT(dbp->open(
dbp, NULL, TESTFILE, NULL, DB_BTREE, DB_CREATE, 0666) == 0);
if (update) {
(void)dbenv->memp_stat(dbenv, &gsp, NULL, DB_STAT_CLEAR);
TIMER_START;
for (; ops > 0; --ops)
DB_BENCH_ASSERT(
dbp->put(dbp, NULL, &key, &data, 0) == 0);
TIMER_STOP;
if (dbenv->memp_stat(dbenv, &gsp, NULL, 0) == 0)
DB_BENCH_ASSERT(gsp->st_page_out == 0);
} else {
DB_BENCH_ASSERT(dbp->put(dbp, NULL, &key, &data, 0) == 0);
(void)dbenv->memp_stat(dbenv, &gsp, NULL, DB_STAT_CLEAR);
TIMER_START;
for (; ops > 0; --ops) {
DB_BENCH_ASSERT(
dbenv->txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(
dbp->get(dbp, NULL, &key, &data, 0) == 0);
DB_BENCH_ASSERT(txn->commit(txn, 0) == 0);
}
TIMER_STOP;
if (dbenv->memp_stat(dbenv, &gsp, NULL, 0) == 0)
DB_BENCH_ASSERT(gsp->st_cache_miss == 0);
}
DB_BENCH_ASSERT(dbp->close(dbp, 0) == 0);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
}
/************************* Transactional Berkeley DB *************************/
gpointer bdb_thread(gpointer d)
{
int res;
DB_ENV *env;
DB *db;
DB_TXN *txn = NULL;
int count = 0;
res = db_env_create(&env, 0);
g_assert(res == 0);
res = env->open(env, ".",
DB_CREATE | DB_RECOVER | DB_INIT_LOCK | DB_INIT_LOG
| DB_INIT_MPOOL | DB_INIT_TXN | DB_THREAD, 0644);
g_assert(res == 0);
if (opt_bdb_async) {
res = env->set_flags(env, DB_TXN_WRITE_NOSYNC, 1);
g_assert(res == 0);
}
res = db_create(&db, env, 0);
g_assert(res == 0);
res = db->open(db, NULL, "log.db", "log", DB_BTREE,
DB_CREATE | DB_THREAD | DB_AUTO_COMMIT, 0644);
g_assert(res == 0);
while (TRUE) {
if (txn == NULL && !opt_bdb_async) {
res = env->txn_begin(env, NULL, &txn, 0);
g_assert(res == 0);
}
struct item *item = get_item();
DBT key, value;
memset(&key, 0, sizeof(key));
memset(&value, 0, sizeof(value));
key.data = item->key;
key.size = strlen(item->key);
value.data = item->data;
value.size = item->len;
res = db->put(db, opt_bdb_async ? NULL : txn, &key, &value, 0);
g_assert(res == 0);
count++;
if (count % opt_batchsize == 0) {
if (opt_bdb_async) {
env->txn_checkpoint(env, 0, 0, 0);
} else {
txn->commit(txn, 0);
txn = NULL;
}
}
finish_item(item);
}
return NULL;
}
static struct nb_db *
nb_db_berkeleydb_open(const struct nb_db_opts *opts)
{
struct nb_db_berkeleydb *berkeleydb = malloc(sizeof(*berkeleydb));
if (berkeleydb == NULL) {
fprintf(stderr, "malloc(%zu) failed", sizeof(*berkeleydb));
goto error_1;
}
int r;
r = mkdir(opts->path, 0777);
if (r != 0 && errno != EEXIST) {
fprintf(stderr, "mkdir: %d\n", r);
goto error_1;
}
DB_ENV *env;
DB *db;
int env_flags = DB_REGION_INIT;
r = db_env_create(&env, 0);
if (r != 0) {
fprintf(stderr, "db_env_create: %s\n",
db_strerror(r));
goto error_1;
}
r = env->set_cachesize(env, 0, 0, 1);
if (r != 0) {
fprintf(stderr, "set_cachesize: %s\n",
db_strerror(r));
goto error_2;
}
env_flags |= DB_TXN_WRITE_NOSYNC;
r = env->set_flags(env, env_flags, 1);
if (r != 0) {
fprintf(stderr, "set_flags: %s\n",
db_strerror(r));
goto error_2;
}
int log_flags = DB_LOG_AUTO_REMOVE;
r = env->log_set_config(env, log_flags, 1);
int env_open_flags = DB_CREATE|DB_INIT_MPOOL;
r = env->open(env, opts->path, env_open_flags, 0666);
if (r != 0) {
fprintf(stderr, "env->open: %s\n",
db_strerror(r));
goto error_2;
}
r = db_create(&db, env, 0);
if (r != 0) {
fprintf(stderr, "db_create: %s\n",
db_strerror(r));
goto error_2;
}
int open_flags = DB_CREATE;
r = db->open(db, NULL, "data.bdb", NULL, DB_BTREE, open_flags, 0664);
if (r != 0) {
fprintf(stderr, "db->open: %s\n",
db_strerror(r));
goto error_3;
}
berkeleydb->env = env;
berkeleydb->db = db;
return (struct nb_db *) berkeleydb;
error_3:
db->close(db, 0);
error_2:
env->close(env, 0);
error_1:
return NULL;
}
static int
bdb_init_tx_handle(struct storage* s, char* db_env_path)
{
int result;
DB_ENV* dbenv;
//Create environment handle
result = db_env_create(&dbenv, 0);
if (result != 0) {
paxos_log_error("DB_ENV creation failed: %s", db_strerror(result));
return -1;
}
//Durability mode
if (!paxos_config.bdb_sync)
result = dbenv->set_flags(dbenv, DB_TXN_WRITE_NOSYNC, 1);
if (result != 0) {
paxos_log_error("DB_ENV set_flags failed: %s", db_strerror(result));
return -1;
}
//Redirect errors to sdout
dbenv->set_errfile(dbenv, stdout);
//Set the size of the memory cache
result = dbenv->set_cachesize(dbenv, 0, paxos_config.bdb_cachesize, 1);
if (result != 0) {
paxos_log_error("DB_ENV set_cachesize failed: %s",
db_strerror(result));
return -1;
}
//TODO see page size impact
//Set page size for this db
// result = dbp->set_pagesize(dbp, pagesize);
// assert(result == 0);
//FIXME set log size
// Environment open flags
int flags;
flags =
DB_CREATE | /* Create if not existing */
DB_RECOVER | /* Run normal recovery. */
DB_INIT_LOCK | /* Initialize the locking subsystem */
DB_INIT_LOG | /* Initialize the logging subsystem */
DB_INIT_TXN | /* Initialize the transactional subsystem. */
DB_THREAD | /* Cause the environment to be free-threaded */
DB_REGISTER |
DB_INIT_MPOOL; /* Initialize the memory pool (in-memory cache) */
//Open the DB environment
result = dbenv->open(dbenv,
db_env_path, /* Environment directory */
flags, /* Open flags */
0); /* Default file permissions */
if (result != 0) {
paxos_log_error("DB_ENV open failed: %s", db_strerror(result));
return -1;
}
paxos_log_info("Berkeley DB storage opened successfully");
s->env = dbenv;
return 0;
}
void
op_tds(u_int ops, int update, u_int32_t flags)
{
DB *dbp;
DBT key, data;
DB_ENV *dbenv;
DB_TXN *txn;
char *keybuf, *databuf;
DB_MPOOL_STAT *gsp;
DB_BENCH_ASSERT((keybuf = malloc(keysize)) != NULL);
DB_BENCH_ASSERT((databuf = malloc(datasize)) != NULL);
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
key.data = keybuf;
key.size = keysize;
memset(keybuf, 'a', keysize);
data.data = databuf;
data.size = datasize;
memset(databuf, 'b', datasize);
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
#ifdef DB_AUTO_COMMIT
DB_BENCH_ASSERT(dbenv->set_flags(dbenv, DB_AUTO_COMMIT, 1) == 0);
#endif
DB_BENCH_ASSERT(dbenv->set_flags(dbenv, flags, 1) == 0);
#ifdef DB_LOG_INMEMORY
if (!(flags & DB_LOG_INMEMORY))
#endif
DB_BENCH_ASSERT(dbenv->set_lg_max(dbenv, logbufsize * 10) == 0);
DB_BENCH_ASSERT(dbenv->set_lg_bsize(dbenv, logbufsize) == 0);
DB_BENCH_ASSERT(dbenv->open(dbenv, "TESTDIR",
DB_CREATE | DB_PRIVATE | DB_INIT_LOCK |
DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN, 0666) == 0);
DB_BENCH_ASSERT(db_create(&dbp, dbenv, 0) == 0);
DB_BENCH_ASSERT(dbp->set_pagesize(dbp, pagesize) == 0);
DB_BENCH_ASSERT(
dbp->open(dbp, NULL, "a", NULL, DB_BTREE, DB_CREATE, 0666) == 0);
if (update) {
dbenv->memp_stat(dbenv, &gsp, NULL, DB_STAT_CLEAR);
TIMER_START;
for (; ops > 0; --ops)
DB_BENCH_ASSERT(
dbp->put(dbp, NULL, &key, &data, 0) == 0);
TIMER_STOP;
dbenv->memp_stat(dbenv, &gsp, NULL, 0);
DB_BENCH_ASSERT(gsp->st_page_out == 0);
} else {
DB_BENCH_ASSERT(dbp->put(dbp, NULL, &key, &data, 0) == 0);
dbenv->memp_stat(dbenv, &gsp, NULL, DB_STAT_CLEAR);
TIMER_START;
for (; ops > 0; --ops) {
DB_BENCH_ASSERT(
dbenv->txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(
dbp->get(dbp, NULL, &key, &data, 0) == 0);
DB_BENCH_ASSERT(txn->commit(txn, 0) == 0);
}
TIMER_STOP;
dbenv->memp_stat(dbenv, &gsp, NULL, 0);
DB_BENCH_ASSERT(gsp->st_cache_miss == 0);
}
DB_BENCH_ASSERT(dbp->close(dbp, 0) == 0);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
}
/*
* 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);
}
