X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fdaemon%2Fplugin.c;h=8b84e6a7920583c48ea3f6570dc9a900b9ec79d6;hb=7aa46a8e912feef20c2bb1e614f2d4e4e1639493;hp=e7993f1e8686b4adce2670754f9f24f82f3e9dc4;hpb=43ef00c0eb99991902d3c9a5fbe582cde049b055;p=collectd.git

diff --git a/src/daemon/plugin.c b/src/daemon/plugin.c
index e7993f1e..8b84e6a7 100644
--- a/src/daemon/plugin.c
+++ b/src/daemon/plugin.c
@@ -26,6 +26,7 @@
  **/
 
 #include "collectd.h"
+
 #include "common.h"
 #include "plugin.h"
 #include "configfile.h"
@@ -107,7 +108,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;
@@ -150,34 +151,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);
@@ -187,7 +182,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);
@@ -318,8 +314,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;
 
@@ -364,17 +360,16 @@ static void log_list_callbacks (llist_t **list, /* {{{ */
 } /* }}} 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)
@@ -527,12 +522,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'. */
@@ -655,8 +646,6 @@ static void *plugin_read_thread (void __attribute__((unused)) *args)
 
 static void start_read_threads (int num)
 {
-	int i;
-
 	if (read_threads != NULL)
 		return;
 
@@ -668,7 +657,7 @@ 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)
@@ -685,8 +674,6 @@ static void start_read_threads (int num)
 
 static void stop_read_threads (void)
 {
-	int i;
-
 	if (read_threads == NULL)
 		return;
 
@@ -698,7 +685,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)
 		{
@@ -732,6 +719,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)
 	{
@@ -870,8 +860,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;
 
@@ -883,7 +871,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;
 
@@ -977,7 +965,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);
@@ -1244,14 +1232,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;
@@ -1273,19 +1260,18 @@ int plugin_register_read (const char *name,
 int plugin_register_complex_read (const char *group, const char *name,
 		plugin_read_cb callback,
 		cdtime_t interval,
-		user_data_t *user_data)
+		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));
@@ -1318,7 +1304,7 @@ 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));
@@ -1351,7 +1337,7 @@ static char *plugin_flush_callback_name (const char *name)
 	prefix_size = strlen(flush_prefix);
 	name_size = strlen(name);
 
-	flush_name = malloc (sizeof(char) * (name_size + prefix_size + 1));
+	flush_name = malloc (name_size + prefix_size + 1);
 	if (flush_name == NULL)
 	{
 		ERROR ("plugin_flush_callback_name: malloc failed.");
@@ -1365,7 +1351,7 @@ static char *plugin_flush_callback_name (const char *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)
 {
 	int status;
 	plugin_ctx_t ctx = plugin_get_ctx ();
@@ -1384,7 +1370,7 @@ int plugin_register_flush (const char *name,
 		if (flush_name == NULL)
 			return (-1);
 
-		cb = malloc(sizeof(flush_callback_t));
+		cb = malloc(sizeof (*cb));
 		if (cb == NULL)
 		{
 			ERROR ("plugin_register_flush: malloc failed.");
@@ -1402,15 +1388,15 @@ int plugin_register_flush (const char *name,
 		}
 		cb->timeout = ctx.flush_timeout;
 
-		ud->data = cb;
-		ud->free_func = plugin_flush_timeout_callback_free;
-
 		status = plugin_register_complex_read (
 			/* group     = */ "flush",
 			/* name      = */ flush_name,
 			/* callback  = */ plugin_flush_timeout_callback,
 			/* interval  = */ ctx.flush_interval,
-			/* user data = */ ud);
+			/* user data = */ &(user_data_t) {
+				.data = cb,
+				.free_func = plugin_flush_timeout_callback_free,
+			});
 
 		sfree (flush_name);
 		if (status != 0)
@@ -1425,7 +1411,7 @@ int plugin_register_flush (const char *name,
 } /* 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));
@@ -1462,7 +1448,6 @@ static void plugin_free_data_sets (void)
 int plugin_register_data_set (const data_set_t *ds)
 {
 	data_set_t *ds_copy;
-	size_t i;
 
 	if ((data_sets != NULL)
 			&& (c_avl_get (data_sets, ds->type, NULL) == 0))
@@ -1477,12 +1462,12 @@ 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)
 	{
@@ -1490,21 +1475,21 @@ int plugin_register_data_set (const data_set_t *ds)
 		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));
@@ -1693,11 +1678,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 ();
@@ -1742,7 +1728,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
@@ -1771,6 +1757,7 @@ void plugin_init_all (void)
 			 * handling themselves. */
 			/* FIXME: Unload _all_ functions */
 			plugin_unregister_read (le->key);
+			ret = -1;
 		}
 
 		le = le->next;
@@ -1792,6 +1779,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. */
@@ -1975,14 +1963,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;
@@ -1990,6 +1979,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);
@@ -2014,13 +2007,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
@@ -2036,6 +2028,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) /* {{{ */
@@ -2084,15 +2077,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;
+
+	assert (vl != NULL);
 
-	if ((vl == NULL) || (vl->type[0] == 0)
-			|| (vl->values == NULL) || (vl->values_len < 1))
+	/* 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);
@@ -2130,11 +2126,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; "
@@ -2172,31 +2163,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);
@@ -2208,17 +2174,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)
-			{
-				sfree (vl->values);
-				vl->values     = saved_values;
-				vl->values_len = saved_values_len;
-			}
 			return (0);
-		}
 	}
 
 	/* Update the value cache */
@@ -2238,15 +2194,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)
-	{
-		sfree (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);
@@ -2357,7 +2304,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)
@@ -2400,7 +2347,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);
@@ -2578,13 +2525,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;
@@ -2681,14 +2627,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,