#include "citserver.h"
#include "database.h"
#include "sysdep_decls.h"
+#include "dynloader.h"
-#define DATABASE_NAME "citadel.db"
+
+/*
+ * FIXME this should be defined somewhere else.
+ */
+int transaction_based = 1;
+
+DB *dbp[MAXCDB]; /* One DB handle for each Citadel database */
+DB_ENV *dbenv; /* The DB environment (global) */
+
+struct cdbssd { /* Session-specific DB stuff */
+ DBC *cursor; /* Cursor, for traversals... */
+ DB_TXN *tid; /* Transaction ID */
+};
+
+struct cdbssd *ssd_arr = NULL;
+int num_ssd = 0;
+#define MYCURSOR ssd_arr[CC->cs_pid].cursor
+#define MYTID ssd_arr[CC->cs_pid].tid
/*
- * This array holds one DB handle for each Citadel database.
+ * Ensure that we have enough space for session-specific data. We don't
+ * put anything in here that Citadel cares about; this is just database
+ * related stuff like cursors and transactions.
*/
-DB *dbp[MAXCDB];
+void cdb_allocate_ssd(void) {
+ /*
+ * Make sure we have a cursor allocated for this session
+ */
+
+ lprintf(9, "num_ssd before realloc = %d\n", num_ssd);
+ if (num_ssd <= CC->cs_pid) {
+ num_ssd = CC->cs_pid + 1;
+ if (ssd_arr == NULL) {
+ ssd_arr = (struct cdbssd *)
+ mallok((sizeof(struct cdbssd) * num_ssd));
+ } else {
+ ssd_arr = (struct cdbssd *)
+ reallok(ssd_arr, (sizeof(struct cdbssd) * num_ssd));
+ }
+ }
+ lprintf(9, "num_ssd after realloc = %d\n", num_ssd);
+}
-DBC *MYCURSOR; /* FIXME !! */
/*
* Reclaim unused space in the databases. We need to do each one of
* these discretely, rather than in a loop.
+ *
+ * This is a stub function in the Sleepycat DB backend, because there is no
+ * such API call available.
*/
void defrag_databases(void)
{
- /* FIXME ... do we even need this? If not, we'll just keep it as
- * a stub function to keep the API consistent.
- */
+ /* do nothing */
}
int ret;
int i;
char dbfilename[256];
+ u_int32_t flags = 0;
+
+ /*
+ * 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");
+ ret = db_env_create(&dbenv, 0);
+ if (ret) {
+ lprintf(1, "db_env_create: %s\n", db_strerror(ret));
+ exit(ret);
+ }
+ dbenv->set_errpfx(dbenv, "citserver");
+
+ /*
+ * We want to specify the shared memory buffer pool cachesize,
+ * but everything else is the default.
+ */
+ ret = dbenv->set_cachesize(dbenv, 0, 64 * 1024, 0);
+ if (ret) {
+ lprintf(1, "set_cachesize: %s\n", db_strerror(ret));
+ dbenv->close(dbenv, 0);
+ exit(ret);
+ }
+
+ /*
+ * We specify DB_PRIVATE but not DB_INIT_LOCK or DB_THREAD, even
+ * though this is a multithreaded application. Since Citadel does all
+ * database access in S_DATABASE critical sections, access to the db
+ * is serialized already, so don't bother the database manager with
+ * it. Besides, it locks up when we do it that way.
+ */
+ flags = DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE;
+ if (transaction_based) flags = flags | DB_INIT_TXN;
+ ret = dbenv->open(dbenv, "./data", flags, 0);
+ if (ret) {
+ lprintf(1, "dbenv->open: %s\n", db_strerror(ret));
+ dbenv->close(dbenv, 0);
+ exit(ret);
+ }
lprintf(7, "Starting up DB\n");
for (i = 0; i < MAXCDB; ++i) {
/* Create a database handle */
- ret = db_create(&dbp[i], NULL, 0);
- if (ret != 0) {
+ ret = db_create(&dbp[i], dbenv, 0);
+ if (ret) {
lprintf(1, "db_create: %s\n", db_strerror(ret));
exit(ret);
}
- /* FIXME these are tunable, so tune them */
- dbp[i]->set_pagesize(dbp[i], 1024);
- dbp[i]->set_cachesize(dbp[i], 0, 32768, 0);
/* Arbitrary names for our tables -- we reference them by
* number, so we don't have string names for them.
sprintf(dbfilename, "cdb.%02x", i);
ret = dbp[i]->open(dbp[i],
- DATABASE_NAME,
dbfilename,
+ NULL,
DB_BTREE,
- (DB_CREATE|DB_NOMMAP|DB_THREAD|DB_UPGRADE),
+ DB_CREATE,
0600);
-
- if (ret != 0) {
- lprintf(1, "db_open: %s\n", db_strerror(ret));
+ if (ret) {
+ lprintf(1, "db_open[%d]: %s\n", i, db_strerror(ret));
exit(ret);
}
}
+ cdb_allocate_ssd();
+ CtdlRegisterSessionHook(cdb_allocate_ssd, EVT_START);
+
+
}
for (a = 0; a < MAXCDB; ++a) {
lprintf(7, "Closing database %d\n", a);
ret = dbp[a]->close(dbp[a], 0);
- if (ret != 0) {
+ if (ret) {
lprintf(1, "db_close: %s\n", db_strerror(ret));
}
}
+
+
+
+ /* Close the handle. */
+ ret = dbenv->close(dbenv, 0);
+ if (ret) {
+ lprintf(1, "DBENV->close: %s\n", db_strerror(ret));
+ }
+
+
end_critical_section(S_DATABASE);
}
* key already exists it should be overwritten.
*/
int cdb_store(int cdb,
- void *key, int keylen,
- void *data, int datalen)
+ void *ckey, int ckeylen,
+ void *cdata, int cdatalen)
{
DBT dkey, ddata;
int ret;
- dkey.size = keylen;
- dkey.data = key;
- ddata.size = datalen;
- ddata.data = data;
+ memset(&dkey, 0, sizeof(DBT));
+ memset(&ddata, 0, sizeof(DBT));
+ dkey.size = ckeylen;
+ dkey.data = ckey;
+ ddata.size = cdatalen;
+ ddata.data = cdata;
begin_critical_section(S_DATABASE);
ret = dbp[cdb]->put(dbp[cdb], /* db */
- NULL, /* transaction ID (hmm...) */
+ MYTID, /* transaction ID */
&dkey, /* key */
&ddata, /* data */
0); /* flags */
end_critical_section(S_DATABASE);
- if (ret < 0) {
+ if (ret) {
lprintf(1, "cdb_store: %s\n", db_strerror(ret));
return (-1);
}
dkey.data = key;
begin_critical_section(S_DATABASE);
- ret = dbp[cdb]->del(dbp[cdb], NULL, &dkey, 0);
+ ret = dbp[cdb]->del(dbp[cdb], MYTID, &dkey, 0);
end_critical_section(S_DATABASE);
return (ret);
DBT dkey, dret;
int ret;
+ memset(&dkey, 0, sizeof(DBT));
+ memset(&dret, 0, sizeof(DBT));
dkey.size = keylen;
dkey.data = key;
+ dret.flags = DB_DBT_MALLOC;
begin_critical_section(S_DATABASE);
- ret = dbp[cdb]->get(dbp[cdb], NULL, &dkey, &dret, 0);
+ ret = dbp[cdb]->get(dbp[cdb], MYTID, &dkey, &dret, 0);
end_critical_section(S_DATABASE);
- if (ret) {
- return NULL;
+ if ((ret != 0) && (ret != DB_NOTFOUND)) {
+ lprintf(1, "cdb_fetch: %s\n", db_strerror(ret));
}
+ if (ret != 0) return NULL;
tempcdb = (struct cdbdata *) mallok(sizeof(struct cdbdata));
if (tempcdb == NULL) {
lprintf(2, "Cannot allocate memory!\n");
/*
- * Prepare for a sequential search of an entire database. (In the DB model,
- * use per-session key. There is guaranteed to be no more than one traversal in
+ * Prepare for a sequential search of an entire database.
+ * (There is guaranteed to be no more than one traversal in
* progress per session at any given time.)
*/
void cdb_rewind(int cdb)
{
int ret = 0;
+ cdb_allocate_ssd();
+
+ /*
+ * Now initialize the cursor
+ */
begin_critical_section(S_DATABASE);
- ret = dbp[cdb]->cursor(dbp[cdb], NULL, &MYCURSOR, 0);
- if (ret != 0) {
- lprintf(1, "db_create: %s\n", db_strerror(ret));
+ ret = dbp[cdb]->cursor(dbp[cdb], MYTID, &MYCURSOR, 0);
+ if (ret) {
+ lprintf(1, "db_cursor: %s\n", db_strerror(ret));
}
end_critical_section(S_DATABASE);
}
/* Initialize the key/data pair so the flags aren't set. */
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
+ data.flags = DB_DBT_MALLOC;
begin_critical_section(S_DATABASE);
ret = MYCURSOR->c_get(MYCURSOR,
return (cdbret);
}
+
+
+/*
+ * Transaction-based stuff. I'm writing this as I bake cookies...
+ */
+
+void cdb_begin_transaction(void) {
+ if (!transaction_based) {
+ MYTID = NULL;
+ return;
+ }
+
+ txn_begin(dbenv, NULL, &MYTID, 0);
+}
+
+void cdb_end_transaction(void) {
+ if (transaction_based) txn_commit(MYTID, 0);
+}
projects / citadel.git / blobdiff