void
bdb_open(void)
{
DB *db;
DBC *dbc;
DB_ENV *dbenv;
assert(db_env_create(&dbenv, 0) == 0);
dbenv->set_errpfx(dbenv, "bdb");
dbenv->set_errfile(dbenv, stderr);
assert(dbenv->mutex_set_max(dbenv, 10000) == 0);
assert(dbenv->set_cachesize(dbenv, 0, 50 * 1024 * 1024, 1) == 0);
assert(dbenv->open(dbenv, NULL,
DB_CREATE | DB_INIT_LOCK | DB_INIT_MPOOL | DB_PRIVATE, 0) == 0);
assert(db_create(&db, dbenv, 0) == 0);
if (g.c_reverse)
assert(db->set_bt_compare(db, bdb_compare_reverse) == 0);
assert(db->open(
db, NULL, g.home_bdb, NULL, DB_BTREE, DB_CREATE, 0) == 0);
g.bdb = db;
assert(db->cursor(db, NULL, &dbc, 0) == 0);
g.dbc = dbc;
key_gen_init(&keyitem);
}
void BDB_RecoverEnv(const string& path,
bool fatal_recover)
{
DB_ENV *dbenv;
int ret;
if ((ret = db_env_create(&dbenv, 0)) != 0) {
string msg =
"Cannot create environment " + string(db_strerror(ret));
BDB_THROW(eInvalidOperation, msg);
}
dbenv->set_errfile(dbenv, stderr);
//if (verbose)
// (void)dbenv->set_verbose(dbenv, DB_VERB_RECOVERY, 1);
u_int32_t flags = 0;
flags |= DB_CREATE | DB_INIT_LOG |
DB_INIT_MPOOL | DB_INIT_TXN | DB_USE_ENVIRON;
flags |= fatal_recover ? DB_RECOVER_FATAL : DB_RECOVER;
flags |= DB_PRIVATE;
if ((ret = dbenv->open(dbenv, path.c_str(), flags, 0)) != 0) {
dbenv->close(dbenv, 0);
string msg =
"Cannot open environment " + string(db_strerror(ret));
BDB_THROW(eInvalidOperation, msg);
}
ret = dbenv->close(dbenv, 0);
}
void
bdb_open(void)
{
DB *db;
DBC *dbc;
DB_ENV *dbenv;
assert(db_env_create(&dbenv, 0) == 0);
dbenv->set_errpfx(dbenv, "bdb");
dbenv->set_errfile(dbenv, stderr);
assert(dbenv->mutex_set_max(dbenv, 10000) == 0);
assert(dbenv->set_cachesize(dbenv, 0, 50 * 1024 * 1024, 1) == 0);
assert(dbenv->open(dbenv, NULL,
DB_CREATE |
(g.c_delete_pct == 0 && g.c_insert_pct == 0 && g.c_write_pct == 0 ?
0 : DB_INIT_LOCK) |
DB_INIT_MPOOL | DB_PRIVATE, 0) == 0);
assert(db_create(&db, dbenv, 0) == 0);
if (g.c_file_type == ROW && g.c_reverse)
assert(db->set_bt_compare(db, bdb_compare_reverse) == 0);
assert(db->open(db, NULL, "__bdb", NULL, DB_BTREE, DB_CREATE, 0) == 0);
g.bdb = db;
assert(db->cursor(db, NULL, &dbc, 0) == 0);
g.dbc = dbc;
key_gen_setup(&keybuf);
}
void
env_open(DB_ENV **dbenvp)
{
DB_ENV *dbenv;
int ret;
/* Create the environment handle. */
if ((ret = db_env_create(&dbenv, 0)) != 0) {
fprintf(stderr,
"txnapp: db_env_create: %s\n", db_strerror(ret));
exit (1);
}
/* Set up error handling. */
dbenv->set_errpfx(dbenv, "txnapp");
dbenv->set_errfile(dbenv, stderr);
// match lladd's defaults...
dbenv->set_lg_bsize(dbenv, 1024*1024);
// match lladd's defaults...
dbenv->set_cachesize(dbenv, 0, 8204288, 0);
/* Do deadlock detection internally. */
/* if ((ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT)) != 0) {
dbenv->err(dbenv, ret, "set_lk_detect: DB_LOCK_DEFAULT");
exit (1);
}*/
dbenv->set_tx_max(dbenv, 32000);
unsigned int max;
dbenv->get_tx_max(dbenv, &max);
printf("Max xact count: %d\n", max);
/*
* Open a transactional environment:
* create if it doesn't exist
* free-threaded handle
* run recovery
* read/write owner only
*/
if ((ret = dbenv->open(dbenv, ENV_DIRECTORY,
DB_CREATE |/* DB_INIT_LOCK |*/ DB_INIT_LOG | DB_PRIVATE |
DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER | DB_THREAD,
S_IRUSR | S_IWUSR)) != 0) {
dbenv->err(dbenv, ret, "dbenv->open: %s", ENV_DIRECTORY);
exit (1);
}
*dbenvp = dbenv;
}
void
env_open(DB_ENV **dbenvp)
{
DB_ENV *dbenv;
int ret;
/* Create the environment handle. */
if ((ret = db_env_create(&dbenv, 0)) != 0) {
fprintf(stderr,
"txnapp: db_env_create: %s\n", db_strerror(ret));
exit (1);
}
/* Set up error handling. */
dbenv->set_errpfx(dbenv, "txnapp");
dbenv->set_errfile(dbenv, stderr);
/*
* Open a transactional environment:
* create if it doesn't exist
* free-threaded handle
* run recovery
* read/write owner only
*/
if ((ret = dbenv->open(dbenv, ENV_DIRECTORY,
DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG |
DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER ,
S_IRUSR | S_IWUSR)) != 0) {
(void)dbenv->close(dbenv, 0);
fprintf(stderr, "dbenv->open: %s: %s\n",
ENV_DIRECTORY, db_strerror(ret));
exit (1);
}
*dbenvp = dbenv;
}
OptimisticDb* optimisticDb_create()
{
OptimisticDb *optimisticDb;
DB_ENV *envp;
u_int32_t envFlags;
int ret;
/* Allocate memory */
optimisticDb = malloc( sizeof( OptimisticDb ) );
ret = db_env_create( &envp, 0 );
if( ret != 0 ) {
printf( "Failed to create anvironment for optimistic database store\n" );
exit(1);
}
envFlags =
DB_CREATE |
DB_INIT_LOCK |
DB_INIT_LOG |
DB_INIT_TXN |
DB_INIT_MPOOL |
DB_PRIVATE /* Don't put region files on disk */
;
/* Store database logs entirely in memory */
envp->log_set_config( envp, DB_LOG_IN_MEMORY, 1 );
/* Increase the cache size */
envp->set_cachesize( envp, 0, 100 * 1024 * 1024, 1 );
envp->set_errfile( envp, stderr );
ret = envp->open( envp, NULL, envFlags, 0 );
if( ret != 0 ) {
printf( "Failed to create environment for optimistic database store\n");
exit( 1 );
}
optimisticDb->envp = envp;
optimisticDb->isOpen = 0;
return optimisticDb;
}
/* Create and configure an environment handle. */
int
create_env(const char *progname, DB_ENV **dbenvp)
{
DB_ENV *dbenv;
int ret;
if ((ret = db_env_create(&dbenv, 0)) != 0) {
fprintf(stderr, "can't create env handle: %s\n",
db_strerror(ret));
return (ret);
}
dbenv->set_errfile(dbenv, stderr);
dbenv->set_errpfx(dbenv, progname);
*dbenvp = dbenv;
return (0);
}
int
dbfe_initialize_dbenv (DB_ENV **dbep, str filename, bool join, unsigned int cachesize = 1024)
{
int r (-1);
r = mkdir (filename, 0755);
if (r < 0 && errno != EEXIST) {
fatal ("Couldn't mkdir for database %s: %m", filename.cstr ());
}
r = db_env_create (dbep, 0);
if (r) return r;
DB_ENV *dbe = *dbep;
// Enable verbose dead lock detection.
dbe->set_verbose (dbe, DB_VERB_DEADLOCK, 1);
dbe->set_verbose (dbe, DB_VERB_WAITSFOR, 1);
dbe->set_lk_detect (dbe, DB_LOCK_DEFAULT);
dbe->set_errfile (dbe, stderr);
if (!join) {
// Force the latest parameters
strbuf db_config_path ("%s/DB_CONFIG", filename.cstr ());
dbfe_generate_config (db_config_path, cachesize);
// We use all the fixings
r = dbe->open (dbe, filename, DB_CREATE |
DB_INIT_MPOOL |
DB_INIT_LOCK |
DB_INIT_LOG |
DB_INIT_TXN |
DB_RECOVER , 0);
} else {
r = dbe->open (dbe, filename, DB_JOINENV, 0);
}
return r;
}
void
env_open(DB_ENV **dbenvp)
{
DB_ENV *dbenv;
int ret;
/* Create the environment handle. */
if ((ret = db_env_create(&dbenv, 0)) != 0) {
fprintf(stderr,
"txnapp: db_env_create: %s\n", db_strerror(ret));
exit (1);
}
/* Set up error handling. */
dbenv->set_errpfx(dbenv, "txnapp");
dbenv->set_errfile(dbenv, stderr);
/* Do deadlock detection internally. */
if ((ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT)) != 0) {
dbenv->err(dbenv, ret, "set_lk_detect: DB_LOCK_DEFAULT");
exit (1);
}
/*
* Open a transactional environment:
* create if it doesn't exist
* free-threaded handle
* run recovery
* read/write owner only
*/
if ((ret = dbenv->open(dbenv, ENV_DIRECTORY,
DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG |
DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER | DB_THREAD,
S_IRUSR | S_IWUSR)) != 0) {
dbenv->err(dbenv, ret, "dbenv->open: %s", ENV_DIRECTORY);
exit (1);
}
*dbenvp = dbenv;
}
/*
* env_init --
* Initialize the environment.
*/
DB_ENV * env_init( char *home, char *prefix, int cachesize)
{
DB_ENV *dbenv;
int ret;
if ((ret = db_env_create(&dbenv, 0)) != 0) {
dbenv->err(dbenv, ret, "db_env_create");
return (NULL);
}
dbenv->set_errfile(dbenv, stderr);
dbenv->set_errpfx(dbenv, prefix);
if ((ret = dbenv->set_cachesize(dbenv, 0, cachesize, 0)) != 0) {
dbenv->err(dbenv, ret, "DB_ENV->set_cachesize");
return (NULL);
}
if ((ret = dbenv->open(dbenv, home, DB_CREATE | DB_INIT_MPOOL |
DB_INIT_TXN | DB_INIT_LOCK, 0)) != 0) {
dbenv->err(dbenv, ret, "DB_ENV->open: %s", home);
(void)dbenv->close(dbenv, 0);
return (NULL);
}
return (dbenv);
}
/*
* db_init --
* Initialize the environment.
*/
int
db_init(char *home, DB_ENV **dbenvp)
{
int ret;
DB_ENV *dbenv;
if ((ret = db_env_create(&dbenv, 0)) != 0)
return (ret);
/* dbenv->set_lk_max(dbenv, 10000); */
dbenv->set_cachesize(dbenv, 0, 16 * 1024 * 1024, 0);
/* new version only ... dbenv->set_flags(dbenv, DB_CDB_ALLDB, 1); */
if (home == NULL) {
home = getenv("CHESHIRE_DB_HOME");
if (home == NULL) {
fprintf(stderr, "CHESHIRE_DB_HOME must be set OR config file <DBENV> set\n");
fprintf(LOGFILE, "CHESHIRE_DB_HOME must be set OR config file <DBENV> set\n");
return(1);
}
}
if ((ret = dbenv->open(dbenv, home,
DB_INIT_MPOOL | DB_INIT_CDB
| DB_CREATE | DB_USE_ENVIRON,
0)) == 0) {
*dbenvp = dbenv;
dbenv->set_errfile(dbenv, LOGFILE);
dbenv->set_errpfx(dbenv, "BerkeleyDB");
return (0);
}
/* this goes to stdout and screws up z39.50 connections -- hangs them */
/* dbenv->err(dbenv, ret, "Could not open DB environment: %s", home); */
fprintf(LOGFILE,"Could not open DB environment: %s\n",home);
(void)dbenv->close(dbenv, 0);
return (ret);
}
int TestKeyExistErrorReturn(CuTest *ct) {
DB *pdbp;
DB *sdbp;
DB_ENV *dbenv;
const char *sec_db_file = "secondary.db";
const char *pri_db_file = "primary.db";
const char *env_dir = "TESTDIR";
int i;
thread_t writer_threads[NUMWRITERS];
u_int32_t db_flags, env_flags;
pdbp = sdbp = NULL;
dbenv = NULL;
db_flags = DB_CREATE | DB_AUTO_COMMIT | DB_READ_UNCOMMITTED;
env_flags = DB_CREATE | DB_RECOVER | DB_INIT_LOCK | DB_INIT_LOG |
DB_INIT_MPOOL | DB_INIT_TXN | DB_THREAD;
TestEnvConfigTestSetup(ct);
CuAssert(ct, "db_env_create", db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
dbenv->set_errpfx(dbenv, "TestKeyExistErrorReturn");
/* Run deadlock detector on every lock conflict. */
CuAssert(ct, "dbenv->set_lk_detect",
dbenv->set_lk_detect(dbenv, DB_LOCK_MINWRITE) == 0);
CuAssert(ct, "dbenv->open",
dbenv->open(dbenv, env_dir, env_flags, 0) == 0);
CuAssert(ct, "db_create", db_create(&pdbp, dbenv, 0) == 0);
CuAssert(ct, "pdbp->open", pdbp->open(pdbp, NULL,
pri_db_file, NULL, DB_BTREE, db_flags, 0) == 0);
CuAssert(ct, "db_create", db_create(&sdbp, dbenv, 0) == 0);
CuAssert(ct, "sdbp->set_flags", sdbp->set_flags(sdbp,
DB_DUPSORT) == 0);
CuAssert(ct, "sdbp->open", sdbp->open(sdbp, NULL, sec_db_file,
NULL, DB_BTREE, db_flags, 0) == 0);
CuAssert(ct, "DB->associate", pdbp->associate(pdbp, NULL, sdbp,
assoc_callback, DB_AUTO_COMMIT) == 0);
/* Initialize a mutex. Used to help provide thread ids. */
(void)mutex_init(&thread_num_lock, NULL);
for (i = 0; i < NUMWRITERS; ++i)
(void)thread_create(&writer_threads[i], NULL,
writer_thread, (void *)pdbp);
for (i = 0; i < NUMWRITERS; ++i)
(void)thread_join(writer_threads[i], NULL);
if (sdbp != NULL)
CuAssert(ct, "sdbp->close", sdbp->close(sdbp, 0) == 0);
if (pdbp != NULL)
CuAssert(ct, "pdbp->close", pdbp->close(pdbp, 0) == 0);
if (dbenv != NULL)
CuAssert(ct, "dbenv->close", dbenv->close(dbenv, 0) == 0);
TestEnvConfigTestTeardown(ct);
return (EXIT_SUCCESS);
}
int
b_open(int argc, char *argv[])
{
extern char *optarg;
extern int optind, __db_getopt_reset;
DB_ENV *dbenv;
DB *dbp;
DBTYPE type;
int ch, i, count;
char *fname, *dbname, *ts;
type = DB_BTREE;
count = 1000;
fname = dbname = NULL;
ts = "Btree";
__db_getopt_reset = 1;
while ((ch = getopt(argc, argv, "c:dft:")) != EOF)
switch (ch) {
case 'c':
count = atoi(optarg);
break;
case 'd':
dbname = "dbname";
break;
case 'f':
fname = "filename";
break;
case 't':
switch (optarg[0]) {
case 'B': case 'b':
ts = "Btree";
type = DB_BTREE;
break;
case 'H': case 'h':
if (b_util_have_hash())
return (0);
ts = "Hash";
type = DB_HASH;
break;
case 'Q': case 'q':
if (b_util_have_queue())
return (0);
ts = "Queue";
type = DB_QUEUE;
break;
case 'R': case 'r':
ts = "Recno";
type = DB_RECNO;
break;
default:
return (b_open_usage());
}
break;
case '?':
default:
return (b_open_usage());
}
argc -= optind;
argv += optind;
if (argc != 0)
return (b_open_usage());
#if DB_VERSION_MAJOR < 4
/*
* Don't run in-memory database tests on versions less than 3, it
* takes forever and eats memory.
*/
if (fname == NULL && dbname == NULL)
return (0);
#endif
#if DB_VERSION_MAJOR < 4 || DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR < 4
/*
* Named in-memory databases weren't available until 4.4.
*/
if (fname == NULL && dbname != NULL)
return (0);
#endif
/* Create the environment. */
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 0
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR,
NULL, DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE, 0666) == 0);
#else
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR,
DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE, 0666) == 0);
#endif
/* Create the database. */
DB_BENCH_ASSERT(db_create(&dbp, dbenv, 0) == 0);
#if DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR >= 1
DB_BENCH_ASSERT(dbp->open(
dbp, NULL, fname, dbname, type, DB_CREATE, 0666) == 0);
#else
DB_BENCH_ASSERT(dbp->open(
dbp, fname, dbname, type, DB_CREATE, 0666) == 0);
#endif
DB_BENCH_ASSERT(dbp->close(dbp, 0) == 0);
/* Open the database count times. */
TIMER_START;
for (i = 0; i < count; ++i) {
DB_BENCH_ASSERT(db_create(&dbp, dbenv, 0) == 0);
#if DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR >= 1
DB_BENCH_ASSERT(dbp->open(
dbp, NULL, fname, dbname, type, DB_CREATE, 0666) == 0);
#else
DB_BENCH_ASSERT(dbp->open(
dbp, fname, dbname, type, DB_CREATE, 0666) == 0);
#endif
DB_BENCH_ASSERT(dbp->close(dbp, 0) == 0);
}
TIMER_STOP;
printf("# %d %s %sdatabase open/close pairs\n",
count, ts,
fname == NULL ?
(dbname == NULL ? "in-memory " : "named in-memory ") :
(dbname == NULL ? "" : "sub-"));
TIMER_DISPLAY(count);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
return (0);
}
int
b_txn(int argc, char *argv[])
{
extern char *optarg;
extern int optind;
DB_ENV *dbenv;
DB_TXN *txn;
int tabort, ch, i, count;
count = 1000;
tabort = 0;
while ((ch = getopt(argc, argv, "ac:")) != EOF)
switch (ch) {
case 'a':
tabort = 1;
break;
case 'c':
count = atoi(optarg);
break;
case '?':
default:
return (usage());
}
argc -= optind;
argv += optind;
if (argc != 0)
return (usage());
/* Create the environment. */
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR < 1
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR,
NULL, DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG |
DB_INIT_MPOOL | DB_INIT_TXN | DB_PRIVATE, 0666) == 0);
#else
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR,
DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG |
DB_INIT_MPOOL | DB_INIT_TXN | DB_PRIVATE, 0666) == 0);
#endif
/* Start and commit/abort a transaction count times. */
TIMER_START;
if (tabort)
for (i = 0; i < count; ++i) {
#if DB_VERSION_MAJOR < 4
DB_BENCH_ASSERT(txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(txn_abort(txn) == 0);
#else
DB_BENCH_ASSERT(
dbenv->txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(txn->abort(txn) == 0);
#endif
}
else
for (i = 0; i < count; ++i) {
#if DB_VERSION_MAJOR < 4
DB_BENCH_ASSERT(txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(txn_commit(txn, 0) == 0);
#else
DB_BENCH_ASSERT(
dbenv->txn_begin(dbenv, NULL, &txn, 0) == 0);
DB_BENCH_ASSERT(txn->commit(txn, 0) == 0);
#endif
}
TIMER_STOP;
printf("# %d empty transaction start/%s pairs\n",
count, tabort ? "abort" : "commit");
TIMER_DISPLAY(count);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
return (0);
}
int
b_recover(int argc, char *argv[])
{
extern char *optarg;
extern int optind;
DB *dbp;
DBT key, data;
DB_ENV *dbenv;
DB_TXN *txn;
u_int32_t cachesize;
int ch, i, count;
/*
* Recover was too slow before release 4.0 that it's not worth
* running the test.
*/
#if DB_VERSION_MAJOR < 4
return (0);
#endif
cachesize = MEGABYTE;
count = 1000;
while ((ch = getopt(argc, argv, "C:c:")) != EOF)
switch (ch) {
case 'C':
cachesize = (u_int32_t)atoi(optarg);
break;
case 'c':
count = atoi(optarg);
break;
case '?':
default:
return (usage());
}
argc -= optind;
argv += optind;
if (argc != 0)
return (usage());
/* Create the environment. */
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
DB_BENCH_ASSERT(dbenv->set_cachesize(dbenv, 0, cachesize, 0) == 0);
#define OFLAGS \
(DB_CREATE | DB_INIT_LOCK | \
DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN | DB_PRIVATE)
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 0
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR, NULL, OFLAGS, 0666) == 0);
#endif
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR, OFLAGS, 0666) == 0);
#endif
#if DB_VERSION_MAJOR > 3 || DB_VERSION_MINOR > 1
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR, OFLAGS, 0666) == 0);
#endif
/* Create the database. */
DB_BENCH_ASSERT(db_create(&dbp, dbenv, 0) == 0);
#if DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR >= 1
DB_BENCH_ASSERT(dbp->open(dbp, NULL,
TESTFILE, NULL, DB_BTREE, DB_CREATE | DB_AUTO_COMMIT, 0666) == 0);
#else
DB_BENCH_ASSERT(
dbp->open(dbp, TESTFILE, NULL, DB_BTREE, DB_CREATE, 0666) == 0);
#endif
/* Initialize the data. */
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
key.size = data.size = 20;
key.data = data.data = "01234567890123456789";
/* Start/commit a transaction count times. */
for (i = 0; i < count; ++i) {
#if DB_VERSION_MAJOR < 4
DB_BENCH_ASSERT(
txn_begin(dbenv, NULL, &txn, DB_TXN_NOSYNC) == 0);
DB_BENCH_ASSERT(dbp->put(dbp, txn, &key, &data, 0) == 0);
DB_BENCH_ASSERT(txn_commit(txn, 0) == 0);
#else
DB_BENCH_ASSERT(
dbenv->txn_begin(dbenv, NULL, &txn, DB_TXN_NOSYNC) == 0);
DB_BENCH_ASSERT(dbp->put(dbp, txn, &key, &data, 0) == 0);
DB_BENCH_ASSERT(txn->commit(txn, 0) == 0);
#endif
}
DB_BENCH_ASSERT(dbp->close(dbp, 0) == 0);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
/* Create a new DB_ENV handle. */
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
DB_BENCH_ASSERT(
dbenv->set_cachesize(dbenv, 0, 1048576 /* 1MB */, 0) == 0);
/* Now run recovery. */
TIMER_START;
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 0
DB_BENCH_ASSERT(dbenv->open(
dbenv, TESTDIR, NULL, OFLAGS | DB_RECOVER, 0666) == 0);
#endif
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 1
DB_BENCH_ASSERT(
dbenv->open(dbenv, TESTDIR, OFLAGS | DB_RECOVER, 0666) == 0);
#endif
#if DB_VERSION_MAJOR > 3 || DB_VERSION_MINOR > 1
DB_BENCH_ASSERT(
dbenv->open(dbenv, TESTDIR, OFLAGS | DB_RECOVER, 0666) == 0);
#endif
TIMER_STOP;
/*
* We divide the time by the number of transactions, so an "operation"
* is the recovery of a single transaction.
*/
printf("# recovery after %d transactions\n", count);
TIMER_DISPLAY(count);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
return (0);
}
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);
}
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;
}
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);
}
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;
}
static int db3close(dbiIndex dbi, unsigned int flags)
{
rpmdb rpmdb = dbi->dbi_rpmdb;
const char * root;
const char * home;
char * dbhome;
const char * dbfile;
const char * dbsubfile;
DB * db = dbi->dbi_db;
int _printit;
int rc = 0, xx;
flags = 0; /* XXX unused */
/*
* Get the prefix/root component and directory path.
*/
root = (dbi->dbi_root ? dbi->dbi_root : rpmdb->db_root);
if ((root[0] == '/' && root[1] == '\0') || rpmdb->db_chrootDone)
root = NULL;
home = (dbi->dbi_home ? dbi->dbi_home : rpmdb->db_home);
dbhome = rpmGenPath(root, home, NULL);
if (dbi->dbi_temporary) {
dbfile = NULL;
dbsubfile = NULL;
} else {
#ifdef HACK /* XXX necessary to support dbsubfile */
dbfile = (dbi->dbi_file ? dbi->dbi_file : db3basename);
dbsubfile = (dbi->dbi_subfile ? dbi->dbi_subfile : rpmTagGetName(dbi->dbi_rpmtag));
#else
dbfile = (dbi->dbi_file ? dbi->dbi_file : rpmTagGetName(dbi->dbi_rpmtag));
dbsubfile = NULL;
#endif
}
if (db) {
rc = db->close(db, 0);
/* XXX ignore not found error messages. */
_printit = (rc == ENOENT ? 0 : _debug);
rc = cvtdberr(dbi, "db->close", rc, _printit);
db = dbi->dbi_db = NULL;
rpmlog(RPMLOG_DEBUG, "closed db index %s/%s\n",
dbhome, (dbfile ? dbfile : rpmTagGetName(dbi->dbi_rpmtag)));
}
if (rpmdb->db_dbenv != NULL && dbi->dbi_use_dbenv) {
if (rpmdb->db_opens == 1) {
xx = db_fini(dbi, (dbhome ? dbhome : ""), dbfile, dbsubfile);
rpmdb->db_dbenv = NULL;
}
rpmdb->db_opens--;
}
if (dbi->dbi_verify_on_close && !dbi->dbi_temporary) {
DB_ENV * dbenv = NULL;
rc = db_env_create(&dbenv, 0);
rc = cvtdberr(dbi, "db_env_create", rc, _debug);
if (rc || dbenv == NULL) goto exit;
dbenv->set_errcall(dbenv, (void *) rpmdb->db_errcall);
dbenv->set_errfile(dbenv, rpmdb->db_errfile);
dbenv->set_errpfx(dbenv, rpmdb->db_errpfx);
/* dbenv->set_paniccall(???) */
#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_tmpdir) {
char * tmpdir = rpmGenPath(root, dbi->dbi_tmpdir, NULL);
rc = dbenv->set_tmp_dir(dbenv, tmpdir);
rc = cvtdberr(dbi, "dbenv->set_tmp_dir", rc, _debug);
tmpdir = _free(tmpdir);
if (rc) goto exit;
}
rc = (dbenv->open)(dbenv, dbhome,
DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE | DB_USE_ENVIRON, 0);
rc = cvtdberr(dbi, "dbenv->open", rc, _debug);
if (rc) goto exit;
rc = db_create(&db, dbenv, 0);
rc = cvtdberr(dbi, "db_create", rc, _debug);
if (db != NULL) {
char * dbf = rpmGetPath(dbhome, "/", dbfile, NULL);
rc = db->verify(db, dbf, NULL, NULL, flags);
rc = cvtdberr(dbi, "db->verify", rc, _debug);
rpmlog(RPMLOG_DEBUG, "verified db index %s/%s\n",
(dbhome ? dbhome : ""),
(dbfile ? dbfile : rpmTagGetName(dbi->dbi_rpmtag)));
/*
* The DB handle may not be accessed again after
* DB->verify is called, regardless of its return.
*/
db = NULL;
dbf = _free(dbf);
}
xx = dbenv->close(dbenv, 0);
xx = cvtdberr(dbi, "dbenv->close", xx, _debug);
if (rc == 0 && xx) rc = xx;
}
exit:
dbi->dbi_db = NULL;
free(dbhome);
dbi = db3Free(dbi);
return rc;
}
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;
}
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);
}
int
wiredtiger_extension_init(WT_CONNECTION *connection, WT_CONFIG_ARG *config)
{
/*
* List of the WT_DATA_SOURCE methods -- it's static so it breaks at
* compile-time should the structure changes underneath us.
*/
static WT_DATA_SOURCE wtds = {
kvs_session_create, /* session.create */
NULL, /* No session.compaction */
kvs_session_drop, /* session.drop */
kvs_session_open_cursor, /* session.open_cursor */
kvs_session_rename, /* session.rename */
NULL, /* No session.salvage */
kvs_session_truncate, /* session.truncate */
NULL, /* No range_truncate */
kvs_session_verify, /* session.verify */
NULL, /* session.checkpoint */
kvs_terminate /* termination */
};
DATA_SOURCE *ds;
DB_ENV *dbenv;
WT_EXTENSION_API *wt_api;
size_t len;
int ret = 0;
const char *home;
char *path;
(void)config; /* Unused parameters */
ds = NULL;
dbenv = NULL;
path = NULL;
/* Acquire the extension API */
wt_api = connection->get_extension_api(connection);
/* Allocate the local data-source structure. */
if ((ds = calloc(1, sizeof(DATA_SOURCE))) == NULL)
return (os_errno());
ds->wt_api = wt_api;
/* Configure the global lock */
if ((ret = lock_init(wt_api, NULL, &ds->rwlock)) != 0)
goto err;
ds->wtds = wtds; /* Configure the methods */
/* Berkeley DB environment */
if ((ret = db_env_create(&dbenv, 0)) != 0) {
ESET(wt_api,
NULL, WT_ERROR, "db_env_create: %s", db_strerror(ret));
goto err;
}
dbenv->set_errpfx(dbenv, "bdb");
dbenv->set_errfile(dbenv, stderr);
home = connection->get_home(connection);
len = strlen(home) + 10;
if ((path = malloc(len)) == NULL)
goto err;
(void)snprintf(path, len, "%s/KVS", home);
if ((ret = dbenv->open(dbenv, path,
DB_CREATE | DB_INIT_LOCK | DB_INIT_MPOOL | DB_PRIVATE, 0)) != 0) {
ESET(wt_api,
NULL, WT_ERROR, "DbEnv.open: %s", db_strerror(ret));
goto err;
}
ds->dbenv = dbenv;
if ((ret = /* Add the data source */
connection->add_data_source(
connection, "kvsbdb:", (WT_DATA_SOURCE *)ds, NULL)) != 0) {
ESET(wt_api, NULL, ret, "WT_CONNECTION.add_data_source");
goto err;
}
if (0) {
err: if (dbenv != NULL)
(void)dbenv->close(dbenv, 0);
free(ds);
}
free(path);
return (ret);
}
int
b_put(int argc, char *argv[])
{
extern char *optarg;
extern int optind, __db_getopt_reset;
DB_ENV *dbenv;
DB *dbp, **second;
DBTYPE type;
DBT key, data;
db_recno_t recno;
u_int32_t cachesize, dsize;
int ch, i, count, secondaries;
char *ts, buf[64];
second = NULL;
type = DB_BTREE;
cachesize = MEGABYTE;
dsize = 20;
count = 100000;
secondaries = 0;
ts = "Btree";
__db_getopt_reset = 1;
while ((ch = getopt(argc, argv, "C:c:d:s:t:")) != EOF)
switch (ch) {
case 'C':
cachesize = (u_int32_t)atoi(optarg);
break;
case 'c':
count = atoi(optarg);
break;
case 'd':
dsize = (u_int32_t)atoi(optarg);
break;
case 's':
secondaries = atoi(optarg);
break;
case 't':
switch (optarg[0]) {
case 'B': case 'b':
ts = "Btree";
type = DB_BTREE;
break;
case 'H': case 'h':
if (b_util_have_hash())
return (0);
ts = "Hash";
type = DB_HASH;
break;
case 'Q': case 'q':
if (b_util_have_queue())
return (0);
ts = "Queue";
type = DB_QUEUE;
break;
case 'R': case 'r':
ts = "Recno";
type = DB_RECNO;
break;
default:
return (b_put_usage());
}
break;
case '?':
default:
return (b_put_usage());
}
argc -= optind;
argv += optind;
if (argc != 0)
return (b_put_usage());
#if DB_VERSION_MAJOR < 3 || DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR < 3
/*
* Secondaries were added after DB 3.2.9.
*/
if (secondaries)
return (0);
#endif
/* Create the environment. */
DB_BENCH_ASSERT(db_env_create(&dbenv, 0) == 0);
dbenv->set_errfile(dbenv, stderr);
DB_BENCH_ASSERT(dbenv->set_cachesize(dbenv, 0, cachesize, 0) == 0);
#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR < 1
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR,
NULL, DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE, 0666) == 0);
#else
DB_BENCH_ASSERT(dbenv->open(dbenv, TESTDIR,
DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE, 0666) == 0);
#endif
/*
* Create the database.
* Optionally set the record length for Queue.
*/
DB_BENCH_ASSERT(db_create(&dbp, dbenv, 0) == 0);
if (type == DB_QUEUE)
DB_BENCH_ASSERT(dbp->set_re_len(dbp, dsize) == 0);
#if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 1)
DB_BENCH_ASSERT(
dbp->open(dbp, NULL, TESTFILE, NULL, type, DB_CREATE, 0666) == 0);
#else
DB_BENCH_ASSERT(
dbp->open(dbp, TESTFILE, NULL, type, DB_CREATE, 0666) == 0);
#endif
/* Optionally create the secondaries. */
if (secondaries != 0) {
DB_BENCH_ASSERT((second =
calloc(sizeof(DB *), (size_t)secondaries)) != NULL);
for (i = 0; i < secondaries; ++i) {
DB_BENCH_ASSERT(db_create(&second[i], dbenv, 0) == 0);
(void)snprintf(buf, sizeof(buf), "%d.db", i);
#if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 1)
DB_BENCH_ASSERT(second[i]->open(second[i], NULL,
buf, NULL, DB_BTREE, DB_CREATE, 0600) == 0);
#else
DB_BENCH_ASSERT(second[i]->open(second[i],
buf, NULL, DB_BTREE, DB_CREATE, 0600) == 0);
#endif
#if DB_VERSION_MAJOR > 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 1)
/*
* The DB_TXN argument to Db.associate was added in
* 4.1.25.
*/
DB_BENCH_ASSERT(dbp->associate(
dbp, NULL, second[i], b_put_secondary, 0) == 0);
#else
DB_BENCH_ASSERT(dbp->associate(
dbp, second[i], b_put_secondary, 0) == 0);
#endif
}
}
/* Store a key/data pair. */
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
switch (type) {
case DB_BTREE:
case DB_HASH:
key.data = "01234567890123456789";
key.size = 20;
break;
case DB_QUEUE:
case DB_RECNO:
recno = 1;
key.data = &recno;
key.size = sizeof(recno);
break;
case DB_UNKNOWN:
b_util_abort();
break;
}
data.size = dsize;
DB_BENCH_ASSERT(
(data.data = malloc((size_t)dsize)) != NULL);
/* Store the key/data pair count times. */
TIMER_START;
for (i = 0; i < count; ++i) {
/* Change data value so the secondaries are updated. */
(void)snprintf(data.data, data.size, "%10lu", (u_long)i);
DB_BENCH_ASSERT(dbp->put(dbp, NULL, &key, &data, 0) == 0);
}
TIMER_STOP;
if (type == DB_BTREE || type == DB_HASH)
printf(
"# %d %s database put of 10 byte key, %lu byte data",
count, ts, (u_long)dsize);
else
printf("# %d %s database put of key, %lu byte data",
count, ts, (u_long)dsize);
if (secondaries)
printf(" with %d secondaries", secondaries);
printf("\n");
TIMER_DISPLAY(count);
if (second != NULL) {
for (i = 0; i < secondaries; ++i)
DB_BENCH_ASSERT(second[i]->close(second[i], 0) == 0);
free(second);
}
DB_BENCH_ASSERT(dbp->close(dbp, 0) == 0);
DB_BENCH_ASSERT(dbenv->close(dbenv, 0) == 0);
return (0);
}
///////////////////
// //
// Main Function //
// //
///////////////////
int main(int argc, char *argv[]) {
/* Declare local vars */ /***********************************/
DB_ENV *dbenv; /* pointer to database environment */
DB *dbp1; /* pointer to 1st database */
DB *dbp2; /* pointer to 2nd database */
DBT key1, data1; /* Database key and data variables */
DBT key2, data2; /* Database key and data variables */
int ret; /* return code/message */
/* Creates the DB environment */
if ((ret = db_env_create(&dbenv, 0)) != 0) {
fprintf(stderr, "%s: %s\n", argv[0], db_strerror(ret));
return(1);
};
dbenv->set_errfile(dbenv, stderr);
dbenv->set_errpfx(dbenv, argv[0]);
/* Set shared memory buffer pool cachesize: 5MB. */
/* Databases are in a subdirectory of the environment home. */
if ((ret = dbenv->set_cachesize(dbenv, 0, 5 * 1024 * 1024, 0)) != 0) {
dbenv->err(dbenv, ret, "set_cachesize");
dbenv->close(dbenv, 0);
return(1);
};
if ((ret = dbenv->set_data_dir(dbenv, MY_DBENV_DIR_DATA)) != 0) {
dbenv->err(dbenv, ret, "set_data_dir: %s", MY_DBENV_DIR_DATA);
dbenv->close(dbenv, 0);
return(1);
};
/* Open the environment with full transactional support. */
dbenv->open(
dbenv,
MY_DBENV_DIR_HOME,
DB_CREATE
| DB_INIT_LOG
| DB_INIT_LOCK
| DB_INIT_MPOOL
| DB_INIT_TXN,
0
);
if (ret != 0) {
dbenv->err(dbenv, ret, "environment open: %s", MY_DBENV_DIR_HOME);
dbenv->close(dbenv, 0);
return(1);
};
/* Create first Database handle */
if ((ret = db_create(&dbp1, dbenv, 0)) != 0) {
dbenv->err(dbenv, ret, "database create");
dbenv->close(dbenv, 0);
return(1);
};
/* Opens first database */
if ((ret = dbp1->open(dbp1, NULL, MY_DB1_FILE, NULL, DB_BTREE, DB_CREATE, 0640)) != 0) {
dbenv->err(dbenv, ret, "DB->open: %s", MY_DB1_FILE);
dbp1->close(dbp1, 0);
dbenv->close(dbenv, 0);
return (ret);
};
/* Create second Database handle */
if ((ret = db_create(&dbp2, dbenv, 0)) != 0) {
dbenv->err(dbenv, ret, "database create");
dbp1->close(dbp1, 0);
dbenv->close(dbenv, 0);
return(1);
};
/* Opens second database */
if ((ret = dbp2->open(dbp2, NULL, MY_DB2_FILE, NULL, DB_BTREE, DB_CREATE, 0640)) != 0) {
dbenv->err(dbenv, ret, "DB->open: %s", MY_DB2_FILE);
dbp1->close(dbp1, 0);
dbp2->close(dbp1, 0);
dbenv->close(dbenv, 0);
return (ret);
};
/* Clears variables to avoid garbage */
memset(&key1, 0, sizeof(key1));
memset(&data1, 0, sizeof(data1));
memset(&key2, 0, sizeof(key2));
memset(&data2, 0, sizeof(data2));
/* Preps data to be added to first database */
key1.data = "fruit";
key1.size = sizeof("fruit");
data1.data = "apple";
data1.size = sizeof("apple");
/* pushes data into first database */
if ((ret = dbp1->put(dbp1, NULL, &key1, &data1, 0)) == 0) {
printf("db: %s: key stored.\n", (char *)key1.data);
} else {
dbp1->err(dbp1, ret, "DB->put");
dbp1->close(dbp1, 0);
dbp2->close(dbp2, 0);
dbenv->close(dbenv, 0);
return(1);
};
/* Preps data for second database */
key2 = data1;
data2.data = "red";
data2.size = sizeof("red");
/* pushes data into second database */
if ((ret = dbp2->put(dbp2, NULL, &key2, &data2, 0)) == 0) {
printf("db: %s: key stored.\n", (char *)key2.data);
} else {
dbp1->err(dbp2, ret, "DB->put");
dbp1->close(dbp1, 0);
dbp2->close(dbp2, 0);
dbenv->close(dbenv, 0);
return(1);
};
/* Pulls data from database */
if ((ret = dbp1->get(dbp1, NULL, &key1, &data1, 0)) == 0) {
printf("db: %s: key retrieved: data was %s.\n", (char *)key1.data, (char *)data1.data);
if ((ret = dbp1->get(dbp2, NULL, &data1, &data2, 0)) == 0) {
printf("db: %s: key retrieved: data was %s.\n", (char *)data1.data, (char *)data2.data);
} else {
dbp1->err(dbp2, ret, "DB->get");
dbp1->close(dbp1, 0);
dbp2->close(dbp2, 0);
dbenv->close(dbenv, 0);
return(1);
};
} else {
dbp1->err(dbp2, ret, "DB->get");
dbp1->close(dbp1, 0);
dbp2->close(dbp2, 0);
dbenv->close(dbenv, 0);
return(1);
};
/* Exit function */
dbp1->close(dbp1, 0);
dbp2->close(dbp2, 0);
dbenv->close(dbenv, 0);
return(0);
};
