X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fnetapp.c;h=83cfe454ff16410288ad63b9832d957d02e85457;hb=f9238bf523ae35366f4b1a40dc0149b01b7dba8d;hp=eeacfff56c1ebecc40273d9561e015389604bb1f;hpb=c1f2e919c91217ade1b53d3398fa5966a2ca8f5d;p=collectd.git

diff --git a/src/netapp.c b/src/netapp.c
index eeacfff5..83cfe454 100644
--- a/src/netapp.c
+++ b/src/netapp.c
@@ -21,11 +21,12 @@
  * DEALINGS IN THE SOFTWARE.
  *
  * Authors:
- *   Sven Trenkel <sven.trenkel at noris.net>
+ *   Sven Trenkel <collectd at semidefinite.de>  
  **/
 
 #include "collectd.h"
 #include "common.h"
+#include "utils_ignorelist.h"
 
 #include <netapp_api.h>
 
@@ -34,28 +35,24 @@
 typedef struct host_config_s host_config_t;
 typedef void service_handler_t(host_config_t *host, na_elem_t *result, void *data);
 
-/*!
- * \brief Persistent data for system performance counters
- */
-#define CFG_SYSTEM_CPU  0x01
-#define CFG_SYSTEM_NET  0x02
-#define CFG_SYSTEM_OPS  0x04
-#define CFG_SYSTEM_DISK 0x08
-#define CFG_SYSTEM_ALL  0x0F
-typedef struct {
-	uint32_t flags;
-} cfg_system_t;
+struct cna_interval_s
+{
+	time_t interval;
+	time_t last_read;
+};
+typedef struct cna_interval_s cna_interval_t;
 
-/*!
+/*! Data types for WAFL statistics {{{
+ *
  * \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 +75,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,9 +87,41 @@ typedef struct {
 	uint64_t buf_hash_miss;
 	uint64_t inode_cache_hit;
 	uint64_t inode_cache_miss;
-} data_wafl_t;
+} cfg_wafl_t;
+/* }}} cfg_wafl_t */
 
-/*!
+/*! Data types for disk statistics {{{
+ *
+ * \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;
+	time_t timestamp;
+	uint64_t disk_busy;
+	uint64_t base_for_disk_busy;
+	double disk_busy_percent;
+	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;
+/* }}} cfg_disk_t */
+
+/*! Data types for volume performance statistics {{{
+ *
  * \brief Persistent data for volume performance data.
  *
  * The code below uses the difference of the operations and latency counters to
@@ -129,16 +161,62 @@ typedef struct {
 	uint64_t read_latency;
 	uint64_t write_latency;
 } data_volume_perf_t;
+/* }}} data_volume_perf_t */
 
-/*!
+/*! Data types for volume usage statistics {{{
+ *
  * \brief Configuration struct for volume usage data (free / used).
  */
-#define VOLUME_INIT           0x01
-#define VOLUME_DF             0x02
-#define VOLUME_SNAP           0x04
-typedef struct {
+#define CFG_VOLUME_USAGE_DF             0x0002
+#define CFG_VOLUME_USAGE_SNAP           0x0004
+#define CFG_VOLUME_USAGE_ALL            0x0006
+#define HAVE_VOLUME_USAGE_NORM_FREE     0x0010
+#define HAVE_VOLUME_USAGE_NORM_USED     0x0020
+#define HAVE_VOLUME_USAGE_SNAP_RSVD     0x0040
+#define HAVE_VOLUME_USAGE_SNAP_USED     0x0080
+#define HAVE_VOLUME_USAGE_SIS_SAVED     0x0100
+#define HAVE_VOLUME_USAGE_ALL           0x01f0
+struct data_volume_usage_s;
+typedef struct data_volume_usage_s data_volume_usage_t;
+struct data_volume_usage_s {
+	char *name;
 	uint32_t flags;
+
+	uint64_t norm_free;
+	uint64_t norm_used;
+	uint64_t snap_reserved;
+	uint64_t snap_used;
+	uint64_t sis_saved;
+
+	data_volume_usage_t *next;
+};
+
+typedef struct {
+	cna_interval_t interval;
+	na_elem_t *query;
+
+	ignorelist_t *il_capacity;
+	ignorelist_t *il_snapshot;
+
+	data_volume_usage_t *volumes;
 } cfg_volume_usage_t;
+/* }}} cfg_volume_usage_t */
+
+/*! Data types for system statistics {{{
+ *
+ * \brief Persistent data for system performance counters
+ */
+#define CFG_SYSTEM_CPU  0x01
+#define CFG_SYSTEM_NET  0x02
+#define CFG_SYSTEM_OPS  0x04
+#define CFG_SYSTEM_DISK 0x08
+#define CFG_SYSTEM_ALL  0x0F
+typedef struct {
+	uint32_t flags;
+	cna_interval_t interval;
+	na_elem_t *query;
+} cfg_system_t;
+/* }}} cfg_system_t */
 
 typedef struct service_config_s {
 	na_elem_t *query;
@@ -164,37 +242,10 @@ typedef struct service_config_s {
 typedef struct volume_s {
 	char *name;
 	data_volume_perf_t perf_data;
-	cfg_volume_usage_t cfg_volume_usage;
 	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.
- */
-typedef struct disk_s {
-	char *name;
-	uint32_t flags;
-	time_t timestamp;
-	uint64_t disk_busy;
-	uint64_t base_for_disk_busy;
-	double disk_busy_percent;
-	struct disk_s *next;
-} disk_t;
-
 struct host_config_s {
-	na_server_t *srv;
 	char *name;
 	na_server_transport_t protocol;
 	char *host;
@@ -202,17 +253,169 @@ struct host_config_s {
 	char *username;
 	char *password;
 	int interval;
+
+	na_server_t *srv;
 	cfg_service_t *services;
-	disk_t *disks;
+	cfg_wafl_t *cfg_wafl;
+	cfg_disk_t *cfg_disk;
+	cfg_volume_usage_t *cfg_volume_usage;
+	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, NULL, NULL, \
+	NULL}
+
+static host_config_t *global_host_config;
+
+/*
+ * Free functions
+ *
+ * Used to free the various structures above.
+ */
+static void free_volume (volume_t *volume) /* {{{ */
+{
+	volume_t *next;
+
+	if (volume == NULL)
+		return;
+
+	next = volume->next;
+
+	sfree (volume->name);
+	sfree (volume);
+
+	free_volume (next);
+} /* }}} void free_volume */
+
+static void free_disk (disk_t *disk) /* {{{ */
+{
+	disk_t *next;
+
+	if (disk == NULL)
+		return;
+
+	next = disk->next;
+
+	sfree (disk->name);
+	sfree (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;
 
-static host_config_t *host_config;
+	if (cfg_disk->query != NULL)
+		na_elem_free (cfg_disk->query);
 
+	free_disk (cfg_disk->disks);
+	sfree (cfg_disk);
+} /* }}} void free_cfg_disk */
+
+static void free_cfg_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */
+{
+	data_volume_usage_t *data;
+
+	if (cvu == NULL)
+		return;
+
+	/* Free the ignorelists */
+	ignorelist_free (cvu->il_capacity);
+	ignorelist_free (cvu->il_snapshot);
+
+	/* Free the linked list of volumes */
+	data = cvu->volumes;
+	while (data != NULL)
+	{
+		data_volume_usage_t *next = data->next;
+		sfree (data->name);
+		sfree (data);
+		data = next;
+	}
+
+	if (cvu->query != NULL)
+		na_elem_free (cvu->query);
+
+	sfree (cvu);
+} /* }}} void free_cfg_volume_usage */
+
+static void free_cfg_system (cfg_system_t *cs) /* {{{ */
+{
+	if (cs == NULL)
+		return;
+
+	if (cs->query != NULL)
+		na_elem_free (cs->query);
+
+	sfree (cs);
+} /* }}} void free_cfg_system */
+
+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);
+} /* }}} void free_cfg_service */
+
+static void free_host_config (host_config_t *hc) /* {{{ */
+{
+	host_config_t *next;
+
+	if (hc == NULL)
+		return;
+
+	next = hc->next;
+
+	sfree (hc->name);
+	sfree (hc->host);
+	sfree (hc->username);
+	sfree (hc->password);
+
+	free_cfg_service (hc->services);
+	free_cfg_disk (hc->cfg_disk);
+	free_cfg_wafl (hc->cfg_wafl);
+	free_cfg_volume_usage (hc->cfg_volume_usage);
+	free_cfg_system (hc->cfg_system);
+	free_volume (hc->volumes);
+
+	sfree (hc);
+
+	free_host_config (next);
+} /* }}} void free_host_config */
+
+/*
+ * Auxiliary functions
+ *
+ * Used to look up volumes and disks or to handle flags.
+ */
 static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */
-		uint32_t vol_usage_flags, uint32_t vol_perf_flags)
+		uint32_t vol_perf_flags)
 {
 	volume_t *v;
 
@@ -220,8 +423,6 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */
 		return (NULL);
 	
 	/* Make sure the default flags include the init-bit. */
-	if (vol_usage_flags != 0)
-		vol_usage_flags |= VOLUME_INIT;
 	if (vol_perf_flags != 0)
 		vol_perf_flags |= CFG_VOLUME_PERF_INIT;
 
@@ -230,9 +431,6 @@ 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)
-				&& (vol_usage_flags != 0))
-			v->cfg_volume_usage.flags = vol_usage_flags;
 		if (((v->perf_data.flags & CFG_VOLUME_PERF_INIT) == 0)
 				&& (vol_perf_flags != 0))
 			v->perf_data.flags = vol_perf_flags;
@@ -246,7 +444,6 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */
 		return (NULL);
 	memset (v, 0, sizeof (*v));
 
-	v->cfg_volume_usage.flags = vol_usage_flags;
 	v->perf_data.flags = vol_perf_flags;
 
 	v->name = strdup(name);
@@ -261,35 +458,113 @@ 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 data_volume_usage_t *get_volume_usage (cfg_volume_usage_t *cvu, /* {{{ */
+		const char *name)
+{
+	data_volume_usage_t *last;
+	data_volume_usage_t *new;
+
+	int ignore_capacity = 0;
+	int ignore_snapshot = 0;
+
+	if ((cvu == NULL) || (name == NULL))
+		return (NULL);
+
+	last = cvu->volumes;
+	while (last != NULL)
+	{
+		if (strcmp (last->name, name) == 0)
+			return (last);
+
+		if (last->next == NULL)
+			break;
+
+		last = last->next;
+	}
+
+	/* Check the ignorelists. If *both* tell us to ignore a volume, return NULL. */
+	ignore_capacity = ignorelist_match (cvu->il_capacity, name);
+	ignore_snapshot = ignorelist_match (cvu->il_snapshot, name);
+	if ((ignore_capacity != 0) && (ignore_snapshot != 0))
+		return (NULL);
+
+	/* Not found: allocate. */
+	new = malloc (sizeof (*new));
+	if (new == NULL)
+		return (NULL);
+	memset (new, 0, sizeof (*new));
+	new->next = NULL;
+
+	new->name = strdup (name);
+	if (new->name == NULL)
+	{
+		sfree (new);
+		return (NULL);
+	}
+
+	if (ignore_capacity == 0)
+		new->flags |= CFG_VOLUME_USAGE_DF;
+	if (ignore_snapshot == 0)
+		new->flags |= CFG_VOLUME_USAGE_SNAP;
+
+	/* Add to end of list. */
+	if (last == NULL)
+		cvu->volumes = new;
+	else
+		last->next = new;
+
+	return (new);
+} /* }}} data_volume_usage_t *get_volume_usage */
+
+static void host_set_all_perf_data_flags(const host_config_t *host, /* {{{ */
+		uint32_t flag, _Bool set)
+{
+	volume_t *v;
+	
+	for (v = host->volumes; v; v = v->next) {
+		if (set)
+			v->perf_data.flags |= flag;
+		else /* if (!set) */
+			v->perf_data.flags &= ~flag;
+	}
+} /* }}} void host_set_all_perf_data_flags */
+
+/*
+ * Various submit functions.
+ *
+ * They all eventually call "submit_values" which creates a value_list_t and
+ * dispatches it to the daemon.
+ */
 static int submit_values (const char *host, /* {{{ */
 		const char *plugin_inst,
 		const char *type, const char *type_inst,
@@ -366,6 +641,8 @@ static int submit_double (const char *host, const char *plugin_inst, /* {{{ */
 				&v, 1, timestamp));
 } /* }}} int submit_uint64 */
 
+/* Calculate hit ratio from old and new counters and submit the resulting
+ * percentage. Used by "submit_wafl_data". */
 static int submit_cache_ratio (const char *host, /* {{{ */
 		const char *plugin_inst,
 		const char *type_inst,
@@ -393,34 +670,35 @@ static int submit_cache_ratio (const char *host, /* {{{ */
 				&v, 1, timestamp));
 } /* }}} int 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)
+/* Submits all the caches used by WAFL. Uses "submit_cache_ratio". */
+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);
@@ -445,6 +723,8 @@ static int submit_wafl_data (const host_config_t *host, const char *instance, /*
 	return (0);
 } /* }}} int submit_wafl_data */
 
+/* Submits volume performance data to the daemon, taking care to honor and
+ * update flags appropriately. */
 static int submit_volume_perf_data (const host_config_t *host, /* {{{ */
 		volume_t *volume,
 		const data_volume_perf_t *new_data)
@@ -527,27 +807,49 @@ static int submit_volume_perf_data (const host_config_t *host, /* {{{ */
 	return (0);
 } /* }}} int submit_volume_perf_data */
 
-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;
+/* 
+ * Query functions
+ *
+ * These functions are called with appropriate data returned by the libnetapp
+ * interface which is parsed and submitted with the above functions.
+ */
+/* 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;
 
@@ -584,48 +886,151 @@ 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 void query_submit_disk_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */
-	cfg_disk_t *cfg_disk = data;
-	time_t timestamp;
-	na_elem_t *counter, *inst;
-	disk_t *worst_disk = 0;
-	
-	timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0);
-	out = na_elem_child(out, "instances");
+static int cna_setup_wafl (cfg_wafl_t *cw) /* {{{ */
+{
+	na_elem_t *e;
 
-	/* 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)) {
-		disk_t *old_data;
-		disk_t  new_data;
+	if (cw == NULL)
+		return (EINVAL);
 
-		memset (&new_data, 0, sizeof (new_data));
-		new_data.timestamp = timestamp;
-		new_data.disk_busy_percent = NAN;
+	if (cw->query != NULL)
+		return (0);
 
-		old_data = get_disk(host, na_child_get_string(inst, "name"));
-		if (old_data == NULL)
-			continue;
+	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");
 
-		/* 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)) {
-			const char *name;
-			uint64_t value;
+	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");
 
-			name = na_child_get_string(counter, "name");
-			if (name == NULL)
-				continue;
+	na_child_add(cw->query, e);
 
-			value = na_child_get_uint64(counter, "value", UINT64_MAX);
+	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;
+
+	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 *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(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 */
+	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(cfg_disk, na_child_get_string (instance, "name"));
+		if (old_data == NULL)
+			continue;
+
+		/* Look for the "disk_busy" and "base_for_disk_busy" counters */
+		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;
+
+			name = na_child_get_string(counter, "name");
+			if (name == NULL)
+				continue;
+
+			value = na_child_get_uint64(counter, "value", UINT64_MAX);
 			if (value == UINT64_MAX)
 				continue;
 
@@ -639,6 +1044,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,
@@ -677,58 +1088,203 @@ 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 */
 
-static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */
-	na_elem_t *inst;
-	volume_t *volume;
-	cfg_volume_usage_t *cfg_volume_data = data;
+	return (0);
+} /* }}} int cna_handle_disk_data */
 
-	out = na_elem_child(out, "volumes");
-	na_elem_iter_t inst_iter = na_child_iterator(out);
-	for (inst = na_iterator_next(&inst_iter); inst; inst = na_iterator_next(&inst_iter)) {
-		uint64_t size_free = 0, size_used = 0, snap_reserved = 0;
+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 <VolumeUsage /> */
+static int cna_submit_volume_usage_data (const char *hostname, /* {{{ */
+		cfg_volume_usage_t *cfg_volume)
+{
+	data_volume_usage_t *v;
+
+	for (v = cfg_volume->volumes; v != NULL; v = v->next)
+	{
+		if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_FREE))
+			submit_double (hostname, /* plugin instance = */ v->name,
+					"df_complex", "free",
+					(double) v->norm_free, /* timestamp = */ 0);
+
+		if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_USED))
+			submit_double (hostname, /* plugin instance = */ v->name,
+					"df_complex", "used",
+					(double) v->norm_used, /* timestamp = */ 0);
+
+		if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_RSVD))
+			submit_double (hostname, /* plugin instance = */ v->name,
+					"df_complex", "snap_reserved",
+					(double) v->snap_reserved, /* timestamp = */ 0);
+
+		if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_USED))
+			submit_double (hostname, /* plugin instance = */ v->name,
+					"df_complex", "snap_used",
+					(double) v->snap_used, /* timestamp = */ 0);
+
+		if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SIS_SAVED))
+			submit_double (hostname, /* plugin instance = */ v->name,
+					"df_complex", "sis_saved",
+					(double) v->sis_saved, /* timestamp = */ 0);
+
+		/* Clear all the HAVE_* flags */
+		v->flags &= ~HAVE_VOLUME_USAGE_ALL;
+	} /* for (v = cfg_volume->volumes) */
+
+	return (0);
+} /* }}} int cna_submit_volume_usage_data */
+
+static int cna_handle_volume_usage_data (const char *hostname, /* {{{ */
+		cfg_volume_usage_t *cfg_volume, na_elem_t *data)
+{
+	na_elem_t *elem_volume;
+	na_elem_t *elem_volumes;
+	na_elem_iter_t iter_volume;
+
+	elem_volumes = na_elem_child (data, "volumes");
+	if (elem_volumes == NULL)
+	{
+		ERROR ("netapp plugin: cna_handle_volume_usage_data: "
+				"na_elem_child (\"volumes\") failed.");
+		return (-1);
+	}
+
+	iter_volume = na_child_iterator (elem_volumes);
+	for (elem_volume = na_iterator_next (&iter_volume);
+			elem_volume != NULL;
+			elem_volume = na_iterator_next (&iter_volume))
+	{
+		const char *volume_name;
+
+		data_volume_usage_t *v;
+		uint64_t value;
 
 		na_elem_t *sis;
 		const char *sis_state;
 		uint64_t sis_saved_reported;
 		uint64_t sis_saved;
 
-		volume = get_volume(host, na_child_get_string(inst, "name"),
-				cfg_volume_data->flags, /* perf_flags = */ 0);
-		if (volume == NULL)
+		volume_name = na_child_get_string (elem_volume, "name");
+		if (volume_name == NULL)
+			continue;
+
+		/* get_volume_usage may return NULL if the volume is to be ignored. */
+		v = get_volume_usage (cfg_volume, volume_name);
+		if (v == NULL)
 			continue;
 
-		if (!(volume->cfg_volume_usage.flags & VOLUME_DF))
+		if ((v->flags & CFG_VOLUME_USAGE_DF) == 0)
 			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);
-
-		snap_reserved = na_child_get_uint64(inst, "snapshot-blocks-reserved", UINT64_MAX);
-		if (snap_reserved != UINT64_MAX)
+		value = na_child_get_uint64(elem_volume, "size-available", UINT64_MAX);
+		if (value != UINT64_MAX) {
+			v->norm_free = value;
+			v->flags |= HAVE_VOLUME_USAGE_NORM_FREE;
+		}
+
+		value = na_child_get_uint64(elem_volume, "size-used", UINT64_MAX);
+		if (value != UINT64_MAX) {
+			v->norm_used = value;
+			v->flags |= HAVE_VOLUME_USAGE_NORM_USED;
+		}
+
+		value = na_child_get_uint64(elem_volume, "snapshot-blocks-reserved", UINT64_MAX);
+		if (value != UINT64_MAX) {
 			/* 1 block == 1024 bytes  as per API docs */
-			submit_double (host->name, volume->name, "df_complex", "snap_reserved",
-					(double) (1024 * snap_reserved), /* time = */ 0);
+			v->norm_used = 1024 * value;
+			v->flags |= HAVE_VOLUME_USAGE_SNAP_RSVD;
+		}
 
-		sis = na_elem_child(inst, "sis");
+		sis = na_elem_child(elem_volume, "sis");
 		if (sis == NULL)
 			continue;
 
 		sis_state = na_child_get_string(sis, "state");
-		if ((sis_state == NULL)
-				|| (strcmp ("enabled", sis_state) != 0))
+		if (sis_state == NULL)
+			continue;
+
+		/* If SIS is not enabled, set the HAVE_VOLUME_USAGE_SIS_SAVED flag and set
+		 * sis_saved to UINT64_MAX to signal this condition to the submit function. */
+		if (strcmp ("enabled", sis_state) != 0) {
+			v->sis_saved = UINT64_MAX;
+			v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED;
 			continue;
+		}
 
 		sis_saved_reported = na_child_get_uint64(sis, "size-saved", UINT64_MAX);
 		if (sis_saved_reported == UINT64_MAX)
@@ -738,12 +1294,17 @@ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data)
 		if ((sis_saved_reported >> 32) != 0) {
 			/* In case they ever fix this bug. */
 			sis_saved = sis_saved_reported;
-		} else {
+		} else { /* really hacky work-around code. {{{ */
 			uint64_t sis_saved_percent;
 			uint64_t sis_saved_guess;
 			uint64_t overflow_guess;
 			uint64_t guess1, guess2, guess3;
 
+			/* Check if we have v->norm_used. Without it, we cannot calculate
+			 * sis_saved_guess. */
+			if ((v->flags & HAVE_VOLUME_USAGE_NORM_USED) == 0)
+				continue;
+
 			sis_saved_percent = na_child_get_uint64(sis, "percentage-saved", UINT64_MAX);
 			if (sis_saved_percent > 100)
 				continue;
@@ -756,9 +1317,9 @@ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data)
 			 * 400 GBytes. */
 			/* percentage-saved = size-saved / (size-saved + size-used) */
 			if (sis_saved_percent < 100)
-				sis_saved_guess = size_used * sis_saved_percent / (100 - sis_saved_percent);
+				sis_saved_guess = v->norm_used * sis_saved_percent / (100 - sis_saved_percent);
 			else
-				sis_saved_guess = size_used;
+				sis_saved_guess = v->norm_used;
 
 			overflow_guess = sis_saved_guess >> 32;
 			guess1 = overflow_guess ? ((overflow_guess - 1) << 32) + sis_saved_reported : sis_saved_reported;
@@ -776,13 +1337,74 @@ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data)
 				else
 					sis_saved = guess3;
 			}
-		} /* end of 32-bit workaround */
+		} /* }}} end of 32-bit workaround */
+	} /* for (elem_volume) */
+
+	return (cna_submit_volume_usage_data (hostname, cfg_volume));
+} /* }}} int cna_handle_volume_usage_data */
+
+static int cna_setup_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */
+{
+	if (cvu == NULL)
+		return (EINVAL);
 
-		submit_double (host->name, volume->name, "df_complex", "sis_saved",
-				(double) sis_saved, /* time = */ 0);
+	if (cvu->query != NULL)
+		return (0);
+
+	cvu->query = na_elem_new ("volume-list-info");
+	if (cvu->query == NULL)
+	{
+		ERROR ("netapp plugin: na_elem_new failed.");
+		return (-1);
+	}
+
+	/* TODO: cvu->snap_query = na_elem_new("snapshot-list-info"); */
+
+	return (0);
+} /* }}} int cna_setup_volume_usage */
+
+static int cna_query_volume_usage (host_config_t *host) /* {{{ */
+{
+	na_elem_t *data;
+	int status;
+	time_t now;
+
+	if (host == NULL)
+		return (EINVAL);
+
+	/* If the user did not configure volume_usage statistics, return without
+	 * doing anything. */
+	if (host->cfg_volume_usage == NULL)
+		return (0);
+
+	now = time (NULL);
+	if ((host->cfg_volume_usage->interval.interval + host->cfg_volume_usage->interval.last_read) > now)
+		return (0);
+
+	status = cna_setup_volume_usage (host->cfg_volume_usage);
+	if (status != 0)
+		return (status);
+	assert (host->cfg_volume_usage->query != NULL);
+
+	data = na_server_invoke_elem(host->srv, host->cfg_volume_usage->query);
+	if (na_results_status (data) != NA_OK)
+	{
+		ERROR ("netapp plugin: cna_query_volume_usage: na_server_invoke_elem failed: %s",
+				na_results_reason (data));
+		na_elem_free (data);
+		return (-1);
 	}
-} /* }}} void collect_volume_data */
 
+	status = cna_handle_volume_usage_data (host->name, host->cfg_volume_usage, data);
+
+	if (status == 0)
+		host->cfg_volume_usage->interval.last_read = now;
+
+	na_elem_free (data);
+	return (status);
+} /* }}} int cna_query_volume_usage */
+
+/* Data corresponding to <GetVolumePerfData /> */
 static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */
 	cfg_volume_perf_t *cfg_volume_perf = data;
 	time_t timestamp;
@@ -800,7 +1422,7 @@ static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *da
 		perf_data.timestamp = timestamp;
 
 		volume = get_volume(host, na_child_get_string(inst, "name"),
-				/* data_flags = */ 0, cfg_volume_perf->flags);
+				cfg_volume_perf->flags);
 		if (volume == NULL)
 			continue;
 
@@ -842,23 +1464,45 @@ static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *da
 	} /* for (volume) */
 } /* }}} void query_volume_perf_data */
 
-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;
 
@@ -889,111 +1533,100 @@ static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void *
 			cpu_total = (counter_t) value;
 			counter_flags |= 0x20;
 		} else if ((cfg_system->flags & CFG_SYSTEM_OPS)
-				&& (strlen(name) > 4)
+				&& (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 */
 
-static int cna_init(void) { /* {{{ */
-	char err[256];
-	na_elem_t *e;
-	host_config_t *host;
-	cfg_service_t *service;
-	
-	if (!host_config) {
-		WARNING("netapp plugin: Plugin loaded but no hosts defined.");
-		return 1;
-	}
+	return (0);
+} /* }}} int cna_handle_system_data */
 
-	if (!na_startup(err, sizeof(err))) {
-		ERROR("netapp plugin: Error initializing netapp API: %s", err);
-		return 1;
+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");
 
-	for (host = 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);
-		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);
-		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) {
-				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");
-				na_child_add_string(e, "foo", "read_ops");
-				na_child_add_string(e, "foo", "write_ops");
-				na_child_add_string(e, "foo", "read_data");
-				na_child_add_string(e, "foo", "write_data");
-				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"); */
-			}
-		}
+	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);
 	}
-	return 0;
-} /* }}} int cna_init */
 
-static int config_bool_to_flag (const oconfig_item_t *ci, /* {{{ */
+	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
+ */
+/* Sets a given flag if the boolean argument is true and unsets the flag if it
+ * is false. On error, the flag-field is not changed. */
+static int cna_config_bool_to_flag (const oconfig_item_t *ci, /* {{{ */
 		uint32_t *flags, uint32_t flag)
 {
 	if ((ci == NULL) || (flags == NULL))
@@ -1012,9 +1645,10 @@ static int config_bool_to_flag (const oconfig_item_t *ci, /* {{{ */
 		*flags &= ~flag;
 
 	return (0);
-} /* }}} int config_bool_to_flag */
+} /* }}} int cna_config_bool_to_flag */
 
-static int config_get_multiplier (const oconfig_item_t *ci, /* {{{ */
+/* Handling of the "Multiplier" option which is allowed in every block. */
+static int cna_config_get_multiplier (const oconfig_item_t *ci, /* {{{ */
 		cfg_service_t *service)
 {
 	int tmp;
@@ -1039,34 +1673,39 @@ static int config_get_multiplier (const oconfig_item_t *ci, /* {{{ */
 	service->skip_countdown = tmp;
 
 	return (0);
-} /* }}} int config_get_multiplier */
+} /* }}} int cna_config_get_multiplier */
 
-static void set_global_perf_vol_flag(const host_config_t *host, /* {{{ */
-		uint32_t flag, _Bool set)
+/* 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)
 {
-	volume_t *v;
-	
-	for (v = host->volumes; v; v = v->next) {
-		if (set)
-			v->perf_data.flags |= flag;
-		else /* if (!set) */
-			v->perf_data.flags &= ~flag;
+	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);
 	}
-} /* }}} void set_global_perf_vol_flag */
 
-static void set_global_vol_flag(const host_config_t *host, /* {{{ */
-		uint32_t flag, _Bool set) {
-	volume_t *v;
-	
-	for (v = host->volumes; v; v = v->next) {
-		if (set)
-			v->cfg_volume_usage.flags |= flag;
-		else /* if (!set) */
-			v->cfg_volume_usage.flags &= ~flag;
+	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);
 	}
-} /* }}} void set_global_vol_flag */
 
-static void process_perf_volume_flag (host_config_t *host, /* {{{ */
+	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, /* {{{ */
 		cfg_volume_perf_t *perf_volume, const oconfig_item_t *item,
 		uint32_t flag)
 {
@@ -1098,11 +1737,11 @@ static void process_perf_volume_flag (host_config_t *host, /* {{{ */
 			else /* if (!set) */
 				perf_volume->flags &= ~flag;
 
-			set_global_perf_vol_flag(host, flag, set);
+			host_set_all_perf_data_flags(host, flag, set);
 			continue;
 		}
 
-		v = get_volume (host, name, /* data_flags = */ 0, perf_volume->flags);
+		v = get_volume (host, name, perf_volume->flags);
 		if (v == NULL)
 			continue;
 
@@ -1111,58 +1750,10 @@ static void process_perf_volume_flag (host_config_t *host, /* {{{ */
 		else /* if (!set) */
 			v->perf_data.flags &= ~flag;
 	} /* for (i = 0 .. item->values_num) */
-} /* }}} void process_perf_volume_flag */
-
-static void process_volume_flag (host_config_t *host, /* {{{ */
-		cfg_volume_usage_t *cfg_volume_data, const oconfig_item_t *item, uint32_t flag)
-{
-	int i;
-	
-	for (i = 0; i < item->values_num; ++i) {
-		const char *name;
-		volume_t *v;
-		_Bool set = true;
-
-		if (item->values[i].type != OCONFIG_TYPE_STRING) {
-			WARNING("netapp plugin: Ignoring non-string argument in \"GetVolData\""
-					"block for host %s", host->name);
-			continue;
-		}
-
-		name = item->values[i].value.string;
-		if (name[0] == '+') {
-			set = true;
-			++name;
-		} else if (name[0] == '-') {
-			set = false;
-			++name;
-		}
-
-		if (!name[0]) {
-			if (set)
-				cfg_volume_data->flags |= flag;
-			else /* if (!set) */
-				cfg_volume_data->flags &= ~flag;
-
-			set_global_vol_flag(host, flag, set);
-			continue;
-		}
-
-		v = get_volume(host, name, cfg_volume_data->flags, /* perf_flags = */ 0);
-		if (v == NULL)
-			continue;
+} /* }}} void cna_config_volume_performance_option */
 
-		if (!v->cfg_volume_usage.flags)
-			v->cfg_volume_usage.flags = cfg_volume_data->flags;
-
-		if (set)
-			v->cfg_volume_usage.flags |= flag;
-		else /* if (!set) */
-			v->cfg_volume_usage.flags &= ~flag;
-	}
-} /* }}} void process_volume_flag */
-
-static void build_perf_vol_config(host_config_t *host, const oconfig_item_t *ci) { /* {{{ */
+/* 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;
 	cfg_volume_perf_t *perf_volume;
@@ -1179,255 +1770,472 @@ static void build_perf_vol_config(host_config_t *host, const oconfig_item_t *ci)
 		
 		/* if (!item || !item->key || !*item->key) continue; */
 		if (!strcasecmp(item->key, "Multiplier")) {
-			config_get_multiplier (item, service);
+			cna_config_get_multiplier (item, service);
 		} else if (!strcasecmp(item->key, "GetIO")) {
 			had_io = 1;
-			process_perf_volume_flag(host, perf_volume, item, CFG_VOLUME_PERF_IO);
+			cna_config_volume_performance_option(host, perf_volume, item, CFG_VOLUME_PERF_IO);
 		} else if (!strcasecmp(item->key, "GetOps")) {
 			had_ops = 1;
-			process_perf_volume_flag(host, perf_volume, item, CFG_VOLUME_PERF_OPS);
+			cna_config_volume_performance_option(host, perf_volume, item, CFG_VOLUME_PERF_OPS);
 		} else if (!strcasecmp(item->key, "GetLatency")) {
 			had_latency = 1;
-			process_perf_volume_flag(host, perf_volume, item, CFG_VOLUME_PERF_LATENCY);
+			cna_config_volume_performance_option(host, perf_volume, item, CFG_VOLUME_PERF_LATENCY);
 		}
 	}
 	if (!had_io) {
 		perf_volume->flags |= CFG_VOLUME_PERF_IO;
-		set_global_perf_vol_flag(host, CFG_VOLUME_PERF_IO, /* set = */ true);
+		host_set_all_perf_data_flags(host, CFG_VOLUME_PERF_IO, /* set = */ true);
 	}
 	if (!had_ops) {
 		perf_volume->flags |= CFG_VOLUME_PERF_OPS;
-		set_global_perf_vol_flag(host, CFG_VOLUME_PERF_OPS, /* set = */ true);
+		host_set_all_perf_data_flags(host, CFG_VOLUME_PERF_OPS, /* set = */ true);
 	}
 	if (!had_latency) {
 		perf_volume->flags |= CFG_VOLUME_PERF_LATENCY;
-		set_global_perf_vol_flag(host, CFG_VOLUME_PERF_LATENCY, /* set = */ true);
+		host_set_all_perf_data_flags(host, CFG_VOLUME_PERF_LATENCY, /* set = */ true);
 	}
-} /* }}} void build_perf_vol_config */
+} /* }}} void cna_config_volume_performance */
 
-static void build_volume_config(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
-	int i, had_df = 0;
-	cfg_service_t *service;
-	cfg_volume_usage_t *cfg_volume_data;
+/* Handling of the "Capacity" and "Snapshot" options within a <VolumeUsage />
+ * block. */
+static void cna_config_volume_usage_option (cfg_volume_usage_t *cvu, /* {{{ */
+		const oconfig_item_t *ci)
+{
+	char *name;
+	ignorelist_t * il;
+
+	if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING))
+	{
+		WARNING ("netapp plugin: The %s option requires exactly one string argument.",
+				ci->key);
+		return;
+	}
+
+	name = ci->values[0].value.string;
+
+	if (strcasecmp ("Capacity", ci->key) == 0)
+		il = cvu->il_capacity;
+	else if (strcasecmp ("Snapshot", ci->key) == 0)
+		il = cvu->il_snapshot;
+	else
+		return;
+
+	ignorelist_add (il, name);
+} /* }}} void cna_config_volume_usage_option */
+
+/* Handling of the "IgnoreSelectedCapacity" and "IgnoreSelectedSnapshot"
+ * options within a <VolumeUsage /> block. */
+static void cna_config_volume_usage_default (cfg_volume_usage_t *cvu, /* {{{ */
+		const oconfig_item_t *ci)
+{
+	ignorelist_t *il;
+
+	if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN))
+	{
+		WARNING ("netapp plugin: The %s option requires exactly one string argument.",
+				ci->key);
+		return;
+	}
+
+	if (strcasecmp ("IgnoreSelectedCapacity", ci->key) == 0)
+		il = cvu->il_capacity;
+	else if (strcasecmp ("IgnoreSelectedSnapshot", ci->key) == 0)
+		il = cvu->il_snapshot;
+	else
+		return;
+
+	if (ci->values[0].value.boolean)
+		ignorelist_set_invert (il, /* invert = */ 0);
+	else
+		ignorelist_set_invert (il, /* invert = */ 1);
+} /* }}} void cna_config_volume_usage_default */
+
+/* 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 = collect_volume_data;
-	cfg_volume_data = service->data = malloc(sizeof(*cfg_volume_data));
-	cfg_volume_data->flags = VOLUME_INIT;
-	service->next = host->services;
-	host->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")) {
-			config_get_multiplier (item, service);
-		} else if (!strcasecmp(item->key, "GetDiskUtil")) {
-			had_df = 1;
-			process_volume_flag(host, cfg_volume_data, item, VOLUME_DF);
-		}
+		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);
 	}
-	if (!had_df) {
-		cfg_volume_data->flags |= VOLUME_DF;
-		set_global_vol_flag(host, VOLUME_DF, /* set = */ true);
+
+	if ((cfg_disk->flags & CFG_DISK_ALL) == 0)
+	{
+		NOTICE ("netapp plugin: All disk related values have been disabled. "
+				"Collection of per-disk data will be disabled entirely.");
+		free_cfg_disk (host->cfg_disk);
+		host->cfg_disk = NULL;
 	}
-} /* }}} void build_volume_config */
 
-static void build_perf_disk_config(host_config_t *temp, 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;
-	cfg_disk_t *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;
+
+	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 (!item || !item->key || !*item->key) continue; */
-		if (!strcasecmp(item->key, "Multiplier")) {
-			config_get_multiplier (item, service);
-		} else if (!strcasecmp(item->key, "GetBusy")) {
-			config_bool_to_flag (item, &cfg_disk->flags, CFG_SYSTEM_CPU);
-		}
+		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 "
+					"`WAFL' blocks.", item->key);
 	}
-} /* }}} void build_perf_disk_config */
 
-static void build_perf_wafl_config(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
+	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 */
+
+/*
+ * <VolumeUsage>
+ *   Capacity "vol0"
+ *   Capacity "vol1"
+ *   Capacity "vol2"
+ *   Capacity "vol3"
+ *   Capacity "vol4"
+ *   IgnoreSelectedCapacity false
+ *
+ *   Snapshot "vol0"
+ *   Snapshot "vol3"
+ *   Snapshot "vol4"
+ *   Snapshot "vol7"
+ *   IgnoreSelectedSnapshot false
+ * </VolumeUsage>
+ */
+/* Corresponds to a <VolumeUsage /> block */
+static int cna_config_volume_usage(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
+	cfg_volume_usage_t *cfg_volume_usage;
 	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_volume_usage == NULL)
+	{
+		cfg_volume_usage = malloc (sizeof (*cfg_volume_usage));
+		if (cfg_volume_usage == NULL)
+			return (ENOMEM);
+		memset (cfg_volume_usage, 0, sizeof (*cfg_volume_usage));
 
+		/* Set default flags */
+		cfg_volume_usage->query = NULL;
+		cfg_volume_usage->volumes = NULL;
+
+		cfg_volume_usage->il_capacity = ignorelist_create (/* invert = */ 1);
+		if (cfg_volume_usage->il_capacity == NULL)
+		{
+			sfree (cfg_volume_usage);
+			return (ENOMEM);
+		}
+
+		cfg_volume_usage->il_snapshot = ignorelist_create (/* invert = */ 1);
+		if (cfg_volume_usage->il_snapshot == NULL)
+		{
+			ignorelist_free (cfg_volume_usage->il_capacity);
+			sfree (cfg_volume_usage);
+			return (ENOMEM);
+		}
+
+		host->cfg_volume_usage = cfg_volume_usage;
+	}
+	cfg_volume_usage = host->cfg_volume_usage;
+	
 	for (i = 0; i < ci->children_num; ++i) {
 		oconfig_item_t *item = ci->children + i;
 		
-		if (!strcasecmp(item->key, "Multiplier")) {
-			config_get_multiplier (item, service);
-		} else if (!strcasecmp(item->key, "GetNameCache")) {
-			config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_NAME_CACHE);
-		} else if (!strcasecmp(item->key, "GetDirCache")) {
-			config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_DIR_CACHE);
-		} else if (!strcasecmp(item->key, "GetBufCache")) {
-			config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_BUF_CACHE);
-		} else if (!strcasecmp(item->key, "GetInodeCache")) {
-			config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_INODE_CACHE);
-		} else {
-			WARNING ("netapp plugin: The %s config option is not allowed within "
-					"`GetWaflPerfData' blocks.", item->key);
-		}
+		/* if (!item || !item->key || !*item->key) continue; */
+		if (strcasecmp(item->key, "Interval") == 0)
+			cna_config_get_interval (item, &cfg_volume_usage->interval);
+		else if (!strcasecmp(item->key, "Capacity"))
+			cna_config_volume_usage_option (cfg_volume_usage, item);
+		else if (!strcasecmp(item->key, "Snapshot"))
+			cna_config_volume_usage_option (cfg_volume_usage, item);
+		else if (!strcasecmp(item->key, "IgnoreSelectedCapacity"))
+			cna_config_volume_usage_default (cfg_volume_usage, item);
+		else if (!strcasecmp(item->key, "IgnoreSelectedSnapshot"))
+			cna_config_volume_usage_default (cfg_volume_usage, item);
 	}
 
-	service->next = host->services;
-	host->services = service;
-} /* }}} void build_perf_wafl_config */
+	return (0);
+} /* }}} int cna_config_volume_usage */
 
-static int build_perf_sys_config (host_config_t *host, /* {{{ */
+/* 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")) {
-			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")) {
-			config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_CPU);
+			cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_CPU);
 		} else if (!strcasecmp(item->key, "GetInterfaces")) {
-			config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_NET);
+			cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_NET);
 		} else if (!strcasecmp(item->key, "GetDiskOps")) {
-			config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_OPS);
+			cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_OPS);
 		} else if (!strcasecmp(item->key, "GetDiskIO")) {
-			config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_DISK);
+			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;
+	if ((cfg_system->flags & CFG_SYSTEM_ALL) == 0)
+	{
+		NOTICE ("netapp plugin: All system related values have been disabled. "
+				"Collection of system data will be disabled entirely.");
+		free_cfg_system (host->cfg_system);
+		host->cfg_system = NULL;
+	}
 
 	return (0);
-} /* }}} int build_perf_sys_config */
+} /* }}} int cna_config_system */
 
-static host_config_t *build_host_config(const oconfig_item_t *ci, const host_config_t *default_host, const cfg_service_t *def_def_service) { /* {{{ */
-	int i;
+/* Corresponds to a <Host /> block. */
+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, temp = *default_host;
+	host_config_t *host;
 	cfg_service_t default_service = *def_def_service;
+	int status;
+	int i;
 	
 	if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
 		WARNING("netapp plugin: \"Host\" needs exactly one string argument. Ignoring host block.");
 		return 0;
 	}
 
-	temp.name = ci->values[0].value.string;
+	host = malloc(sizeof(*host));
+	memcpy (host, default_host, sizeof (*host));
+
+	status = cf_util_get_string (ci, &host->name);
+	if (status != 0)
+	{
+		sfree (host);
+		return (NULL);
+	}
+
 	for (i = 0; i < ci->children_num; ++i) {
 		item = ci->children + i;
 
-		/* if (!item || !item->key || !*item->key) continue; */
+		status = 0;
+
 		if (!strcasecmp(item->key, "Address")) {
-			if ((item->values_num != 1) || (item->values[0].type != OCONFIG_TYPE_STRING)) {
-				WARNING("netapp plugin: \"Name\" needs exactly one string argument. Ignoring host block \"%s\".", ci->values[0].value.string);
-				return 0;
-			}
-			temp.host = item->values[0].value.string;
+			status = cf_util_get_string (item, &host->host);
 		} else if (!strcasecmp(item->key, "Port")) {
-			if ((item->values_num != 1) || (item->values[0].type != OCONFIG_TYPE_NUMBER) || (item->values[0].value.number != (int) (item->values[0].value.number)) || (item->values[0].value.number < 1) || (item->values[0].value.number > 65535)) {
-				WARNING("netapp plugin: \"Port\" needs exactly one integer argument in the range of 1-65535. Ignoring host block \"%s\".", ci->values[0].value.string);
-				return 0;
-			}
-			temp.port = item->values[0].value.number;
+			int tmp;
+
+			tmp = cf_util_get_port_number (item);
+			if (tmp > 0)
+				host->port = tmp;
 		} else if (!strcasecmp(item->key, "Protocol")) {
 			if ((item->values_num != 1) || (item->values[0].type != OCONFIG_TYPE_STRING) || (strcasecmp(item->values[0].value.string, "http") && strcasecmp(item->values[0].value.string, "https"))) {
 				WARNING("netapp plugin: \"Protocol\" needs to be either \"http\" or \"https\". Ignoring host block \"%s\".", ci->values[0].value.string);
 				return 0;
 			}
-			if (!strcasecmp(item->values[0].value.string, "http")) temp.protocol = NA_SERVER_TRANSPORT_HTTP;
-			else temp.protocol = NA_SERVER_TRANSPORT_HTTPS;
-		} else if (!strcasecmp(item->key, "Login")) {
-			if ((item->values_num != 2) || (item->values[0].type != OCONFIG_TYPE_STRING) || (item->values[1].type != OCONFIG_TYPE_STRING)) {
-				WARNING("netapp plugin: \"Login\" needs exactly two string arguments, username and password. Ignoring host block \"%s\".", ci->values[0].value.string);
-				return 0;
-			}
-			temp.username = item->values[0].value.string;
-			temp.password = item->values[1].value.string;
+			if (!strcasecmp(item->values[0].value.string, "http")) host->protocol = NA_SERVER_TRANSPORT_HTTP;
+			else host->protocol = NA_SERVER_TRANSPORT_HTTPS;
+		} else if (!strcasecmp(item->key, "User")) {
+			status = cf_util_get_string (item, &host->username);
+		} else if (!strcasecmp(item->key, "Password")) {
+			status = cf_util_get_string (item, &host->password);
 		} else if (!strcasecmp(item->key, "Interval")) {
 			if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_NUMBER || item->values[0].value.number != (int) item->values[0].value.number || item->values[0].value.number < 2) {
 				WARNING("netapp plugin: \"Interval\" of host %s needs exactly one integer argument.", ci->values[0].value.string);
 				continue;
 			}
-			temp.interval = item->values[0].value.number;
+			host->interval = item->values[0].value.number;
+		} else if (!strcasecmp(item->key, "WAFL")) {
+			cna_config_wafl(host, item);
+		} else if (!strcasecmp(item->key, "Disks")) {
+			cna_config_disk(host, item);
 		} else if (!strcasecmp(item->key, "GetVolumePerfData")) {
-			build_perf_vol_config(&temp, item);
-		} else if (!strcasecmp(item->key, "GetSystemPerfData")) {
-			build_perf_sys_config(&temp, item, &default_service);
-		} else if (!strcasecmp(item->key, "GetWaflPerfData")) {
-			build_perf_wafl_config(&temp, item);
-		} else if (!strcasecmp(item->key, "GetDiskPerfData")) {
-			build_perf_disk_config(&temp, item);
-		} else if (!strcasecmp(item->key, "GetVolumeData")) {
-			build_volume_config(&temp, item);
+			cna_config_volume_performance(host, item);
+		} else if (!strcasecmp(item->key, "VolumeUsage")) {
+			cna_config_volume_usage(host, item);
+		} else if (!strcasecmp(item->key, "System")) {
+			cna_config_system(host, item, &default_service);
 		} else {
 			WARNING("netapp plugin: Ignoring unknown config option \"%s\" in host block \"%s\".",
 					item->key, ci->values[0].value.string);
 		}
+
+		if (status != 0)
+			break;
 	}
-	
-	if (!temp.host) temp.host = temp.name;
-	if (!temp.port) temp.port = temp.protocol == NA_SERVER_TRANSPORT_HTTP ? 80 : 443;
-	if (!temp.username) {
-		WARNING("netapp plugin: Please supply login information for host \"%s\". Ignoring host block.", temp.name);
-		return 0;
+
+	if (host->host == NULL)
+		host->host = strdup (host->name);
+
+	if (host->host == NULL)
+		status = -1;
+
+	if (host->port <= 0)
+		host->port = (host->protocol == NA_SERVER_TRANSPORT_HTTP) ? 80 : 443;
+
+	if ((host->username == NULL) || (host->password == NULL)) {
+		WARNING("netapp plugin: Please supply login information for host \"%s\". "
+				"Ignoring host block.", host->name);
+		status = -1;
 	}
-	for (hc = host_config; hc; hc = hc->next) {
-		if (!strcasecmp(hc->name, temp.name)) WARNING("netapp plugin: Duplicate definition of host \"%s\". This is probably a bad idea.", hc->name);
+
+	if (status != 0)
+	{
+		free_host_config (host);
+		return (NULL);
 	}
-	host = malloc(sizeof(*host));
-	*host = temp;
-	host->name = strdup(temp.name);
-	host->protocol = temp.protocol;
-	host->host = strdup(temp.host);
-	host->username = strdup(temp.username);
-	host->password = strdup(temp.password);
-	host->next = host_config;
-	host_config = host;
+
 	return host;
-} /* }}} host_config_t *build_host_config */
+} /* }}} host_config_t *cna_config_host */
+
+/*
+ * Callbacks registered with the daemon
+ *
+ * Pretty standard stuff here.
+ */
+static int cna_init(void) { /* {{{ */
+	char err[256];
+	na_elem_t *e;
+	host_config_t *host;
+	cfg_service_t *service;
+	
+	if (!global_host_config) {
+		WARNING("netapp plugin: Plugin loaded but no hosts defined.");
+		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) {
+		/* 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 /* seconds */);
+
+		for (service = host->services; service; service = service->next) {
+			service->interval = host->interval * service->multiplier;
+
+			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("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");
+				na_child_add_string(e, "foo", "write_data");
+				na_child_add_string(e, "foo", "read_latency");
+				na_child_add_string(e, "foo", "write_latency");
+				na_child_add(service->query, e);
+			}
+		} /* for (host->services) */
+	}
+	return 0;
+} /* }}} int cna_init */
 
 static int cna_config (oconfig_item_t *ci) { /* {{{ */
 	int i;
@@ -1438,9 +2246,30 @@ 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")) {
-			build_host_config(item, &default_host, &default_service);
+			host_config_t *host;
+			host_config_t *tmp;
+
+			host = cna_config_host(item, &default_host, &default_service);
+			if (host == NULL)
+				continue;
+
+			for (tmp = global_host_config; tmp != NULL; tmp = tmp->next)
+			{
+				if (strcasecmp (host->name, tmp->name) == 0)
+					WARNING ("netapp plugin: Duplicate definition of host `%s'. "
+							"This is probably a bad idea.",
+							host->name);
+
+				if (tmp->next == NULL)
+					break;
+			}
+
+			host->next = NULL;
+			if (tmp == NULL)
+				global_host_config = host;
+			else
+				tmp->next = host;
 		} else {
 			WARNING("netapp plugin: Ignoring unknown config option \"%s\".", item->key);
 		}
@@ -1453,7 +2282,7 @@ static int cna_read(void) { /* {{{ */
 	host_config_t *host;
 	cfg_service_t *service;
 	
-	for (host = host_config; host; host = host->next) {
+	for (host = global_host_config; host; host = host->next) {
 		for (service = host->services; service; service = service->next) {
 			if (--service->skip_countdown > 0) continue;
 			service->skip_countdown = service->multiplier;
@@ -1470,7 +2299,12 @@ 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_volume_usage (host);
+		cna_query_system (host);
 	}
 	return 0;
 } /* }}} int cna_read */