extern "C"
{
#include "httpd.h"
#include "http_config.h"
#include "http_core.h"
#include "http_log.h"
#include "sem_utils.h"
#include "skiplist.h"
#include "mm_hash.h"
}
#include "utils.h"
#include "db_cxx.h"
static int semset;
#define OK_TO_PROCEED 0
#define GLOBAL_LOCK 1
#define NUM_SEMS 2
static MM *mm;
static MM_Hash *ref_counts;
int env_locks_init()
{
char shmpath[32];
unsigned short start[2] = { 1, 1 };
snprintf(shmpath, 32, "/tmp/.mod_db4.%d", getpid());
mm = mm_create(0, shmpath);
if(NULL == mm) {
return -1;
}
mm_lock(mm, MM_LOCK_RW);
ref_counts = mm_hash_new(mm, NULL);
mm_unlock(mm);
if((semset = md4_sem_create(NUM_SEMS, start)) < 0) {
return -1;
}
return 0;
}
void env_global_rw_lock()
{
mm_lock(mm, MM_LOCK_RW);
}
void env_global_rd_lock()
{
mm_lock(mm, MM_LOCK_RD);
}
void env_global_unlock()
{
mm_unlock(mm);
}
void env_wait_for_child_crash()
{
md4_sem_wait_for_zero(semset, OK_TO_PROCEED);
}
void env_child_crash()
{
md4_sem_set(semset, OK_TO_PROCEED, 0);
}
void env_ok_to_proceed()
{
md4_sem_set(semset, OK_TO_PROCEED, 1);
}
static Skiplist open_transactions;
static Skiplist open_cursors;
static Skiplist open_log_cursors;
static Skiplist open_dbs;
static Skiplist open_dbenvs;
struct named_resource {
char *name;
void *ptr;
};
static int VP_COMPARE(void *a, void *b)
{
return (a < b) ? (-1) : ((a == b) ? (0) : (1));
}
struct db_key {
const char *fname;
const char *dname;
};
static int DB_COMPARE(void *a, void *b)
{
int ret;
DB *ae = (DB *) a;
DB *be = (DB *) b;
if(ae->fname == NULL) {
if(be->fname == NULL) {
return (ae < be) ? (-1) : ((ae == be) ? (0) : (1));
}
return 1;
}
else if(be->fname == NULL) {
return -1;
}
ret = strcmp(ae->fname, be->fname);
if(ret == 0) {
if(ae->dname == NULL) {
if(be->dname == NULL) {
return 0;
}
return 1;
}
else if(be->dname == NULL) {
return -1;
}
ret = strcmp(ae->dname, be->dname);
}
return ret;
}
static int DB_COMPARE_K(void *a, void *b)
{
struct db_key *akey = (struct db_key *) a;
DB *be = (DB *) b;
int ret;
if(akey->fname == NULL) {
if(be->fname == NULL) {
return (a < b) ? (-1) : ((a == b) ? (0) : (1));
}
return 1;
}
else if(be->fname == NULL) {
return -1;
}
ret = strcmp(akey->fname, be->fname);
if(ret == 0) {
if(akey->dname == NULL) {
if(be->dname == NULL) {
return 0;
}
return 1;
}
else if(be->dname == NULL) {
return -1;
}
ret = strcmp(akey->dname, be->dname);
}
return ret;
}
static int DBENV_COMPARE(void *a, void *b)
{
DB_ENV *ae = (DB_ENV *) a;
DB_ENV *be = (DB_ENV *) b;
return strcmp(ae->db_home, be->db_home);
}
static int DBENV_COMPARE_K(void *a, void *b)
{
const char *aname = (const char *) a;
DB_ENV *be = (DB_ENV *) b;
return strcmp(aname, be->db_home);
}
void env_rsrc_list_init()
{
skiplist_init(&open_transactions);
skiplist_set_compare(&open_transactions, VP_COMPARE, VP_COMPARE);
skiplist_init(&open_cursors);
skiplist_set_compare(&open_cursors, VP_COMPARE, VP_COMPARE);
skiplist_init(&open_log_cursors);
skiplist_set_compare(&open_log_cursors, VP_COMPARE, VP_COMPARE);
skiplist_init(&open_dbs);
skiplist_set_compare(&open_dbs, DB_COMPARE, DB_COMPARE_K);
skiplist_init(&open_dbenvs);
skiplist_set_compare(&open_dbenvs, DBENV_COMPARE, DBENV_COMPARE_K);
}
static void register_cursor(DBC *dbc)
{
skiplist_insert(&open_cursors, dbc);
}
static void unregister_cursor(DBC *dbc)
{
skiplist_remove(&open_cursors, dbc, NULL);
}
static void register_log_cursor(DB_LOGC *cursor)
{
skiplist_insert(&open_log_cursors, cursor);
}
static void unregister_log_cursor(DB_LOGC *cursor)
{
skiplist_remove(&open_log_cursors, cursor, NULL);
}
static void register_transaction(DB_TXN *txn)
{
skiplist_insert(&open_transactions, txn);
}
static void unregister_transaction(DB_TXN *txn)
{
skiplist_remove(&open_transactions, txn, NULL);
}
static DB *retrieve_db(const char *fname, const char *dname)
{
DB *rv;
struct db_key key;
if(fname == NULL) {
return NULL;
}
key.fname = fname;
key.dname = dname;
rv = (DB *) skiplist_find(&open_dbs, (void *) &key, NULL);
return rv;
}
static void register_db(DB *db)
{
skiplist_insert(&open_dbs, db);
}
static void unregister_db(DB *db)
{
struct db_key key;
key.fname = db->fname;
key.dname = db->dname;
skiplist_remove(&open_dbs, &key, NULL);
}
static DB_ENV *retrieve_db_env(const char *db_home)
{
return (DB_ENV *) skiplist_find(&open_dbenvs, (void *) db_home, NULL);
}
static void register_db_env(DB_ENV *dbenv)
{
global_ref_count_increase(dbenv->db_home);
skiplist_insert(&open_dbenvs, dbenv);
}
static void unregister_db_env(DB_ENV *dbenv)
{
global_ref_count_decrease(dbenv->db_home);
skiplist_remove(&open_dbenvs, dbenv->db_home, NULL);
}
int global_ref_count_increase(char *path)
{
int refcount = 0;
int pathlen = 0;
pathlen = strlen(path);
env_global_rw_lock();
refcount = (int) mm_hash_find(ref_counts, path, pathlen);
refcount++;
mm_hash_update(ref_counts, path, pathlen, (void *)refcount);
env_global_unlock();
return refcount;
}
int global_ref_count_decrease(char *path)
{
int refcount = 0;
int pathlen = 0;
pathlen = strlen(path);
env_global_rw_lock();
refcount = (int) mm_hash_find(ref_counts, path, pathlen);
if(refcount > 0) refcount--;
mm_hash_update(ref_counts, path, pathlen, (void *)refcount);
env_global_unlock();
return refcount;
}
int global_ref_count_get(const char *path)
{
int refcount = 0;
int pathlen = 0;
pathlen = strlen(path);
env_global_rd_lock();
refcount = (int) mm_hash_find(ref_counts, path, pathlen);
env_global_unlock();
return refcount;
}
void global_ref_count_clean()
{
env_global_rd_lock();
mm_hash_free(ref_counts);
ref_counts = mm_hash_new(mm, NULL);
env_global_unlock();
}
static int (*old_log_cursor_close)(DB_LOGC *, u_int32_t) = NULL;
static int new_log_cursor_close(DB_LOGC *cursor, u_int32_t flags)
{
unregister_log_cursor(cursor);
return old_log_cursor_close(cursor, flags);
}
static int (*old_db_txn_abort)(DB_TXN *) = NULL;
static int new_db_txn_abort(DB_TXN *tid)
{
unregister_transaction(tid);
return old_db_txn_abort(tid);
}
static int (*old_db_txn_commit)(DB_TXN *, u_int32_t) = NULL;
static int new_db_txn_commit(DB_TXN *tid, u_int32_t flags)
{
unregister_transaction(tid);
return old_db_txn_commit(tid, flags);
}
static int (*old_db_txn_discard)(DB_TXN *, u_int32_t) = NULL;
static int new_db_txn_discard(DB_TXN *tid, u_int32_t flags)
{
unregister_transaction(tid);
return old_db_txn_discard(tid, flags);
}
static int (*old_db_env_txn_begin)(DB_ENV *, DB_TXN *, DB_TXN **, u_int32_t);
static int new_db_env_txn_begin(DB_ENV *env, DB_TXN *parent, DB_TXN **tid, u_int32_t flags)
{
int ret;
if((ret = old_db_env_txn_begin(env, parent, tid, flags)) == 0) {
register_transaction(*tid);
if(old_db_txn_abort == NULL) {
old_db_txn_abort = (*tid)->abort;
}
(*tid)->abort = new_db_txn_abort;
if(old_db_txn_commit == NULL) {
old_db_txn_commit = (*tid)->commit;
}
(*tid)->commit = new_db_txn_commit;
if(old_db_txn_discard == NULL) {
old_db_txn_discard = (*tid)->discard;
}
(*tid)->discard = new_db_txn_discard;
}
return ret;
}
static int (*old_db_env_open)(DB_ENV *, const char *, u_int32_t, int) = NULL;
static int new_db_env_open(DB_ENV *dbenv, const char *db_home, u_int32_t flags, int mode)
{
int ret =666;
DB_ENV *cached_dbenv;
flags |= DB_INIT_MPOOL;
if(global_ref_count_get(db_home) == 0) {
flags |= DB_RECOVER;
flags |= DB_INIT_TXN;
flags |= DB_CREATE;
}
if((cached_dbenv = retrieve_db_env(db_home)) != NULL) {
memcpy(dbenv, cached_dbenv, sizeof(DB_ENV));
ret = 0;
}
else if((ret = old_db_env_open(dbenv, db_home, flags, mode)) == 0) {
register_db_env(dbenv);
}
return ret;
}
static int(*old_db_env_close)(DB_ENV *, u_int32_t) = NULL;
static int new_db_env_close(DB_ENV *dbenv, u_int32_t flags)
{
int ret;
unregister_db_env(dbenv);
ret = old_db_env_close(dbenv, flags);
}
static int (*old_db_env_log_cursor)(DB_ENV *, DB_LOGC **, u_int32_t) = NULL;
static int new_db_env_log_cursor(DB_ENV *dbenv, DB_LOGC **cursop, u_int32_t flags)
{
int ret;
if((ret = old_db_env_log_cursor(dbenv, cursop, flags)) == 0) {
register_log_cursor(*cursop);
if(old_log_cursor_close == NULL) {
old_log_cursor_close = (*cursop)->close;
}
(*cursop)->close = new_log_cursor_close;
}
return ret;
}
static int (*old_db_open)(DB *, DB_TXN *, const char *, const char *, DBTYPE, u_int32_t, int) = NULL;
static int new_db_open(DB *db, DB_TXN *txnid, const char *file,
const char *database, DBTYPE type, u_int32_t flags, int mode)
{
int ret;
DB *cached_db;
cached_db = retrieve_db(file, database);
if(cached_db) {
memcpy(db, cached_db, sizeof(DB));
ret = 0;
}
else if((ret = old_db_open(db, txnid, file, database, type, flags, mode)) == 0) {
register_db(db);
}
return ret;
}
static int (*old_db_close)(DB *, u_int32_t) = NULL;
static int new_db_close(DB *db, u_int32_t flags)
{
unregister_db(db);
return old_db_close(db, flags);
}
static int (*old_dbc_close)(DBC *);
static int new_dbc_close(DBC *cursor)
{
unregister_cursor(cursor);
return old_dbc_close(cursor);
}
static int (*old_dbc_dup)(DBC *, DBC **, u_int32_t) = NULL;
static int new_dbc_dup(DBC *oldcursor, DBC **newcursor, u_int32_t flags)
{
int ret;
if((ret = old_dbc_dup(oldcursor, newcursor, flags)) == 0) {
register_cursor(*newcursor);
(*newcursor)->close = oldcursor->close;
(*newcursor)->dup = oldcursor->dup;
}
return ret;
}
static int (*old_db_cursor)(DB *, DB_TXN *, DBC **, u_int32_t) = NULL;
static int new_db_cursor(DB *db, DB_TXN *txnid, DBC **cursop, u_int32_t flags)
{
int ret;
if((ret = old_db_cursor(db, txnid, cursop, flags)) == 0) {
register_cursor(*cursop);
if(old_dbc_close == NULL) {
old_dbc_close = (*cursop)->close;
}
(*cursop)->close = new_dbc_close;
if(old_dbc_dup == NULL) {
old_dbc_dup = (*cursop)->dup;
}
(*cursop)->dup = new_dbc_dup;
}
return ret;
}
int mod_db4_db_env_create(DB_ENV **dbenvp, u_int32_t flags)
{
int cachesize = 0;
int ret;
DB_ENV *dbenv;
if ((ret = db_env_create(dbenvp, 0)) != 0) {
return ret;
}
dbenv = *dbenvp;
DbEnv::wrap_DB_ENV(dbenv);
if (0 && cachesize) {
if ((ret = dbenv->set_cachesize(dbenv, 0, cachesize, 0)) != 0) {
dbenv->err(dbenv, ret, "set_cachesize");
dbenv->close(dbenv, 0);
}
}
if(old_db_env_open == NULL) {
old_db_env_open = dbenv->open;
}
dbenv->open = new_db_env_open;
if(old_db_env_close == NULL) {
old_db_env_close = dbenv->close;
}
dbenv->close = new_db_env_close;
if(old_db_env_log_cursor == NULL) {
old_db_env_log_cursor = dbenv->log_cursor;
}
dbenv->log_cursor = new_db_env_log_cursor;
if(old_db_env_txn_begin == NULL) {
old_db_env_txn_begin = dbenv->txn_begin;
}
dbenv->txn_begin = new_db_env_txn_begin;
return 0;
}
int mod_db4_db_create(DB **dbp, DB_ENV *dbenv, u_int32_t flags)
{
int ret;
flags = 0;
if((ret = db_create(dbp, dbenv, flags)) == 0) {
if(old_db_open == NULL) {
old_db_open = (*dbp)->open;
}
(*dbp)->open = new_db_open;
if(old_db_close == NULL) {
old_db_close = (*dbp)->close;
}
(*dbp)->close = new_db_close;
if(old_db_cursor == NULL) {
old_db_cursor = (*dbp)->cursor;
}
(*dbp)->cursor = new_db_cursor;
}
return ret;
}
void mod_db4_child_clean_request_shutdown()
{
DBC *cursor;
DB_TXN *transaction;
while(cursor = (DBC *)skiplist_pop(&open_cursors, NULL)) {
cursor->close(cursor);
}
while(transaction = (DB_TXN *)skiplist_pop(&open_transactions, NULL)) {
transaction->abort(transaction);
}
}
void mod_db4_child_clean_process_shutdown()
{
DB *db;
DB_ENV *dbenv;
mod_db4_child_clean_request_shutdown();
while(db = (DB *)skiplist_pop(&open_dbs, NULL)) {
db->close(db, 0);
}
while(dbenv = (DB_ENV *)skiplist_pop(&open_dbenvs, NULL)) {
DbEnv *dbe = DbEnv::get_DbEnv(dbenv);
global_ref_count_decrease(dbenv->db_home);
dbe->close(0);
delete dbe;
}
}