/**
* RRDTool - src/rrd_daemon.c
* Copyright (C) 2008 Florian octo Forster
+ * Copyright (C) 2008 Kevin Brintnall
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
*
* Authors:
* Florian octo Forster <octo at verplant.org>
+ * kevin brintnall <kbrint@rufus.net>
**/
+#if 0
/*
* First tell the compiler to stick to the C99 and POSIX standards as close as
* possible.
# undef _GNU_SOURCE
#endif
/* }}} */
+#endif /* 0 */
/*
* Now for some includes..
/*
* Types
*/
+typedef enum
+{
+ PRIV_LOW,
+ PRIV_HIGH
+} socket_privilege;
+
struct listen_socket_s
{
int fd;
- char path[PATH_MAX + 1];
+ char addr[PATH_MAX + 1];
+ int family;
+ socket_privilege privilege;
};
typedef struct listen_socket_s listen_socket_t;
char **values;
int values_num;
time_t last_flush_time;
-#define CI_FLAGS_IN_TREE 0x01
-#define CI_FLAGS_IN_QUEUE 0x02
+#define CI_FLAGS_IN_TREE (1<<0)
+#define CI_FLAGS_IN_QUEUE (1<<1)
int flags;
-
+ pthread_cond_t flushed;
+ cache_item_t *prev;
cache_item_t *next;
};
};
typedef enum queue_side_e queue_side_t;
+/* max length of socket command or response */
+#define CMD_MAX 4096
+
/*
* Variables
*/
+static int stay_foreground = 0;
+
static listen_socket_t *listen_fds = NULL;
static size_t listen_fds_num = 0;
static pthread_t queue_thread;
-static pthread_t *connetion_threads = NULL;
-static pthread_mutex_t connetion_threads_lock = PTHREAD_MUTEX_INITIALIZER;
-static int connetion_threads_num = 0;
+static pthread_t *connection_threads = NULL;
+static pthread_mutex_t connection_threads_lock = PTHREAD_MUTEX_INITIALIZER;
+static int connection_threads_num = 0;
/* Cache stuff */
static GTree *cache_tree = NULL;
static pthread_mutex_t cache_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cache_cond = PTHREAD_COND_INITIALIZER;
-static pthread_cond_t flush_cond = PTHREAD_COND_INITIALIZER;
-
static int config_write_interval = 300;
+static int config_write_jitter = 0;
static int config_flush_interval = 3600;
+static int config_flush_at_shutdown = 0;
static char *config_pid_file = NULL;
static char *config_base_dir = NULL;
+static size_t _config_base_dir_len = 0;
+static int config_write_base_only = 0;
-static char **config_listen_address_list = NULL;
+static listen_socket_t **config_listen_address_list = NULL;
static int config_listen_address_list_len = 0;
static uint64_t stats_queue_length = 0;
+static uint64_t stats_updates_received = 0;
+static uint64_t stats_flush_received = 0;
static uint64_t stats_updates_written = 0;
static uint64_t stats_data_sets_written = 0;
+static uint64_t stats_journal_bytes = 0;
+static uint64_t stats_journal_rotate = 0;
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;
+static pthread_mutex_t journal_lock = PTHREAD_MUTEX_INITIALIZER;
+static int journal_write(char *cmd, char *args);
+static void journal_done(void);
+static void journal_rotate(void);
+
/*
* Functions
*/
-static void sig_int_handler (int s __attribute__((unused))) /* {{{ */
+static void sig_common (const char *sig) /* {{{ */
{
+ RRDD_LOG(LOG_NOTICE, "caught SIG%s", sig);
do_shutdown++;
+ pthread_cond_broadcast(&cache_cond);
+} /* }}} void sig_common */
+
+static void sig_int_handler (int s __attribute__((unused))) /* {{{ */
+{
+ sig_common("INT");
} /* }}} void sig_int_handler */
static void sig_term_handler (int s __attribute__((unused))) /* {{{ */
{
- do_shutdown++;
+ sig_common("TERM");
} /* }}} void sig_term_handler */
-static int write_pidfile (void) /* {{{ */
+static void sig_usr1_handler (int s __attribute__((unused))) /* {{{ */
{
- pid_t pid;
+ config_flush_at_shutdown = 1;
+ sig_common("USR1");
+} /* }}} void sig_usr1_handler */
+
+static void sig_usr2_handler (int s __attribute__((unused))) /* {{{ */
+{
+ config_flush_at_shutdown = 0;
+ sig_common("USR2");
+} /* }}} void sig_usr2_handler */
+
+static void install_signal_handlers(void) /* {{{ */
+{
+ /* These structures are static, because `sigaction' behaves weird if the are
+ * overwritten.. */
+ static struct sigaction sa_int;
+ static struct sigaction sa_term;
+ static struct sigaction sa_pipe;
+ static struct sigaction sa_usr1;
+ static struct sigaction sa_usr2;
+
+ /* Install signal handlers */
+ memset (&sa_int, 0, sizeof (sa_int));
+ sa_int.sa_handler = sig_int_handler;
+ sigaction (SIGINT, &sa_int, NULL);
+
+ memset (&sa_term, 0, sizeof (sa_term));
+ sa_term.sa_handler = sig_term_handler;
+ sigaction (SIGTERM, &sa_term, NULL);
+
+ memset (&sa_pipe, 0, sizeof (sa_pipe));
+ sa_pipe.sa_handler = SIG_IGN;
+ sigaction (SIGPIPE, &sa_pipe, NULL);
+
+ memset (&sa_pipe, 0, sizeof (sa_usr1));
+ sa_usr1.sa_handler = sig_usr1_handler;
+ sigaction (SIGUSR1, &sa_usr1, NULL);
+
+ memset (&sa_usr2, 0, sizeof (sa_usr2));
+ sa_usr2.sa_handler = sig_usr2_handler;
+ sigaction (SIGUSR2, &sa_usr2, NULL);
+
+} /* }}} void install_signal_handlers */
+
+static int open_pidfile(void) /* {{{ */
+{
+ int fd;
char *file;
- FILE *fh;
- pid = getpid ();
-
file = (config_pid_file != NULL)
? config_pid_file
: LOCALSTATEDIR "/run/rrdcached.pid";
- fh = fopen (file, "w");
+ fd = open(file, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IRGRP|S_IROTH);
+ if (fd < 0)
+ fprintf(stderr, "FATAL: cannot create '%s' (%s)\n",
+ file, rrd_strerror(errno));
+
+ return(fd);
+} /* }}} static int open_pidfile */
+
+static int write_pidfile (int fd) /* {{{ */
+{
+ pid_t pid;
+ FILE *fh;
+
+ pid = getpid ();
+
+ fh = fdopen (fd, "w");
if (fh == NULL)
{
- RRDD_LOG (LOG_ERR, "write_pidfile: Opening `%s' failed.", file);
+ RRDD_LOG (LOG_ERR, "write_pidfile: fdopen() failed.");
+ close(fd);
return (-1);
}
size_t nleft;
ssize_t status;
+ /* special case for journal replay */
+ if (fd < 0) return 0;
+
ptr = (const char *) buf;
nleft = count;
if (status < 0)
return (status);
- nleft = nleft - status;
- ptr = ptr + status;
+ nleft -= status;
+ ptr += status;
}
return (0);
} /* }}} ssize_t swrite */
+static void wipe_ci_values(cache_item_t *ci, time_t when)
+{
+ ci->values = NULL;
+ ci->values_num = 0;
+
+ ci->last_flush_time = when;
+ if (config_write_jitter > 0)
+ ci->last_flush_time += (random() % config_write_jitter);
+}
+
+/* remove_from_queue
+ * remove a "cache_item_t" item from the queue.
+ * must hold 'cache_lock' when calling this
+ */
+static void remove_from_queue(cache_item_t *ci) /* {{{ */
+{
+ if (ci == NULL) return;
+
+ if (ci->prev == NULL)
+ cache_queue_head = ci->next; /* reset head */
+ else
+ ci->prev->next = ci->next;
+
+ if (ci->next == NULL)
+ cache_queue_tail = ci->prev; /* reset the tail */
+ else
+ ci->next->prev = ci->prev;
+
+ ci->next = ci->prev = NULL;
+ ci->flags &= ~CI_FLAGS_IN_QUEUE;
+} /* }}} static void remove_from_queue */
+
/*
* enqueue_cache_item:
* `cache_lock' must be acquired before calling this function!
static int enqueue_cache_item (cache_item_t *ci, /* {{{ */
queue_side_t side)
{
- int did_insert = 0;
-
if (ci == NULL)
return (-1);
if (side == HEAD)
{
- if ((ci->flags & CI_FLAGS_IN_QUEUE) == 0)
- {
- assert (ci->next == NULL);
- ci->next = cache_queue_head;
- cache_queue_head = ci;
+ if (cache_queue_head == ci)
+ return 0;
- if (cache_queue_tail == NULL)
- cache_queue_tail = cache_queue_head;
-
- did_insert = 1;
- }
- else if (cache_queue_head == ci)
- {
- /* do nothing */
- }
- else /* enqueued, but not first entry */
- {
- cache_item_t *prev;
+ /* remove from the double linked list */
+ if (ci->flags & CI_FLAGS_IN_QUEUE)
+ remove_from_queue(ci);
- /* find previous entry */
- for (prev = cache_queue_head; prev != NULL; prev = prev->next)
- if (prev->next == ci)
- break;
- assert (prev != NULL);
+ ci->prev = NULL;
+ ci->next = cache_queue_head;
+ if (ci->next != NULL)
+ ci->next->prev = ci;
+ cache_queue_head = ci;
- /* move to the front */
- prev->next = ci->next;
- ci->next = cache_queue_head;
- cache_queue_head = ci;
-
- /* check if we need to adapt the tail */
- if (cache_queue_tail == ci)
- cache_queue_tail = prev;
- }
+ if (cache_queue_tail == NULL)
+ cache_queue_tail = cache_queue_head;
}
else /* (side == TAIL) */
{
/* We don't move values back in the list.. */
- if ((ci->flags & CI_FLAGS_IN_QUEUE) != 0)
+ if (ci->flags & CI_FLAGS_IN_QUEUE)
return (0);
assert (ci->next == NULL);
+ assert (ci->prev == NULL);
+
+ ci->prev = cache_queue_tail;
if (cache_queue_tail == NULL)
cache_queue_head = ci;
else
cache_queue_tail->next = ci;
- cache_queue_tail = ci;
- did_insert = 1;
+ cache_queue_tail = ci;
}
ci->flags |= CI_FLAGS_IN_QUEUE;
- if (did_insert)
- {
- pthread_mutex_lock (&stats_lock);
- stats_queue_length++;
- pthread_mutex_unlock (&stats_lock);
- }
+ pthread_cond_broadcast(&cache_cond);
+ pthread_mutex_lock (&stats_lock);
+ stats_queue_length++;
+ pthread_mutex_unlock (&stats_lock);
return (0);
} /* }}} int enqueue_cache_item */
if (max_age > 0)
cfd.abs_timeout = cfd.now - max_age;
else
- cfd.abs_timeout = cfd.now + 1;
+ cfd.abs_timeout = cfd.now + 2*config_write_jitter + 1;
/* `tree_callback_flush' will return the keys of all values that haven't
* been touched in the last `config_flush_interval' seconds in `cfd'.
{
struct timeval now;
struct timespec next_flush;
+ int final_flush = 0; /* make sure we only flush once on shutdown */
gettimeofday (&now, NULL);
next_flush.tv_sec = now.tv_sec + config_flush_interval;
flush_old_values (config_write_interval);
/* Determine the time of the next cache flush. */
- while (next_flush.tv_sec < now.tv_sec)
+ while (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);
+ journal_rotate();
+ pthread_mutex_lock(&cache_lock);
}
/* Now, check if there's something to store away. If not, wait until
- * something comes in or it's time to do the cache flush. */
- if (cache_queue_head == NULL)
+ * something comes in or it's time to do the cache flush. if we are
+ * shutting down, do not wait around. */
+ if (cache_queue_head == NULL && !do_shutdown)
{
status = pthread_cond_timedwait (&cache_cond, &cache_lock, &next_flush);
if ((status != 0) && (status != ETIMEDOUT))
}
}
- /* We're about to shut down, so lets flush the entire tree. */
- if ((do_shutdown != 0) && (cache_queue_head == NULL))
- flush_old_values (/* max age = */ -1);
+ /* We're about to shut down */
+ if (do_shutdown != 0 && !final_flush++)
+ {
+ if (config_flush_at_shutdown)
+ flush_old_values (-1); /* flush everything */
+ else
+ break;
+ }
/* Check if a value has arrived. This may be NULL if we timed out or there
* was an interrupt such as a signal. */
continue;
}
+ assert(ci->values != NULL);
+ assert(ci->values_num > 0);
+
values = ci->values;
values_num = ci->values_num;
- ci->values = NULL;
- ci->values_num = 0;
-
- ci->last_flush_time = time (NULL);
- ci->flags &= ~(CI_FLAGS_IN_QUEUE);
-
- cache_queue_head = ci->next;
- if (cache_queue_head == NULL)
- cache_queue_tail = NULL;
- ci->next = NULL;
+ wipe_ci_values(ci, time(NULL));
+ remove_from_queue(ci);
pthread_mutex_lock (&stats_lock);
assert (stats_queue_length > 0);
pthread_mutex_unlock (&cache_lock);
+ rrd_clear_error ();
status = rrd_update_r (file, NULL, values_num, (void *) values);
if (status != 0)
{
- RRDD_LOG (LOG_ERR, "queue_thread_main: "
- "rrd_update_r failed with status %i.",
- status);
+ RRDD_LOG (LOG_NOTICE, "queue_thread_main: "
+ "rrd_update_r (%s) failed with status %i. (%s)",
+ file, status, rrd_get_error());
}
- free (file);
+ journal_write("wrote", file);
+ pthread_cond_broadcast(&ci->flushed);
+
for (i = 0; i < values_num; i++)
free (values[i]);
+ free(values);
+ free(file);
+
if (status == 0)
{
pthread_mutex_lock (&stats_lock);
}
pthread_mutex_lock (&cache_lock);
- pthread_cond_broadcast (&flush_cond);
- /* We're about to shut down, so lets flush the entire tree. */
- if ((do_shutdown != 0) && (cache_queue_head == NULL))
- flush_old_values (/* max age = */ -1);
+ /* We're about to shut down */
+ if (do_shutdown != 0 && !final_flush++)
+ {
+ if (config_flush_at_shutdown)
+ flush_old_values (-1); /* flush everything */
+ else
+ break;
+ }
} /* while ((do_shutdown == 0) || (cache_queue_head != NULL)) */
pthread_mutex_unlock (&cache_lock);
+ if (config_flush_at_shutdown)
+ {
+ assert(cache_queue_head == NULL);
+ RRDD_LOG(LOG_INFO, "clean shutdown; all RRDs flushed");
+ }
+
+ journal_done();
+
return (NULL);
} /* }}} void *queue_thread_main */
return (-1);
/* This is ensured by `handle_request'. */
- assert (buffer[buffer_size - 1] == ' ');
+ assert (buffer[buffer_size - 1] == '\0');
status = -1;
while (buffer_pos < buffer_size)
{
/* Check for end-of-field or end-of-buffer */
- if (buffer[buffer_pos] == ' ')
+ if (buffer[buffer_pos] == ' ' || buffer[buffer_pos] == '\0')
{
field[field_size] = 0;
field_size++;
return (0);
} /* }}} int buffer_get_field */
+/* if we're restricting writes to the base directory,
+ * check whether the file falls within the dir
+ * returns 1 if OK, otherwise 0
+ */
+static int check_file_access (const char *file, int fd) /* {{{ */
+{
+ char error[CMD_MAX];
+ assert(file != NULL);
+
+ if (!config_write_base_only
+ || fd < 0 /* journal replay */
+ || config_base_dir == NULL)
+ return 1;
+
+ if (strstr(file, "../") != NULL) goto err;
+
+ /* relative paths without "../" are ok */
+ if (*file != '/') return 1;
+
+ /* file must be of the format base + "/" + <1+ char filename> */
+ if (strlen(file) < _config_base_dir_len + 2) goto err;
+ if (strncmp(file, config_base_dir, _config_base_dir_len) != 0) goto err;
+ if (*(file + _config_base_dir_len) != '/') goto err;
+
+ return 1;
+
+err:
+ snprintf(error, sizeof(error)-1, "-1 %s\n", rrd_strerror(EACCES));
+ swrite(fd, error, strlen(error));
+ return 0;
+} /* }}} static int check_file_access */
+
static int flush_file (const char *filename) /* {{{ */
{
cache_item_t *ci;
return (ENOENT);
}
- /* Enqueue at head */
- enqueue_cache_item (ci, HEAD);
- pthread_cond_signal (&cache_cond);
-
- while ((ci->flags & CI_FLAGS_IN_QUEUE) != 0)
+ if (ci->values_num > 0)
{
- ci = NULL;
-
- pthread_cond_wait (&flush_cond, &cache_lock);
-
- ci = g_tree_lookup (cache_tree, filename);
- if (ci == NULL)
- {
- RRDD_LOG (LOG_ERR, "flush_file: Tree node went away "
- "while waiting for flush.");
- pthread_mutex_unlock (&cache_lock);
- return (-1);
- }
+ /* Enqueue at head */
+ enqueue_cache_item (ci, HEAD);
+ pthread_cond_wait(&ci->flushed, &cache_lock);
}
- pthread_mutex_unlock (&cache_lock);
+ pthread_mutex_unlock(&cache_lock);
+
return (0);
} /* }}} int flush_file */
char *help_help[] =
{
- "4 Command overview\n",
+ "5 Command overview\n",
"FLUSH <filename>\n",
+ "FLUSHALL\n",
"HELP [<command>]\n",
"UPDATE <filename> <values> [<values> ...]\n",
"STATS\n"
};
size_t help_flush_len = sizeof (help_flush) / sizeof (help_flush[0]);
+ char *help_flushall[] =
+ {
+ "3 Help for FLUSHALL\n",
+ "Usage: FLUSHALL\n",
+ "\n",
+ "Triggers writing of all pending updates. Returns immediately.\n"
+ };
+ size_t help_flushall_len = sizeof(help_flushall) / sizeof(help_flushall[0]);
+
char *help_update[] =
{
"9 Help for UPDATE\n",
help_text = help_flush;
help_text_len = help_flush_len;
}
+ else if (strcasecmp (command, "flushall") == 0)
+ {
+ help_text = help_flushall;
+ help_text_len = help_flushall_len;
+ }
else if (strcasecmp (command, "stats") == 0)
{
help_text = help_stats;
size_t buffer_size __attribute__((unused)))
{
int status;
- char outbuf[4096];
+ char outbuf[CMD_MAX];
uint64_t copy_queue_length;
+ uint64_t copy_updates_received;
+ uint64_t copy_flush_received;
uint64_t copy_updates_written;
uint64_t copy_data_sets_written;
+ uint64_t copy_journal_bytes;
+ uint64_t copy_journal_rotate;
uint64_t tree_nodes_number;
uint64_t tree_depth;
pthread_mutex_lock (&stats_lock);
copy_queue_length = stats_queue_length;
+ copy_updates_received = stats_updates_received;
+ copy_flush_received = stats_flush_received;
copy_updates_written = stats_updates_written;
copy_data_sets_written = stats_data_sets_written;
+ copy_journal_bytes = stats_journal_bytes;
+ copy_journal_rotate = stats_journal_rotate;
pthread_mutex_unlock (&stats_lock);
pthread_mutex_lock (&cache_lock);
return (status); \
}
- strncpy (outbuf, "5 Statistics follow\n", sizeof (outbuf));
+ strncpy (outbuf, "9 Statistics follow\n", sizeof (outbuf));
RRDD_STATS_SEND;
snprintf (outbuf, sizeof (outbuf),
RRDD_STATS_SEND;
snprintf (outbuf, sizeof (outbuf),
+ "UpdatesReceived: %"PRIu64"\n", copy_updates_received);
+ RRDD_STATS_SEND;
+
+ snprintf (outbuf, sizeof (outbuf),
+ "FlushesReceived: %"PRIu64"\n", copy_flush_received);
+ RRDD_STATS_SEND;
+
+ snprintf (outbuf, sizeof (outbuf),
"UpdatesWritten: %"PRIu64"\n", copy_updates_written);
RRDD_STATS_SEND;
"TreeDepth: %"PRIu64"\n", tree_depth);
RRDD_STATS_SEND;
+ snprintf (outbuf, sizeof(outbuf),
+ "JournalBytes: %"PRIu64"\n", copy_journal_bytes);
+ RRDD_STATS_SEND;
+
+ snprintf (outbuf, sizeof(outbuf),
+ "JournalRotate: %"PRIu64"\n", copy_journal_rotate);
+ RRDD_STATS_SEND;
+
return (0);
#undef RRDD_STATS_SEND
} /* }}} int handle_request_stats */
{
char *file;
int status;
- char result[4096];
+ char result[CMD_MAX];
status = buffer_get_field (&buffer, &buffer_size, &file);
if (status != 0)
}
else
{
+ pthread_mutex_lock(&stats_lock);
+ stats_flush_received++;
+ pthread_mutex_unlock(&stats_lock);
+
+ if (!check_file_access(file, fd)) return 0;
+
status = flush_file (file);
if (status == 0)
snprintf (result, sizeof (result), "0 Successfully flushed %s.\n", file);
else if (status == ENOENT)
- snprintf (result, sizeof (result), "-1 No such file: %s.\n", file);
+ {
+ /* no file in our tree; see whether it exists at all */
+ struct stat statbuf;
+
+ memset(&statbuf, 0, sizeof(statbuf));
+ if (stat(file, &statbuf) == 0 && S_ISREG(statbuf.st_mode))
+ snprintf (result, sizeof (result), "0 Nothing to flush: %s.\n", file);
+ else
+ snprintf (result, sizeof (result), "-1 No such file: %s.\n", file);
+ }
else if (status < 0)
strncpy (result, "-1 Internal error.\n", sizeof (result));
else
return (0);
} /* }}} int handle_request_flush */
+static int handle_request_flushall(int fd) /* {{{ */
+{
+ int status;
+ char answer[] ="0 Started flush.\n";
+
+ RRDD_LOG(LOG_DEBUG, "Received FLUSHALL");
+
+ pthread_mutex_lock(&cache_lock);
+ flush_old_values(-1);
+ pthread_mutex_unlock(&cache_lock);
+
+ status = swrite(fd, answer, strlen(answer));
+ if (status < 0)
+ {
+ status = errno;
+ RRDD_LOG(LOG_INFO, "handle_request_flushall: swrite returned an error.");
+ }
+
+ return (status);
+} /* }}} static int handle_request_flushall */
+
static int handle_request_update (int fd, /* {{{ */
char *buffer, size_t buffer_size)
{
time_t now;
cache_item_t *ci;
- char answer[4096];
+ char answer[CMD_MAX];
#define RRDD_UPDATE_SEND \
answer[sizeof (answer) - 1] = 0; \
return (0);
}
- pthread_mutex_lock (&cache_lock);
+ pthread_mutex_lock(&stats_lock);
+ stats_updates_received++;
+ pthread_mutex_unlock(&stats_lock);
+ if (!check_file_access(file, fd)) return 0;
+
+ pthread_mutex_lock (&cache_lock);
ci = g_tree_lookup (cache_tree, file);
+
if (ci == NULL) /* {{{ */
{
struct stat statbuf;
+ /* don't hold the lock while we setup; stat(2) might block */
+ pthread_mutex_unlock(&cache_lock);
+
memset (&statbuf, 0, sizeof (statbuf));
status = stat (file, &statbuf);
if (status != 0)
{
- pthread_mutex_unlock (&cache_lock);
- RRDD_LOG (LOG_ERR, "handle_request_update: stat (%s) failed.", file);
+ RRDD_LOG (LOG_NOTICE, "handle_request_update: stat (%s) failed.", file);
status = errno;
if (status == ENOENT)
- snprintf (answer, sizeof (answer), "-1 No such file: %s", file);
+ snprintf (answer, sizeof (answer), "-1 No such file: %s\n", file);
else
snprintf (answer, sizeof (answer), "-1 stat failed with error %i.\n",
status);
}
if (!S_ISREG (statbuf.st_mode))
{
- pthread_mutex_unlock (&cache_lock);
-
- snprintf (answer, sizeof (answer), "-1 Not a regular file: %s", file);
+ snprintf (answer, sizeof (answer), "-1 Not a regular file: %s\n", file);
+ RRDD_UPDATE_SEND;
+ return (0);
+ }
+ if (access(file, R_OK|W_OK) != 0)
+ {
+ snprintf (answer, sizeof (answer), "-1 Cannot read/write %s: %s\n",
+ file, rrd_strerror(errno));
RRDD_UPDATE_SEND;
return (0);
}
ci = (cache_item_t *) malloc (sizeof (cache_item_t));
if (ci == NULL)
{
- pthread_mutex_unlock (&cache_lock);
RRDD_LOG (LOG_ERR, "handle_request_update: malloc failed.");
strncpy (answer, "-1 malloc failed.\n", sizeof (answer));
ci->file = strdup (file);
if (ci->file == NULL)
{
- pthread_mutex_unlock (&cache_lock);
free (ci);
RRDD_LOG (LOG_ERR, "handle_request_update: strdup failed.");
return (0);
}
- ci->values = NULL;
- ci->values_num = 0;
- ci->last_flush_time = now;
+ wipe_ci_values(ci, now);
ci->flags = CI_FLAGS_IN_TREE;
+ pthread_mutex_lock(&cache_lock);
g_tree_insert (cache_tree, (void *) ci->file, (void *) ci);
} /* }}} */
assert (ci != NULL);
&& (ci->values_num > 0))
{
enqueue_cache_item (ci, TAIL);
- pthread_cond_signal (&cache_cond);
}
pthread_mutex_unlock (&cache_lock);
#undef RRDD_UPDATE_SEND
} /* }}} int handle_request_update */
-static int handle_request (int fd) /* {{{ */
+/* we came across a "WROTE" entry during journal replay.
+ * throw away any values that we have accumulated for this file
+ */
+static int handle_request_wrote (int fd __attribute__((unused)), /* {{{ */
+ const char *buffer,
+ size_t buffer_size __attribute__((unused)))
{
- char buffer[4096];
- size_t buffer_size;
- char *buffer_ptr;
- char *command;
- int status;
+ int i;
+ cache_item_t *ci;
+ const char *file = buffer;
- status = (int) sread (fd, buffer, sizeof (buffer));
- if (status == 0)
+ pthread_mutex_lock(&cache_lock);
+
+ ci = g_tree_lookup(cache_tree, file);
+ if (ci == NULL)
{
- return (1);
+ pthread_mutex_unlock(&cache_lock);
+ return (0);
}
- else if (status < 0)
+
+ if (ci->values)
{
- RRDD_LOG (LOG_ERR, "handle_request: sread failed.");
- return (-1);
+ for (i=0; i < ci->values_num; i++)
+ free(ci->values[i]);
+
+ free(ci->values);
}
- buffer_size = (size_t) status;
- assert (buffer_size <= sizeof (buffer));
- assert (buffer[buffer_size - 1] == 0);
- /* Place the normal field separator at the end to simplify
- * `buffer_get_field's work. */
- buffer[buffer_size - 1] = ' ';
+ wipe_ci_values(ci, time(NULL));
+ remove_from_queue(ci);
+
+ pthread_mutex_unlock(&cache_lock);
+ return (0);
+} /* }}} int handle_request_wrote */
+
+/* returns 1 if we have the required privilege level */
+static int has_privilege (socket_privilege priv, /* {{{ */
+ socket_privilege required, int fd)
+{
+ int status;
+ char error[CMD_MAX];
+
+ if (priv >= required)
+ return 1;
+
+ sprintf(error, "-1 %s\n", rrd_strerror(EACCES));
+ status = swrite(fd, error, strlen(error));
+
+ if (status < 0)
+ return status;
+ else
+ return 0;
+} /* }}} static int has_privilege */
+
+/* if fd < 0, we are in journal replay mode */
+static int handle_request (int fd, socket_privilege privilege, /* {{{ */
+ char *buffer, size_t buffer_size)
+{
+ char *buffer_ptr;
+ char *command;
+ int status;
+
+ assert (buffer[buffer_size - 1] == '\0');
buffer_ptr = buffer;
command = NULL;
if (strcasecmp (command, "update") == 0)
{
+ status = has_privilege(privilege, PRIV_HIGH, fd);
+ if (status <= 0)
+ return status;
+
+ /* don't re-write updates in replay mode */
+ if (fd >= 0)
+ journal_write(command, buffer_ptr);
+
return (handle_request_update (fd, buffer_ptr, buffer_size));
}
+ else if (strcasecmp (command, "wrote") == 0 && fd < 0)
+ {
+ /* this is only valid in replay mode */
+ return (handle_request_wrote (fd, buffer_ptr, buffer_size));
+ }
else if (strcasecmp (command, "flush") == 0)
{
return (handle_request_flush (fd, buffer_ptr, buffer_size));
}
+ else if (strcasecmp (command, "flushall") == 0)
+ {
+ status = has_privilege(privilege, PRIV_HIGH, fd);
+ if (status <= 0)
+ return status;
+
+ return (handle_request_flushall(fd));
+ }
else if (strcasecmp (command, "stats") == 0)
{
return (handle_request_stats (fd, buffer_ptr, buffer_size));
}
else
{
- char result[4096];
+ char result[CMD_MAX];
snprintf (result, sizeof (result), "-1 Unknown command: %s\n", command);
result[sizeof (result) - 1] = 0;
return (0);
} /* }}} int handle_request */
-static void *connection_thread_main (void *args /* {{{ */
- __attribute__((unused)))
+/* MUST NOT hold journal_lock before calling this */
+static void journal_rotate(void) /* {{{ */
+{
+ FILE *old_fh = NULL;
+
+ if (journal_cur == NULL || journal_old == NULL)
+ return;
+
+ pthread_mutex_lock(&journal_lock);
+
+ /* 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)
+ {
+ old_fh = journal_fh;
+ rename(journal_cur, journal_old);
+ ++stats_journal_rotate;
+ }
+
+ journal_fh = fopen(journal_cur, "a");
+ pthread_mutex_unlock(&journal_lock);
+
+ if (old_fh != NULL)
+ fclose(old_fh);
+
+ if (journal_fh == NULL)
+ {
+ RRDD_LOG(LOG_CRIT,
+ "JOURNALING DISABLED: Cannot open journal file '%s' : (%s)",
+ journal_cur, rrd_strerror(errno));
+
+ RRDD_LOG(LOG_ERR,
+ "JOURNALING DISABLED: All values will be flushed at shutdown");
+ config_flush_at_shutdown = 1;
+ }
+
+} /* }}} static void journal_rotate */
+
+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;
+ }
+
+ if (config_flush_at_shutdown)
+ {
+ RRDD_LOG(LOG_INFO, "removing journals");
+ unlink(journal_old);
+ unlink(journal_cur);
+ }
+ else
+ {
+ RRDD_LOG(LOG_INFO, "expedited shutdown; "
+ "journals will be used at next startup");
+ }
+
+ pthread_mutex_unlock(&journal_lock);
+
+} /* }}} static void journal_done */
+
+static int journal_write(char *cmd, char *args) /* {{{ */
+{
+ int chars;
+
+ if (journal_fh == NULL)
+ return 0;
+
+ pthread_mutex_lock(&journal_lock);
+ chars = fprintf(journal_fh, "%s %s\n", cmd, args);
+ pthread_mutex_unlock(&journal_lock);
+
+ if (chars > 0)
+ {
+ pthread_mutex_lock(&stats_lock);
+ stats_journal_bytes += chars;
+ pthread_mutex_unlock(&stats_lock);
+ }
+
+ return chars;
+} /* }}} static int journal_write */
+
+static int journal_replay (const char *file) /* {{{ */
+{
+ FILE *fh;
+ int entry_cnt = 0;
+ int fail_cnt = 0;
+ uint64_t line = 0;
+ char entry[CMD_MAX];
+
+ if (file == NULL) return 0;
+
+ fh = fopen(file, "r");
+ if (fh == NULL)
+ {
+ if (errno != ENOENT)
+ RRDD_LOG(LOG_ERR, "journal_replay: cannot open journal file: '%s' (%s)",
+ file, rrd_strerror(errno));
+ return 0;
+ }
+ else
+ RRDD_LOG(LOG_NOTICE, "replaying from journal: %s", file);
+
+ while(!feof(fh))
+ {
+ size_t entry_len;
+
+ ++line;
+ if (fgets(entry, sizeof(entry), fh) == NULL)
+ break;
+ entry_len = strlen(entry);
+
+ /* check \n termination in case journal writing crashed mid-line */
+ if (entry_len == 0)
+ continue;
+ else if (entry[entry_len - 1] != '\n')
+ {
+ RRDD_LOG(LOG_NOTICE, "Malformed journal entry at line %"PRIu64, line);
+ ++fail_cnt;
+ continue;
+ }
+
+ entry[entry_len - 1] = '\0';
+
+ if (handle_request(-1, PRIV_HIGH, entry, entry_len) == 0)
+ ++entry_cnt;
+ else
+ ++fail_cnt;
+ }
+
+ fclose(fh);
+
+ if (entry_cnt > 0)
+ {
+ RRDD_LOG(LOG_INFO, "Replayed %d entries (%d failures)",
+ entry_cnt, fail_cnt);
+ return 1;
+ }
+ else
+ return 0;
+
+} /* }}} static int journal_replay */
+
+static void *connection_thread_main (void *args) /* {{{ */
{
pthread_t self;
+ listen_socket_t *sock;
int i;
int fd;
-
- fd = *((int *) args);
- pthread_mutex_lock (&connetion_threads_lock);
+ sock = (listen_socket_t *) args;
+ fd = sock->fd;
+
+ pthread_mutex_lock (&connection_threads_lock);
{
pthread_t *temp;
- temp = (pthread_t *) realloc (connetion_threads,
- sizeof (pthread_t) * (connetion_threads_num + 1));
+ temp = (pthread_t *) realloc (connection_threads,
+ sizeof (pthread_t) * (connection_threads_num + 1));
if (temp == NULL)
{
RRDD_LOG (LOG_ERR, "connection_thread_main: realloc failed.");
}
else
{
- connetion_threads = temp;
- connetion_threads[connetion_threads_num] = pthread_self ();
- connetion_threads_num++;
+ connection_threads = temp;
+ connection_threads[connection_threads_num] = pthread_self ();
+ connection_threads_num++;
}
}
- pthread_mutex_unlock (&connetion_threads_lock);
+ pthread_mutex_unlock (&connection_threads_lock);
while (do_shutdown == 0)
{
+ char buffer[CMD_MAX];
+
struct pollfd pollfd;
int status;
pollfd.revents = 0;
status = poll (&pollfd, 1, /* timeout = */ 500);
- if (status == 0) /* timeout */
+ if (do_shutdown)
+ break;
+ else if (status == 0) /* timeout */
continue;
else if (status < 0) /* error */
{
break;
}
- status = handle_request (fd);
- if (status != 0)
+ status = (int) sread (fd, buffer, sizeof (buffer));
+ if (status <= 0)
{
close (fd);
+
+ if (status < 0)
+ RRDD_LOG(LOG_ERR, "connection_thread_main: sread failed.");
+
break;
}
+
+ status = handle_request (fd, sock->privilege, buffer, status);
+ if (status != 0)
+ break;
}
+ close(fd);
+ free(args);
+
self = pthread_self ();
/* Remove this thread from the connection threads list */
- pthread_mutex_lock (&connetion_threads_lock);
+ pthread_mutex_lock (&connection_threads_lock);
/* Find out own index in the array */
- for (i = 0; i < connetion_threads_num; i++)
- if (pthread_equal (connetion_threads[i], self) != 0)
+ for (i = 0; i < connection_threads_num; i++)
+ if (pthread_equal (connection_threads[i], self) != 0)
break;
- assert (i < connetion_threads_num);
+ assert (i < connection_threads_num);
/* Move the trailing threads forward. */
- if (i < (connetion_threads_num - 1))
+ if (i < (connection_threads_num - 1))
{
- memmove (connetion_threads + i,
- connetion_threads + i + 1,
- sizeof (pthread_t) * (connetion_threads_num - i - 1));
+ memmove (connection_threads + i,
+ connection_threads + i + 1,
+ sizeof (pthread_t) * (connection_threads_num - i - 1));
}
- connetion_threads_num--;
- pthread_mutex_unlock (&connetion_threads_lock);
+ connection_threads_num--;
+ pthread_mutex_unlock (&connection_threads_lock);
- free (args);
return (NULL);
} /* }}} void *connection_thread_main */
-static int open_listen_socket_unix (const char *path) /* {{{ */
+static int open_listen_socket_unix (const listen_socket_t *sock) /* {{{ */
{
int fd;
struct sockaddr_un sa;
listen_socket_t *temp;
int status;
+ const char *path;
+
+ path = sock->addr;
+ if (strncmp(path, "unix:", strlen("unix:")) == 0)
+ path += strlen("unix:");
temp = (listen_socket_t *) realloc (listen_fds,
sizeof (listen_fds[0]) * (listen_fds_num + 1));
return (-1);
}
listen_fds = temp;
- memset (listen_fds + listen_fds_num, 0, sizeof (listen_fds[0]));
+ memcpy (listen_fds + listen_fds_num, sock, sizeof (listen_fds[0]));
fd = socket (PF_UNIX, SOCK_STREAM, /* protocol = */ 0);
if (fd < 0)
unlink (path);
return (-1);
}
-
+
listen_fds[listen_fds_num].fd = fd;
- snprintf (listen_fds[listen_fds_num].path,
- sizeof (listen_fds[listen_fds_num].path) - 1,
- "unix:%s", path);
+ listen_fds[listen_fds_num].family = PF_UNIX;
+ strncpy(listen_fds[listen_fds_num].addr, path,
+ sizeof (listen_fds[listen_fds_num].addr) - 1);
listen_fds_num++;
return (0);
} /* }}} int open_listen_socket_unix */
-static int open_listen_socket (const char *addr) /* {{{ */
+static int open_listen_socket_network(const listen_socket_t *sock) /* {{{ */
{
struct addrinfo ai_hints;
struct addrinfo *ai_res;
struct addrinfo *ai_ptr;
+ char addr_copy[NI_MAXHOST];
+ char *addr;
+ char *port;
int status;
- assert (addr != NULL);
-
- if (strncmp ("unix:", addr, strlen ("unix:")) == 0)
- return (open_listen_socket_unix (addr + strlen ("unix:")));
- else if (addr[0] == '/')
- return (open_listen_socket_unix (addr));
+ strncpy (addr_copy, sock->addr, sizeof (addr_copy));
+ addr_copy[sizeof (addr_copy) - 1] = 0;
+ addr = addr_copy;
memset (&ai_hints, 0, sizeof (ai_hints));
ai_hints.ai_flags = 0;
ai_hints.ai_family = AF_UNSPEC;
ai_hints.ai_socktype = SOCK_STREAM;
+ port = NULL;
+ if (*addr == '[') /* IPv6+port format */
+ {
+ /* `addr' is something like "[2001:780:104:2:211:24ff:feab:26f8]:12345" */
+ addr++;
+
+ port = strchr (addr, ']');
+ if (port == NULL)
+ {
+ RRDD_LOG (LOG_ERR, "open_listen_socket_network: Malformed address: %s",
+ sock->addr);
+ return (-1);
+ }
+ *port = 0;
+ port++;
+
+ if (*port == ':')
+ port++;
+ else if (*port == 0)
+ port = NULL;
+ else
+ {
+ RRDD_LOG (LOG_ERR, "open_listen_socket_network: Garbage after address: %s",
+ port);
+ return (-1);
+ }
+ } /* if (*addr = ']') */
+ else if (strchr (addr, '.') != NULL) /* Hostname or IPv4 */
+ {
+ port = rindex(addr, ':');
+ if (port != NULL)
+ {
+ *port = 0;
+ port++;
+ }
+ }
ai_res = NULL;
- status = getaddrinfo (addr, RRDCACHED_DEFAULT_PORT, &ai_hints, &ai_res);
+ status = getaddrinfo (addr,
+ port == NULL ? RRDCACHED_DEFAULT_PORT : port,
+ &ai_hints, &ai_res);
if (status != 0)
{
- RRDD_LOG (LOG_ERR, "open_listen_socket: getaddrinfo(%s) failed: "
+ RRDD_LOG (LOG_ERR, "open_listen_socket_network: getaddrinfo(%s) failed: "
"%s", addr, gai_strerror (status));
return (-1);
}
{
int fd;
listen_socket_t *temp;
+ int one = 1;
temp = (listen_socket_t *) realloc (listen_fds,
sizeof (listen_fds[0]) * (listen_fds_num + 1));
if (temp == NULL)
{
- RRDD_LOG (LOG_ERR, "open_listen_socket: realloc failed.");
+ RRDD_LOG (LOG_ERR, "open_listen_socket_network: realloc failed.");
continue;
}
listen_fds = temp;
- memset (listen_fds + listen_fds_num, 0, sizeof (listen_fds[0]));
+ memcpy (listen_fds + listen_fds_num, sock, sizeof (listen_fds[0]));
fd = socket (ai_ptr->ai_family, ai_ptr->ai_socktype, ai_ptr->ai_protocol);
if (fd < 0)
{
- RRDD_LOG (LOG_ERR, "open_listen_socket: socket(2) failed.");
+ RRDD_LOG (LOG_ERR, "open_listen_socket_network: socket(2) failed.");
continue;
}
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
+
status = bind (fd, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
if (status != 0)
{
- RRDD_LOG (LOG_ERR, "open_listen_socket: bind(2) failed.");
+ RRDD_LOG (LOG_ERR, "open_listen_socket_network: bind(2) failed.");
close (fd);
continue;
}
status = listen (fd, /* backlog = */ 10);
if (status != 0)
{
- RRDD_LOG (LOG_ERR, "open_listen_socket: listen(2) failed.");
+ RRDD_LOG (LOG_ERR, "open_listen_socket_network: listen(2) failed.");
close (fd);
return (-1);
}
listen_fds[listen_fds_num].fd = fd;
- strncpy (listen_fds[listen_fds_num].path, addr,
- sizeof (listen_fds[listen_fds_num].path) - 1);
+ listen_fds[listen_fds_num].family = ai_ptr->ai_family;
listen_fds_num++;
} /* for (ai_ptr) */
return (0);
+} /* }}} static int open_listen_socket_network */
+
+static int open_listen_socket (const listen_socket_t *sock) /* {{{ */
+{
+ assert(sock != NULL);
+ assert(sock->addr != NULL);
+
+ if (strncmp ("unix:", sock->addr, strlen ("unix:")) == 0
+ || sock->addr[0] == '/')
+ return (open_listen_socket_unix(sock));
+ else
+ return (open_listen_socket_network(sock));
} /* }}} int open_listen_socket */
static int close_listen_sockets (void) /* {{{ */
for (i = 0; i < listen_fds_num; i++)
{
close (listen_fds[i].fd);
- if (strncmp ("unix:", listen_fds[i].path, strlen ("unix:")) == 0)
- unlink (listen_fds[i].path + strlen ("unix:"));
+
+ if (listen_fds[i].family == PF_UNIX)
+ unlink(listen_fds[i].addr);
}
free (listen_fds);
open_listen_socket (config_listen_address_list[i]);
if (config_listen_address_list_len < 1)
- open_listen_socket (RRDCACHED_DEFAULT_ADDRESS);
+ {
+ listen_socket_t sock;
+ memset(&sock, 0, sizeof(sock));
+ strncpy(sock.addr, RRDCACHED_DEFAULT_ADDRESS, sizeof(sock.addr));
+ open_listen_socket (&sock);
+ }
if (listen_fds_num < 1)
{
}
memset (pollfds, 0, sizeof (*pollfds) * pollfds_num);
+ RRDD_LOG(LOG_INFO, "listening for connections");
+
while (do_shutdown == 0)
{
assert (pollfds_num == ((int) listen_fds_num));
pollfds[i].revents = 0;
}
- status = poll (pollfds, pollfds_num, /* timeout = */ -1);
- if (status < 1)
+ status = poll (pollfds, pollfds_num, /* timeout = */ 1000);
+ if (do_shutdown)
+ break;
+ else if (status == 0) /* timeout */
+ continue;
+ else if (status < 0) /* error */
{
status = errno;
if (status != EINTR)
for (i = 0; i < pollfds_num; i++)
{
- int *client_sd;
+ listen_socket_t *client_sock;
struct sockaddr_storage client_sa;
socklen_t client_sa_size;
pthread_t tid;
continue;
}
- client_sd = (int *) malloc (sizeof (int));
- if (client_sd == NULL)
+ client_sock = (listen_socket_t *) malloc (sizeof (listen_socket_t));
+ if (client_sock == NULL)
{
RRDD_LOG (LOG_ERR, "listen_thread_main: malloc failed.");
continue;
}
+ memcpy(client_sock, &listen_fds[i], sizeof(listen_fds[0]));
client_sa_size = sizeof (client_sa);
- *client_sd = accept (pollfds[i].fd,
+ client_sock->fd = accept (pollfds[i].fd,
(struct sockaddr *) &client_sa, &client_sa_size);
- if (*client_sd < 0)
+ if (client_sock->fd < 0)
{
RRDD_LOG (LOG_ERR, "listen_thread_main: accept(2) failed.");
+ free(client_sock);
continue;
}
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
status = pthread_create (&tid, &attr, connection_thread_main,
- /* args = */ (void *) client_sd);
+ client_sock);
if (status != 0)
{
RRDD_LOG (LOG_ERR, "listen_thread_main: pthread_create failed.");
- close (*client_sd);
- free (client_sd);
+ close (client_sock->fd);
+ free (client_sock);
continue;
}
} /* for (pollfds_num) */
} /* while (do_shutdown == 0) */
+ RRDD_LOG(LOG_INFO, "starting shutdown");
+
close_listen_sockets ();
- pthread_mutex_lock (&connetion_threads_lock);
- while (connetion_threads_num > 0)
+ pthread_mutex_lock (&connection_threads_lock);
+ while (connection_threads_num > 0)
{
pthread_t wait_for;
- wait_for = connetion_threads[0];
+ wait_for = connection_threads[0];
- pthread_mutex_unlock (&connetion_threads_lock);
+ pthread_mutex_unlock (&connection_threads_lock);
pthread_join (wait_for, /* retval = */ NULL);
- pthread_mutex_lock (&connetion_threads_lock);
+ pthread_mutex_lock (&connection_threads_lock);
}
- pthread_mutex_unlock (&connetion_threads_lock);
+ pthread_mutex_unlock (&connection_threads_lock);
return (NULL);
} /* }}} void *listen_thread_main */
static int daemonize (void) /* {{{ */
{
- pid_t child;
int status;
+ int fd;
char *base_dir;
- /* These structures are static, because `sigaction' behaves weird if the are
- * overwritten.. */
- static struct sigaction sa_int;
- static struct sigaction sa_term;
- static struct sigaction sa_pipe;
+ fd = open_pidfile();
+ if (fd < 0) return fd;
- child = fork ();
- if (child < 0)
+ if (!stay_foreground)
{
- fprintf (stderr, "daemonize: fork(2) failed.\n");
- return (-1);
- }
- else if (child > 0)
- {
- return (1);
- }
+ pid_t child;
+
+ child = fork ();
+ if (child < 0)
+ {
+ fprintf (stderr, "daemonize: fork(2) failed.\n");
+ return (-1);
+ }
+ else if (child > 0)
+ {
+ return (1);
+ }
+
+ /* Become session leader */
+ setsid ();
+
+ /* Open the first three file descriptors to /dev/null */
+ close (2);
+ close (1);
+ close (0);
+
+ open ("/dev/null", O_RDWR);
+ dup (0);
+ dup (0);
+ } /* if (!stay_foreground) */
/* Change into the /tmp directory. */
base_dir = (config_base_dir != NULL)
return (-1);
}
- /* Become session leader */
- setsid ();
-
- /* Open the first three file descriptors to /dev/null */
- close (2);
- close (1);
- close (0);
-
- open ("/dev/null", O_RDWR);
- dup (0);
- dup (0);
-
- /* Install signal handlers */
- memset (&sa_int, 0, sizeof (sa_int));
- sa_int.sa_handler = sig_int_handler;
- sigaction (SIGINT, &sa_int, NULL);
-
- memset (&sa_term, 0, sizeof (sa_term));
- sa_term.sa_handler = sig_term_handler;
- sigaction (SIGTERM, &sa_term, NULL);
-
- memset (&sa_pipe, 0, sizeof (sa_pipe));
- sa_pipe.sa_handler = SIG_IGN;
- sigaction (SIGPIPE, &sa_pipe, NULL);
+ install_signal_handlers();
openlog ("rrdcached", LOG_PID, LOG_DAEMON);
+ RRDD_LOG(LOG_INFO, "starting up");
cache_tree = g_tree_new ((GCompareFunc) strcmp);
if (cache_tree == NULL)
return (-1);
}
- memset (&queue_thread, 0, sizeof (queue_thread));
- status = pthread_create (&queue_thread, /* attr = */ NULL,
- queue_thread_main, /* args = */ NULL);
- if (status != 0)
- {
- RRDD_LOG (LOG_ERR, "daemonize: pthread_create failed.");
- return (-1);
- }
-
- write_pidfile ();
-
- return (0);
+ status = write_pidfile (fd);
+ return status;
} /* }}} int daemonize */
static int cleanup (void) /* {{{ */
remove_pidfile ();
+ RRDD_LOG(LOG_INFO, "goodbye");
closelog ();
return (0);
int option;
int status = 0;
- while ((option = getopt(argc, argv, "l:f:w:b:p:h?")) != -1)
+ while ((option = getopt(argc, argv, "gl:L:f:w:b:Bz:p:j:h?F")) != -1)
{
switch (option)
{
+ case 'g':
+ stay_foreground=1;
+ break;
+
+ case 'L':
case 'l':
{
- char **temp;
+ listen_socket_t **temp;
+ listen_socket_t *new;
- temp = (char **) realloc (config_listen_address_list,
- sizeof (char *) * (config_listen_address_list_len + 1));
+ new = malloc(sizeof(listen_socket_t));
+ if (new == NULL)
+ {
+ fprintf(stderr, "read_options: malloc failed.\n");
+ return(2);
+ }
+ memset(new, 0, sizeof(listen_socket_t));
+
+ temp = (listen_socket_t **) realloc (config_listen_address_list,
+ sizeof (listen_socket_t *) * (config_listen_address_list_len + 1));
if (temp == NULL)
{
fprintf (stderr, "read_options: realloc failed.\n");
}
config_listen_address_list = temp;
- temp[config_listen_address_list_len] = strdup (optarg);
- if (temp[config_listen_address_list_len] == NULL)
- {
- fprintf (stderr, "read_options: strdup failed.\n");
- return (2);
- }
+ strncpy(new->addr, optarg, sizeof(new->addr)-1);
+ new->privilege = (option == 'l') ? PRIV_HIGH : PRIV_LOW;
+
+ temp[config_listen_address_list_len] = new;
config_listen_address_list_len++;
}
break;
}
break;
+ case 'z':
+ {
+ int temp;
+
+ temp = atoi(optarg);
+ if (temp > 0)
+ config_write_jitter = temp;
+ else
+ {
+ fprintf (stderr, "Invalid write jitter: -z %s\n", optarg);
+ status = 2;
+ }
+
+ break;
+ }
+
+ case 'B':
+ config_write_base_only = 1;
+ break;
+
case 'b':
{
size_t len;
fprintf (stderr, "Invalid base directory: %s\n", optarg);
return (4);
}
+
+ _config_base_dir_len = len;
}
break;
}
break;
+ case 'F':
+ config_flush_at_shutdown = 1;
+ break;
+
+ case 'j':
+ {
+ struct stat statbuf;
+ const char *dir = optarg;
+
+ status = stat(dir, &statbuf);
+ if (status != 0)
+ {
+ fprintf(stderr, "Cannot stat '%s' : %s\n", dir, rrd_strerror(errno));
+ return 6;
+ }
+
+ if (!S_ISDIR(statbuf.st_mode)
+ || access(dir, R_OK|W_OK|X_OK) != 0)
+ {
+ fprintf(stderr, "Must specify a writable directory with -j! (%s)\n",
+ 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;
+
case 'h':
case '?':
- printf ("RRDd %s Copyright (C) 2008 Florian octo Forster\n"
+ printf ("RRDCacheD %s Copyright (C) 2008 Florian octo Forster\n"
"\n"
"Usage: rrdcached [options]\n"
"\n"
"Valid options are:\n"
" -l <address> Socket address to listen to.\n"
+ " -L <address> Socket address to listen to ('FLUSH' only).\n"
" -w <seconds> Interval in which to write data.\n"
+ " -z <delay> Delay writes up to <delay> seconds to spread load\n"
" -f <seconds> Interval in which to flush dead data.\n"
" -p <file> Location of the PID-file.\n"
" -b <dir> Base directory to change to.\n"
+ " -B Restrict file access to paths within -b <dir>\n"
+ " -g Do not fork and run in the foreground.\n"
+ " -j <dir> Directory in which to create the journal files.\n"
+ " -F Always flush all updates at shutdown\n"
"\n"
"For more information and a detailed description of all options "
"please refer\n"
} /* switch (option) */
} /* while (getopt) */
+ /* advise the user when values are not sane */
+ if (config_flush_interval < 2 * config_write_interval)
+ fprintf(stderr, "WARNING: flush interval (-f) should be at least"
+ " 2x write interval (-w) !\n");
+ if (config_write_jitter > config_write_interval)
+ fprintf(stderr, "WARNING: write delay (-z) should NOT be larger than"
+ " write interval (-w) !\n");
+
+ if (config_write_base_only && config_base_dir == NULL)
+ fprintf(stderr, "WARNING: -B does not make sense without -b!\n"
+ " Consult the rrdcached documentation\n");
+
+ if (journal_cur == NULL)
+ config_flush_at_shutdown = 1;
+
return (status);
} /* }}} int read_options */
return (1);
}
- listen_thread_main (NULL);
+ if (journal_cur != NULL)
+ {
+ int had_journal = 0;
+
+ pthread_mutex_lock(&journal_lock);
+
+ RRDD_LOG(LOG_INFO, "checking for journal files");
+ had_journal += journal_replay(journal_old);
+ had_journal += journal_replay(journal_cur);
+
+ if (had_journal)
+ flush_old_values(-1);
+
+ pthread_mutex_unlock(&journal_lock);
+ journal_rotate();
+
+ RRDD_LOG(LOG_INFO, "journal processing complete");
+ }
+
+ /* start the queue thread */
+ memset (&queue_thread, 0, sizeof (queue_thread));
+ status = pthread_create (&queue_thread,
+ NULL, /* attr */
+ queue_thread_main,
+ NULL); /* args */
+ if (status != 0)
+ {
+ RRDD_LOG (LOG_ERR, "FATAL: cannot create queue thread");
+ cleanup();
+ return (1);
+ }
+
+ listen_thread_main (NULL);
cleanup ();
return (0);
projects / rrdtool.git / blobdiff