static void
cleanup()
{
int rc;
DB *db;
DB_ENV *dbenv;
rc = get_db(&db, 0);
assert(! rc);
rc = get_dbenv(&dbenv, 0);
assert(! rc);
if (dbkey.data)
free(dbkey.data);
if (db)
call_db(db->close(db, 0), "DB close");
if (dbenv) {
rc = call_db(db_create(&db, dbenv, 0), "db_create");
if (!rc)
if (! db->remove(db, "tls_stats.db", 0, 0))
syslog(LOG_NOTICE, "Unused database tls_stats.db removed");
call_db(dbenv->txn_checkpoint(dbenv, 100 * 1024, 24 * 60, 0),
"txn_checkpoint");
call_db(dbenv->log_archive(dbenv, NULL, DB_ARCH_REMOVE), "log_archive");
call_db(dbenv->close(dbenv, 0), "DB_ENV close");
}
policy_cleanup();
}
void *db_maint(void *arg)
{
DB_ENV *dbenv = arg;
int i, ret;
char **begin, **list;
for(;; sleep(db_maint_delay * 60))
{
if((ret = dbenv->txn_checkpoint(dbenv, 0, 0, DB_FORCE)) != 0)
{
NETERROR(MRADC, ("db_maint thread: checkpoint failed: %d\n", ret));
}
if((ret = dbenv->log_archive(dbenv, &list, DB_ARCH_ABS)) != 0)
{
NETERROR(MRADC, ("db_maint thread: log archive failed: %d\n", ret));
}
if(list != NULL)
{
for(begin = list; *list != NULL; ++list)
{
if((ret = remove(*list)) != 0)
{
NETERROR(MRADC, ("db_maint thread: remove %s failed: %d\n", *list, ret));
}
}
free(begin);
}
}
}
static void *bdb_checkpoint_thread(void *arg){
DB_ENV *dbenv;
int ret;
dbenv = arg;
for (;; sleep(bdb_settings.checkpoint_val)) {
if ((ret = dbenv->txn_checkpoint(dbenv, 0, 0, 0)) != 0) {
dbenv->err(dbenv, ret, "checkpoint thread");
}
dbenv->errx(dbenv, "checkpoint thread: a txn_checkpoint is done");
}
return (NULL);
}
static void *bdb_chkpoint_thread(void *arg)
{
DB_ENV *dbenv;
int ret;
dbenv = arg;
if (settings.verbose > 1) {
dbenv->errx(dbenv, "checkpoint thread created: %lu, every %d seconds",
(u_long)pthread_self(), bdb_settings.chkpoint_val);
}
for (;; sleep(bdb_settings.chkpoint_val)) {
if ((ret = dbenv->txn_checkpoint(dbenv, 0, 0, 0)) != 0) {
dbenv->err(dbenv, ret, "checkpoint thread");
}
dbenv->errx(dbenv, "checkpoint thread: a txn_checkpoint is done");
}
return (NULL);
}
void *
checkpoint_thread(void *arg)
{
DB_ENV *dbenv;
int ret;
dbenv = arg;
dbenv->errx(dbenv, "Checkpoint thread: %lu", (u_long)pthread_self());
/* Checkpoint once a minute. */
for (;; sleep(60))
if ((ret = dbenv->txn_checkpoint(dbenv, 0, 0, 0)) != 0) {
dbenv->err(dbenv, ret, "checkpoint thread");
exit (1);
}
/* NOTREACHED */
}
/************************* Transactional Berkeley DB *************************/
gpointer bdb_thread(gpointer d)
{
int res;
DB_ENV *env;
DB *db;
DB_TXN *txn = NULL;
int count = 0;
res = db_env_create(&env, 0);
g_assert(res == 0);
res = env->open(env, ".",
DB_CREATE | DB_RECOVER | DB_INIT_LOCK | DB_INIT_LOG
| DB_INIT_MPOOL | DB_INIT_TXN | DB_THREAD, 0644);
g_assert(res == 0);
if (opt_bdb_async) {
res = env->set_flags(env, DB_TXN_WRITE_NOSYNC, 1);
g_assert(res == 0);
}
res = db_create(&db, env, 0);
g_assert(res == 0);
res = db->open(db, NULL, "log.db", "log", DB_BTREE,
DB_CREATE | DB_THREAD | DB_AUTO_COMMIT, 0644);
g_assert(res == 0);
while (TRUE) {
if (txn == NULL && !opt_bdb_async) {
res = env->txn_begin(env, NULL, &txn, 0);
g_assert(res == 0);
}
struct item *item = get_item();
DBT key, value;
memset(&key, 0, sizeof(key));
memset(&value, 0, sizeof(value));
key.data = item->key;
key.size = strlen(item->key);
value.data = item->data;
value.size = item->len;
res = db->put(db, opt_bdb_async ? NULL : txn, &key, &value, 0);
g_assert(res == 0);
count++;
if (count % opt_batchsize == 0) {
if (opt_bdb_async) {
env->txn_checkpoint(env, 0, 0, 0);
} else {
txn->commit(txn, 0);
txn = NULL;
}
}
finish_item(item);
}
return NULL;
}
void *
checkpoint_thread(void *arg)
{
DB_ENV *dbenv;
int ret;
int my_pid = (int)pthread_self();
dbenv = arg;
if(init_log(my_pid))
{
exit(1);
}
write_log("CHP %d: starting\n", my_pid);
/* Checkpoint once in 30 seconds. */
for (;; poll(0,0,30000))
{
switch (ret = dbenv->txn_checkpoint(dbenv, 0, 0, 0))
{
case 0:
write_log("CHP %d: checkpoint...\n", my_pid);
break;
default:
write_log("CHP %d: checkpoint error - %s\n",
my_pid, db_strerror(ret));
break;
}
if(pthread_mutex_lock(&checkpoint_mutex))
{
write_log("CHP %d: pthread_mutex_lock error - %s\n",
my_pid, strerror(errno));
goto error;
}
if(checkpoint_exit_flag)
{
/* The thread was told to exit */
if(pthread_mutex_unlock(&checkpoint_mutex))
{
write_log("CHP %d: pthread_mutex_unlock error - %s\n",
my_pid, strerror(errno));
goto error;
}
write_log("CHP %d: exiting gracefully\n", my_pid);
goto done;
}
if(pthread_mutex_unlock(&checkpoint_mutex))
{
write_log("CHP %d: pthread_mutex_unlock error - %s\n",
my_pid, strerror(errno));
goto error;
}
}
error:
write_log("CHP %d: exiting from ERROR\n", my_pid);
done:
return (void *)0;
}
