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_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); }
int TestSetThreadCount(CuTest *ct) { /* SKIP */ /* Run this test only when hash is supported. */ #ifdef HAVE_HASH DB_ENV *dbenv; DB *db; CuAssert(ct, "db_env_create", db_env_create(&dbenv, 0) == 0); dbenv->set_errpfx(dbenv, "TestSetThreadCount"); CuAssert(ct, "set_thread_count", dbenv->set_thread_count(dbenv, 2) == 0); CuAssert(ct, "env->open", dbenv->open(dbenv, ".", DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN | DB_PRIVATE | DB_THREAD, 0) == 0); CuAssert(ct, "db_create", db_create(&db, dbenv, 0) == 0); CuAssert(ct, "DB->open", db->open( db, NULL, NULL, "TestSetThreadCount", DB_HASH, DB_CREATE, 0) == 0); db->close(db, 0); dbenv->close(dbenv, 0); #else printf("TestSetThreadCount is not supported by the build.\n"); #endif /* HAVE_HASH */ return (0); }
DB_ENV *ldbm_initialize_env(const char *home, int dbcachesize, int *envdirok) { DB_ENV *env = NULL; int err; u_int32_t envFlags; err = db_env_create( &env, 0 ); if ( err ) { #ifdef LDAP_SYSLOG syslog( LOG_INFO, "ldbm_initialize_env(): " "FATAL error in db_env_create() : %s (%d)\n", db_strerror( err ), err ); #endif return NULL; } #if DB_VERSION_X >= 0x030300 /* This interface appeared in 3.3 */ env->set_alloc( env, ldbm_malloc, NULL, NULL ); #endif env->set_errcall( env, ldbm_db_errcall ); env->set_errpfx( env, "==>" ); if (dbcachesize) { env->set_cachesize( env, 0, dbcachesize, 0 ); } envFlags = DB_CREATE | DB_INIT_MPOOL | DB_USE_ENVIRON; #ifdef DB_PRIVATE envFlags |= DB_PRIVATE; #endif #ifdef DB_MPOOL_PRIVATE envFlags |= DB_MPOOL_PRIVATE; #endif #ifdef HAVE_BERKELEY_DB_THREAD envFlags |= DB_THREAD; #endif #if DB_VERSION_X >= 0x030100 err = env->open( env, home, envFlags, 0 ); #else /* 3.0.x requires an extra argument */ err = env->open( env, home, NULL, envFlags, 0 ); #endif if ( err != 0 ) { #ifdef LDAP_SYSLOG syslog( LOG_INFO, "ldbm_initialize_env(): " "FATAL error in dbEnv->open() : %s (%d)\n", db_strerror( err ), err ); #endif env->close( env, 0 ); return NULL; } *envdirok = 1; return env; }
int bdblib_create_dbenv(DB_ENV **_dbenv, char* _home) { DB_ENV *env; char *progname; int rc, flags; progname = "kamailio"; /* Create an environment and initialize it for additional error * reporting. */ if ((rc = db_env_create(&env, 0)) != 0) { ERR("db_env_create failed! bdb error: %s.\n", db_strerror(rc)); return (rc); } env->set_errpfx(env, progname); /* Specify the shared memory buffer pool cachesize */ if ((rc = env->set_cachesize(env, 0, _bdb_parms->cache_size, 0)) != 0) { ERR("dbenv set_cachsize failed! bdb error: %s.\n", db_strerror(rc)); env->err(env, rc, "set_cachesize"); goto err; } /* Concurrent Data Store flags */ flags = DB_CREATE | DB_INIT_CDB | DB_INIT_MPOOL | DB_THREAD; /* Transaction Data Store flags ; not supported yet */ /* flags = DB_CREATE | DB_RECOVER | DB_INIT_LOG | DB_INIT_LOCK | DB_INIT_MPOOL | DB_THREAD | DB_INIT_TXN; */ /* Open the environment */ if ((rc = env->open(env, _home, flags, 0)) != 0) { ERR("dbenv is not initialized! bdb error: %s.\n",db_strerror(rc)); env->err(env, rc, "environment open: %s", _home); goto err; } *_dbenv = env; return (0); err: (void)env->close(env, 0); return (rc); }
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; }
/* 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); }
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; }
/* * 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); }
/* * 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); }
/////////////////// // // // 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); };
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 int db_init(rpmdb rdb, const char * dbhome) { DB_ENV *dbenv = NULL; int rc, xx; int retry_open = 2; int lockfd = -1; struct dbConfig_s * cfg = &rdb->cfg; /* This is our setup, thou shall not have other setups before us */ uint32_t eflags = (DB_CREATE|DB_INIT_MPOOL|DB_INIT_CDB); if (rdb->db_dbenv != NULL) { rdb->db_opens++; return 0; } else { /* On first call, set backend description to something... */ free(rdb->db_descr); rasprintf(&rdb->db_descr, "db%u", DB_VERSION_MAJOR); } /* * Both verify and rebuild are rather special, if for different reasons: * On rebuild we dont want to be affected by eg paniced environment, and * CDB only slows things down there. Verify is a quirky beast unlike * anything else in BDB, and does not like shared env or CDB. */ if (rdb->db_flags & (RPMDB_FLAG_VERIFYONLY|RPMDB_FLAG_REBUILD)) { eflags |= DB_PRIVATE; eflags &= ~DB_INIT_CDB; } rc = db_env_create(&dbenv, 0); rc = dbapi_err(rdb, "db_env_create", rc, _debug); if (dbenv == NULL || rc) goto errxit; dbenv->set_alloc(dbenv, rmalloc, rrealloc, NULL); dbenv->set_errcall(dbenv, NULL); dbenv->set_errpfx(dbenv, _errpfx); dbenv->set_msgcall(dbenv, warnlog); /* * 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, isalive); dbenv->set_verbose(dbenv, DB_VERB_DEADLOCK, (cfg->db_verbose & DB_VERB_DEADLOCK)); dbenv->set_verbose(dbenv, DB_VERB_RECOVERY, (cfg->db_verbose & DB_VERB_RECOVERY)); dbenv->set_verbose(dbenv, DB_VERB_WAITSFOR, (cfg->db_verbose & DB_VERB_WAITSFOR)); if (cfg->db_mmapsize) { xx = dbenv->set_mp_mmapsize(dbenv, cfg->db_mmapsize); xx = dbapi_err(rdb, "dbenv->set_mp_mmapsize", xx, _debug); } if (cfg->db_cachesize) { xx = dbenv->set_cachesize(dbenv, 0, cfg->db_cachesize, 0); xx = dbapi_err(rdb, "dbenv->set_cachesize", xx, _debug); } /* * Serialize shared environment open (and clock) via fcntl() lock. * Otherwise we can end up calling dbenv->failchk() while another * process is joining the environment, leading to transient * DB_RUNRECOVER errors. Also prevents races wrt removing the * environment (eg chrooted operation). Silently fall back to * private environment on failure to allow non-privileged queries * to "work", broken as it might be. */ if (!(eflags & DB_PRIVATE)) { lockfd = serialize_env(dbhome); if (lockfd < 0) { eflags |= DB_PRIVATE; retry_open--; rpmlog(RPMLOG_DEBUG, "serialize failed, using private dbenv\n"); } } /* * Actually open the environment. Fall back to private environment * if we dont have permission to join/create shared environment or * system doesn't support it.. */ while (retry_open) { char *fstr = prDbiOpenFlags(eflags, 1); rpmlog(RPMLOG_DEBUG, "opening db environment %s %s\n", dbhome, fstr); free(fstr); rc = (dbenv->open)(dbenv, dbhome, eflags, rdb->db_perms); if ((rc == EACCES || rc == EROFS) || (rc == EINVAL && errno == rc)) { eflags |= DB_PRIVATE; retry_open--; } else { retry_open = 0; } } rc = dbapi_err(rdb, "dbenv->open", rc, _debug); if (rc) goto errxit; dbenv->set_errcall(dbenv, errlog); /* stale lock removal */ rc = dbenv->failchk(dbenv, 0); rc = dbapi_err(rdb, "dbenv->failchk", rc, _debug); if (rc) goto errxit; rdb->db_dbenv = dbenv; rdb->db_opens = 1; if (lockfd >= 0) close(lockfd); return 0; errxit: if (dbenv) { int xx; xx = dbenv->close(dbenv, 0); xx = dbapi_err(rdb, "dbenv->close", xx, _debug); } if (lockfd >= 0) close(lockfd); return rc; }
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 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); }
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 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; }