X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fnetapp.c;h=c2ebc9f96efbe202147edfcdcdb5f32299279ca8;hb=7658e9919a3ac9efafe4c7c2c76112ec67eeee3b;hp=bce92ea640c7429c02d2b60eceb978201a7675ec;hpb=65029e9cd7f810d33daafc4e10e4ef69ab534d02;p=collectd.git

diff --git a/src/netapp.c b/src/netapp.c
index bce92ea6..c2ebc9f9 100644
--- a/src/netapp.c
+++ b/src/netapp.c
@@ -21,7 +21,7 @@
  * DEALINGS IN THE SOFTWARE.
  *
  * Authors:
- *   Sven Trenkel <sven.trenkel at noris.net>
+ *   Sven Trenkel <collectd at semidefinite.de>  
  **/
 
 #include "collectd.h"
@@ -34,6 +34,13 @@
 typedef struct host_config_s host_config_t;
 typedef void service_handler_t(host_config_t *host, na_elem_t *result, void *data);
 
+struct cna_interval_s
+{
+	time_t interval;
+	time_t last_read;
+};
+typedef struct cna_interval_s cna_interval_t;
+
 /*!
  * \brief Persistent data for system performance counters
  */
@@ -44,18 +51,20 @@ typedef void service_handler_t(host_config_t *host, na_elem_t *result, void *dat
 #define CFG_SYSTEM_ALL  0x0F
 typedef struct {
 	uint32_t flags;
+	cna_interval_t interval;
+	na_elem_t *query;
 } cfg_system_t;
 
 /*!
  * \brief Persistent data for WAFL performance counters. (a.k.a. cache performance)
  *
  * The cache counters use old counter values to calculate a hit ratio for each
- * counter. The "data_wafl_t" struct therefore contains old counter values
- * along with flags, which are set if the counter is valid.
+ * counter. The "cfg_wafl_t" struct therefore contains old counter values along
+ * with flags, which are set if the counter is valid.
  *
- * The function "query_wafl_data" will fill a new structure of this kind with
- * new values, then pass both, new and old data, to "submit_wafl_data". That
- * function calculates the hit ratios, submits the calculated values and
+ * The function "cna_handle_wafl_data" will fill a new structure of this kind
+ * with new values, then pass both, new and old data, to "submit_wafl_data".
+ * That function calculates the hit ratios, submits the calculated values and
  * updates the old counter values for the next iteration.
  */
 #define CFG_WAFL_NAME_CACHE        0x0001
@@ -78,6 +87,9 @@ typedef struct {
 #define HAVE_WAFL_ALL              0xff00
 typedef struct {
 	uint32_t flags;
+	cna_interval_t interval;
+	na_elem_t *query;
+
 	time_t timestamp;
 	uint64_t name_cache_hit;
 	uint64_t name_cache_miss;
@@ -87,7 +99,7 @@ typedef struct {
 	uint64_t buf_hash_miss;
 	uint64_t inode_cache_hit;
 	uint64_t inode_cache_miss;
-} data_wafl_t;
+} cfg_wafl_t;
 
 /*!
  * \brief Persistent data for volume performance data.
@@ -133,11 +145,13 @@ typedef struct {
 /*!
  * \brief Configuration struct for volume usage data (free / used).
  */
-#define VOLUME_INIT           0x01
-#define VOLUME_DF             0x02
-#define VOLUME_SNAP           0x04
+#define CFG_VOLUME_USAGE_INIT           0x0001
+#define CFG_VOLUME_USAGE_DF             0x0002
+#define CFG_VOLUME_USAGE_SNAP           0x0004
+#define HAVE_VOLUME_USAGE_SNAP          0x0008
 typedef struct {
 	uint32_t flags;
+	uint64_t snap_used;
 } cfg_volume_usage_t;
 
 typedef struct service_config_s {
@@ -168,21 +182,15 @@ typedef struct volume_s {
 	struct volume_s *next;
 } volume_t;
 
-#define CFG_DISK_BUSIEST 0x01
-#define CFG_DISK_ALL     0x01
-#define HAVE_DISK_BUSY   0x10
-#define HAVE_DISK_BASE   0x20
-#define HAVE_DISK_ALL    0x30
-typedef struct {
-	uint32_t flags;
-} cfg_disk_t;
-
 /*!
  * \brief A disk in the NetApp.
  *
  * A disk doesn't have any more information than its name at the moment.
  * The name includes the "disk_" prefix.
  */
+#define HAVE_DISK_BUSY   0x10
+#define HAVE_DISK_BASE   0x20
+#define HAVE_DISK_ALL    0x30
 typedef struct disk_s {
 	char *name;
 	uint32_t flags;
@@ -193,8 +201,16 @@ typedef struct disk_s {
 	struct disk_s *next;
 } disk_t;
 
+#define CFG_DISK_BUSIEST 0x01
+#define CFG_DISK_ALL     0x01
+typedef struct {
+	uint32_t flags;
+	cna_interval_t interval;
+	na_elem_t *query;
+	disk_t *disks;
+} cfg_disk_t;
+
 struct host_config_s {
-	na_server_t *srv;
 	char *name;
 	na_server_transport_t protocol;
 	char *host;
@@ -202,12 +218,19 @@ struct host_config_s {
 	char *username;
 	char *password;
 	int interval;
+
+	na_server_t *srv;
 	cfg_service_t *services;
-	disk_t *disks;
+	cfg_disk_t *cfg_disk;
+	cfg_wafl_t *cfg_wafl;
+	cfg_system_t *cfg_system;
 	volume_t *volumes;
+
 	struct host_config_s *next;
 };
-#define HOST_INIT {NULL, NULL, NA_SERVER_TRANSPORT_HTTPS, NULL, 0, NULL, NULL, 10, NULL, NULL, NULL, NULL}
+#define HOST_INIT { NULL, NA_SERVER_TRANSPORT_HTTPS, NULL, 0, NULL, NULL, 0, \
+	NULL, NULL, NULL, NULL, \
+	NULL}
 
 static host_config_t *global_host_config;
 
@@ -240,13 +263,38 @@ static void free_disk (disk_t *disk) /* {{{ */
 	free_disk (next);
 } /* }}} void free_disk */
 
+static void free_cfg_wafl (cfg_wafl_t *cw) /* {{{ */
+{
+	if (cw == NULL)
+		return;
+
+	if (cw->query != NULL)
+		na_elem_free (cw->query);
+
+	sfree (cw);
+} /* }}} void free_cfg_wafl */
+
+static void free_cfg_disk (cfg_disk_t *cfg_disk) /* {{{ */
+{
+	if (cfg_disk == NULL)
+		return;
+
+	free_disk (cfg_disk->disks);
+	sfree (cfg_disk);
+} /* }}} void free_cfg_disk */
+
 static void free_cfg_service (cfg_service_t *service) /* {{{ */
 {
 	cfg_service_t *next;
 
+	if (service == NULL)
+		return;
+	
 	next = service->next;
 
 	/* FIXME: Free service->data? */
+	na_elem_free(service->query);
+	
 	sfree (service);
 
 	free_cfg_service (next);
@@ -267,7 +315,8 @@ static void free_host_config (host_config_t *hc) /* {{{ */
 	sfree (hc->password);
 
 	free_cfg_service (hc->services);
-	free_disk (hc->disks);
+	free_cfg_disk (hc->cfg_disk);
+	free_cfg_wafl (hc->cfg_wafl);
 	free_volume (hc->volumes);
 
 	sfree (hc);
@@ -290,7 +339,7 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */
 	
 	/* Make sure the default flags include the init-bit. */
 	if (vol_usage_flags != 0)
-		vol_usage_flags |= VOLUME_INIT;
+		vol_usage_flags |= CFG_VOLUME_USAGE_INIT;
 	if (vol_perf_flags != 0)
 		vol_perf_flags |= CFG_VOLUME_PERF_INIT;
 
@@ -299,7 +348,7 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */
 			continue;
 
 		/* Check if the flags have been initialized. */
-		if (((v->cfg_volume_usage.flags & VOLUME_INIT) == 0)
+		if (((v->cfg_volume_usage.flags & CFG_VOLUME_USAGE_INIT) == 0)
 				&& (vol_usage_flags != 0))
 			v->cfg_volume_usage.flags = vol_usage_flags;
 		if (((v->perf_data.flags & CFG_VOLUME_PERF_INIT) == 0)
@@ -330,33 +379,34 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */
 	return v;
 } /* }}} volume_t *get_volume */
 
-static disk_t *get_disk(host_config_t *host, const char *name) /* {{{ */
+static disk_t *get_disk(cfg_disk_t *cd, const char *name) /* {{{ */
 {
-	disk_t *v;
+	disk_t *d;
 
-	if (name == NULL)
+	if ((cd == NULL) || (name == NULL))
 		return (NULL);
-	
-	for (v = host->disks; v; v = v->next) {
-		if (strcmp(v->name, name) == 0)
-			return v;
+
+	for (d = cd->disks; d != NULL; d = d->next) {
+		if (strcmp(d->name, name) == 0)
+			return d;
 	}
-	v = malloc(sizeof(*v));
-	if (v == NULL)
+
+	d = malloc(sizeof(*d));
+	if (d == NULL)
 		return (NULL);
-	memset (v, 0, sizeof (*v));
-	v->next = NULL;
+	memset (d, 0, sizeof (*d));
+	d->next = NULL;
 
-	v->name = strdup(name);
-	if (v->name == NULL) {
-		sfree (v);
+	d->name = strdup(name);
+	if (d->name == NULL) {
+		sfree (d);
 		return (NULL);
 	}
 
-	v->next = host->disks;
-	host->disks = v;
+	d->next = cd->disks;
+	cd->disks = d;
 
-	return v;
+	return d;
 } /* }}} disk_t *get_disk */
 
 static void host_set_all_perf_data_flags(const host_config_t *host, /* {{{ */
@@ -496,34 +546,34 @@ static int submit_cache_ratio (const char *host, /* {{{ */
 } /* }}} int submit_cache_ratio */
 
 /* Submits all the caches used by WAFL. Uses "submit_cache_ratio". */
-static int submit_wafl_data (const host_config_t *host, const char *instance, /* {{{ */
-		data_wafl_t *old_data, const data_wafl_t *new_data)
+static int submit_wafl_data (const char *hostname, const char *instance, /* {{{ */
+		cfg_wafl_t *old_data, const cfg_wafl_t *new_data)
 {
 	/* Submit requested counters */
 	if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_NAME_CACHE | HAVE_WAFL_NAME_CACHE)
 			&& HAS_ALL_FLAGS (new_data->flags, HAVE_WAFL_NAME_CACHE))
-		submit_cache_ratio (host->name, instance, "name_cache_hit",
+		submit_cache_ratio (hostname, instance, "name_cache_hit",
 				new_data->name_cache_hit, new_data->name_cache_miss,
 				old_data->name_cache_hit, old_data->name_cache_miss,
 				new_data->timestamp);
 
 	if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_DIR_CACHE | HAVE_WAFL_FIND_DIR)
 			&& HAS_ALL_FLAGS (new_data->flags, HAVE_WAFL_FIND_DIR))
-		submit_cache_ratio (host->name, instance, "find_dir_hit",
+		submit_cache_ratio (hostname, instance, "find_dir_hit",
 				new_data->find_dir_hit, new_data->find_dir_miss,
 				old_data->find_dir_hit, old_data->find_dir_miss,
 				new_data->timestamp);
 
 	if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_BUF_CACHE | HAVE_WAFL_BUF_HASH)
 			&& HAS_ALL_FLAGS (new_data->flags, HAVE_WAFL_BUF_HASH))
-		submit_cache_ratio (host->name, instance, "buf_hash_hit",
+		submit_cache_ratio (hostname, instance, "buf_hash_hit",
 				new_data->buf_hash_hit, new_data->buf_hash_miss,
 				old_data->buf_hash_hit, old_data->buf_hash_miss,
 				new_data->timestamp);
 
 	if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_INODE_CACHE | HAVE_WAFL_INODE_CACHE)
 			&& HAS_ALL_FLAGS (new_data->flags, HAVE_WAFL_INODE_CACHE))
-		submit_cache_ratio (host->name, instance, "inode_cache_hit",
+		submit_cache_ratio (hostname, instance, "inode_cache_hit",
 				new_data->inode_cache_hit, new_data->inode_cache_miss,
 				old_data->inode_cache_hit, old_data->inode_cache_miss,
 				new_data->timestamp);
@@ -638,28 +688,43 @@ static int submit_volume_perf_data (const host_config_t *host, /* {{{ */
  * These functions are called with appropriate data returned by the libnetapp
  * interface which is parsed and submitted with the above functions.
  */
-/* Data corresponding to <GetWaflPerfData /> */
-static void query_wafl_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */
-	data_wafl_t *wafl = data;
-	data_wafl_t perf_data;
+/* Data corresponding to <WAFL /> */
+static int cna_handle_wafl_data (const char *hostname, cfg_wafl_t *cfg_wafl, /* {{{ */
+		na_elem_t *data)
+{
+	cfg_wafl_t perf_data;
 	const char *plugin_inst;
+
+	na_elem_t *instances;
 	na_elem_t *counter;
+	na_elem_iter_t counter_iter;
 
 	memset (&perf_data, 0, sizeof (perf_data));
 	
-	perf_data.timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0);
+	perf_data.timestamp = (time_t) na_child_get_uint64 (data, "timestamp", 0);
 
-	out = na_elem_child(na_elem_child(out, "instances"), "instance-data");
-	if (out == NULL)
-		return;
+	instances = na_elem_child(na_elem_child (data, "instances"), "instance-data");
+	if (instances == NULL)
+	{
+		ERROR ("netapp plugin: cna_handle_wafl_data: "
+				"na_elem_child (\"instances\") failed.");
+		return (-1);
+	}
 
-	plugin_inst = na_child_get_string(out, "name");
+	plugin_inst = na_child_get_string(instances, "name");
 	if (plugin_inst == NULL)
-		return;
+	{
+		ERROR ("netapp plugin: cna_handle_wafl_data: "
+				"na_child_get_string (\"name\") failed.");
+		return (-1);
+	}
 
 	/* Iterate over all counters */
-	na_elem_iter_t iter = na_child_iterator(na_elem_child(out, "counters"));
-	for (counter = na_iterator_next(&iter); counter; counter = na_iterator_next(&iter)) {
+	counter_iter = na_child_iterator (na_elem_child (instances, "counters"));
+	for (counter = na_iterator_next (&counter_iter);
+			counter != NULL;
+			counter = na_iterator_next (&counter_iter))
+	{
 		const char *name;
 		uint64_t value;
 
@@ -696,41 +761,143 @@ static void query_wafl_data(host_config_t *host, na_elem_t *out, void *data) { /
 			perf_data.inode_cache_miss = value;
 			perf_data.flags |= HAVE_WAFL_INODE_CACHE_MISS;
 		} else {
-			DEBUG("netapp plugin: query_wafl_data: Found unexpected child: %s",
-					name);
+			DEBUG("netapp plugin: cna_handle_wafl_data: "
+					"Found unexpected child: %s", name);
 		}
 	}
 
-	submit_wafl_data (host, plugin_inst, wafl, &perf_data);
-} /* }}} void query_wafl_data */
+	return (submit_wafl_data (hostname, plugin_inst, cfg_wafl, &perf_data));
+} /* }}} void cna_handle_wafl_data */
+
+static int cna_setup_wafl (cfg_wafl_t *cw) /* {{{ */
+{
+	na_elem_t *e;
+
+	if (cw == NULL)
+		return (EINVAL);
+
+	if (cw->query != NULL)
+		return (0);
+
+	cw->query = na_elem_new("perf-object-get-instances");
+	if (cw->query == NULL)
+	{
+		ERROR ("netapp plugin: na_elem_new failed.");
+		return (-1);
+	}
+	na_child_add_string (cw->query, "objectname", "wafl");
+
+	e = na_elem_new("counters");
+	if (e == NULL)
+	{
+		na_elem_free (cw->query);
+		cw->query = NULL;
+		ERROR ("netapp plugin: na_elem_new failed.");
+		return (-1);
+	}
+	na_child_add_string(e, "foo", "name_cache_hit");
+	na_child_add_string(e, "foo", "name_cache_miss");
+	na_child_add_string(e, "foo", "find_dir_hit");
+	na_child_add_string(e, "foo", "find_dir_miss");
+	na_child_add_string(e, "foo", "buf_hash_hit");
+	na_child_add_string(e, "foo", "buf_hash_miss");
+	na_child_add_string(e, "foo", "inode_cache_hit");
+	na_child_add_string(e, "foo", "inode_cache_miss");
+
+	na_child_add(cw->query, e);
+
+	return (0);
+} /* }}} int cna_setup_wafl */
+
+static int cna_query_wafl (host_config_t *host) /* {{{ */
+{
+	na_elem_t *data;
+	int status;
+	time_t now;
+
+	if (host == NULL)
+		return (EINVAL);
+
+	/* If WAFL was not configured, return without doing anything. */
+	if (host->cfg_wafl == NULL)
+		return (0);
+
+	now = time (NULL);
+	if ((host->cfg_wafl->interval.interval + host->cfg_wafl->interval.last_read) > now)
+		return (0);
+
+	status = cna_setup_wafl (host->cfg_wafl);
+	if (status != 0)
+		return (status);
+	assert (host->cfg_wafl->query != NULL);
+
+	data = na_server_invoke_elem(host->srv, host->cfg_wafl->query);
+	if (na_results_status (data) != NA_OK)
+	{
+		ERROR ("netapp plugin: cna_query_wafl: na_server_invoke_elem failed: %s",
+				na_results_reason (data));
+		na_elem_free (data);
+		return (-1);
+	}
+
+	status = cna_handle_wafl_data (host->name, host->cfg_wafl, data);
+
+	if (status == 0)
+		host->cfg_wafl->interval.last_read = now;
 
-/* Data corresponding to <GetDiskPerfData /> */
-static void query_submit_disk_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */
-	cfg_disk_t *cfg_disk = data;
+	na_elem_free (data);
+	return (status);
+} /* }}} int cna_query_wafl */
+
+/* Data corresponding to <Disks /> */
+static int cna_handle_disk_data (const char *hostname, /* {{{ */
+		cfg_disk_t *cfg_disk, na_elem_t *data)
+{
 	time_t timestamp;
-	na_elem_t *counter, *inst;
-	disk_t *worst_disk = 0;
+	na_elem_t *instances;
+	na_elem_t *instance;
+	na_elem_iter_t instance_iter;
+	disk_t *worst_disk = NULL;
+
+	if ((cfg_disk == NULL) || (data == NULL))
+		return (EINVAL);
 	
-	timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0);
-	out = na_elem_child(out, "instances");
+	timestamp = (time_t) na_child_get_uint64(data, "timestamp", 0);
+
+	instances = na_elem_child (data, "instances");
+	if (instances == NULL)
+	{
+		ERROR ("netapp plugin: cna_handle_disk_data: "
+				"na_elem_child (\"instances\") failed.");
+		return (-1);
+	}
 
 	/* Iterate over all children */
-	na_elem_iter_t inst_iter = na_child_iterator(out);
-	for (inst = na_iterator_next(&inst_iter); inst; inst = na_iterator_next(&inst_iter)) {
+	instance_iter = na_child_iterator (instances);
+	for (instance = na_iterator_next (&instance_iter);
+			instance != NULL;
+			instance = na_iterator_next(&instance_iter))
+	{
 		disk_t *old_data;
 		disk_t  new_data;
 
+		na_elem_iter_t counter_iterator;
+		na_elem_t *counter;
+
 		memset (&new_data, 0, sizeof (new_data));
 		new_data.timestamp = timestamp;
 		new_data.disk_busy_percent = NAN;
 
-		old_data = get_disk(host, na_child_get_string(inst, "name"));
+		old_data = get_disk(cfg_disk, na_child_get_string (instance, "name"));
 		if (old_data == NULL)
 			continue;
 
 		/* Look for the "disk_busy" and "base_for_disk_busy" counters */
-		na_elem_iter_t count_iter = na_child_iterator(na_elem_child(inst, "counters"));
-		for (counter = na_iterator_next(&count_iter); counter; counter = na_iterator_next(&count_iter)) {
+		counter_iterator = na_child_iterator(na_elem_child(instance, "counters"));
+		for (counter = na_iterator_next(&counter_iterator);
+				counter != NULL;
+				counter = na_iterator_next(&counter_iterator))
+		{
 			const char *name;
 			uint64_t value;
 
@@ -752,6 +919,12 @@ static void query_submit_disk_data(host_config_t *host, na_elem_t *out, void *da
 				new_data.base_for_disk_busy = value;
 				new_data.flags |= HAVE_DISK_BASE;
 			}
+			else
+			{
+				DEBUG ("netapp plugin: cna_handle_disk_data: "
+						"Counter not handled: %s = %"PRIu64,
+						name, value);
+			}
 		}
 
 		/* If all required counters are available and did not just wrap around,
@@ -790,9 +963,85 @@ static void query_submit_disk_data(host_config_t *host, na_elem_t *out, void *da
 	} /* for (all disks) */
 
 	if ((cfg_disk->flags & CFG_DISK_BUSIEST) && (worst_disk != NULL))
-		submit_double (host->name, "system", "percent", "disk_busy",
+		submit_double (hostname, "system", "percent", "disk_busy",
 				worst_disk->disk_busy_percent, timestamp);
-} /* }}} void query_submit_disk_data */
+
+	return (0);
+} /* }}} int cna_handle_disk_data */
+
+static int cna_setup_disk (cfg_disk_t *cd) /* {{{ */
+{
+	na_elem_t *e;
+
+	if (cd == NULL)
+		return (EINVAL);
+
+	if (cd->query != NULL)
+		return (0);
+
+	cd->query = na_elem_new ("perf-object-get-instances");
+	if (cd->query == NULL)
+	{
+		ERROR ("netapp plugin: na_elem_new failed.");
+		return (-1);
+	}
+	na_child_add_string (cd->query, "objectname", "disk");
+
+	e = na_elem_new("counters");
+	if (e == NULL)
+	{
+		na_elem_free (cd->query);
+		cd->query = NULL;
+		ERROR ("netapp plugin: na_elem_new failed.");
+		return (-1);
+	}
+	na_child_add_string(e, "foo", "disk_busy");
+	na_child_add_string(e, "foo", "base_for_disk_busy");
+	na_child_add(cd->query, e);
+
+	return (0);
+} /* }}} int cna_setup_disk */
+
+static int cna_query_disk (host_config_t *host) /* {{{ */
+{
+	na_elem_t *data;
+	int status;
+	time_t now;
+
+	if (host == NULL)
+		return (EINVAL);
+
+	/* If the user did not configure disk statistics, return without doing
+	 * anything. */
+	if (host->cfg_disk == NULL)
+		return (0);
+
+	now = time (NULL);
+	if ((host->cfg_disk->interval.interval + host->cfg_disk->interval.last_read) > now)
+		return (0);
+
+	status = cna_setup_disk (host->cfg_disk);
+	if (status != 0)
+		return (status);
+	assert (host->cfg_disk->query != NULL);
+
+	data = na_server_invoke_elem(host->srv, host->cfg_disk->query);
+	if (na_results_status (data) != NA_OK)
+	{
+		ERROR ("netapp plugin: cna_query_disk: na_server_invoke_elem failed: %s",
+				na_results_reason (data));
+		na_elem_free (data);
+		return (-1);
+	}
+
+	status = cna_handle_disk_data (host->name, host->cfg_disk, data);
+
+	if (status == 0)
+		host->cfg_disk->interval.last_read = now;
+
+	na_elem_free (data);
+	return (status);
+} /* }}} int cna_query_disk */
 
 /* Data corresponding to <GetVolumeData /> */
 static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */
@@ -815,22 +1064,27 @@ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data)
 		if (volume == NULL)
 			continue;
 
-		if (!(volume->cfg_volume_usage.flags & VOLUME_DF))
+		if (!(volume->cfg_volume_usage.flags & CFG_VOLUME_USAGE_DF))
 			continue;
 
 		/* 2^4 exa-bytes? This will take a while ;) */
 		size_free = na_child_get_uint64(inst, "size-available", UINT64_MAX);
 		if (size_free != UINT64_MAX)
-			submit_double (host->name, volume->name, "df_complex", "used",
-					(double) size_used, /* time = */ 0);
-
-		size_used = na_child_get_uint64(inst, "size-used", UINT64_MAX);
-		if (size_free != UINT64_MAX)
 			submit_double (host->name, volume->name, "df_complex", "free",
 					(double) size_free, /* time = */ 0);
 
+		size_used = na_child_get_uint64(inst, "size-used", UINT64_MAX);
+		if (size_used != UINT64_MAX) {
+			if ((volume->cfg_volume_usage.flags & HAVE_VOLUME_USAGE_SNAP)
+					&& (size_used >= volume->cfg_volume_usage.snap_used))
+				size_used -= volume->cfg_volume_usage.snap_used;
+			submit_double (host->name, volume->name, "df_complex", "used",
+					(double) size_used, /* time = */ 0);
+		}
+
 		snap_reserved = na_child_get_uint64(inst, "snapshot-blocks-reserved", UINT64_MAX);
-		if (snap_reserved != UINT64_MAX)
+		if (!(volume->cfg_volume_usage.flags & HAVE_VOLUME_USAGE_SNAP) && (snap_reserved != UINT64_MAX))
+			/* If we have snap usage data this value has already been submitted. */
 			/* 1 block == 1024 bytes  as per API docs */
 			submit_double (host->name, volume->name, "df_complex", "snap_reserved",
 					(double) (1024 * snap_reserved), /* time = */ 0);
@@ -957,24 +1211,45 @@ static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *da
 	} /* for (volume) */
 } /* }}} void query_volume_perf_data */
 
-/* Data corresponding to <GetSystemPerfData /> */
-static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */
+/* Data corresponding to <System /> */
+static int cna_handle_system_data (const char *hostname, /* {{{ */
+		cfg_system_t *cfg_system, na_elem_t *data)
+{
+	na_elem_t *instances;
+	na_elem_t *counter;
+	na_elem_iter_t counter_iter;
+
 	counter_t disk_read = 0, disk_written = 0;
 	counter_t net_recv = 0, net_sent = 0;
 	counter_t cpu_busy = 0, cpu_total = 0;
-	unsigned int counter_flags = 0;
+	uint32_t counter_flags = 0;
 
-	cfg_system_t *cfg_system = data;
 	const char *instance;
 	time_t timestamp;
-	na_elem_t *counter;
 	
-	timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0);
-	out = na_elem_child(na_elem_child(out, "instances"), "instance-data");
-	instance = na_child_get_string(out, "name");
+	timestamp = (time_t) na_child_get_uint64 (data, "timestamp", 0);
+
+	instances = na_elem_child(na_elem_child (data, "instances"), "instance-data");
+	if (instances == NULL)
+	{
+		ERROR ("netapp plugin: cna_handle_system_data: "
+				"na_elem_child (\"instances\") failed.");
+		return (-1);
+	}
+
+	instance = na_child_get_string (instances, "name");
+	if (instance == NULL)
+	{
+		ERROR ("netapp plugin: cna_handle_system_data: "
+				"na_child_get_string (\"name\") failed.");
+		return (-1);
+	}
 
-	na_elem_iter_t iter = na_child_iterator(na_elem_child(out, "counters"));
-	for (counter = na_iterator_next(&iter); counter; counter = na_iterator_next(&iter)) {
+	counter_iter = na_child_iterator (na_elem_child (instances, "counters"));
+	for (counter = na_iterator_next (&counter_iter);
+			counter != NULL;
+			counter = na_iterator_next (&counter_iter))
+	{
 		const char *name;
 		uint64_t value;
 
@@ -1007,29 +1282,91 @@ static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void *
 		} else if ((cfg_system->flags & CFG_SYSTEM_OPS)
 				&& (value > 0) && (strlen(name) > 4)
 				&& (!strcmp(name + strlen(name) - 4, "_ops"))) {
-			submit_counter (host->name, instance, "disk_ops_complex", name,
+			submit_counter (hostname, instance, "disk_ops_complex", name,
 					(counter_t) value, timestamp);
 		}
 	} /* for (counter) */
 
 	if ((cfg_system->flags & CFG_SYSTEM_DISK)
-			&& ((counter_flags & 0x03) == 0x03))
-		submit_two_counters (host->name, instance, "disk_octets", NULL,
+			&& (HAS_ALL_FLAGS (counter_flags, 0x01 | 0x02)))
+		submit_two_counters (hostname, instance, "disk_octets", NULL,
 				disk_read, disk_written, timestamp);
 				
 	if ((cfg_system->flags & CFG_SYSTEM_NET)
-			&& ((counter_flags & 0x0c) == 0x0c))
-		submit_two_counters (host->name, instance, "if_octets", NULL,
+			&& (HAS_ALL_FLAGS (counter_flags, 0x04 | 0x08)))
+		submit_two_counters (hostname, instance, "if_octets", NULL,
 				net_recv, net_sent, timestamp);
 
 	if ((cfg_system->flags & CFG_SYSTEM_CPU)
-			&& ((counter_flags & 0x30) == 0x30)) {
-		submit_counter (host->name, instance, "cpu", "system",
+			&& (HAS_ALL_FLAGS (counter_flags, 0x10 | 0x20)))
+	{
+		submit_counter (hostname, instance, "cpu", "system",
 				cpu_busy, timestamp);
-		submit_counter (host->name, instance, "cpu", "idle",
+		submit_counter (hostname, instance, "cpu", "idle",
 				cpu_total - cpu_busy, timestamp);
 	}
-} /* }}} void collect_perf_system_data */
+
+	return (0);
+} /* }}} int cna_handle_system_data */
+
+static int cna_setup_system (cfg_system_t *cs) /* {{{ */
+{
+	if (cs == NULL)
+		return (EINVAL);
+
+	if (cs->query != NULL)
+		return (0);
+
+	cs->query = na_elem_new ("perf-object-get-instances");
+	if (cs->query == NULL)
+	{
+		ERROR ("netapp plugin: na_elem_new failed.");
+		return (-1);
+	}
+	na_child_add_string (cs->query, "objectname", "system");
+
+	return (0);
+} /* }}} int cna_setup_system */
+
+static int cna_query_system (host_config_t *host) /* {{{ */
+{
+	na_elem_t *data;
+	int status;
+	time_t now;
+
+	if (host == NULL)
+		return (EINVAL);
+
+	/* If system statistics were not configured, return without doing anything. */
+	if (host->cfg_system == NULL)
+		return (0);
+
+	now = time (NULL);
+	if ((host->cfg_system->interval.interval + host->cfg_system->interval.last_read) > now)
+		return (0);
+
+	status = cna_setup_system (host->cfg_system);
+	if (status != 0)
+		return (status);
+	assert (host->cfg_system->query != NULL);
+
+	data = na_server_invoke_elem(host->srv, host->cfg_system->query);
+	if (na_results_status (data) != NA_OK)
+	{
+		ERROR ("netapp plugin: cna_query_system: na_server_invoke_elem failed: %s",
+				na_results_reason (data));
+		na_elem_free (data);
+		return (-1);
+	}
+
+	status = cna_handle_system_data (host->name, host->cfg_system, data);
+
+	if (status == 0)
+		host->cfg_system->interval.last_read = now;
+
+	na_elem_free (data);
+	return (status);
+} /* }}} int cna_query_system */
 
 /*
  * Configuration handling
@@ -1085,6 +1422,34 @@ static int cna_config_get_multiplier (const oconfig_item_t *ci, /* {{{ */
 	return (0);
 } /* }}} int cna_config_get_multiplier */
 
+/* Handling of the "Interval" option which is allowed in every block. */
+static int cna_config_get_interval (const oconfig_item_t *ci, /* {{{ */
+		cna_interval_t *out_interval)
+{
+	time_t tmp;
+
+	if ((ci == NULL) || (out_interval == NULL))
+		return (EINVAL);
+
+	if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER))
+	{
+		WARNING ("netapp plugin: The `Multiplier' option needs exactly one numeric argument.");
+		return (-1);
+	}
+
+	tmp = (time_t) (ci->values[0].value.number + .5);
+	if (tmp < 1)
+	{
+		WARNING ("netapp plugin: The `Multiplier' option needs a positive integer argument.");
+		return (-1);
+	}
+
+	out_interval->interval = tmp;
+	out_interval->last_read = 0;
+
+	return (0);
+} /* }}} int cna_config_get_interval */
+
 /* Handling of the "GetIO", "GetOps" and "GetLatency" options within a
  * <GetVolumePerfData /> block. */
 static void cna_config_volume_performance_option (host_config_t *host, /* {{{ */
@@ -1134,7 +1499,7 @@ static void cna_config_volume_performance_option (host_config_t *host, /* {{{ */
 	} /* for (i = 0 .. item->values_num) */
 } /* }}} void cna_config_volume_performance_option */
 
-/* Corresponds to a <GetDiskPerfData /> block */
+/* Corresponds to a <GetVolumePerfData /> block */
 static void cna_config_volume_performance(host_config_t *host, const oconfig_item_t *ci) { /* {{{ */
 	int i, had_io = 0, had_ops = 0, had_latency = 0;
 	cfg_service_t *service;
@@ -1238,7 +1603,7 @@ static void cna_config_volume_usage(host_config_t *host, oconfig_item_t *ci) { /
 	service->query = 0;
 	service->handler = collect_volume_data;
 	cfg_volume_data = service->data = malloc(sizeof(*cfg_volume_data));
-	cfg_volume_data->flags = VOLUME_INIT;
+	cfg_volume_data->flags = CFG_VOLUME_USAGE_INIT;
 	service->next = host->services;
 	host->services = service;
 	for (i = 0; i < ci->children_num; ++i) {
@@ -1249,108 +1614,140 @@ static void cna_config_volume_usage(host_config_t *host, oconfig_item_t *ci) { /
 			cna_config_get_multiplier (item, service);
 		} else if (!strcasecmp(item->key, "GetDiskUtil")) {
 			had_df = 1;
-			cna_config_volume_usage_option(host, cfg_volume_data, item, VOLUME_DF);
+			cna_config_volume_usage_option(host, cfg_volume_data, item, CFG_VOLUME_USAGE_DF);
+		} else if (!strcasecmp(item->key, "GetSnapUtil")) {
+			had_df = 1;
+			cna_config_volume_usage_option(host, cfg_volume_data, item, CFG_VOLUME_USAGE_SNAP);
 		}
 	}
 	if (!had_df) {
-		cfg_volume_data->flags |= VOLUME_DF;
-		host_set_all_cfg_volume_usage_flags(host, VOLUME_DF, /* set = */ true);
+		cfg_volume_data->flags |= CFG_VOLUME_USAGE_DF;
+		host_set_all_cfg_volume_usage_flags(host, CFG_VOLUME_USAGE_DF, /* set = */ true);
+	}
+	if (cfg_volume_data->flags & CFG_VOLUME_USAGE_SNAP) {
+		WARNING("netapp plugin: The \"GetSnapUtil\" option does not support the \"+\" wildcard.");
 	}
 } /* }}} void cna_config_volume_usage */
 
-/* Corresponds to a <GetDiskPerfData /> block */
-static void cna_config_disk(host_config_t *temp, oconfig_item_t *ci) { /* {{{ */
-	int i;
-	cfg_service_t *service;
+/* Corresponds to a <Disks /> block */
+static int cna_config_disk(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
 	cfg_disk_t *cfg_disk;
+	int i;
+
+	if ((host == NULL) || (ci == NULL))
+		return (EINVAL);
+
+	if (host->cfg_disk == NULL)
+	{
+		cfg_disk = malloc (sizeof (*cfg_disk));
+		if (cfg_disk == NULL)
+			return (ENOMEM);
+		memset (cfg_disk, 0, sizeof (*cfg_disk));
+
+		/* Set default flags */
+		cfg_disk->flags = CFG_DISK_ALL;
+		cfg_disk->query = NULL;
+		cfg_disk->disks = NULL;
+
+		host->cfg_disk = cfg_disk;
+	}
+	cfg_disk = host->cfg_disk;
 	
-	service = malloc(sizeof(*service));
-	service->query = 0;
-	service->handler = query_submit_disk_data;
-	cfg_disk = service->data = malloc(sizeof(*cfg_disk));
-	cfg_disk->flags = CFG_DISK_ALL;
-	service->next = temp->services;
-	temp->services = service;
 	for (i = 0; i < ci->children_num; ++i) {
 		oconfig_item_t *item = ci->children + i;
 		
 		/* if (!item || !item->key || !*item->key) continue; */
-		if (!strcasecmp(item->key, "Multiplier")) {
-			cna_config_get_multiplier (item, service);
-		} else if (!strcasecmp(item->key, "GetBusy")) {
-			cna_config_bool_to_flag (item, &cfg_disk->flags, CFG_SYSTEM_CPU);
-		}
+		if (strcasecmp(item->key, "Interval") == 0)
+			cna_config_get_interval (item, &cfg_disk->interval);
+		else if (strcasecmp(item->key, "GetBusy") == 0)
+			cna_config_bool_to_flag (item, &cfg_disk->flags, CFG_DISK_BUSIEST);
 	}
-} /* }}} void cna_config_disk */
 
-/* Corresponds to a <GetWaflPerfData /> block */
-static void cna_config_wafl(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
+	return (0);
+} /* }}} int cna_config_disk */
+
+/* Corresponds to a <WAFL /> block */
+static int cna_config_wafl(host_config_t *host, oconfig_item_t *ci) /* {{{ */
+{
+	cfg_wafl_t *cfg_wafl;
 	int i;
-	cfg_service_t *service;
-	data_wafl_t *perf_wafl;
-	
-	service = malloc(sizeof(*service));
-	if (service == NULL)
-		return;
-	memset (service, 0, sizeof (*service));
 
-	service->query = 0;
-	service->handler = query_wafl_data;
-	perf_wafl = service->data = malloc(sizeof(*perf_wafl));
-	perf_wafl->flags = CFG_WAFL_ALL;
+	if ((host == NULL) || (ci == NULL))
+		return (EINVAL);
+
+	if (host->cfg_wafl == NULL)
+	{
+		cfg_wafl = malloc (sizeof (*cfg_wafl));
+		if (cfg_wafl == NULL)
+			return (ENOMEM);
+		memset (cfg_wafl, 0, sizeof (*cfg_wafl));
+
+		/* Set default flags */
+		cfg_wafl->flags = CFG_WAFL_ALL;
+
+		host->cfg_wafl = cfg_wafl;
+	}
+	cfg_wafl = host->cfg_wafl;
 
 	for (i = 0; i < ci->children_num; ++i) {
 		oconfig_item_t *item = ci->children + i;
 		
-		if (!strcasecmp(item->key, "Multiplier")) {
-			cna_config_get_multiplier (item, service);
-		} else if (!strcasecmp(item->key, "GetNameCache")) {
-			cna_config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_NAME_CACHE);
-		} else if (!strcasecmp(item->key, "GetDirCache")) {
-			cna_config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_DIR_CACHE);
-		} else if (!strcasecmp(item->key, "GetBufCache")) {
-			cna_config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_BUF_CACHE);
-		} else if (!strcasecmp(item->key, "GetInodeCache")) {
-			cna_config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_INODE_CACHE);
-		} else {
+		if (strcasecmp(item->key, "Interval") == 0)
+			cna_config_get_interval (item, &cfg_wafl->interval);
+		else if (!strcasecmp(item->key, "GetNameCache"))
+			cna_config_bool_to_flag (item, &cfg_wafl->flags, CFG_WAFL_NAME_CACHE);
+		else if (!strcasecmp(item->key, "GetDirCache"))
+			cna_config_bool_to_flag (item, &cfg_wafl->flags, CFG_WAFL_DIR_CACHE);
+		else if (!strcasecmp(item->key, "GetBufferCache"))
+			cna_config_bool_to_flag (item, &cfg_wafl->flags, CFG_WAFL_BUF_CACHE);
+		else if (!strcasecmp(item->key, "GetInodeCache"))
+			cna_config_bool_to_flag (item, &cfg_wafl->flags, CFG_WAFL_INODE_CACHE);
+		else
 			WARNING ("netapp plugin: The %s config option is not allowed within "
-					"`GetWaflPerfData' blocks.", item->key);
-		}
+					"`WAFL' blocks.", item->key);
 	}
 
-	service->next = host->services;
-	host->services = service;
-} /* }}} void cna_config_wafl */
+	if ((cfg_wafl->flags & CFG_WAFL_ALL) == 0)
+	{
+		NOTICE ("netapp plugin: All WAFL related values have been disabled. "
+				"Collection of WAFL data will be disabled entirely.");
+		free_cfg_wafl (host->cfg_wafl);
+		host->cfg_wafl = NULL;
+	}
+
+	return (0);
+} /* }}} int cna_config_wafl */
 
-/* Corresponds to a <GetSystemPerfData /> block */
+/* Corresponds to a <System /> block */
 static int cna_config_system (host_config_t *host, /* {{{ */
 		oconfig_item_t *ci, const cfg_service_t *default_service)
 {
-	int i;
-	cfg_service_t *service;
 	cfg_system_t *cfg_system;
+	int i;
 	
-	service = malloc(sizeof(*service));
-	if (service == NULL)
-		return (-1);
-	memset (service, 0, sizeof (*service));
-	*service = *default_service;
-	service->handler = collect_perf_system_data;
+	if ((host == NULL) || (ci == NULL))
+		return (EINVAL);
 
-	cfg_system = malloc(sizeof(*cfg_system));
-	if (cfg_system == NULL) {
-		sfree (service);
-		return (-1);
+	if (host->cfg_system == NULL)
+	{
+		cfg_system = malloc (sizeof (*cfg_system));
+		if (cfg_system == NULL)
+			return (ENOMEM);
+		memset (cfg_system, 0, sizeof (*cfg_system));
+
+		/* Set default flags */
+		cfg_system->flags = CFG_SYSTEM_ALL;
+		cfg_system->query = NULL;
+
+		host->cfg_system = cfg_system;
 	}
-	memset (cfg_system, 0, sizeof (*cfg_system));
-	cfg_system->flags = CFG_SYSTEM_ALL;
-	service->data = cfg_system;
+	cfg_system = host->cfg_system;
 
 	for (i = 0; i < ci->children_num; ++i) {
 		oconfig_item_t *item = ci->children + i;
 
-		if (!strcasecmp(item->key, "Multiplier")) {
-			cna_config_get_multiplier (item, service);
+		if (strcasecmp(item->key, "Interval") == 0) {
+			cna_config_get_interval (item, &cfg_system->interval);
 		} else if (!strcasecmp(item->key, "GetCPULoad")) {
 			cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_CPU);
 		} else if (!strcasecmp(item->key, "GetInterfaces")) {
@@ -1361,13 +1758,10 @@ static int cna_config_system (host_config_t *host, /* {{{ */
 			cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_DISK);
 		} else {
 			WARNING ("netapp plugin: The %s config option is not allowed within "
-					"`GetSystemPerfData' blocks.", item->key);
+					"`System' blocks.", item->key);
 		}
 	}
 
-	service->next = host->services;
-	host->services = service;
-
 	return (0);
 } /* }}} int cna_config_system */
 
@@ -1376,7 +1770,7 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */
 		const host_config_t *default_host, const cfg_service_t *def_def_service)
 {
 	oconfig_item_t *item;
-	host_config_t *host, *hc;
+	host_config_t *host;
 	cfg_service_t default_service = *def_def_service;
 	int status;
 	int i;
@@ -1428,11 +1822,11 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */
 			host->interval = item->values[0].value.number;
 		} else if (!strcasecmp(item->key, "GetVolumePerfData")) {
 			cna_config_volume_performance(host, item);
-		} else if (!strcasecmp(item->key, "GetSystemPerfData")) {
+		} else if (!strcasecmp(item->key, "System")) {
 			cna_config_system(host, item, &default_service);
-		} else if (!strcasecmp(item->key, "GetWaflPerfData")) {
+		} else if (!strcasecmp(item->key, "WAFL")) {
 			cna_config_wafl(host, item);
-		} else if (!strcasecmp(item->key, "GetDiskPerfData")) {
+		} else if (!strcasecmp(item->key, "Disks")) {
 			cna_config_disk(host, item);
 		} else if (!strcasecmp(item->key, "GetVolumeData")) {
 			cna_config_volume_usage(host, item);
@@ -1466,9 +1860,6 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */
 		return (NULL);
 	}
 
-	for (hc = global_host_config; hc; hc = hc->next) {
-		if (!strcasecmp(hc->name, host->name)) WARNING("netapp plugin: Duplicate definition of host \"%s\". This is probably a bad idea.", hc->name);
-	}
 	return host;
 } /* }}} host_config_t *cna_config_host */
 
@@ -1488,30 +1879,41 @@ static int cna_init(void) { /* {{{ */
 		return 1;
 	}
 
+	memset (err, 0, sizeof (err));
 	if (!na_startup(err, sizeof(err))) {
+		err[sizeof (err) - 1] = 0;
 		ERROR("netapp plugin: Error initializing netapp API: %s", err);
 		return 1;
 	}
 
 	for (host = global_host_config; host; host = host->next) {
-		host->srv = na_server_open(host->host, 1, 1); 
-		na_server_set_transport_type(host->srv, host->protocol, 0);
+		/* Request version 1.1 of the ONTAP API */
+		host->srv = na_server_open(host->host,
+				/* major version = */ 1, /* minor version = */ 1); 
+		if (host->srv == NULL) {
+			ERROR ("netapp plugin: na_server_open (%s) failed.", host->host);
+			continue;
+		}
+
+		if (host->interval < interval_g)
+			host->interval = interval_g;
+
+		na_server_set_transport_type(host->srv, host->protocol,
+				/* transportarg = */ NULL);
 		na_server_set_port(host->srv, host->port);
 		na_server_style(host->srv, NA_STYLE_LOGIN_PASSWORD);
 		na_server_adminuser(host->srv, host->username, host->password);
-		na_server_set_timeout(host->srv, 5);
+		na_server_set_timeout(host->srv, 5 /* seconds */);
+
 		for (service = host->services; service; service = service->next) {
 			service->interval = host->interval * service->multiplier;
-			if (service->handler == collect_perf_system_data) {
-				service->query = na_elem_new("perf-object-get-instances");
-				na_child_add_string(service->query, "objectname", "system");
-			} else if (service->handler == query_volume_perf_data) {
+
+			if (service->handler == query_volume_perf_data) {
 				service->query = na_elem_new("perf-object-get-instances");
 				na_child_add_string(service->query, "objectname", "volume");
-/*				e = na_elem_new("instances");
-				na_child_add_string(e, "foo", "system");
-				na_child_add(root, e);*/
 				e = na_elem_new("counters");
+				/* "foo" means: This string has to be here but
+				   the content doesn't matter. */
 				na_child_add_string(e, "foo", "read_ops");
 				na_child_add_string(e, "foo", "write_ops");
 				na_child_add_string(e, "foo", "read_data");
@@ -1519,38 +1921,13 @@ static int cna_init(void) { /* {{{ */
 				na_child_add_string(e, "foo", "read_latency");
 				na_child_add_string(e, "foo", "write_latency");
 				na_child_add(service->query, e);
-			} else if (service->handler == query_wafl_data) {
-				service->query = na_elem_new("perf-object-get-instances");
-				na_child_add_string(service->query, "objectname", "wafl");
-/*				e = na_elem_new("instances");
-				na_child_add_string(e, "foo", "system");
-				na_child_add(root, e);*/
-				e = na_elem_new("counters");
-				na_child_add_string(e, "foo", "name_cache_hit");
-				na_child_add_string(e, "foo", "name_cache_miss");
-				na_child_add_string(e, "foo", "find_dir_hit");
-				na_child_add_string(e, "foo", "find_dir_miss");
-				na_child_add_string(e, "foo", "buf_hash_hit");
-				na_child_add_string(e, "foo", "buf_hash_miss");
-				na_child_add_string(e, "foo", "inode_cache_hit");
-				na_child_add_string(e, "foo", "inode_cache_miss");
-				/* na_child_add_string(e, "foo", "inode_eject_time"); */
-				/* na_child_add_string(e, "foo", "buf_eject_time"); */
-				na_child_add(service->query, e);
-			} else if (service->handler == query_submit_disk_data) {
-				service->query = na_elem_new("perf-object-get-instances");
-				na_child_add_string(service->query, "objectname", "disk");
-				e = na_elem_new("counters");
-				na_child_add_string(e, "foo", "disk_busy");
-				na_child_add_string(e, "foo", "base_for_disk_busy");
-				na_child_add(service->query, e);
 			} else if (service->handler == collect_volume_data) {
 				service->query = na_elem_new("volume-list-info");
 				/* na_child_add_string(service->query, "objectname", "volume"); */
 				/* } else if (service->handler == collect_snapshot_data) { */
 				/* service->query = na_elem_new("snapshot-list-info"); */
 			}
-		}
+		} /* for (host->services) */
 	}
 	return 0;
 } /* }}} int cna_init */
@@ -1564,7 +1941,6 @@ static int cna_config (oconfig_item_t *ci) { /* {{{ */
 	for (i = 0; i < ci->children_num; ++i) {
 		item = ci->children + i;
 
-		/* if (!item || !item->key || !*item->key) continue; */
 		if (!strcasecmp(item->key, "Host")) {
 			host_config_t *host;
 			host_config_t *tmp;
@@ -1618,7 +1994,11 @@ static int cna_read(void) { /* {{{ */
 			}
 			service->handler(host, out, service->data);
 			na_elem_free(out);
-		}
+		} /* for (host->services) */
+
+		cna_query_wafl (host);
+		cna_query_disk (host);
+		cna_query_system (host);
 	}
 	return 0;
 } /* }}} int cna_read */