void LMDB::Open(const string& source, Mode mode) {
MDB_CHECK(mdb_env_create(&mdb_env_));
MDB_CHECK(mdb_env_set_mapsize(mdb_env_, LMDB_MAP_SIZE));
if (mode == NEW) {
CHECK_EQ(mkdir(source.c_str(), 0744), 0) << "mkdir " << source << " failed";
}
int flags = 0;
if (mode == READ) {
flags = MDB_RDONLY | MDB_NOTLS;
}
int rc = mdb_env_open(mdb_env_, source.c_str(), flags, 0664);
#ifndef ALLOW_LMDB_NOLOCK
MDB_CHECK(rc);
#else
if (rc == EACCES) {
LOG(WARNING) << "Permission denied. Trying with MDB_NOLOCK ...";
// Close and re-open environment handle
mdb_env_close(mdb_env_);
MDB_CHECK(mdb_env_create(&mdb_env_));
// Try again with MDB_NOLOCK
flags |= MDB_NOLOCK;
MDB_CHECK(mdb_env_open(mdb_env_, source.c_str(), flags, 0664));
} else {
MDB_CHECK(rc);
}
#endif
LOG(INFO) << "Opened lmdb " << source;
}
/** Close database */
PageDBError
page_db_delete(PageDB *db) {
if (!db)
return 0;
mdb_env_close(db->txn_manager->env);
if (txn_manager_delete(db->txn_manager) != 0) {
page_db_set_error(db, page_db_error_internal, __func__);
page_db_add_error(db, "deleting transaction manager");
page_db_add_error(db, db->txn_manager->error->message);
return db->error->code;
}
if (!db->persist) {
char *data = build_path(db->path, "data.mdb");
char *lock = build_path(db->path, "lock.mdb");
// proceeed even the data files cannot be deleted from disk
(void)remove(data);
(void)remove(lock);
(void)remove(db->path);
free(data);
free(lock);
}
free(db->path);
domain_temp_delete(db->domain_temp);
error_delete(db->error);
free(db);
return 0;
}
int mail_cache_db_open(const char * filename,
struct mail_cache_db ** pcache_db)
{
int r;
struct mail_cache_db * cache_db;
MDB_env *env;
r = mdb_env_create(&env);
if (r != 0)
return -1;
r = mdb_env_set_mapsize(env, 512*1024*1024 /*max mmap and file size*/);
if (r != 0)
return -1;
r = mdb_env_open(env, filename, MDB_NOSUBDIR, 0660);
if (r != 0)
goto close_db;
cache_db = mail_cache_lmdb_new(env);
if (cache_db == NULL)
goto close_db;
* pcache_db = cache_db;
return 0;
close_db:
mdb_env_close(env);
return -1;
}
virtual void Close() {
if (mdb_env_ != NULL) {
mdb_dbi_close(mdb_env_, mdb_dbi_);
mdb_env_close(mdb_env_);
mdb_env_ = NULL;
}
}
void kvenv_free_lmdb(kvenv_t *kvenv)
{
kvenv_lmdb_t *kvenv_lmdb = (kvenv_lmdb_t*)kvenv;
mdb_env_close(kvenv_lmdb->env);
zfree(kvenv);
}
CDbxMdb::~CDbxMdb()
{
// destroy modules
HeapDestroy(m_hModHeap);
mdb_env_close(m_pMdbEnv);
DestroyServiceFunction(hService);
UnhookEvent(hHook);
if (m_crypto)
m_crypto->destroy();
DestroyHookableEvent(hContactDeletedEvent);
DestroyHookableEvent(hContactAddedEvent);
DestroyHookableEvent(hSettingChangeEvent);
DestroyHookableEvent(hEventMarkedRead);
DestroyHookableEvent(hEventAddedEvent);
DestroyHookableEvent(hEventDeletedEvent);
DestroyHookableEvent(hEventFilterAddedEvent);
DestroyDbInstance(this);
mir_free(m_tszProfileName);
}
int slmdb_close(SLMDB *slmdb)
{
int status = 0;
/*
* Finish an open bulk transaction. If slmdb_recover() returns after a
* bulk-transaction error, then it was unable to recover.
*/
if (slmdb->txn != 0
&& (status = mdb_txn_commit(slmdb->txn)) != 0)
status = slmdb_recover(slmdb, status);
/*
* Clean up after an unfinished sequence() operation.
*/
if (slmdb->cursor != 0)
slmdb_cursor_close(slmdb);
mdb_env_close(slmdb->env);
/*
* Clean up the saved key information.
*/
if (HAVE_SLMDB_SAVED_KEY(slmdb))
slmdb_saved_key_free(slmdb);
SLMDB_API_RETURN(slmdb, status);
}
static int dbase_open(struct cache *cache, const char *handle)
{
long page_size = sysconf(_SC_PAGESIZE);
if (page_size <= 0) {
return KNOT_EINVAL;
}
int ret = mdb_env_create(&cache->env);
if (ret != 0) {
return ret;
}
size_t map_size = (LMDB_MAPSIZE / page_size) * page_size;
ret = mdb_env_set_mapsize(cache->env, map_size);
if (ret != 0) {
mdb_env_close(cache->env);
return ret;
}
ret = mdb_env_open(cache->env, handle, 0, 0644);
if (ret != 0) {
mdb_env_close(cache->env);
return ret;
}
MDB_txn *txn = NULL;
ret = mdb_txn_begin(cache->env, NULL, 0, &txn);
if (ret != 0) {
mdb_env_close(cache->env);
return ret;
}
ret = mdb_open(txn, NULL, MDB_DUPSORT, &cache->dbi);
if (ret != 0) {
mdb_txn_abort(txn);
mdb_env_close(cache->env);
return ret;
}
ret = mdb_txn_commit(txn);
if (ret != 0) {
mdb_env_close(cache->env);
return ret;
}
return 0;
}
void gcache_close(struct gcache *gc)
{
if (gc == NULL)
return;
mdb_env_close(gc->env);
free(gc);
}
void mail_cache_db_close(struct mail_cache_db * cache_db)
{
MDB_env *env;
env = cache_db->internal_database;
mdb_env_close(env);
mail_cache_db_free(cache_db);
}
Context::~Context() {
if(txnHandle!=nullptr) {
mdb_txn_abort(txnHandle);
txnHandle=nullptr;
}
if (envHandle!=nullptr){
mdb_env_close (envHandle);
envHandle=nullptr;
}
}
void LmdbDataset<K, V, KCoder, VCoder>::close() {
DLOG(INFO) << "LMDB: Close";
if (env_ && dbi_) {
mdb_close(env_, dbi_);
mdb_env_close(env_);
env_ = NULL;
dbi_ = 0;
txn_ = NULL;
}
}
void db_close(db_t db){
if(db){
if(db->env)
mdb_env_close(db->env);
if(db->handles)
free(db->handles);
pthread_mutex_destroy(&db->mutex);
pthread_cond_destroy(&db->cond);
free(db);
}
}
int main(int argc,char * argv[])
{
int rc;
MDB_env *env;
const char *progname = argv[0], *act;
unsigned flags = MDB_RDONLY;
unsigned cpflags = 0;
for (; argc > 1 && argv[1][0] == '-'; argc--, argv++) {
if (argv[1][1] == 'n' && argv[1][2] == '\0')
flags |= MDB_NOSUBDIR;
else if (argv[1][1] == 'c' && argv[1][2] == '\0')
cpflags |= MDB_CP_COMPACT;
else if (argv[1][1] == 'V' && argv[1][2] == '\0') {
printf("%s\n", MDB_VERSION_STRING);
exit(0);
} else
argc = 0;
}
if (argc<2 || argc>3) {
fprintf(stderr, "usage: %s [-V] [-c] [-n] srcpath [dstpath]\n", progname);
exit(EXIT_FAILURE);
}
#ifdef SIGPIPE
signal(SIGPIPE, sighandle);
#endif
#ifdef SIGHUP
signal(SIGHUP, sighandle);
#endif
signal(SIGINT, sighandle);
signal(SIGTERM, sighandle);
act = "opening environment";
rc = mdb_env_create(&env);
if (rc == MDB_SUCCESS) {
rc = mdb_env_open(env, argv[1], flags, 0600);
}
if (rc == MDB_SUCCESS) {
act = "copying";
if (argc == 2)
rc = mdb_env_copyfd2(env, MDB_STDOUT, cpflags);
else
rc = mdb_env_copy2(env, argv[2], cpflags);
}
if (rc)
fprintf(stderr, "%s: %s failed, error %d (%s)\n",
progname, act, rc, mdb_strerror(rc));
mdb_env_close(env);
return rc ? EXIT_FAILURE : EXIT_SUCCESS;
}
void DBPrivCloseDB(DBPriv *db)
{
/* Abort LMDB transaction of the current thread. There should only be some
* transaction open when the signal handler or atexit() hook is called. */
AbortTransaction(db);
if (db->env)
{
mdb_env_close(db->env);
}
pthread_key_delete(db->txn_key);
free(db);
}
void LmdbDataset<K, V, KCoder, VCoder>::close() {
DLOG(INFO) << "LMDB: Close";
if (env_ && dbi_) {
mdb_txn_abort(write_txn_);
mdb_txn_abort(read_txn_);
mdb_close(env_, dbi_);
mdb_env_close(env_);
env_ = NULL;
dbi_ = 0;
write_txn_ = NULL;
read_txn_ = NULL;
}
}
static int
mdb_db_close( BackendDB *be, ConfigReply *cr )
{
int rc;
struct mdb_info *mdb = (struct mdb_info *) be->be_private;
/* monitor handling */
(void)mdb_monitor_db_close( be );
mdb->mi_flags &= ~MDB_IS_OPEN;
if( mdb->mi_dbenv ) {
mdb_reader_flush( mdb->mi_dbenv );
}
if ( mdb->mi_dbenv ) {
if ( mdb->mi_dbis[0] ) {
int i;
mdb_attr_dbs_close( mdb );
for ( i=0; i<MDB_NDB; i++ )
mdb_dbi_close( mdb->mi_dbenv, mdb->mi_dbis[i] );
/* force a sync, but not if we were ReadOnly,
* and not in Quick mode.
*/
if (!(slapMode & (SLAP_TOOL_QUICK|SLAP_TOOL_READONLY))) {
rc = mdb_env_sync( mdb->mi_dbenv, 1 );
if( rc != 0 ) {
Debug( LDAP_DEBUG_ANY,
"mdb_db_close: database \"%s\": "
"mdb_env_sync failed: %s (%d).\n",
be->be_suffix[0].bv_val, mdb_strerror(rc), rc );
}
}
}
mdb_env_close( mdb->mi_dbenv );
mdb->mi_dbenv = NULL;
}
if ( mdb->mi_search_stack ) {
ch_free( mdb->mi_search_stack );
mdb->mi_search_stack = NULL;
}
return 0;
}
DataLayer<Dtype>::~DataLayer<Dtype>() {
this->JoinPrefetchThread();
// clean up the database resources
switch (this->layer_param_.data_param().backend()) {
case DataParameter_DB_LEVELDB:
break; // do nothing
case DataParameter_DB_LMDB:
mdb_cursor_close(mdb_cursor_);
mdb_close(mdb_env_, mdb_dbi_);
mdb_txn_abort(mdb_txn_);
mdb_env_close(mdb_env_);
break;
default:
LOG(FATAL) << "Unknown database backend";
}
}
int main(int argc,char * argv[])
{
int rc;
MDB_env *env;
MDB_txn *txn;
MDB_dbi dbi;
MDB_stat mst;
char *envname = argv[1];
char *subname = NULL;
rc = mdb_env_create(&env);
if (argc > 2) {
mdb_env_set_maxdbs(env, 4);
subname = argv[2];
}
rc = mdb_env_open(env, envname, MDB_RDONLY, 0);
if (rc) {
printf("mdb_env_open failed, error %d\n", rc);
exit(1);
}
rc = mdb_txn_begin(env, NULL, 1, &txn);
if (rc) {
printf("mdb_txn_begin failed, error %d\n", rc);
exit(1);
}
rc = mdb_open(txn, subname, 0, &dbi);
if (rc) {
printf("mdb_open failed, error %d\n", rc);
exit(1);
}
rc = mdb_stat(txn, dbi, &mst);
printf("Page size: %u\n", mst.ms_psize);
printf("Tree depth: %u\n", mst.ms_depth);
printf("Branch pages: %zu\n", mst.ms_branch_pages);
printf("Leaf pages: %zu\n", mst.ms_leaf_pages);
printf("Overflow pages: %zu\n", mst.ms_overflow_pages);
printf("Entries: %zu\n", mst.ms_entries);
mdb_close(env, dbi);
mdb_txn_abort(txn);
mdb_env_close(env);
return 0;
}
int main(int argc,char * argv[])
{
int rc;
MDB_env *env;
MDB_dbi dbi;
MDB_val key, data;
MDB_txn *txn;
MDB_cursor *cursor;
char sval[MAX_DATA_ALLOCATE_SIZE], kval[MAX_KEY_ALLOCATE_SIZE];
/* Note: Most error checking omitted for simplicity */
rc = mdb_env_create(&env);
mdb_env_set_mapsize(env, MAX_DB_SIZE);
mdb_env_set_maxdbs(env, (MDB_dbi)10);
rc = mdb_env_open(env, "./demoDB", 0, 0664);
rc = mdb_txn_begin(env, NULL, 0, &txn);
rc = mdb_dbi_open(txn, "what", 0, &dbi);
// rc = mdb_put(txn, dbi, &key, &data, 0);
rc = mdb_txn_commit(txn);
if (rc) {
fprintf(stderr, "mdb_txn_commit: (%d) %s\n", rc, mdb_strerror(rc));
goto leave;
}
fprintf(stderr, "print out old data:\n");
rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
rc = mdb_cursor_open(txn, dbi, &cursor);
key.mv_size = sizeof(kval);
key.mv_data = kval;
data.mv_size = sizeof(sval);
data.mv_data = sval;
memset(kval, argv[1][0], sizeof(kval));
rc = mdb_cursor_get(cursor, &key, &data, MDB_SET);
fprintf(stderr, "key: %s, data: %s\n",(char *) key.mv_data,(char *) data.mv_data);
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
leave:
mdb_dbi_close(env, dbi);
mdb_env_close(env);
return 0;
}
static void close_db(struct dbengine *db)
{
assert(db);
if (db->tid) {
syslog(LOG_ERR, "cyrusdb_lmdb(%s): stray transaction %p",
db->fname, db->tid);
abort_txn(db, db->tid);
}
if (db->env) {
mdb_env_close(db->env);
}
if (db->data) {
free(db->data);
}
free(db->fname);
free(db);
}
static int
lmdb_storage_close(void* handle)
{
struct lmdb_storage* s = handle;
if (s->txn) {
mdb_txn_abort(s->txn);
}
if (s->dbi) {
mdb_close(s->env, s->dbi);
}
if (s->env) {
mdb_env_close(s->env);
}
free(s);
paxos_log_info("lmdb storage closed successfully");
return 0;
}
int main(int argc,char * argv[])
{
int rc;
MDB_env *env;
MDB_dbi dbi;
MDB_val key, data;
MDB_txn *txn;
MDB_cursor *cursor;
char sval[32];
rc = mdb_env_create(&env);
rc = mdb_env_open(env, "./testdb", 0, 0664);
rc = mdb_txn_begin(env, NULL, 0, &txn);
rc = mdb_open(txn, NULL, 0, &dbi);
key.mv_size = sizeof(int);
key.mv_data = sval;
data.mv_size = sizeof(sval);
data.mv_data = sval;
sprintf(sval, "%03x %d foo bar", 32, 3141592);
rc = mdb_put(txn, dbi, &key, &data, 0);
rc = mdb_txn_commit(txn);
if (rc) {
fprintf(stderr, "mdb_txn_commit: (%d) %s\n", rc, mdb_strerror(rc));
goto leave;
}
rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
rc = mdb_cursor_open(txn, dbi, &cursor);
while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
printf("key: %p %.*s, data: %p %.*s\n",
key.mv_data, (int) key.mv_size, (char *) key.mv_data,
data.mv_data, (int) data.mv_size, (char *) data.mv_data);
}
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
leave:
mdb_close(env, dbi);
mdb_env_close(env);
return 0;
}
~DB() {
// write the last batch
if (count % 1000 != 0) {
if (use_leveldb) {
db->Write(leveldb::WriteOptions(), batch);
} else { // lmdb
CHECK_EQ(mdb_txn_commit(mdb_txn), MDB_SUCCESS) << "mdb_txn_commit failed";
}
LOG(ERROR) << "Processed " << count << " files.";
}
// close db
if (use_leveldb) {
delete batch;
delete db;
} else { // lmdb
mdb_close(mdb_env, mdb_dbi);
mdb_env_close(mdb_env);
}
LOG(INFO) << "Database closed.";
}
/*
* Close all opened DBs and free environment
*/
DWORD
VmDirMDBShutdownDB(
PVDIR_DB_HANDLE hDB
)
{
PVDIR_MDB_DB pDB = (PVDIR_MDB_DB)hDB;
VmDirLog( LDAP_DEBUG_TRACE, "MDBShutdownDB: Begin" );
VmDirLogDBStats(pDB);
if (pDB->mdbEnv != NULL)
{
MDBCloseDBs(pDB);
VmDirMDBShutdownIndexDB(pDB);
// force buffer sync
mdb_env_sync(pDB->mdbEnv, 1);
mdb_env_close(pDB->mdbEnv);
pDB->mdbEnv = NULL;
}
if (pDB->mdbEntryDB.pMdbDataFiles)
{
VMDIR_SAFE_FREE_MEMORY(pDB->mdbEntryDB.pMdbDataFiles->pszDBFile);
VMDIR_SAFE_FREE_MEMORY(pDB->mdbEntryDB.pMdbDataFiles->pszDBName);
VMDIR_SAFE_FREE_MEMORY(pDB->mdbEntryDB.pMdbDataFiles);
}
VMDIR_SAFE_FREE_MEMORY(pDB->pszDBPath);
VMDIR_SAFE_FREE_MEMORY(pDB);
VmDirLog( LDAP_DEBUG_TRACE, "MDBShutdownDB: End" );
return 0;
}
bool Context::Open(bool setSize, size_t dbMegabytes,size_t osPageSize){
size_t mbbytes = 10485760;
if ((dbMegabytes*mbbytes % osPageSize) != 0){
return false;
}
else if (envCreateReturn!=0){
return false;
}
else {
MDB_dbi dbs = 1;
int maxdbsReturn = mdb_env_set_maxdbs(envHandle,dbs);
if (maxdbsReturn !=0){
Error(maxdbsReturn);
return false;
}
else{
int mapsizeReturn=0;
if (setSize==true){
size_t bytes = dbMegabytes*mbbytes;
mapsizeReturn = mdb_env_set_mapsize(envHandle,bytes);
}
if(setSize==true && mapsizeReturn!=0){
Error(mapsizeReturn);
return false;
}
envOpenReturn = mdb_env_open(envHandle,
"/root/mydb",0,0664);
if (envOpenReturn!=0){
Error(envOpenReturn);
mdb_env_close(envHandle);
envHandle=nullptr;
return false;
}
else return true;
}
}
}
int main(int argc,char * argv[])
{
int i = 0, j = 0, rc;
MDB_env *env;
MDB_dbi dbi;
MDB_val key, data;
MDB_txn *txn;
MDB_stat mst;
MDB_cursor *cursor;
int count;
int *values;
char sval[32];
char kval[sizeof(int)];
srand(time(NULL));
memset(sval, 0, sizeof(sval));
count = (rand()%384) + 64;
values = (int *)je_malloc(count*sizeof(int));
for(i = 0;i<count;i++) {
values[i] = rand()%1024;
}
E(mdb_env_create(&env));
E(mdb_env_set_mapsize(env, 10485760));
E(mdb_env_set_maxdbs(env, 4));
E(mdb_env_open(env, "/tmp/testdb", MDB_FIXEDMAP|MDB_NOSYNC, 0664));
E(mdb_txn_begin(env, NULL, 0, &txn));
E(mdb_open(txn, "id2", MDB_CREATE|MDB_DUPSORT, &dbi));
key.mv_size = sizeof(int);
key.mv_data = kval;
data.mv_size = sizeof(sval);
data.mv_data = sval;
printf("Adding %d values\n", count);
for (i=0;i<count;i++) {
if (!(i & 0x0f))
sprintf(kval, "%03x", values[i]);
sprintf(sval, "%03x %d foo bar", values[i], values[i]);
if (RES(MDB_KEYEXIST, mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA)))
j++;
}
if (j) printf("%d duplicates skipped\n", j);
E(mdb_txn_commit(txn));
E(mdb_env_stat(env, &mst));
E(mdb_txn_begin(env, NULL, 1, &txn));
E(mdb_cursor_open(txn, dbi, &cursor));
while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
printf("key: %p %.*s, data: %p %.*s\n",
key.mv_data, (int) key.mv_size, (char *) key.mv_data,
data.mv_data, (int) data.mv_size, (char *) data.mv_data);
}
CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
j=0;
for (i= count - 1; i > -1; i-= (rand()%5)) {
j++;
txn=NULL;
E(mdb_txn_begin(env, NULL, 0, &txn));
sprintf(kval, "%03x", values[i & ~0x0f]);
sprintf(sval, "%03x %d foo bar", values[i], values[i]);
key.mv_size = sizeof(int);
key.mv_data = kval;
data.mv_size = sizeof(sval);
data.mv_data = sval;
if (RES(MDB_NOTFOUND, mdb_del(txn, dbi, &key, &data))) {
j--;
mdb_txn_abort(txn);
} else {
E(mdb_txn_commit(txn));
}
}
je_free(values);
printf("Deleted %d values\n", j);
E(mdb_env_stat(env, &mst));
E(mdb_txn_begin(env, NULL, 1, &txn));
E(mdb_cursor_open(txn, dbi, &cursor));
printf("Cursor next\n");
while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
printf("key: %.*s, data: %.*s\n",
(int) key.mv_size, (char *) key.mv_data,
(int) data.mv_size, (char *) data.mv_data);
}
CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
printf("Cursor prev\n");
while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_PREV)) == 0) {
printf("key: %.*s, data: %.*s\n",
(int) key.mv_size, (char *) key.mv_data,
(int) data.mv_size, (char *) data.mv_data);
}
CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
mdb_cursor_close(cursor);
mdb_close(env, dbi);
mdb_txn_abort(txn);
mdb_env_close(env);
return 0;
}
int main(int argc, char *argv[])
{
int i, rc;
MDB_env *env;
MDB_txn *txn;
MDB_dbi dbi;
MDB_stat mst;
MDB_envinfo mei;
char *prog = argv[0];
char *envname;
char *subname = NULL;
int alldbs = 0, envinfo = 0, envflags = 0, freinfo = 0, rdrinfo = 0;
if (argc < 2) {
usage(prog);
}
/* -a: print stat of main DB and all subDBs
* -s: print stat of only the named subDB
* -e: print env info
* -f: print freelist info
* -r: print reader info
* -n: use NOSUBDIR flag on env_open
* -V: print version and exit
* (default) print stat of only the main DB
*/
while ((i = getopt(argc, argv, "Vaefnrs:")) != EOF) {
switch(i) {
case 'V':
printf("%s\n", MDB_VERSION_STRING);
exit(0);
break;
case 'a':
if (subname)
usage(prog);
alldbs++;
break;
case 'e':
envinfo++;
break;
case 'f':
freinfo++;
break;
case 'n':
envflags |= MDB_NOSUBDIR;
break;
case 'r':
rdrinfo++;
break;
case 's':
if (alldbs)
usage(prog);
subname = optarg;
break;
default:
usage(prog);
}
}
if (optind != argc - 1)
usage(prog);
envname = argv[optind];
rc = mdb_env_create(&env);
if (rc) {
fprintf(stderr, "mdb_env_create failed, error %d %s\n", rc, mdb_strerror(rc));
return EXIT_FAILURE;
}
if (alldbs || subname) {
mdb_env_set_maxdbs(env, 4);
}
rc = mdb_env_open(env, envname, envflags | MDB_RDONLY, 0664);
if (rc) {
fprintf(stderr, "mdb_env_open failed, error %d %s\n", rc, mdb_strerror(rc));
goto env_close;
}
if (envinfo) {
(void)mdb_env_stat(env, &mst);
(void)mdb_env_info(env, &mei);
printf("Environment Info\n");
printf(" Map address: %p\n", mei.me_mapaddr);
printf(" Map size: %"Z"u\n", mei.me_mapsize);
printf(" Page size: %u\n", mst.ms_psize);
printf(" Max pages: %"Z"u\n", mei.me_mapsize / mst.ms_psize);
printf(" Number of pages used: %"Z"u\n", mei.me_last_pgno+1);
printf(" Last transaction ID: %"Z"u\n", mei.me_last_txnid);
printf(" Max readers: %u\n", mei.me_maxreaders);
printf(" Number of readers used: %u\n", mei.me_numreaders);
}
if (rdrinfo) {
printf("Reader Table Status\n");
rc = mdb_reader_list(env, (MDB_msg_func *)fputs, stdout);
if (rdrinfo > 1) {
int dead;
mdb_reader_check(env, &dead);
printf(" %d stale readers cleared.\n", dead);
rc = mdb_reader_list(env, (MDB_msg_func *)fputs, stdout);
}
if (!(subname || alldbs || freinfo))
goto env_close;
}
rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
if (rc) {
fprintf(stderr, "mdb_txn_begin failed, error %d %s\n", rc, mdb_strerror(rc));
goto env_close;
}
if (freinfo) {
MDB_cursor *cursor;
MDB_val key, data;
size_t pages = 0, *iptr;
printf("Freelist Status\n");
dbi = 0;
rc = mdb_cursor_open(txn, dbi, &cursor);
if (rc) {
fprintf(stderr, "mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
goto txn_abort;
}
rc = mdb_stat(txn, dbi, &mst);
if (rc) {
fprintf(stderr, "mdb_stat failed, error %d %s\n", rc, mdb_strerror(rc));
goto txn_abort;
}
prstat(&mst);
while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
iptr = data.mv_data;
pages += *iptr;
if (freinfo > 1) {
char *bad = "";
size_t pg, prev;
ssize_t i, j, span = 0;
j = *iptr++;
for (i = j, prev = 1; --i >= 0; ) {
pg = iptr[i];
if (pg <= prev)
bad = " [bad sequence]";
prev = pg;
pg += span;
for (; i >= span && iptr[i-span] == pg; span++, pg++) ;
}
printf(" Transaction %"Z"u, %"Z"d pages, maxspan %"Z"d%s\n",
*(size_t *)key.mv_data, j, span, bad);
if (freinfo > 2) {
for (--j; j >= 0; ) {
pg = iptr[j];
for (span=1; --j >= 0 && iptr[j] == pg+span; span++) ;
printf(span>1 ? " %9"Z"u[%"Z"d]\n" : " %9"Z"u\n",
pg, span);
}
}
}
}
mdb_cursor_close(cursor);
printf(" Free pages: %"Z"u\n", pages);
}
rc = mdb_open(txn, subname, 0, &dbi);
if (rc) {
fprintf(stderr, "mdb_open failed, error %d %s\n", rc, mdb_strerror(rc));
goto txn_abort;
}
rc = mdb_stat(txn, dbi, &mst);
if (rc) {
fprintf(stderr, "mdb_stat failed, error %d %s\n", rc, mdb_strerror(rc));
goto txn_abort;
}
printf("Status of %s\n", subname ? subname : "Main DB");
prstat(&mst);
if (alldbs) {
MDB_cursor *cursor;
MDB_val key;
rc = mdb_cursor_open(txn, dbi, &cursor);
if (rc) {
fprintf(stderr, "mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
goto txn_abort;
}
while ((rc = mdb_cursor_get(cursor, &key, NULL, MDB_NEXT_NODUP)) == 0) {
char *str;
MDB_dbi db2;
if (memchr(key.mv_data, '\0', key.mv_size))
continue;
str = malloc(key.mv_size+1);
memcpy(str, key.mv_data, key.mv_size);
str[key.mv_size] = '\0';
rc = mdb_open(txn, str, 0, &db2);
if (rc == MDB_SUCCESS)
printf("Status of %s\n", str);
free(str);
if (rc) continue;
rc = mdb_stat(txn, db2, &mst);
if (rc) {
fprintf(stderr, "mdb_stat failed, error %d %s\n", rc, mdb_strerror(rc));
goto txn_abort;
}
prstat(&mst);
mdb_close(env, db2);
}
mdb_cursor_close(cursor);
}
if (rc == MDB_NOTFOUND)
rc = MDB_SUCCESS;
mdb_close(env, dbi);
txn_abort:
mdb_txn_abort(txn);
env_close:
mdb_env_close(env);
return rc ? EXIT_FAILURE : EXIT_SUCCESS;
}
bool B_ACCURATE_LMDB::init(JCR *jcr, uint32_t nbfile)
{
int result;
MDB_env *env;
size_t mapsize = 10485760;
if (!m_db_env) {
result = mdb_env_create(&env);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to create MDB environment: %s\n"), mdb_strerror(result));
return false;
}
if ((nbfile * AVG_NR_BYTES_PER_ENTRY) > mapsize) {
size_t pagesize;
#ifdef HAVE_GETPAGESIZE
pagesize = getpagesize();
#else
pagesize = B_PAGE_SIZE;
#endif
mapsize = (((nbfile * AVG_NR_BYTES_PER_ENTRY) / pagesize) + 1) * pagesize;
}
result = mdb_env_set_mapsize(env, mapsize);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to set MDB mapsize: %s\n"), mdb_strerror(result));
goto bail_out;
}
/*
* Explicitly set the number of readers to 1.
*/
result = mdb_env_set_maxreaders(env, 1);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to set MDB maxreaders: %s\n"), mdb_strerror(result));
goto bail_out;
}
Mmsg(m_lmdb_name, "%s/.accurate_lmdb.%d", me->working_directory, jcr->JobId);
result = mdb_env_open(env, m_lmdb_name, MDB_NOSUBDIR | MDB_NOLOCK | MDB_NOSYNC, 0600);
if (result) {
Jmsg2(jcr, M_FATAL, 0, _("Unable create LDMD database %s: %s\n"), m_lmdb_name, mdb_strerror(result));
goto bail_out;
}
result = mdb_txn_begin(env, NULL, 0, &m_db_rw_txn);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to start a write transaction: %s\n"), mdb_strerror(result));
goto bail_out;
}
result = mdb_dbi_open(m_db_rw_txn, NULL, MDB_CREATE, &m_db_dbi);
if (result) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to open LMDB internal database: %s\n"), mdb_strerror(result));
mdb_txn_abort(m_db_rw_txn);
m_db_rw_txn = NULL;
goto bail_out;
}
m_db_env = env;
}
if (!m_pay_load) {
m_pay_load = get_pool_memory(PM_MESSAGE);
}
if (!m_lmdb_name) {
m_pay_load = get_pool_memory(PM_FNAME);
}
if (!m_seen_bitmap) {
m_seen_bitmap = (char *)malloc(nbytes_for_bits(nbfile));
clear_all_bits(nbfile, m_seen_bitmap);
}
return true;
bail_out:
if (env) {
mdb_env_close(env);
}
return false;
}
void B_ACCURATE_LMDB::destroy(JCR *jcr)
{
/*
* Abort any pending read transaction.
*/
if (m_db_ro_txn) {
mdb_txn_abort(m_db_ro_txn);
m_db_ro_txn = NULL;
}
/*
* Abort any pending write transaction.
*/
if (m_db_rw_txn) {
mdb_txn_abort(m_db_rw_txn);
m_db_rw_txn = NULL;
}
if (m_db_env) {
/*
* Drop the contents of the LMDB.
*/
if (m_db_dbi) {
int result;
MDB_txn *txn;
result = mdb_txn_begin(m_db_env, NULL, 0, &txn);
if (result == 0) {
result = mdb_drop(txn, m_db_dbi, 1);
if (result == 0) {
mdb_txn_commit(txn);
} else {
mdb_txn_abort(txn);
}
}
m_db_dbi = 0;
}
/*
* Close the environment.
*/
mdb_env_close(m_db_env);
m_db_env = NULL;
}
if (m_pay_load) {
free_pool_memory(m_pay_load);
m_pay_load = NULL;
}
if (m_lmdb_name) {
unlink(m_lmdb_name);
free_pool_memory(m_lmdb_name);
m_lmdb_name = NULL;
}
if (m_seen_bitmap) {
free(m_seen_bitmap);
m_seen_bitmap = NULL;
}
m_filenr = 0;
}
