X-Git-Url: https://git.octo.it/?p=rrdtool.git;a=blobdiff_plain;f=src%2Frrd_daemon.c;h=199ebdb13c1b0071cec8a55bc6db8f438442c703;hp=dcca55d755f53d52513d3e1ba1f9c3a08e5d76bd;hb=9d1a64da41154f4d2f6c803c572f6f7d2684d732;hpb=18ff159c38b7d919bafbdcc46d03c3f83c17476f diff --git a/src/rrd_daemon.c b/src/rrd_daemon.c index dcca55d..199ebdb 100644 --- a/src/rrd_daemon.c +++ b/src/rrd_daemon.c @@ -91,6 +91,7 @@ #include #include +#include #include #include #include @@ -175,7 +176,7 @@ struct cache_item_s { char *file; char **values; - int values_num; + size_t values_num; time_t last_flush_time; time_t last_update_stamp; #define CI_FLAGS_IN_TREE (1<<0) @@ -202,6 +203,12 @@ enum queue_side_e }; 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) @@ -215,7 +222,11 @@ static uid_t daemon_uid; 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; @@ -244,7 +255,7 @@ static size_t _config_base_dir_len = 0; static int config_write_base_only = 0; static listen_socket_t **config_listen_address_list = NULL; -static int config_listen_address_list_len = 0; +static size_t config_listen_address_list_len = 0; static uint64_t stats_queue_length = 0; static uint64_t stats_updates_received = 0; @@ -256,9 +267,13 @@ 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; +#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); @@ -273,7 +288,7 @@ static int handle_request_help (HANDLER_PROTO); 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 */ @@ -379,7 +394,13 @@ static int check_pidfile(void) } 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" @@ -601,7 +622,7 @@ static void wipe_ci_values(cache_item_t *ci, time_t when) ci->last_flush_time = when; if (config_write_jitter > 0) - ci->last_flush_time += (random() % config_write_jitter); + ci->last_flush_time += (rrd_random() % config_write_jitter); } /* remove_from_queue @@ -642,7 +663,7 @@ static void *free_cache_item(cache_item_t *ci) /* {{{ */ remove_from_queue(ci); - for (int i=0; i < ci->values_num; i++) + for (size_t i=0; i < ci->values_num; i++) free(ci->values[i]); free (ci->values); @@ -650,6 +671,7 @@ static void *free_cache_item(cache_item_t *ci) /* {{{ */ /* in case anyone is waiting */ pthread_cond_broadcast(&ci->flushed); + pthread_cond_destroy(&ci->flushed); free (ci); @@ -732,33 +754,20 @@ static gboolean tree_callback_flush (gpointer key, gpointer value, /* {{{ */ 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); } else if (((cfd->now - ci->last_flush_time) >= config_flush_interval) && (ci->values_num <= 0)) { - char **temp; - - temp = (char **) rrd_realloc (cfd->keys, - sizeof (char *) * (cfd->keys_num + 1)); - if (temp == NULL) + assert ((char *) key == ci->file); + if (!rrd_add_ptr((void ***)&cfd->keys, &cfd->keys_num, (void *)key)) { - RRDD_LOG (LOG_ERR, "tree_callback_flush: realloc failed."); + RRDD_LOG (LOG_ERR, "tree_callback_flush: rrd_add_ptrs 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); @@ -815,21 +824,22 @@ static void *flush_thread_main (void *args __attribute__((unused))) /* {{{ */ 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); @@ -848,6 +858,8 @@ static void *flush_thread_main (void *args __attribute__((unused))) /* {{{ */ if (config_flush_at_shutdown) flush_old_values (-1); /* flush everything */ + state = SHUTDOWN; + pthread_mutex_unlock(&cache_lock); return NULL; @@ -857,19 +869,18 @@ static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */ { pthread_mutex_lock (&cache_lock); - while (!do_shutdown + while (state != SHUTDOWN || (cache_queue_head != NULL && config_flush_at_shutdown)) { cache_item_t *ci; char *file; char **values; - int values_num; + size_t values_num; int status; - int i; /* 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)) @@ -906,7 +917,7 @@ static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */ pthread_mutex_unlock (&cache_lock); rrd_clear_error (); - status = rrd_update_r (file, NULL, values_num, (void *) values); + status = rrd_update_r (file, NULL, (int) values_num, (void *) values); if (status != 0) { RRDD_LOG (LOG_NOTICE, "queue_thread_main: " @@ -915,13 +926,14 @@ static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */ } journal_write("wrote", file); - pthread_cond_broadcast(&ci->flushed); - - for (i = 0; i < values_num; i++) - free (values[i]); - free(values); - 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) { @@ -931,6 +943,9 @@ static void *queue_thread_main (void *args __attribute__((unused))) /* {{{ */ pthread_mutex_unlock (&stats_lock); } + rrd_free_ptrs((void ***) &values, &values_num); + free(file); + pthread_mutex_lock (&cache_lock); } pthread_mutex_unlock (&cache_lock); @@ -1227,7 +1242,7 @@ static int handle_request_pending(HANDLER_PROTO) /* {{{ */ return send_response(sock, RESP_ERR, "%s\n", rrd_strerror(ENOENT)); } - for (int i=0; i < ci->values_num; i++) + for (size_t i=0; i < ci->values_num; i++) add_response_info(sock, "%s\n", ci->values[i]); pthread_mutex_unlock(&cache_lock); @@ -1312,6 +1327,7 @@ static int handle_request_update (HANDLER_PROTO) /* {{{ */ 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); @@ -1359,7 +1375,20 @@ static int handle_request_update (HANDLER_PROTO) /* {{{ */ 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); @@ -1369,7 +1398,6 @@ static int handle_request_update (HANDLER_PROTO) /* {{{ */ while (buffer_size > 0) { - char **temp; char *value; time_t stamp; char *eostamp; @@ -1400,22 +1428,11 @@ static int handle_request_update (HANDLER_PROTO) /* {{{ */ else ci->last_update_stamp = stamp; - temp = (char **) rrd_realloc (ci->values, - sizeof (char *) * (ci->values_num + 1)); - if (temp == NULL) + if (!rrd_add_strdup(&ci->values, &ci->values_num, value)) { - RRDD_LOG (LOG_ERR, "handle_request_update: realloc failed."); - continue; - } - ci->values = temp; - - ci->values[ci->values_num] = strdup (value); - if (ci->values[ci->values_num] == NULL) - { - RRDD_LOG (LOG_ERR, "handle_request_update: strdup failed."); + RRDD_LOG (LOG_ERR, "handle_request_update: rrd_add_strdup failed."); continue; } - ci->values_num++; values_num++; } @@ -1445,7 +1462,6 @@ static int handle_request_update (HANDLER_PROTO) /* {{{ */ */ static int handle_request_wrote (HANDLER_PROTO) /* {{{ */ { - int i; cache_item_t *ci; const char *file = buffer; @@ -1459,12 +1475,7 @@ static int handle_request_wrote (HANDLER_PROTO) /* {{{ */ } if (ci->values) - { - for (i=0; i < ci->values_num; i++) - free(ci->values[i]); - - free(ci->values); - } + rrd_free_ptrs((void ***) &ci->values, &ci->values_num); wipe_ci_values(ci, now); remove_from_queue(ci); @@ -1745,74 +1756,136 @@ static int handle_request (DISPATCH_PROTO) /* {{{ */ 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); + + 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); - if (old_fh != NULL) - fclose(old_fh); + 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 { @@ -1820,7 +1893,9 @@ static void journal_done(void) /* {{{ */ "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 */ @@ -1833,6 +1908,11 @@ static int journal_write(char *cmd, char *args) /* {{{ */ 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) @@ -1864,9 +1944,6 @@ static int journal_replay (const char *file) /* {{{ */ memset(&statbuf, 0, sizeof(statbuf)); if (stat(file, &statbuf) != 0) { - if (errno == ENOENT) - return 0; - reason = "stat error"; status = errno; } @@ -1942,25 +2019,79 @@ static int journal_replay (const char *file) /* {{{ */ 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"); @@ -2009,7 +2140,7 @@ static void *connection_thread_main (void *args) /* {{{ */ connection_threads_num++; pthread_mutex_unlock (&connection_threads_lock); - while (do_shutdown == 0) + while (state == RUNNING) { char *cmd; ssize_t cmd_len; @@ -2024,7 +2155,7 @@ static void *connection_thread_main (void *args) /* {{{ */ pollfd.revents = 0; status = poll (&pollfd, 1, /* timeout = */ 500); - if (do_shutdown) + if (state != RUNNING) break; else if (status == 0) /* timeout */ continue; @@ -2329,7 +2460,7 @@ static void *listen_thread_main (void *args __attribute__((unused))) /* {{{ */ RRDD_LOG(LOG_INFO, "listening for connections"); - while (do_shutdown == 0) + while (state == RUNNING) { for (i = 0; i < pollfds_num; i++) { @@ -2339,7 +2470,7 @@ static void *listen_thread_main (void *args __attribute__((unused))) /* {{{ */ } status = poll (pollfds, pollfds_num, /* timeout = */ 1000); - if (do_shutdown) + if (state != RUNNING) break; else if (status == 0) /* timeout */ continue; @@ -2402,7 +2533,7 @@ static void *listen_thread_main (void *args __attribute__((unused))) /* {{{ */ continue; } } /* for (pollfds_num) */ - } /* while (do_shutdown == 0) */ + } /* while (state == RUNNING) */ RRDD_LOG(LOG_INFO, "starting shutdown"); @@ -2434,13 +2565,11 @@ static int daemonize (void) /* {{{ */ /* open all the listen sockets */ if (config_listen_address_list_len > 0) { - for (int i = 0; i < config_listen_address_list_len; i++) - { + for (size_t i = 0; i < config_listen_address_list_len; i++) open_listen_socket (config_listen_address_list[i]); - free_listen_socket (config_listen_address_list[i]); - } - free(config_listen_address_list); + rrd_free_ptrs((void ***) &config_listen_address_list, + &config_listen_address_list_len); } else { @@ -2478,8 +2607,9 @@ static int daemonize (void) /* {{{ */ 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. */ @@ -2515,8 +2645,6 @@ error: static int cleanup (void) /* {{{ */ { - do_shutdown++; - pthread_cond_broadcast (&flush_cond); pthread_join (flush_thread, NULL); @@ -2530,21 +2658,21 @@ static int cleanup (void) /* {{{ */ 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 */ @@ -2564,7 +2692,6 @@ static int read_options (int argc, char **argv) /* {{{ */ case 'L': case 'l': { - listen_socket_t **temp; listen_socket_t *new; new = malloc(sizeof(listen_socket_t)); @@ -2575,20 +2702,15 @@ static int read_options (int argc, char **argv) /* {{{ */ } memset(new, 0, sizeof(listen_socket_t)); - temp = (listen_socket_t **) rrd_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"); - return (2); - } - config_listen_address_list = temp; - 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++; + if (!rrd_add_ptr((void ***)&config_listen_address_list, + &config_listen_address_list_len, new)) + { + fprintf(stderr, "read_options: rrd_add_ptr failed.\n"); + return (2); + } } break; @@ -2728,7 +2850,7 @@ static int read_options (int argc, char **argv) /* {{{ */ case 'j': { struct stat statbuf; - const char *dir = optarg; + const char *dir = journal_dir = strdup(optarg); status = stat(dir, &statbuf); if (status != 0) @@ -2744,19 +2866,6 @@ static int read_options (int argc, char **argv) /* {{{ */ 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; @@ -2801,7 +2910,7 @@ static int read_options (int argc, char **argv) /* {{{ */ 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);