X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fdaemon%2Fplugin.c;h=987f40aaf431c030de6cff4b3b4007b72c806d72;hb=9d9678b9e753ea0936612021f4f87f8092ab4e31;hp=e723af075d112363ac9db07d4cdab99546bfad85;hpb=abc30f241619b3eb66c801c324390e1e9e6e001f;p=collectd.git diff --git a/src/daemon/plugin.c b/src/daemon/plugin.c index e723af07..987f40aa 100644 --- a/src/daemon/plugin.c +++ b/src/daemon/plugin.c @@ -25,7 +25,9 @@ * Sebastian Harl **/ +#define _GNU_SOURCE #include "collectd.h" + #include "common.h" #include "plugin.h" #include "configfile.h" @@ -80,6 +82,12 @@ struct write_queue_s write_queue_t *next; }; +struct flush_callback_s { + char *name; + cdtime_t timeout; +}; +typedef struct flush_callback_s flush_callback_t; + /* * Private variables */ @@ -101,7 +109,7 @@ static c_avl_tree_t *data_sets; static char *plugindir = NULL; #ifndef DEFAULT_MAX_READ_INTERVAL -# define DEFAULT_MAX_READ_INTERVAL TIME_T_TO_CDTIME_T (86400) +# define DEFAULT_MAX_READ_INTERVAL TIME_T_TO_CDTIME_T_STATIC (86400) #endif static c_heap_t *read_heap = NULL; static llist_t *read_list; @@ -144,34 +152,28 @@ static const char *plugin_get_dir (void) } static void plugin_update_internal_statistics (void) { /* {{{ */ - derive_t copy_write_queue_length; - value_list_t vl = VALUE_LIST_INIT; - value_t values[2]; - copy_write_queue_length = write_queue_length; + gauge_t copy_write_queue_length = (gauge_t) write_queue_length; /* Initialize `vl' */ - vl.values = values; - vl.values_len = 2; - vl.time = 0; + value_list_t vl = VALUE_LIST_INIT; sstrncpy (vl.host, hostname_g, sizeof (vl.host)); sstrncpy (vl.plugin, "collectd", sizeof (vl.plugin)); - vl.type_instance[0] = 0; - vl.values_len = 1; - /* Write queue */ sstrncpy (vl.plugin_instance, "write_queue", sizeof (vl.plugin_instance)); /* Write queue : queue length */ - vl.values[0].gauge = (gauge_t) copy_write_queue_length; + vl.values = &(value_t) { .gauge = copy_write_queue_length }; + vl.values_len = 1; sstrncpy (vl.type, "queue_length", sizeof (vl.type)); vl.type_instance[0] = 0; plugin_dispatch_values (&vl); /* Write queue : Values dropped (queue length > low limit) */ - vl.values[0].derive = (derive_t) stats_values_dropped; + vl.values = &(value_t) { .gauge = (gauge_t) stats_values_dropped }; + vl.values_len = 1; sstrncpy (vl.type, "derive", sizeof (vl.type)); sstrncpy (vl.type_instance, "dropped", sizeof (vl.type_instance)); plugin_dispatch_values (&vl); @@ -181,7 +183,8 @@ static void plugin_update_internal_statistics (void) { /* {{{ */ sizeof (vl.plugin_instance)); /* Cache : Nb entry in cache tree */ - vl.values[0].gauge = (gauge_t) uc_get_size(); + vl.values = &(value_t) { .gauge = (gauge_t) uc_get_size() }; + vl.values_len = 1; sstrncpy (vl.type, "cache_size", sizeof (vl.type)); vl.type_instance[0] = 0; plugin_dispatch_values (&vl); @@ -282,7 +285,7 @@ static int register_callback (llist_t **list, /* {{{ */ { ERROR ("plugin: register_callback: " "llentry_create failed."); - free (key); + sfree (key); destroy_callback (cf); return (-1); } @@ -312,8 +315,8 @@ static void log_list_callbacks (llist_t **list, /* {{{ */ { char *str; int len; - llentry_t *le; int i; + llentry_t *le; int n; char **keys; @@ -352,23 +355,22 @@ static void log_list_callbacks (llist_t **list, /* {{{ */ *str = '\0'; strjoin(str, len, keys, n, "', '"); INFO("%s ['%s']", comment, str); - free(str); + sfree (str); } - free(keys); + sfree (keys); } /* }}} void log_list_callbacks */ static int create_register_callback (llist_t **list, /* {{{ */ - const char *name, void *callback, user_data_t *ud) + const char *name, void *callback, user_data_t const *ud) { callback_func_t *cf; - cf = (callback_func_t *) malloc (sizeof (*cf)); + cf = calloc (1, sizeof (*cf)); if (cf == NULL) { - ERROR ("plugin: create_register_callback: malloc failed."); + ERROR ("plugin: create_register_callback: calloc failed."); return (-1); } - memset (cf, 0, sizeof (*cf)); cf->cf_callback = callback; if (ud == NULL) @@ -477,7 +479,9 @@ static void *plugin_read_thread (void __attribute__((unused)) *args) { read_func_t *rf; plugin_ctx_t old_ctx; + cdtime_t start; cdtime_t now; + cdtime_t elapsed; int status; int rf_type; int rc; @@ -519,12 +523,8 @@ static void *plugin_read_thread (void __attribute__((unused)) *args) && (cdtime () < rf->rf_next_read) && rc == 0) { - struct timespec ts = { 0 }; - - CDTIME_T_TO_TIMESPEC (rf->rf_next_read, &ts); - rc = pthread_cond_timedwait (&read_cond, &read_lock, - &ts); + &CDTIME_T_TO_TIMESPEC (rf->rf_next_read)); } /* Must hold `read_lock' when accessing `rf->rf_type'. */ @@ -556,6 +556,8 @@ static void *plugin_read_thread (void __attribute__((unused)) *args) DEBUG ("plugin_read_thread: Handling `%s'.", rf->rf_name); + start = cdtime (); + old_ctx = plugin_set_ctx (rf->rf_ctx); if (rf_type == RF_SIMPLE) @@ -599,8 +601,22 @@ static void *plugin_read_thread (void __attribute__((unused)) *args) /* update the ``next read due'' field */ now = cdtime (); + /* calculate the time spent in the read function */ + elapsed = (now - start); + + if (elapsed > rf->rf_effective_interval) + WARNING ("plugin_read_thread: read-function of the `%s' plugin took %.3f " + "seconds, which is above its read interval (%.3f seconds). You might " + "want to adjust the `Interval' or `ReadThreads' settings.", + rf->rf_name, CDTIME_T_TO_DOUBLE(elapsed), + CDTIME_T_TO_DOUBLE(rf->rf_effective_interval)); + + DEBUG ("plugin_read_thread: read-function of the `%s' plugin took " + "%.6f seconds.", + rf->rf_name, CDTIME_T_TO_DOUBLE(elapsed)); + DEBUG ("plugin_read_thread: Effective interval of the " - "%s plugin is %.3f seconds.", + "`%s' plugin is %.3f seconds.", rf->rf_name, CDTIME_T_TO_DOUBLE (rf->rf_effective_interval)); @@ -617,7 +633,7 @@ static void *plugin_read_thread (void __attribute__((unused)) *args) rf->rf_next_read = now; } - DEBUG ("plugin_read_thread: Next read of the %s plugin at %.3f.", + DEBUG ("plugin_read_thread: Next read of the `%s' plugin at %.3f.", rf->rf_name, CDTIME_T_TO_DOUBLE (rf->rf_next_read)); @@ -631,8 +647,6 @@ static void *plugin_read_thread (void __attribute__((unused)) *args) static void start_read_threads (int num) { - int i; - if (read_threads != NULL) return; @@ -644,11 +658,22 @@ static void start_read_threads (int num) } read_threads_num = 0; - for (i = 0; i < num; i++) + for (int i = 0; i < num; i++) { if (pthread_create (read_threads + read_threads_num, NULL, plugin_read_thread, NULL) == 0) { +#if defined(HAVE_PTHREAD_SETNAME_NP) || defined(HAVE_PTHREAD_SET_NAME_NP) + char thread_name[16]; + sstrncpy (thread_name, "plugin reader", sizeof(thread_name)); +# if defined(HAVE_PTHREAD_SETNAME_NP) + pthread_setname_np (*(read_threads + read_threads_num), + thread_name); +# elif defined(HAVE_PTHREAD_SET_NAME_NP) + pthread_set_name_np (*(read_threads + read_threads_num), + thread_name); +# endif +#endif read_threads_num++; } else @@ -661,8 +686,6 @@ static void start_read_threads (int num) static void stop_read_threads (void) { - int i; - if (read_threads == NULL) return; @@ -674,7 +697,7 @@ static void stop_read_threads (void) pthread_cond_broadcast (&read_cond); pthread_mutex_unlock (&read_lock); - for (i = 0; i < read_threads_num; i++) + for (int i = 0; i < read_threads_num; i++) { if (pthread_join (read_threads[i], NULL) != 0) { @@ -708,6 +731,9 @@ static value_list_t *plugin_value_list_clone (value_list_t const *vl_orig) /* {{ return (NULL); memcpy (vl, vl_orig, sizeof (*vl)); + if (vl->host[0] == 0) + sstrncpy (vl->host, hostname_g, sizeof (vl->host)); + vl->values = calloc (vl_orig->values_len, sizeof (*vl->values)); if (vl->values == NULL) { @@ -846,8 +872,6 @@ static void *plugin_write_thread (void __attribute__((unused)) *args) /* {{{ */ static void start_write_threads (size_t num) /* {{{ */ { - size_t i; - if (write_threads != NULL) return; @@ -859,7 +883,7 @@ static void start_write_threads (size_t num) /* {{{ */ } write_threads_num = 0; - for (i = 0; i < num; i++) + for (size_t i = 0; i < num; i++) { int status; @@ -874,16 +898,27 @@ static void start_write_threads (size_t num) /* {{{ */ "with status %i (%s).", status, sstrerror (status, errbuf, sizeof (errbuf))); return; + } else { +#if defined(HAVE_PTHREAD_SETNAME_NP) || defined(HAVE_PTHREAD_SET_NAME_NP) + char thread_name[16]; + sstrncpy (thread_name, "plugin writer", sizeof(thread_name)); +# if defined(HAVE_PTHREAD_SETNAME_NP) + pthread_setname_np (*(write_threads + write_threads_num), + thread_name); +# elif defined(HAVE_PTHREAD_SET_NAME_NP) + pthread_set_name_np (*(write_threads + write_threads_num), + thread_name); +# endif +#endif + write_threads_num++; } - - write_threads_num++; } /* for (i) */ } /* }}} void start_write_threads */ static void stop_write_threads (void) /* {{{ */ { write_queue_t *q; - int i; + size_t i; if (write_threads == NULL) return; @@ -924,7 +959,7 @@ static void stop_write_threads (void) /* {{{ */ if (i > 0) { - WARNING ("plugin: %i value list%s left after shutting down " + WARNING ("plugin: %zu value list%s left after shutting down " "the write threads.", i, (i == 1) ? " was" : "s were"); } @@ -935,17 +970,17 @@ static void stop_write_threads (void) /* {{{ */ */ void plugin_set_dir (const char *dir) { - if (plugindir != NULL) - free (plugindir); + sfree (plugindir); if (dir == NULL) - plugindir = NULL; - else if ((plugindir = strdup (dir)) == NULL) { - char errbuf[1024]; - ERROR ("strdup failed: %s", - sstrerror (errno, errbuf, sizeof (errbuf))); + plugindir = NULL; + return; } + + plugindir = strdup (dir); + if (plugindir == NULL) + ERROR ("plugin_set_dir: strdup(\"%s\") failed", dir); } static _Bool plugin_is_loaded (char const *name) @@ -953,7 +988,7 @@ static _Bool plugin_is_loaded (char const *name) int status; if (plugins_loaded == NULL) - plugins_loaded = c_avl_create ((void *) strcasecmp); + plugins_loaded = c_avl_create ((int (*) (const void *, const void *)) strcasecmp); assert (plugins_loaded != NULL); status = c_avl_get (plugins_loaded, name, /* ret_value = */ NULL); @@ -1083,6 +1118,7 @@ int plugin_load (char const *plugin_name, uint32_t flags) /* success */ plugin_mark_loaded (plugin_name); ret = 0; + INFO ("plugin_load: plugin \"%s\" successfully loaded.", plugin_name); break; } else @@ -1219,14 +1255,13 @@ int plugin_register_read (const char *name, read_func_t *rf; int status; - rf = malloc (sizeof (*rf)); + rf = calloc (1, sizeof (*rf)); if (rf == NULL) { - ERROR ("plugin_register_read: malloc failed."); + ERROR ("plugin_register_read: calloc failed."); return (ENOMEM); } - memset (rf, 0, sizeof (read_func_t)); rf->rf_callback = (void *) callback; rf->rf_udata.data = NULL; rf->rf_udata.free_func = NULL; @@ -1247,20 +1282,19 @@ int plugin_register_read (const char *name, int plugin_register_complex_read (const char *group, const char *name, plugin_read_cb callback, - const struct timespec *interval, - user_data_t *user_data) + cdtime_t interval, + user_data_t const *user_data) { read_func_t *rf; int status; - rf = malloc (sizeof (*rf)); + rf = calloc (1,sizeof (*rf)); if (rf == NULL) { - ERROR ("plugin_register_complex_read: malloc failed."); + ERROR ("plugin_register_complex_read: calloc failed."); return (ENOMEM); } - memset (rf, 0, sizeof (read_func_t)); rf->rf_callback = (void *) callback; if (group != NULL) sstrncpy (rf->rf_group, group, sizeof (rf->rf_group)); @@ -1268,10 +1302,7 @@ int plugin_register_complex_read (const char *group, const char *name, rf->rf_group[0] = '\0'; rf->rf_name = strdup (name); rf->rf_type = RF_COMPLEX; - if (interval != NULL) - rf->rf_interval = TIMESPEC_TO_CDTIME_T (interval); - else - rf->rf_interval = plugin_get_interval (); + rf->rf_interval = (interval != 0) ? interval : plugin_get_interval (); /* Set user data */ if (user_data == NULL) @@ -1296,21 +1327,114 @@ int plugin_register_complex_read (const char *group, const char *name, } /* int plugin_register_complex_read */ int plugin_register_write (const char *name, - plugin_write_cb callback, user_data_t *ud) + plugin_write_cb callback, user_data_t const *ud) { return (create_register_callback (&list_write, name, (void *) callback, ud)); } /* int plugin_register_write */ +static int plugin_flush_timeout_callback (user_data_t *ud) +{ + flush_callback_t *cb = ud->data; + + return plugin_flush (cb->name, cb->timeout, /* identifier = */ NULL); +} /* static int plugin_flush_callback */ + +static void plugin_flush_timeout_callback_free (void *data) +{ + flush_callback_t *cb = data; + + if (cb == NULL) return; + + sfree (cb->name); + sfree (cb); +} /* static void plugin_flush_callback_free */ + +static char *plugin_flush_callback_name (const char *name) +{ + const char *flush_prefix = "flush/"; + size_t prefix_size; + char *flush_name; + size_t name_size; + + prefix_size = strlen(flush_prefix); + name_size = strlen(name); + + flush_name = malloc (name_size + prefix_size + 1); + if (flush_name == NULL) + { + ERROR ("plugin_flush_callback_name: malloc failed."); + return (NULL); + } + + sstrncpy (flush_name, flush_prefix, prefix_size + 1); + sstrncpy (flush_name + prefix_size, name, name_size + 1); + + return flush_name; +} /* static char *plugin_flush_callback_name */ + int plugin_register_flush (const char *name, - plugin_flush_cb callback, user_data_t *ud) + plugin_flush_cb callback, user_data_t const *ud) { - return (create_register_callback (&list_flush, name, - (void *) callback, ud)); + int status; + plugin_ctx_t ctx = plugin_get_ctx (); + + status = create_register_callback (&list_flush, name, + (void *) callback, ud); + if (status != 0) + return status; + + if (ctx.flush_interval != 0) + { + char *flush_name; + flush_callback_t *cb; + + flush_name = plugin_flush_callback_name (name); + if (flush_name == NULL) + return (-1); + + cb = malloc(sizeof (*cb)); + if (cb == NULL) + { + ERROR ("plugin_register_flush: malloc failed."); + sfree (flush_name); + return (-1); + } + + cb->name = strdup (name); + if (cb->name == NULL) + { + ERROR ("plugin_register_flush: strdup failed."); + sfree (cb); + sfree (flush_name); + return (-1); + } + cb->timeout = ctx.flush_timeout; + + status = plugin_register_complex_read ( + /* group = */ "flush", + /* name = */ flush_name, + /* callback = */ plugin_flush_timeout_callback, + /* interval = */ ctx.flush_interval, + /* user data = */ &(user_data_t) { + .data = cb, + .free_func = plugin_flush_timeout_callback_free, + }); + + sfree (flush_name); + if (status != 0) + { + sfree (cb->name); + sfree (cb); + return status; + } + } + + return 0; } /* int plugin_register_flush */ int plugin_register_missing (const char *name, - plugin_missing_cb callback, user_data_t *ud) + plugin_missing_cb callback, user_data_t const *ud) { return (create_register_callback (&list_missing, name, (void *) callback, ud)); @@ -1347,7 +1471,6 @@ static void plugin_free_data_sets (void) int plugin_register_data_set (const data_set_t *ds) { data_set_t *ds_copy; - int i; if ((data_sets != NULL) && (c_avl_get (data_sets, ds->type, NULL) == 0)) @@ -1362,34 +1485,34 @@ int plugin_register_data_set (const data_set_t *ds) return (-1); } - ds_copy = (data_set_t *) malloc (sizeof (data_set_t)); + ds_copy = malloc (sizeof (*ds_copy)); if (ds_copy == NULL) return (-1); memcpy(ds_copy, ds, sizeof (data_set_t)); - ds_copy->ds = (data_source_t *) malloc (sizeof (data_source_t) + ds_copy->ds = malloc (sizeof (*ds_copy->ds) * ds->ds_num); if (ds_copy->ds == NULL) { - free (ds_copy); + sfree (ds_copy); return (-1); } - for (i = 0; i < ds->ds_num; i++) + for (size_t i = 0; i < ds->ds_num; i++) memcpy (ds_copy->ds + i, ds->ds + i, sizeof (data_source_t)); return (c_avl_insert (data_sets, (void *) ds_copy->type, (void *) ds_copy)); } /* int plugin_register_data_set */ int plugin_register_log (const char *name, - plugin_log_cb callback, user_data_t *ud) + plugin_log_cb callback, user_data_t const *ud) { return (create_register_callback (&list_log, name, (void *) callback, ud)); } /* int plugin_register_log */ int plugin_register_notification (const char *name, - plugin_notification_cb callback, user_data_t *ud) + plugin_notification_cb callback, user_data_t const *ud) { return (create_register_callback (&list_notification, name, (void *) callback, ud)); @@ -1525,7 +1648,21 @@ int plugin_unregister_write (const char *name) int plugin_unregister_flush (const char *name) { - return (plugin_unregister (list_flush, name)); + plugin_ctx_t ctx = plugin_get_ctx (); + + if (ctx.flush_interval != 0) + { + char *flush_name; + + flush_name = plugin_flush_callback_name (name); + if (flush_name != NULL) + { + plugin_unregister_read(flush_name); + sfree (flush_name); + } + } + + return plugin_unregister (list_flush, name); } int plugin_unregister_missing (const char *name) @@ -1564,11 +1701,12 @@ int plugin_unregister_notification (const char *name) return (plugin_unregister (list_notification, name)); } -void plugin_init_all (void) +int plugin_init_all (void) { char const *chain_name; llentry_t *le; int status; + int ret = 0; /* Init the value cache */ uc_init (); @@ -1613,7 +1751,7 @@ void plugin_init_all (void) } if ((list_init == NULL) && (read_heap == NULL)) - return; + return ret; /* Calling all init callbacks before checking if read callbacks * are available allows the init callbacks to register the read @@ -1642,6 +1780,7 @@ void plugin_init_all (void) * handling themselves. */ /* FIXME: Unload _all_ functions */ plugin_unregister_read (le->key); + ret = -1; } le = le->next; @@ -1663,6 +1802,7 @@ void plugin_init_all (void) if (num != -1) start_read_threads ((num > 0) ? num : 5); } + return ret; } /* void plugin_init_all */ /* TODO: Rename this function. */ @@ -1846,14 +1986,15 @@ int plugin_flush (const char *plugin, cdtime_t timeout, const char *identifier) return (0); } /* int plugin_flush */ -void plugin_shutdown_all (void) +int plugin_shutdown_all (void) { llentry_t *le; - - stop_read_threads (); + int ret = 0; // Assume success. destroy_all_callbacks (&list_init); + stop_read_threads (); + pthread_mutex_lock (&read_lock); llist_destroy (read_list); read_list = NULL; @@ -1861,6 +2002,10 @@ void plugin_shutdown_all (void) destroy_read_heap (); + /* blocks until all write threads have shut down. */ + stop_write_threads (); + + /* ask all plugins to write out the state they kept. */ plugin_flush (/* plugin = */ NULL, /* timeout = */ 0, /* identifier = */ NULL); @@ -1885,13 +2030,12 @@ void plugin_shutdown_all (void) * after callback returns. */ le = le->next; - (*callback) (); + if ((*callback) () != 0) + ret = -1; plugin_set_ctx (old_ctx); } - stop_write_threads (); - /* Write plugins which use the `user_data' pointer usually need the * same data available to the flush callback. If this is the case, set * the free_function to NULL when registering the flush callback and to @@ -1907,6 +2051,7 @@ void plugin_shutdown_all (void) plugin_free_loaded (); plugin_free_data_sets (); + return (ret); } /* void plugin_shutdown_all */ int plugin_dispatch_missing (const value_list_t *vl) /* {{{ */ @@ -1955,15 +2100,18 @@ static int plugin_dispatch_values_internal (value_list_t *vl) int status; static c_complain_t no_write_complaint = C_COMPLAIN_INIT_STATIC; - value_t *saved_values; - int saved_values_len; - data_set_t *ds; - int free_meta_data = 0; + _Bool free_meta_data = 0; - if ((vl == NULL) || (vl->type[0] == 0) - || (vl->values == NULL) || (vl->values_len < 1)) + assert (vl != NULL); + + /* These fields are initialized by plugin_value_list_clone() if needed: */ + assert (vl->host[0] != 0); + assert (vl->time != 0); /* The time is determined at _enqueue_ time. */ + assert (vl->interval != 0); + + if (vl->type[0] == 0 || vl->values == NULL || vl->values_len < 1) { ERROR ("plugin_dispatch_values: Invalid value list " "from plugin %s.", vl->plugin); @@ -2001,11 +2149,6 @@ static int plugin_dispatch_values_internal (value_list_t *vl) return (-1); } - /* Assured by plugin_value_list_clone(). The time is determined at - * _enqueue_ time. */ - assert (vl->time != 0); - assert (vl->interval != 0); - DEBUG ("plugin_dispatch_values: time = %.3f; interval = %.3f; " "host = %s; " "plugin = %s; plugin_instance = %s; " @@ -2030,8 +2173,8 @@ static int plugin_dispatch_values_internal (value_list_t *vl) if (ds->ds_num != vl->values_len) { ERROR ("plugin_dispatch_values: ds->type = %s: " - "(ds->ds_num = %i) != " - "(vl->values_len = %i)", + "(ds->ds_num = %zu) != " + "(vl->values_len = %zu)", ds->type, ds->ds_num, vl->values_len); return (-1); } @@ -2043,31 +2186,6 @@ static int plugin_dispatch_values_internal (value_list_t *vl) escape_slashes (vl->type, sizeof (vl->type)); escape_slashes (vl->type_instance, sizeof (vl->type_instance)); - /* Copy the values. This way, we can assure `targets' that they get - * dynamically allocated values, which they can free and replace if - * they like. */ - if ((pre_cache_chain != NULL) || (post_cache_chain != NULL)) - { - saved_values = vl->values; - saved_values_len = vl->values_len; - - vl->values = (value_t *) calloc (vl->values_len, - sizeof (*vl->values)); - if (vl->values == NULL) - { - ERROR ("plugin_dispatch_values: calloc failed."); - vl->values = saved_values; - return (-1); - } - memcpy (vl->values, saved_values, - vl->values_len * sizeof (*vl->values)); - } - else /* if ((pre == NULL) && (post == NULL)) */ - { - saved_values = NULL; - saved_values_len = 0; - } - if (pre_cache_chain != NULL) { status = fc_process_chain (ds, vl, pre_cache_chain); @@ -2079,17 +2197,7 @@ static int plugin_dispatch_values_internal (value_list_t *vl) status, status); } else if (status == FC_TARGET_STOP) - { - /* Restore the state of the value_list so that plugins - * don't get confused.. */ - if (saved_values != NULL) - { - free (vl->values); - vl->values = saved_values; - vl->values_len = saved_values_len; - } return (0); - } } /* Update the value cache */ @@ -2109,15 +2217,6 @@ static int plugin_dispatch_values_internal (value_list_t *vl) else fc_default_action (ds, vl); - /* Restore the state of the value_list so that plugins don't get - * confused.. */ - if (saved_values != NULL) - { - free (vl->values); - vl->values = saved_values; - vl->values_len = saved_values_len; - } - if ((free_meta_data != 0) && (vl->meta != NULL)) { meta_data_destroy (vl->meta); @@ -2228,7 +2327,7 @@ int plugin_dispatch_multivalue (value_list_t const *template, /* {{{ */ assert (template->values_len == 1); - /* Calculate sum for Gauge to calculate percent if needed */ + /* Calculate sum for Gauge to calculate percent if needed */ if (DS_TYPE_GAUGE == store_type) { va_start (ap, store_type); while (42) @@ -2271,7 +2370,7 @@ int plugin_dispatch_multivalue (value_list_t const *template, /* {{{ */ case DS_TYPE_GAUGE: vl->values[0].gauge = va_arg (ap, gauge_t); if (store_percentage) - vl->values[0].gauge *= sum ? (100.0 / sum) : 0; + vl->values[0].gauge *= sum ? (100.0 / sum) : NAN; break; case DS_TYPE_ABSOLUTE: vl->values[0].absolute = va_arg (ap, absolute_t); @@ -2449,13 +2548,12 @@ static int plugin_notification_meta_add (notification_t *n, return (-1); } - meta = (notification_meta_t *) malloc (sizeof (notification_meta_t)); + meta = calloc (1, sizeof (*meta)); if (meta == NULL) { - ERROR ("plugin_notification_meta_add: malloc failed."); + ERROR ("plugin_notification_meta_add: calloc failed."); return (-1); } - memset (meta, 0, sizeof (notification_meta_t)); sstrncpy (meta->name, name, sizeof (meta->name)); meta->type = type; @@ -2552,14 +2650,12 @@ int plugin_notification_meta_add_boolean (notification_t *n, int plugin_notification_meta_copy (notification_t *dst, const notification_t *src) { - notification_meta_t *meta; - assert (dst != NULL); assert (src != NULL); assert (dst != src); assert ((src->meta == NULL) || (src->meta != dst->meta)); - for (meta = src->meta; meta != NULL; meta = meta->next) + for (notification_meta_t *meta = src->meta; meta != NULL; meta = meta->next) { if (meta->type == NM_TYPE_STRING) plugin_notification_meta_add_string (dst, meta->name, @@ -2599,7 +2695,11 @@ int plugin_notification_meta_free (notification_meta_t *n) if (this->type == NM_TYPE_STRING) { - free ((char *)this->nm_value.nm_string); + /* Assign to a temporary variable to work around nm_string's const + * modifier. */ + void *tmp = (void *) this->nm_value.nm_string; + + sfree (tmp); this->nm_value.nm_string = NULL; } sfree (this); @@ -2706,15 +2806,16 @@ static void *plugin_thread_start (void *arg) plugin_set_ctx (plugin_thread->ctx); - free (plugin_thread); + sfree (plugin_thread); return start_routine (plugin_arg); } /* void *plugin_thread_start */ int plugin_thread_create (pthread_t *thread, const pthread_attr_t *attr, - void *(*start_routine) (void *), void *arg) + void *(*start_routine) (void *), void *arg, char *name) { plugin_thread_t *plugin_thread; + int ret; plugin_thread = malloc (sizeof (*plugin_thread)); if (plugin_thread == NULL) @@ -2724,8 +2825,22 @@ int plugin_thread_create (pthread_t *thread, const pthread_attr_t *attr, plugin_thread->start_routine = start_routine; plugin_thread->arg = arg; - return pthread_create (thread, attr, + ret = pthread_create (thread, attr, plugin_thread_start, plugin_thread); + + if (ret == 0 && name != NULL) { +#if defined(HAVE_PTHREAD_SETNAME_NP) || defined(HAVE_PTHREAD_SET_NAME_NP) + char thread_name[16]; + sstrncpy (thread_name, name, sizeof(thread_name)); +# if defined(HAVE_PTHREAD_SETNAME_NP) + pthread_setname_np (*thread, thread_name); +# elif defined(HAVE_PTHREAD_SET_NAME_NP) + pthread_set_name_np (*thread, thread_name); +# endif +#endif + } + + return ret; } /* int plugin_thread_create */ /* vim: set sw=8 ts=8 noet fdm=marker : */