#include <stdio.h>
#include <unistd.h>
#include <string.h>
+#include <strings.h>
+#include <stdint.h>
+#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
cache_item_t *next;
};
+struct callback_flush_data_s
+{
+ time_t now;
+ char **keys;
+ size_t keys_num;
+};
+typedef struct callback_flush_data_s callback_flush_data_t;
+
enum queue_side_e
{
HEAD,
static int config_write_interval = 300;
static int config_flush_interval = 3600;
+static char *config_pid_file = NULL;
+static char *config_base_dir = NULL;
static char **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_written = 0;
+static uint64_t stats_data_sets_written = 0;
+static pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER;
+
/*
* Functions
*/
do_shutdown++;
} /* }}} void sig_term_handler */
+static int write_pidfile (void) /* {{{ */
+{
+ pid_t pid;
+ char *file;
+ FILE *fh;
+
+ pid = getpid ();
+
+ file = (config_pid_file != NULL)
+ ? config_pid_file
+ : LOCALSTATEDIR "/run/rrdcached.pid";
+
+ fh = fopen (file, "w");
+ if (fh == NULL)
+ {
+ RRDD_LOG (LOG_ERR, "write_pidfile: Opening `%s' failed.", file);
+ return (-1);
+ }
+
+ fprintf (fh, "%i\n", (int) pid);
+ fclose (fh);
+
+ return (0);
+} /* }}} int write_pidfile */
+
+static int remove_pidfile (void) /* {{{ */
+{
+ char *file;
+ int status;
+
+ file = (config_pid_file != NULL)
+ ? config_pid_file
+ : LOCALSTATEDIR "/run/rrdcached.pid";
+
+ status = unlink (file);
+ if (status == 0)
+ return (0);
+ return (errno);
+} /* }}} int remove_pidfile */
+
+static ssize_t sread (int fd, void *buffer_void, size_t buffer_size) /* {{{ */
+{
+ char *buffer;
+ size_t buffer_used;
+ size_t buffer_free;
+ ssize_t status;
+
+ buffer = (char *) buffer_void;
+ buffer_used = 0;
+ buffer_free = buffer_size;
+
+ while (buffer_free > 0)
+ {
+ status = read (fd, buffer + buffer_used, buffer_free);
+ if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
+ continue;
+
+ if (status < 0)
+ return (-1);
+
+ if (status == 0)
+ return (0);
+
+ assert ((0 > status) || (buffer_free >= (size_t) status));
+
+ buffer_free = buffer_free - status;
+ buffer_used = buffer_used + status;
+
+ if (buffer[buffer_used - 1] == '\n')
+ break;
+ }
+
+ assert (buffer_used > 0);
+
+ if (buffer[buffer_used - 1] != '\n')
+ {
+ errno = ENOBUFS;
+ return (-1);
+ }
+
+ buffer[buffer_used - 1] = 0;
+
+ /* Fix network line endings. */
+ if ((buffer_used > 1) && (buffer[buffer_used - 2] == '\r'))
+ {
+ buffer_used--;
+ buffer[buffer_used - 1] = 0;
+ }
+
+ return (buffer_used);
+} /* }}} ssize_t sread */
+
+static ssize_t swrite (int fd, const void *buf, size_t count) /* {{{ */
+{
+ const char *ptr;
+ size_t nleft;
+ ssize_t status;
+
+ ptr = (const char *) buf;
+ nleft = count;
+
+ while (nleft > 0)
+ {
+ status = write (fd, (const void *) ptr, nleft);
+
+ if ((status < 0) && ((errno == EAGAIN) || (errno == EINTR)))
+ continue;
+
+ if (status < 0)
+ return (status);
+
+ nleft = nleft - status;
+ ptr = ptr + status;
+ }
+
+ return (0);
+} /* }}} ssize_t swrite */
+
/*
* 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)
{
- RRDD_LOG (LOG_DEBUG, "enqueue_cache_item: Adding %s to the update queue.",
- ci->file);
+ int did_insert = 0;
if (ci == NULL)
return (-1);
if (cache_queue_tail == NULL)
cache_queue_tail = cache_queue_head;
+
+ did_insert = 1;
}
else if (cache_queue_head == ci)
{
else
cache_queue_tail->next = ci;
cache_queue_tail = ci;
+
+ did_insert = 1;
}
ci->flags |= CI_FLAGS_IN_QUEUE;
+ if (did_insert)
+ {
+ pthread_mutex_lock (&stats_lock);
+ stats_queue_length++;
+ pthread_mutex_unlock (&stats_lock);
+ }
+
return (0);
} /* }}} int enqueue_cache_item */
* Called via `g_tree_foreach' in `queue_thread_main'. `cache_lock' is held
* while this is in progress.
*/
-static gboolean tree_callback_flush (gpointer key /* {{{ */
- __attribute__((unused)), gpointer value, gpointer data)
+static gboolean tree_callback_flush (gpointer key, gpointer value, /* {{{ */
+ gpointer data)
{
cache_item_t *ci;
- time_t now;
-
- key = NULL; /* make compiler happy */
+ callback_flush_data_t *cfd;
ci = (cache_item_t *) value;
- now = *((time_t *) data);
+ cfd = (callback_flush_data_t *) data;
- if (((now - ci->last_flush_time) >= config_write_interval)
+ if (((cfd->now - ci->last_flush_time) >= config_write_interval)
&& ((ci->flags & CI_FLAGS_IN_QUEUE) == 0)
&& (ci->values_num > 0))
+ {
enqueue_cache_item (ci, TAIL);
+ }
+ else if (((cfd->now - ci->last_flush_time) >= config_flush_interval)
+ && ((ci->flags & CI_FLAGS_IN_QUEUE) == 0)
+ && (ci->values_num <= 0))
+ {
+ char **temp;
- return (TRUE);
+ temp = (char **) realloc (cfd->keys,
+ sizeof (char *) * (cfd->keys_num + 1));
+ if (temp == NULL)
+ {
+ RRDD_LOG (LOG_ERR, "tree_callback_flush: realloc failed.");
+ return (FALSE);
+ }
+ cfd->keys = temp;
+ /* Make really sure this points to the _same_ place */
+ assert ((char *) key == ci->file);
+ cfd->keys[cfd->keys_num] = (char *) key;
+ cfd->keys_num++;
+ }
+
+ return (FALSE);
} /* }}} gboolean tree_callback_flush */
static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */
|| ((now.tv_sec == next_flush.tv_sec)
&& ((1000 * now.tv_usec) > next_flush.tv_nsec)))
{
- time_t time_now;
+ callback_flush_data_t cfd;
+ size_t k;
+ memset (&cfd, 0, sizeof (cfd));
/* Pass the current time as user data so that we don't need to call
* `time' for each node. */
- time_now = time (NULL);
+ cfd.now = time (NULL);
+ cfd.keys = NULL;
+ cfd.keys_num = 0;
- g_tree_foreach (cache_tree, tree_callback_flush, (gpointer) &time_now);
+ /* `tree_callback_flush' will return the keys of all values that haven't
+ * been touched in the last `config_flush_interval' seconds in `cfd'.
+ * The char*'s in this array point to the same memory as ci->file, so we
+ * don't need to free them separately. */
+ g_tree_foreach (cache_tree, tree_callback_flush, (gpointer) &cfd);
+
+ for (k = 0; k < cfd.keys_num; k++)
+ {
+ /* This must not fail. */
+ ci = (cache_item_t *) g_tree_lookup (cache_tree, cfd.keys[k]);
+ assert (ci != NULL);
+
+ /* If we end up here with values available, something's seriously
+ * messed up. */
+ assert (ci->values_num == 0);
+
+ /* Remove the node from the tree */
+ g_tree_remove (cache_tree, cfd.keys[k]);
+ cfd.keys[k] = NULL;
+
+ /* Now free and clean up `ci'. */
+ free (ci->file);
+ ci->file = NULL;
+ free (ci);
+ ci = NULL;
+ } /* for (k = 0; k < cfd.keys_num; k++) */
+
+ if (cfd.keys != NULL)
+ {
+ free (cfd.keys);
+ cfd.keys = NULL;
+ }
/* Determine the time of the next cache flush. */
while (next_flush.tv_sec < now.tv_sec)
cache_queue_tail = NULL;
ci->next = NULL;
- pthread_mutex_unlock (&cache_lock);
+ pthread_mutex_lock (&stats_lock);
+ assert (stats_queue_length > 0);
+ stats_queue_length--;
+ pthread_mutex_unlock (&stats_lock);
- RRDD_LOG (LOG_DEBUG, "queue_thread_main: rrd_update (%s, %i, %p)",
- file, values_num, (void *) values);
+ pthread_mutex_unlock (&cache_lock);
status = rrd_update_r (file, NULL, values_num, (void *) values);
if (status != 0)
for (i = 0; i < values_num; i++)
free (values[i]);
+ if (status == 0)
+ {
+ pthread_mutex_lock (&stats_lock);
+ stats_updates_written++;
+ stats_data_sets_written += values_num;
+ pthread_mutex_unlock (&stats_lock);
+ }
+
pthread_mutex_lock (&cache_lock);
pthread_cond_broadcast (&flush_cond);
} /* while (do_shutdown == 0) */
pthread_mutex_unlock (&cache_lock);
- RRDD_LOG (LOG_DEBUG, "queue_thread_main: Exiting.");
-
return (NULL);
} /* }}} void *queue_thread_main */
field = *buffer_ret;
field_size = 0;
+ if (buffer_size <= 0)
+ return (-1);
+
/* This is ensured by `handle_request'. */
assert (buffer[buffer_size - 1] == ' ');
pthread_mutex_lock (&cache_lock);
- ci = g_tree_lookup (cache_tree, filename);
+ ci = (cache_item_t *) g_tree_lookup (cache_tree, filename);
if (ci == NULL)
{
pthread_mutex_unlock (&cache_lock);
return (0);
} /* }}} int flush_file */
+static int handle_request_help (int fd, /* {{{ */
+ char *buffer, size_t buffer_size)
+{
+ int status;
+ char **help_text;
+ size_t help_text_len;
+ char *command;
+ size_t i;
+
+ char *help_help[] =
+ {
+ "4 Command overview\n",
+ "FLUSH <filename>\n",
+ "HELP [<command>]\n",
+ "UPDATE <filename> <values> [<values> ...]\n",
+ "STATS\n"
+ };
+ size_t help_help_len = sizeof (help_help) / sizeof (help_help[0]);
+
+ char *help_flush[] =
+ {
+ "4 Help for FLUSH\n",
+ "Usage: FLUSH <filename>\n",
+ "\n",
+ "Adds the given filename to the head of the update queue and returns\n",
+ "after is has been dequeued.\n"
+ };
+ size_t help_flush_len = sizeof (help_flush) / sizeof (help_flush[0]);
+
+ char *help_update[] =
+ {
+ "9 Help for UPDATE\n",
+ "Usage: UPDATE <filename> <values> [<values> ...]\n"
+ "\n",
+ "Adds the given file to the internal cache if it is not yet known and\n",
+ "appends the given value(s) to the entry. See the rrdcached(1) manpage\n",
+ "for details.\n",
+ "\n",
+ "Each <values> has the following form:\n",
+ " <values> = <time>:<value>[:<value>[...]]\n",
+ "See the rrdupdate(1) manpage for details.\n"
+ };
+ size_t help_update_len = sizeof (help_update) / sizeof (help_update[0]);
+
+ char *help_stats[] =
+ {
+ "4 Help for STATS\n",
+ "Usage: STATS\n",
+ "\n",
+ "Returns some performance counters, see the rrdcached(1) manpage for\n",
+ "a description of the values.\n"
+ };
+ size_t help_stats_len = sizeof (help_stats) / sizeof (help_stats[0]);
+
+ status = buffer_get_field (&buffer, &buffer_size, &command);
+ if (status != 0)
+ {
+ help_text = help_help;
+ help_text_len = help_help_len;
+ }
+ else
+ {
+ if (strcasecmp (command, "update") == 0)
+ {
+ help_text = help_update;
+ help_text_len = help_update_len;
+ }
+ else if (strcasecmp (command, "flush") == 0)
+ {
+ help_text = help_flush;
+ help_text_len = help_flush_len;
+ }
+ else if (strcasecmp (command, "stats") == 0)
+ {
+ help_text = help_stats;
+ help_text_len = help_stats_len;
+ }
+ else
+ {
+ help_text = help_help;
+ help_text_len = help_help_len;
+ }
+ }
+
+ for (i = 0; i < help_text_len; i++)
+ {
+ status = swrite (fd, help_text[i], strlen (help_text[i]));
+ if (status < 0)
+ {
+ status = errno;
+ RRDD_LOG (LOG_ERR, "handle_request_help: swrite returned an error.");
+ return (status);
+ }
+ }
+
+ return (0);
+} /* }}} int handle_request_help */
+
+static int handle_request_stats (int fd, /* {{{ */
+ char *buffer __attribute__((unused)),
+ size_t buffer_size __attribute__((unused)))
+{
+ int status;
+ char outbuf[4096];
+
+ uint64_t copy_queue_length;
+ uint64_t copy_updates_written;
+ uint64_t copy_data_sets_written;
+
+ uint64_t tree_nodes_number;
+ uint64_t tree_depth;
+
+ pthread_mutex_lock (&stats_lock);
+ copy_queue_length = stats_queue_length;
+ copy_updates_written = stats_updates_written;
+ copy_data_sets_written = stats_data_sets_written;
+ pthread_mutex_unlock (&stats_lock);
+
+ pthread_mutex_lock (&cache_lock);
+ tree_nodes_number = (uint64_t) g_tree_nnodes (cache_tree);
+ tree_depth = (uint64_t) g_tree_height (cache_tree);
+ pthread_mutex_unlock (&cache_lock);
+
+#define RRDD_STATS_SEND \
+ outbuf[sizeof (outbuf) - 1] = 0; \
+ status = swrite (fd, outbuf, strlen (outbuf)); \
+ if (status < 0) \
+ { \
+ status = errno; \
+ RRDD_LOG (LOG_INFO, "handle_request_stats: swrite returned an error."); \
+ return (status); \
+ }
+
+ strncpy (outbuf, "5 Statistics follow\n", sizeof (outbuf));
+ RRDD_STATS_SEND;
+
+ snprintf (outbuf, sizeof (outbuf),
+ "QueueLength: %"PRIu64"\n", copy_queue_length);
+ RRDD_STATS_SEND;
+
+ snprintf (outbuf, sizeof (outbuf),
+ "UpdatesWritten: %"PRIu64"\n", copy_updates_written);
+ RRDD_STATS_SEND;
+
+ snprintf (outbuf, sizeof (outbuf),
+ "DataSetsWritten: %"PRIu64"\n", copy_data_sets_written);
+ RRDD_STATS_SEND;
+
+ snprintf (outbuf, sizeof (outbuf),
+ "TreeNodesNumber: %"PRIu64"\n", tree_nodes_number);
+ RRDD_STATS_SEND;
+
+ snprintf (outbuf, sizeof (outbuf),
+ "TreeDepth: %"PRIu64"\n", tree_depth);
+ RRDD_STATS_SEND;
+
+ return (0);
+#undef RRDD_STATS_SEND
+} /* }}} int handle_request_stats */
+
static int handle_request_flush (int fd, /* {{{ */
char *buffer, size_t buffer_size)
{
status = buffer_get_field (&buffer, &buffer_size, &file);
if (status != 0)
{
- RRDD_LOG (LOG_INFO, "handle_request_flush: Cannot get file name.");
- return (-1);
+ strncpy (result, "-1 Usage: flush <filename>\n", sizeof (result));
}
-
- 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);
- else if (status < 0)
- strncpy (result, "-1 Internal error.\n", sizeof (result));
else
- snprintf (result, sizeof (result), "-1 Failed with status %i.\n", status);
+ {
+ 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);
+ else if (status < 0)
+ strncpy (result, "-1 Internal error.\n", sizeof (result));
+ else
+ snprintf (result, sizeof (result), "-1 Failed with status %i.\n", status);
+ }
result[sizeof (result) - 1] = 0;
- status = write (fd, result, strlen (result));
+ status = swrite (fd, result, strlen (result));
if (status < 0)
{
status = errno;
- RRDD_LOG (LOG_INFO, "handle_request_flush: write(2) returned an error.");
+ RRDD_LOG (LOG_INFO, "handle_request_flush: swrite returned an error.");
return (status);
}
cache_item_t *ci;
char answer[4096];
+#define RRDD_UPDATE_SEND \
+ answer[sizeof (answer) - 1] = 0; \
+ status = swrite (fd, answer, strlen (answer)); \
+ if (status < 0) \
+ { \
+ status = errno; \
+ RRDD_LOG (LOG_INFO, "handle_request_update: swrite returned an error."); \
+ return (status); \
+ }
+
now = time (NULL);
status = buffer_get_field (&buffer, &buffer_size, &file);
if (status != 0)
{
- RRDD_LOG (LOG_INFO, "handle_request_update: Cannot get file name.");
- return (-1);
+ strncpy (answer, "-1 Usage: UPDATE <filename> <values> [<values> ...]\n",
+ sizeof (answer));
+ RRDD_UPDATE_SEND;
+ return (0);
}
pthread_mutex_lock (&cache_lock);
ci = g_tree_lookup (cache_tree, file);
if (ci == NULL) /* {{{ */
{
+ struct stat statbuf;
+
+ 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);
+
+ status = errno;
+ if (status == ENOENT)
+ snprintf (answer, sizeof (answer), "-1 No such file: %s", file);
+ else
+ snprintf (answer, sizeof (answer), "-1 stat failed with error %i.\n",
+ status);
+ RRDD_UPDATE_SEND;
+ return (0);
+ }
+ if (!S_ISREG (statbuf.st_mode))
+ {
+ pthread_mutex_unlock (&cache_lock);
+
+ snprintf (answer, sizeof (answer), "-1 Not a regular file: %s", file);
+ 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.");
- return (-1);
+
+ strncpy (answer, "-1 malloc failed.\n", sizeof (answer));
+ RRDD_UPDATE_SEND;
+ return (0);
}
memset (ci, 0, sizeof (cache_item_t));
if (ci->file == NULL)
{
pthread_mutex_unlock (&cache_lock);
- RRDD_LOG (LOG_ERR, "handle_request_update: malloc failed.");
free (ci);
- return (-1);
+ RRDD_LOG (LOG_ERR, "handle_request_update: strdup failed.");
+
+ strncpy (answer, "-1 strdup failed.\n", sizeof (answer));
+ RRDD_UPDATE_SEND;
+ return (0);
}
ci->values = NULL;
ci->flags = CI_FLAGS_IN_TREE;
g_tree_insert (cache_tree, (void *) ci->file, (void *) ci);
-
- RRDD_LOG (LOG_DEBUG, "handle_request_update: Created new tree node %s.",
- ci->file);
} /* }}} */
assert (ci != NULL);
pthread_mutex_unlock (&cache_lock);
- snprintf (answer, sizeof (answer), "0 Enqueued %i value(s)\n", values_num);
- answer[sizeof (answer) - 1] = 0;
-
- status = write (fd, answer, strlen (answer));
- if (status < 0)
+ if (values_num < 1)
{
- status = errno;
- RRDD_LOG (LOG_INFO, "handle_request_update: write(2) returned an error.");
- return (status);
+ strncpy (answer, "-1 No values updated.\n", sizeof (answer));
}
-
+ else
+ {
+ snprintf (answer, sizeof (answer), "0 Enqueued %i value%s\n", values_num,
+ (values_num == 1) ? "" : "s");
+ }
+ RRDD_UPDATE_SEND;
return (0);
+#undef RRDD_UPDATE_SEND
} /* }}} int handle_request_update */
static int handle_request (int fd) /* {{{ */
char *command;
int status;
- status = read (fd, buffer, sizeof (buffer));
- if (status < 1)
+ status = (int) sread (fd, buffer, sizeof (buffer));
+ if (status == 0)
{
- RRDD_LOG (LOG_ERR, "handle_request: read(2) failed.");
- return (-1);
+ return (1);
}
- buffer_size = status;
- assert (((size_t) buffer_size) <= sizeof (buffer));
-
- if (buffer[buffer_size - 1] != '\n')
+ else if (status < 0)
{
- RRDD_LOG (LOG_INFO, "handle_request: malformed request.");
+ RRDD_LOG (LOG_ERR, "handle_request: sread failed.");
return (-1);
}
+ 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] = ' ';
return (-1);
}
- if (strcmp (command, "update") == 0)
+ if (strcasecmp (command, "update") == 0)
{
return (handle_request_update (fd, buffer_ptr, buffer_size));
}
- else if (strcmp (command, "flush") == 0)
+ else if (strcasecmp (command, "flush") == 0)
{
return (handle_request_flush (fd, buffer_ptr, buffer_size));
}
+ else if (strcasecmp (command, "stats") == 0)
+ {
+ return (handle_request_stats (fd, buffer_ptr, buffer_size));
+ }
+ else if (strcasecmp (command, "help") == 0)
+ {
+ return (handle_request_help (fd, buffer_ptr, buffer_size));
+ }
else
{
- RRDD_LOG (LOG_INFO, "handle_request: unknown command: %s.", buffer);
- return (-1);
+ char result[4096];
+
+ snprintf (result, sizeof (result), "-1 Unknown command: %s\n", command);
+ result[sizeof (result) - 1] = 0;
+
+ status = swrite (fd, result, strlen (result));
+ if (status < 0)
+ {
+ RRDD_LOG (LOG_ERR, "handle_request: swrite failed.");
+ return (-1);
+ }
}
+
+ return (0);
} /* }}} int handle_request */
static void *connection_thread_main (void *args /* {{{ */
ai_hints.ai_socktype = SOCK_STREAM;
ai_res = NULL;
- status = getaddrinfo (addr, DEFAULT_PORT, &ai_hints, &ai_res);
+ status = getaddrinfo (addr, RRDCACHED_DEFAULT_PORT, &ai_hints, &ai_res);
if (status != 0)
{
RRDD_LOG (LOG_ERR, "open_listen_socket: getaddrinfo(%s) failed: "
int i;
for (i = 0; i < config_listen_address_list_len; i++)
- {
- RRDD_LOG (LOG_DEBUG, "listen_thread_main: config_listen_address_list[%i] "
- "= %s", i, config_listen_address_list[i]);
open_listen_socket (config_listen_address_list[i]);
- }
if (config_listen_address_list_len < 1)
- open_listen_socket (RRDD_SOCK_PATH);
+ open_listen_socket (RRDCACHED_DEFAULT_ADDRESS);
if (listen_fds_num < 1)
{
struct sockaddr_storage client_sa;
socklen_t client_sa_size;
pthread_t tid;
+ pthread_attr_t attr;
if (pollfds[i].revents == 0)
continue;
continue;
}
- status = pthread_create (&tid, /* attr = */ NULL, connection_thread_main,
+ pthread_attr_init (&attr);
+ pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+
+ status = pthread_create (&tid, &attr, connection_thread_main,
/* args = */ (void *) client_sd);
if (status != 0)
{
}
pthread_mutex_unlock (&connetion_threads_lock);
- RRDD_LOG (LOG_DEBUG, "listen_thread_main: Exiting.");
-
return (NULL);
} /* }}} void *listen_thread_main */
{
pid_t child;
int status;
+ 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;
child = fork ();
if (child < 0)
}
/* Change into the /tmp directory. */
- chdir ("/tmp");
+ base_dir = (config_base_dir != NULL)
+ ? config_base_dir
+ : "/tmp";
+ status = chdir (base_dir);
+ if (status != 0)
+ {
+ fprintf (stderr, "daemonize: chdir (%s) failed.\n", base_dir);
+ return (-1);
+ }
/* Become session leader */
setsid ();
dup (0);
dup (0);
- {
- struct sigaction sa;
-
- memset (&sa, 0, sizeof (sa));
- sa.sa_handler = sig_int_handler;
- sigaction (SIGINT, &sa, NULL);
+ /* Install signal handlers */
+ memset (&sa_int, 0, sizeof (sa_int));
+ sa_int.sa_handler = sig_int_handler;
+ sigaction (SIGINT, &sa_int, NULL);
- memset (&sa, 0, sizeof (sa));
- sa.sa_handler = sig_term_handler;
- sigaction (SIGINT, &sa, NULL);
+ memset (&sa_term, 0, sizeof (sa_term));
+ sa_term.sa_handler = sig_term_handler;
+ sigaction (SIGTERM, &sa_term, NULL);
- memset (&sa, 0, sizeof (sa));
- sa.sa_handler = SIG_IGN;
- sigaction (SIGPIPE, &sa, NULL);
- }
+ memset (&sa_pipe, 0, sizeof (sa_pipe));
+ sa_pipe.sa_handler = SIG_IGN;
+ sigaction (SIGPIPE, &sa_pipe, NULL);
openlog ("rrdcached", LOG_PID, LOG_DAEMON);
return (-1);
}
+ write_pidfile ();
+
return (0);
} /* }}} int daemonize */
static int cleanup (void) /* {{{ */
{
- RRDD_LOG (LOG_DEBUG, "cleanup ()");
-
do_shutdown++;
- RRDD_LOG (LOG_DEBUG, "cleanup: Joining queue_thread..");
pthread_cond_signal (&cache_cond);
pthread_join (queue_thread, /* return = */ NULL);
- RRDD_LOG (LOG_DEBUG, "cleanup: done");
+
+ remove_pidfile ();
closelog ();
int option;
int status = 0;
- while ((option = getopt(argc, argv, "l:f:w:h?")) != -1)
+ while ((option = getopt(argc, argv, "l:f:w:b:p:h?")) != -1)
{
switch (option)
{
}
break;
+ case 'b':
+ {
+ size_t len;
+
+ if (config_base_dir != NULL)
+ free (config_base_dir);
+ config_base_dir = strdup (optarg);
+ if (config_base_dir == NULL)
+ {
+ fprintf (stderr, "read_options: strdup failed.\n");
+ return (3);
+ }
+
+ len = strlen (config_base_dir);
+ while ((len > 0) && (config_base_dir[len - 1] == '/'))
+ {
+ config_base_dir[len - 1] = 0;
+ len--;
+ }
+
+ if (len < 1)
+ {
+ fprintf (stderr, "Invalid base directory: %s\n", optarg);
+ return (4);
+ }
+ }
+ break;
+
+ case 'p':
+ {
+ if (config_pid_file != NULL)
+ free (config_pid_file);
+ config_pid_file = strdup (optarg);
+ if (config_pid_file == NULL)
+ {
+ fprintf (stderr, "read_options: strdup failed.\n");
+ return (3);
+ }
+ }
+ break;
+
case 'h':
case '?':
printf ("RRDd %s Copyright (C) 2008 Florian octo Forster\n"
" -l <address> Socket address to listen to.\n"
" -w <seconds> Interval in which to write data.\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"
"\n"
"For more information and a detailed description of all options "
"please refer\n"
projects / rrdtool.git / blobdiff