#define MYTID (((struct cdbtsd*)pthread_getspecific(tsdkey))->tid)
/* just a little helper function */
-static int txabort(DB_TXN *tid) {
+static void txabort(DB_TXN *tid) {
int ret = txn_abort(tid);
- if (ret)
- lprintf(1, "txn_abort: %s\n", db_strerror(ret));
-
- return ret;
+ if (ret) {
+ lprintf(1, "cdb_*: txn_abort: %s\n", db_strerror(ret));
+ abort();
+ }
}
/* this one is even more helpful than the last. */
-static int txcommit(DB_TXN *tid) {
+static void txcommit(DB_TXN *tid) {
int ret = txn_commit(tid, 0);
- if (ret)
- lprintf(1, "txn_commit: %s\n", db_strerror(ret));
-
- return ret;
+ if (ret) {
+ lprintf(1, "cdb_*: txn_commit: %s\n", db_strerror(ret));
+ abort();
+ }
}
/* are you sensing a pattern yet? */
-static int txbegin(DB_TXN **tid) {
+static void txbegin(DB_TXN **tid) {
int ret = txn_begin(dbenv, NULL, tid, 0);
- if (ret)
- lprintf(1, "txn_begin: %s\n", db_strerror(ret));
+ if (ret) {
+ lprintf(1, "cdb_*: txn_begin: %s\n", db_strerror(ret));
+ abort();
+ }
+}
- return ret;
+static void cclose(DBC *cursor) {
+ int ret;
+
+ if ((ret = cursor->c_close(cursor))) {
+ lprintf(1, "cdb_*: c_close: %s\n", db_strerror(ret));
+ abort();
+ }
}
-static void release_handles(void *arg) {
+static void check_handles(void *arg) {
if (arg != NULL) {
struct cdbtsd *tsd = (struct cdbtsd *)arg;
if (tsd->cursor != NULL) {
- lprintf(1, "WARNING: cursor still in progress; "
- "closing!\n");
- tsd->cursor->c_close(tsd->cursor);
+ lprintf(1, "cdb_*: cursor still in progress!");
+ abort();
}
if (tsd->tid != NULL) {
- lprintf(1, "ERROR: transaction still in progress; "
- "aborting!\n");
- txabort(tsd->tid);
+ lprintf(1, "cdb_*: transaction still in progress!");
+ abort();
}
}
}
static void dest_tsd(void *arg) {
if (arg != NULL) {
- release_handles(arg);
+ check_handles(arg);
phree(arg);
}
}
* to use database calls, except for whatever thread calls open_databases.
*/
void cdb_allocate_tsd(void) {
- struct cdbtsd *tsd = mallok(sizeof *tsd);
+ struct cdbtsd *tsd;
+
+ if (pthread_getspecific(tsdkey) != NULL)
+ return;
+
+ tsd = mallok(sizeof *tsd);
tsd->tid = NULL;
tsd->cursor = NULL;
pthread_setspecific(tsdkey, NULL);
}
-void cdb_release_handles(void) {
- release_handles(pthread_getspecific(tsdkey));
+void cdb_check_handles(void) {
+ check_handles(pthread_getspecific(tsdkey));
}
MAX_CHECKPOINT_MINUTES,
0);
if (ret) {
- lprintf(1, "txn_checkpoint: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_checkpoint: txn_checkpoint: %s\n", db_strerror(ret));
+ abort();
}
}
char dbfilename[SIZ];
u_int32_t flags = 0;
- lprintf(9, "open_databases() starting\n");
+ lprintf(9, "cdb_*: open_databases() starting\n");
/*
* Silently try to create the database subdirectory. If it's
* already there, no problem.
*/
system("exec mkdir data 2>/dev/null");
- lprintf(9, "Setting up DB environment\n");
+ lprintf(9, "cdb_*: Setting up DB environment\n");
db_env_set_func_yield(sched_yield);
ret = db_env_create(&dbenv, 0);
if (ret) {
- lprintf(1, "db_env_create: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_*: db_env_create: %s\n", db_strerror(ret));
exit(ret);
}
dbenv->set_errpfx(dbenv, "citserver");
*/
ret = dbenv->set_cachesize(dbenv, 0, 64 * 1024, 0);
if (ret) {
- lprintf(1, "set_cachesize: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_*: set_cachesize: %s\n", db_strerror(ret));
dbenv->close(dbenv, 0);
exit(ret);
}
if ((ret = dbenv->set_lk_detect(dbenv, DB_LOCK_DEFAULT))) {
- lprintf(1, "set_lk_detect: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_*: set_lk_detect: %s\n", db_strerror(ret));
dbenv->close(dbenv, 0);
exit(ret);
}
DB_INIT_LOCK|DB_THREAD;
ret = dbenv->open(dbenv, "./data", flags, 0);
if (ret) {
- lprintf(1, "dbenv->open: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_*: dbenv->open: %s\n", db_strerror(ret));
dbenv->close(dbenv, 0);
exit(ret);
}
- lprintf(7, "Starting up DB\n");
+ lprintf(7, "cdb_*: Starting up DB\n");
for (i = 0; i < MAXCDB; ++i) {
/* Create a database handle */
ret = db_create(&dbp[i], dbenv, 0);
if (ret) {
- lprintf(1, "db_create: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_*: db_create: %s\n", db_strerror(ret));
exit(ret);
}
dbfilename,
NULL,
DB_BTREE,
- DB_CREATE,
+ DB_CREATE|DB_THREAD,
0600);
if (ret) {
- lprintf(1, "db_open[%d]: %s\n", i, db_strerror(ret));
+ lprintf(1, "cdb_*: db_open[%d]: %s\n", i, db_strerror(ret));
exit(ret);
}
}
if ((ret = pthread_key_create(&tsdkey, dest_tsd))) {
- lprintf(1, "pthread_key_create: %s\n", strerror(ret));
+ lprintf(1, "cdb_*: pthread_key_create: %s\n", strerror(ret));
exit(1);
}
cdb_allocate_tsd();
CtdlRegisterSessionHook(cdb_checkpoint, EVT_TIMER);
- lprintf(9, "open_databases() finished\n");
+ lprintf(9, "cdb_*: open_databases() finished\n");
}
/*
- * Close all of the gdbm database files we've opened. This can be done
+ * Close all of the db database files we've opened. This can be done
* in a loop, since it's just a bunch of closes.
*/
void close_databases(void)
cdb_free_tsd();
if ((ret = txn_checkpoint(dbenv, 0, 0, 0))) {
- lprintf(1, "txn_checkpoint: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_*: txn_checkpoint: %s\n", db_strerror(ret));
+ abort();
}
for (a = 0; a < MAXCDB; ++a) {
- lprintf(7, "Closing database %d\n", a);
+ lprintf(7, "cdb_*: Closing database %d\n", a);
ret = dbp[a]->close(dbp[a], 0);
if (ret) {
- lprintf(1, "db_close: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_*: db_close: %s\n", db_strerror(ret));
+ abort();
}
}
/* Close the handle. */
ret = dbenv->close(dbenv, 0);
if (ret) {
- lprintf(1, "DBENV->close: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_*: DBENV->close: %s\n", db_strerror(ret));
+ abort();
}
}
if (ret) {
lprintf(1, "cdb_store(%d): %s\n", cdb,
db_strerror(ret));
+ abort();
}
return ret;
} else {
retry:
- if (txbegin(&tid))
- return -1;
+ txbegin(&tid);
if ((ret = dbp[cdb]->put(dbp[cdb], /* db */
tid, /* transaction ID */
&ddata, /* data */
0))) { /* flags */
if (ret == DB_LOCK_DEADLOCK) {
- if (txabort(tid))
- return ret;
- else
- goto retry;
+ txabort(tid);
+ goto retry;
} else {
lprintf(1, "cdb_store(%d): %s\n", cdb,
db_strerror(ret));
- txabort(tid);
- return ret;
+ abort();
}
} else {
- return txcommit(tid);
+ txcommit(tid);
+ return ret;
}
}
}
DB_TXN *tid;
int ret;
+ memset(&dkey, 0, sizeof dkey);
dkey.size = keylen;
dkey.data = key;
if (MYTID != NULL) {
ret = dbp[cdb]->del(dbp[cdb], MYTID, &dkey, 0);
- return (ret);
+ if (ret) {
+ lprintf(1, "cdb_delete(%d): %s\n", cdb,
+ db_strerror(ret));
+ if (ret != DB_NOTFOUND)
+ abort();
+ }
} else {
retry:
- if (txbegin(&tid))
- return -1;
+ txbegin(&tid);
- if ((ret = dbp[cdb]->del(dbp[cdb], tid, &dkey, 0))) {
+ if ((ret = dbp[cdb]->del(dbp[cdb], tid, &dkey, 0))
+ && ret != DB_NOTFOUND) {
if (ret == DB_LOCK_DEADLOCK) {
- if (txabort(tid))
- return ret;
- else
- goto retry;
+ txabort(tid);
+ goto retry;
} else {
- lprintf(1, "cdb_store(%d): %s\n", cdb,
+ lprintf(1, "cdb_delete(%d): %s\n", cdb,
db_strerror(ret));
- txabort(tid);
- return ret;
+ abort();
}
} else {
- return txcommit(tid);
+ txcommit(tid);
}
}
+ return ret;
}
ret = dbp[cdb]->get(dbp[cdb], MYTID, &dkey, &dret, 0);
} else {
retry:
- if (txbegin(&tid))
- return NULL;
+ txbegin(&tid);
ret = dbp[cdb]->get(dbp[cdb], tid, &dkey, &dret, 0);
if (ret == DB_LOCK_DEADLOCK) {
- if (txabort(tid))
- return NULL;
- else
- goto retry;
- } else if (txcommit(tid))
- return NULL;
+ txabort(tid);
+ goto retry;
+ }
+ if (ret && ret != DB_NOTFOUND)
+ abort();
+
+ txcommit(tid);
}
if ((ret != 0) && (ret != DB_NOTFOUND)) {
lprintf(1, "cdb_fetch: %s\n", db_strerror(ret));
+ abort();
}
if (ret != 0) return NULL;
tempcdb = (struct cdbdata *) mallok(sizeof(struct cdbdata));
if (tempcdb == NULL) {
- lprintf(2, "Cannot allocate memory!\n");
+ lprintf(2, "cdb_fetch: Cannot allocate memory!\n");
+ abort();
}
tempcdb->len = dret.size;
tempcdb->ptr = dret.data;
int ret = 0;
if (MYCURSOR != NULL)
- MYCURSOR->c_close(MYCURSOR);
+ cclose(MYCURSOR);
if (MYTID == NULL) {
- lprintf(1, "ERROR: cursor use outside transaction\n");
+ lprintf(1, "cdb_rewind: ERROR: cursor use outside transaction\n");
abort();
}
*/
ret = dbp[cdb]->cursor(dbp[cdb], MYTID, &MYCURSOR, 0);
if (ret) {
- lprintf(1, "db_cursor: %s\n", db_strerror(ret));
+ lprintf(1, "cdb_rewind: db_cursor: %s\n", db_strerror(ret));
+ abort();
}
}
&key, &data, DB_NEXT);
if (ret) {
- MYCURSOR->c_close(MYCURSOR);
+ if (ret != DB_NOTFOUND) {
+ lprintf(1, "cdb_next_item(%d): %s\n",
+ cdb, db_strerror(ret));
+ abort();
+ }
+ cclose(MYCURSOR);
MYCURSOR = NULL;
return NULL; /* presumably, end of file */
}
void cdb_begin_transaction(void) {
if (MYTID != NULL) { /* FIXME this slows it down, take it out */
- lprintf(1, "ERROR: opening a new transaction with one already open!\n");
+ lprintf(1, "cdb_begin_transaction: ERROR: opening a new transaction with one already open!\n");
abort();
}
else {
void cdb_end_transaction(void) {
if (MYCURSOR != NULL) {
- lprintf(1, "WARNING: cursor still open at transaction end\n");
- MYCURSOR->c_close(MYCURSOR);
+ lprintf(1, "cdb_end_transaction: WARNING: cursor still open at transaction end\n");
+ cclose(MYCURSOR);
MYCURSOR = NULL;
}
- if (MYTID == NULL) lprintf(1, "ERROR: txcommit(NULL) !!\n");
- else txcommit(MYTID);
+ if (MYTID == NULL) {
+ lprintf(1, "cdb_end_transaction: ERROR: txcommit(NULL) !!\n");
+ abort();
+ } else
+ txcommit(MYTID);
+
MYTID = NULL;
}
projects / citadel.git / blobdiff