#include <sys/types.h>
#include <sys/stat.h>
+#include <dirent.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/un.h>
};
typedef enum queue_side_e queue_side_t;
+/* describe a set of journal files */
+typedef struct {
+ char **files;
+ size_t files_num;
+} journal_set;
+
/* max length of socket command or response */
#define CMD_MAX 4096
#define RBUF_SIZE (CMD_MAX*2)
static listen_socket_t *listen_fds = NULL;
static size_t listen_fds_num = 0;
-static int do_shutdown = 0;
+enum {
+ RUNNING, /* normal operation */
+ FLUSHING, /* flushing remaining values */
+ SHUTDOWN /* shutting down */
+} state = RUNNING;
static pthread_t *queue_threads;
static pthread_cond_t queue_cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER;
/* Journaled updates */
-static char *journal_cur = NULL;
-static char *journal_old = NULL;
-static FILE *journal_fh = NULL;
+#define JOURNAL_BASE "rrd.journal"
+static journal_set *journal_cur = NULL;
+static journal_set *journal_old = NULL;
+static char *journal_dir = NULL;
+static FILE *journal_fh = NULL; /* current journal file handle */
+static long journal_size = 0; /* current journal size */
+#define JOURNAL_MAX (1 * 1024 * 1024 * 1024)
static pthread_mutex_t journal_lock = PTHREAD_MUTEX_INITIALIZER;
static int journal_write(char *cmd, char *args);
static void journal_done(void);
static void sig_common (const char *sig) /* {{{ */
{
RRDD_LOG(LOG_NOTICE, "caught SIG%s", sig);
- do_shutdown++;
+ state = FLUSHING;
pthread_cond_broadcast(&flush_cond);
pthread_cond_broadcast(&queue_cond);
} /* }}} void sig_common */
}
lseek(pid_fd, 0, SEEK_SET);
- ftruncate(pid_fd, 0);
+ if (ftruncate(pid_fd, 0) == -1)
+ {
+ fprintf(stderr,
+ "FATAL: Faild to truncate stale PID file. (pid %d)\n", pid);
+ close(pid_fd);
+ return -1;
+ }
fprintf(stderr,
"rrdcached: removed stale PID file (no rrdcached on pid %d)\n"
/* in case anyone is waiting */
pthread_cond_broadcast(&ci->flushed);
+ pthread_cond_destroy(&ci->flushed);
free (ci);
if (ci->flags & CI_FLAGS_IN_QUEUE)
return FALSE;
- if ((ci->last_flush_time <= cfd->abs_timeout)
- && (ci->values_num > 0))
- {
- enqueue_cache_item (ci, TAIL);
- }
- else if ((do_shutdown != 0)
- && (ci->values_num > 0))
+ if (ci->values_num > 0
+ && (ci->last_flush_time <= cfd->abs_timeout || state != RUNNING))
{
enqueue_cache_item (ci, TAIL);
}
pthread_mutex_lock(&cache_lock);
- while (!do_shutdown)
+ while (state == RUNNING)
{
gettimeofday (&now, NULL);
if ((now.tv_sec > next_flush.tv_sec)
|| ((now.tv_sec == next_flush.tv_sec)
&& ((1000 * now.tv_usec) > next_flush.tv_nsec)))
{
+ RRDD_LOG(LOG_DEBUG, "flushing old values");
+
+ /* Determine the time of the next cache flush. */
+ next_flush.tv_sec = now.tv_sec + config_flush_interval;
+
/* Flush all values that haven't been written in the last
* `config_write_interval' seconds. */
flush_old_values (config_write_interval);
- /* Determine the time of the next cache flush. */
- next_flush.tv_sec =
- now.tv_sec + next_flush.tv_sec % config_flush_interval;
-
/* unlock the cache while we rotate so we don't block incoming
* updates if the fsync() blocks on disk I/O */
pthread_mutex_unlock(&cache_lock);
if (config_flush_at_shutdown)
flush_old_values (-1); /* flush everything */
+ state = SHUTDOWN;
+
pthread_mutex_unlock(&cache_lock);
return NULL;
{
pthread_mutex_lock (&cache_lock);
- while (!do_shutdown
+ while (state != SHUTDOWN
|| (cache_queue_head != NULL && config_flush_at_shutdown))
{
cache_item_t *ci;
int status;
/* Now, check if there's something to store away. If not, wait until
- * something comes in. if we are shutting down, do not wait around. */
- if (cache_queue_head == NULL && !do_shutdown)
+ * something comes in. */
+ if (cache_queue_head == NULL)
{
status = pthread_cond_wait (&queue_cond, &cache_lock);
if ((status != 0) && (status != ETIMEDOUT))
}
journal_write("wrote", file);
- pthread_cond_broadcast(&ci->flushed);
- rrd_free_ptrs((void ***) &values, &values_num);
- free(file);
+ /* Search again in the tree. It's possible someone issued a "FORGET"
+ * while we were writing the update values. */
+ pthread_mutex_lock(&cache_lock);
+ ci = (cache_item_t *) g_tree_lookup(cache_tree, file);
+ if (ci)
+ pthread_cond_broadcast(&ci->flushed);
+ pthread_mutex_unlock(&cache_lock);
if (status == 0)
{
pthread_mutex_unlock (&stats_lock);
}
+ rrd_free_ptrs((void ***) &values, &values_num);
+ free(file);
+
pthread_mutex_lock (&cache_lock);
}
pthread_mutex_unlock (&cache_lock);
if (ci == NULL) /* {{{ */
{
struct stat statbuf;
+ cache_item_t *tmp;
/* don't hold the lock while we setup; stat(2) might block */
pthread_mutex_unlock(&cache_lock);
pthread_cond_init(&ci->flushed, NULL);
pthread_mutex_lock(&cache_lock);
- g_tree_replace (cache_tree, (void *) ci->file, (void *) ci);
+
+ /* another UPDATE might have added this entry in the meantime */
+ tmp = g_tree_lookup (cache_tree, file);
+ if (tmp == NULL)
+ g_tree_replace (cache_tree, (void *) ci->file, (void *) ci);
+ else
+ {
+ free_cache_item (ci);
+ ci = tmp;
+ }
+
+ /* state may have changed while we were unlocked */
+ if (state == SHUTDOWN)
+ return -1;
} /* }}} */
assert (ci != NULL);
return cmd->handler(cmd, sock, now, buffer_ptr, buffer_size);
} /* }}} int handle_request */
-/* MUST NOT hold journal_lock before calling this */
-static void journal_rotate(void) /* {{{ */
+static void journal_set_free (journal_set *js) /* {{{ */
{
- FILE *old_fh = NULL;
- int new_fd;
-
- if (journal_cur == NULL || journal_old == NULL)
+ if (js == NULL)
return;
- pthread_mutex_lock(&journal_lock);
+ rrd_free_ptrs((void ***) &js->files, &js->files_num);
- /* we rotate this way (rename before close) so that the we can release
- * the journal lock as fast as possible. Journal writes to the new
- * journal can proceed immediately after the new file is opened. The
- * fclose can then block without affecting new updates.
- */
- if (journal_fh != NULL)
+ free(js);
+} /* }}} journal_set_free */
+
+static void journal_set_remove (journal_set *js) /* {{{ */
+{
+ if (js == NULL)
+ return;
+
+ for (uint i=0; i < js->files_num; i++)
{
- old_fh = journal_fh;
- journal_fh = NULL;
- rename(journal_cur, journal_old);
- ++stats_journal_rotate;
+ RRDD_LOG(LOG_DEBUG, "removing old journal %s", js->files[i]);
+ unlink(js->files[i]);
}
+} /* }}} journal_set_remove */
- new_fd = open(journal_cur, O_WRONLY|O_CREAT|O_APPEND,
- S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
- if (new_fd >= 0)
+/* close current journal file handle.
+ * MUST hold journal_lock before calling */
+static void journal_close(void) /* {{{ */
+{
+ if (journal_fh != NULL)
{
- journal_fh = fdopen(new_fd, "a");
- if (journal_fh == NULL)
- close(new_fd);
+ if (fclose(journal_fh) != 0)
+ RRDD_LOG(LOG_ERR, "cannot close journal: %s", rrd_strerror(errno));
}
- pthread_mutex_unlock(&journal_lock);
+ journal_fh = NULL;
+ journal_size = 0;
+} /* }}} journal_close */
+
+/* MUST hold journal_lock before calling */
+static void journal_new_file(void) /* {{{ */
+{
+ struct timeval now;
+ int new_fd;
+ char new_file[PATH_MAX + 1];
+
+ assert(journal_dir != NULL);
+ assert(journal_cur != NULL);
- if (old_fh != NULL)
- fclose(old_fh);
+ journal_close();
+ gettimeofday(&now, NULL);
+ /* this format assures that the files sort in strcmp() order */
+ snprintf(new_file, PATH_MAX, "%s/%s.%010d.%06d",
+ journal_dir, JOURNAL_BASE, (int)now.tv_sec, (int)now.tv_usec);
+
+ new_fd = open(new_file, O_WRONLY|O_CREAT|O_APPEND,
+ S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
+ if (new_fd < 0)
+ goto error;
+
+ journal_fh = fdopen(new_fd, "a");
if (journal_fh == NULL)
- {
- RRDD_LOG(LOG_CRIT,
- "JOURNALING DISABLED: Cannot open journal file '%s' : (%s)",
- journal_cur, rrd_strerror(errno));
+ goto error;
- RRDD_LOG(LOG_ERR,
- "JOURNALING DISABLED: All values will be flushed at shutdown");
- config_flush_at_shutdown = 1;
- }
+ journal_size = ftell(journal_fh);
+ RRDD_LOG(LOG_DEBUG, "started new journal %s", new_file);
+
+ /* record the file in the journal set */
+ rrd_add_strdup(&journal_cur->files, &journal_cur->files_num, new_file);
+
+ return;
+
+error:
+ RRDD_LOG(LOG_CRIT,
+ "JOURNALING DISABLED: Error while trying to create %s : %s",
+ new_file, rrd_strerror(errno));
+ RRDD_LOG(LOG_CRIT,
+ "JOURNALING DISABLED: All values will be flushed at shutdown");
+
+ close(new_fd);
+ config_flush_at_shutdown = 1;
+
+} /* }}} journal_new_file */
+
+/* MUST NOT hold journal_lock before calling this */
+static void journal_rotate(void) /* {{{ */
+{
+ journal_set *old_js = NULL;
+
+ if (journal_dir == NULL)
+ return;
+
+ RRDD_LOG(LOG_DEBUG, "rotating journals");
+
+ pthread_mutex_lock(&stats_lock);
+ ++stats_journal_rotate;
+ pthread_mutex_unlock(&stats_lock);
+
+ pthread_mutex_lock(&journal_lock);
+
+ journal_close();
+
+ /* rotate the journal sets */
+ old_js = journal_old;
+ journal_old = journal_cur;
+ journal_cur = calloc(1, sizeof(journal_set));
+
+ if (journal_cur != NULL)
+ journal_new_file();
+ else
+ RRDD_LOG(LOG_CRIT, "journal_rotate: malloc(journal_set) failed\n");
+
+ pthread_mutex_unlock(&journal_lock);
+
+ journal_set_remove(old_js);
+ journal_set_free (old_js);
} /* }}} static void journal_rotate */
+/* MUST hold journal_lock when calling */
static void journal_done(void) /* {{{ */
{
if (journal_cur == NULL)
return;
- pthread_mutex_lock(&journal_lock);
- if (journal_fh != NULL)
- {
- fclose(journal_fh);
- journal_fh = NULL;
- }
+ journal_close();
if (config_flush_at_shutdown)
{
RRDD_LOG(LOG_INFO, "removing journals");
- unlink(journal_old);
- unlink(journal_cur);
+ journal_set_remove(journal_old);
+ journal_set_remove(journal_cur);
}
else
{
"journals will be used at next startup");
}
- pthread_mutex_unlock(&journal_lock);
+ journal_set_free(journal_cur);
+ journal_set_free(journal_old);
+ free(journal_dir);
} /* }}} static void journal_done */
pthread_mutex_lock(&journal_lock);
chars = fprintf(journal_fh, "%s %s\n", cmd, args);
+ journal_size += chars;
+
+ if (journal_size > JOURNAL_MAX)
+ journal_new_file();
+
pthread_mutex_unlock(&journal_lock);
if (chars > 0)
memset(&statbuf, 0, sizeof(statbuf));
if (stat(file, &statbuf) != 0)
{
- if (errno == ENOENT)
- return 0;
-
reason = "stat error";
status = errno;
}
return entry_cnt > 0 ? 1 : 0;
} /* }}} static int journal_replay */
+static int journal_sort(const void *v1, const void *v2)
+{
+ char **jn1 = (char **) v1;
+ char **jn2 = (char **) v2;
+
+ return strcmp(*jn1,*jn2);
+}
+
static void journal_init(void) /* {{{ */
{
int had_journal = 0;
+ DIR *dir;
+ struct dirent *dent;
+ char path[PATH_MAX+1];
- if (journal_cur == NULL) return;
+ if (journal_dir == NULL) return;
pthread_mutex_lock(&journal_lock);
+ journal_cur = calloc(1, sizeof(journal_set));
+ if (journal_cur == NULL)
+ {
+ RRDD_LOG(LOG_CRIT, "journal_rotate: malloc(journal_set) failed\n");
+ return;
+ }
+
RRDD_LOG(LOG_INFO, "checking for journal files");
- had_journal += journal_replay(journal_old);
- had_journal += journal_replay(journal_cur);
+ /* Handle old journal files during transition. This gives them the
+ * correct sort order. TODO: remove after first release
+ */
+ {
+ char old_path[PATH_MAX+1];
+ snprintf(old_path, PATH_MAX, "%s/%s", journal_dir, JOURNAL_BASE ".old" );
+ snprintf(path, PATH_MAX, "%s/%s", journal_dir, JOURNAL_BASE ".0000");
+ rename(old_path, path);
+
+ snprintf(old_path, PATH_MAX, "%s/%s", journal_dir, JOURNAL_BASE );
+ snprintf(path, PATH_MAX, "%s/%s", journal_dir, JOURNAL_BASE ".0001");
+ rename(old_path, path);
+ }
+
+ dir = opendir(journal_dir);
+ while ((dent = readdir(dir)) != NULL)
+ {
+ /* looks like a journal file? */
+ if (strncmp(dent->d_name, JOURNAL_BASE, strlen(JOURNAL_BASE)))
+ continue;
+
+ snprintf(path, PATH_MAX, "%s/%s", journal_dir, dent->d_name);
+
+ if (!rrd_add_strdup(&journal_cur->files, &journal_cur->files_num, path))
+ {
+ RRDD_LOG(LOG_CRIT, "journal_init: cannot add journal file %s!",
+ dent->d_name);
+ break;
+ }
+ }
+ closedir(dir);
+
+ qsort(journal_cur->files, journal_cur->files_num,
+ sizeof(journal_cur->files[0]), journal_sort);
+
+ for (uint i=0; i < journal_cur->files_num; i++)
+ had_journal += journal_replay(journal_cur->files[i]);
+
+ journal_new_file();
/* it must have been a crash. start a flush */
if (had_journal && config_flush_at_shutdown)
flush_old_values(-1);
pthread_mutex_unlock(&journal_lock);
- journal_rotate();
RRDD_LOG(LOG_INFO, "journal processing complete");
connection_threads_num++;
pthread_mutex_unlock (&connection_threads_lock);
- while (do_shutdown == 0)
+ while (state == RUNNING)
{
char *cmd;
ssize_t cmd_len;
pollfd.revents = 0;
status = poll (&pollfd, 1, /* timeout = */ 500);
- if (do_shutdown)
+ if (state != RUNNING)
break;
else if (status == 0) /* timeout */
continue;
RRDD_LOG(LOG_INFO, "listening for connections");
- while (do_shutdown == 0)
+ while (state == RUNNING)
{
for (i = 0; i < pollfds_num; i++)
{
}
status = poll (pollfds, pollfds_num, /* timeout = */ 1000);
- if (do_shutdown)
+ if (state != RUNNING)
break;
else if (status == 0) /* timeout */
continue;
continue;
}
} /* for (pollfds_num) */
- } /* while (do_shutdown == 0) */
+ } /* while (state == RUNNING) */
RRDD_LOG(LOG_INFO, "starting shutdown");
close (0);
open ("/dev/null", O_RDWR);
- dup (0);
- dup (0);
+ if (dup(0) == -1 || dup(0) == -1){
+ RRDD_LOG (LOG_ERR, "faild to run dup.\n");
+ }
} /* if (!stay_foreground) */
/* Change into the /tmp directory. */
static int cleanup (void) /* {{{ */
{
- do_shutdown++;
-
pthread_cond_broadcast (&flush_cond);
pthread_join (flush_thread, NULL);
RRDD_LOG(LOG_INFO, "clean shutdown; all RRDs flushed");
}
- journal_done();
- remove_pidfile ();
-
free(queue_threads);
free(config_base_dir);
free(config_pid_file);
- free(journal_cur);
- free(journal_old);
pthread_mutex_lock(&cache_lock);
g_tree_destroy(cache_tree);
+ pthread_mutex_lock(&journal_lock);
+ journal_done();
+
RRDD_LOG(LOG_INFO, "goodbye");
closelog ();
+ remove_pidfile ();
+
return (0);
} /* }}} int cleanup */
case 'j':
{
struct stat statbuf;
- const char *dir = optarg;
+ const char *dir = journal_dir = strdup(optarg);
status = stat(dir, &statbuf);
if (status != 0)
errno ? rrd_strerror(errno) : "");
return 6;
}
-
- journal_cur = malloc(PATH_MAX + 1);
- journal_old = malloc(PATH_MAX + 1);
- if (journal_cur == NULL || journal_old == NULL)
- {
- fprintf(stderr, "malloc failure for journal files\n");
- return 6;
- }
- else
- {
- snprintf(journal_cur, PATH_MAX, "%s/rrd.journal", dir);
- snprintf(journal_old, PATH_MAX, "%s/rrd.journal.old", dir);
- }
}
break;
fprintf(stderr, "WARNING: -B does not make sense without -b!\n"
" Consult the rrdcached documentation\n");
- if (journal_cur == NULL)
+ if (journal_dir == NULL)
config_flush_at_shutdown = 1;
return (status);
projects / rrdtool.git / blobdiff