X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fnetapp.c;h=c532062645b97b2292df079e9fbd2150eb75efa0;hb=d425636110c5fb146d1f6205e2749218f3c31076;hp=e65ec0e6ee78d390e77832fb9d2f8967bfb8650f;hpb=194379810c9113c8eedd79c883ab6e960e5b4162;p=collectd.git

diff --git a/src/netapp.c b/src/netapp.c
index e65ec0e6..c5320626 100644
--- a/src/netapp.c
+++ b/src/netapp.c
@@ -1,6 +1,7 @@
 /**
  * collectd - src/netapp.c
  * Copyright (C) 2009,2010  Sven Trenkel
+ * Copyright (C) 2012-2013  teamix GmbH
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -21,10 +22,12 @@
  * DEALINGS IN THE SOFTWARE.
  *
  * Authors:
- *   Sven Trenkel <collectd at semidefinite.de>  
+ *   Sven Trenkel <collectd at semidefinite.de>
+ *   Sebastian 'tokkee' Harl <sh@teamix.net>
  **/
 
 #include "collectd.h"
+
 #include "common.h"
 #include "utils_ignorelist.h"
 
@@ -181,16 +184,18 @@ typedef struct {
  *
  * \brief Configuration struct for volume usage data (free / used).
  */
-#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
-#define IS_VOLUME_USAGE_OFFLINE         0x0200
+#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_COMPRESS_SAVED 0x0200
+#define HAVE_VOLUME_USAGE_DEDUP_SAVED    0x0400
+#define HAVE_VOLUME_USAGE_ALL            0x07f0
+#define IS_VOLUME_USAGE_OFFLINE          0x0800
 struct data_volume_usage_s;
 typedef struct data_volume_usage_s data_volume_usage_t;
 struct data_volume_usage_s {
@@ -204,6 +209,8 @@ struct data_volume_usage_s {
 	uint64_t snap_reserved;
 	uint64_t snap_used;
 	uint64_t sis_saved;
+	uint64_t compress_saved;
+	uint64_t dedup_saved;
 
 	data_volume_usage_t *next;
 };
@@ -219,6 +226,16 @@ typedef struct {
 } cfg_volume_usage_t;
 /* }}} cfg_volume_usage_t */
 
+/*! Data types for quota statistics {{{
+ *
+ * \brief Persistent data for quota statistics
+ */
+typedef struct {
+	cna_interval_t interval;
+	na_elem_t *query;
+} cfg_quota_t;
+/* }}} cfg_quota_t */
+
 /*! Data types for SnapVault statistics {{{
  *
  * \brief Persistent data for SnapVault(R) statistics
@@ -260,6 +277,7 @@ struct host_config_s {
 	cfg_disk_t *cfg_disk;
 	cfg_volume_perf_t *cfg_volume_perf;
 	cfg_volume_usage_t *cfg_volume_usage;
+	cfg_quota_t *cfg_quota;
 	cfg_snapvault_t *cfg_snapvault;
 	cfg_system_t *cfg_system;
 
@@ -366,6 +384,17 @@ static void free_cfg_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */
 	sfree (cvu);
 } /* }}} void free_cfg_volume_usage */
 
+static void free_cfg_quota (cfg_quota_t *q) /* {{{ */
+{
+	if (q == NULL)
+		return;
+
+	if (q->query != NULL)
+		na_elem_free (q->query);
+
+	sfree (q);
+} /* }}} void free_cfg_quota */
+
 static void free_cfg_snapvault (cfg_snapvault_t *sv) /* {{{ */
 {
 	if (sv == NULL)
@@ -407,6 +436,7 @@ static void free_host_config (host_config_t *hc) /* {{{ */
 	free_cfg_wafl (hc->cfg_wafl);
 	free_cfg_volume_perf (hc->cfg_volume_perf);
 	free_cfg_volume_usage (hc->cfg_volume_usage);
+	free_cfg_quota (hc->cfg_quota);
 	free_cfg_snapvault (hc->cfg_snapvault);
 	free_cfg_system (hc->cfg_system);
 
@@ -435,10 +465,9 @@ static disk_t *get_disk(cfg_disk_t *cd, const char *name) /* {{{ */
 			return d;
 	}
 
-	d = malloc(sizeof(*d));
+	d = calloc (1, sizeof (*d));
 	if (d == NULL)
 		return (NULL);
-	memset (d, 0, sizeof (*d));
 	d->next = NULL;
 
 	d->name = strdup(name);
@@ -484,10 +513,9 @@ static data_volume_usage_t *get_volume_usage (cfg_volume_usage_t *cvu, /* {{{ */
 		return (NULL);
 
 	/* Not found: allocate. */
-	new = malloc (sizeof (*new));
+	new = calloc (1, sizeof (*new));
 	if (new == NULL)
 		return (NULL);
-	memset (new, 0, sizeof (*new));
 	new->next = NULL;
 
 	new->name = strdup (name);
@@ -552,10 +580,9 @@ static data_volume_perf_t *get_volume_perf (cfg_volume_perf_t *cvp, /* {{{ */
 		return (NULL);
 
 	/* Not found: allocate. */
-	new = malloc (sizeof (*new));
+	new = calloc (1, sizeof (*new));
 	if (new == NULL)
 		return (NULL);
-	memset (new, 0, sizeof (*new));
 	new->next = NULL;
 
 	new->name = strdup (name);
@@ -590,7 +617,7 @@ static data_volume_perf_t *get_volume_perf (cfg_volume_perf_t *cvp, /* {{{ */
 static int submit_values (const char *host, /* {{{ */
 		const char *plugin_inst,
 		const char *type, const char *type_inst,
-		value_t *values, int values_len,
+		value_t *values, size_t values_len,
 		cdtime_t timestamp, cdtime_t interval)
 {
 	value_list_t vl = VALUE_LIST_INIT;
@@ -606,8 +633,6 @@ static int submit_values (const char *host, /* {{{ */
 
 	if (host != NULL)
 		sstrncpy (vl.host, host, sizeof (vl.host));
-	else
-		sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 	sstrncpy (vl.plugin, "netapp", sizeof (vl.plugin));
 	if (plugin_inst != NULL)
 		sstrncpy (vl.plugin_instance, plugin_inst, sizeof (vl.plugin_instance));
@@ -622,50 +647,42 @@ static int submit_two_derive (const char *host, const char *plugin_inst, /* {{{
 		const char *type, const char *type_inst, derive_t val0, derive_t val1,
 		cdtime_t timestamp, cdtime_t interval)
 {
-	value_t values[2];
-
-	values[0].derive = val0;
-	values[1].derive = val1;
+	value_t values[] = {
+		{ .derive = val0 },
+		{ .derive = val1 },
+	};
 
 	return (submit_values (host, plugin_inst, type, type_inst,
-				values, 2, timestamp, interval));
+				values, STATIC_ARRAY_SIZE (values), timestamp, interval));
 } /* }}} int submit_two_derive */
 
 static int submit_derive (const char *host, const char *plugin_inst, /* {{{ */
 		const char *type, const char *type_inst, derive_t counter,
 		cdtime_t timestamp, cdtime_t interval)
 {
-	value_t v;
-
-	v.derive = counter;
-
 	return (submit_values (host, plugin_inst, type, type_inst,
-				&v, 1, timestamp, interval));
+				&(value_t) { .derive = counter }, 1, timestamp, interval));
 } /* }}} int submit_derive */
 
 static int submit_two_gauge (const char *host, const char *plugin_inst, /* {{{ */
 		const char *type, const char *type_inst, gauge_t val0, gauge_t val1,
 		cdtime_t timestamp, cdtime_t interval)
 {
-	value_t values[2];
-
-	values[0].gauge = val0;
-	values[1].gauge = val1;
+	value_t values[] = {
+		{ .gauge = val0 },
+		{ .gauge = val1 },
+	};
 
 	return (submit_values (host, plugin_inst, type, type_inst,
-				values, 2, timestamp, interval));
+				values, STATIC_ARRAY_SIZE (values), timestamp, interval));
 } /* }}} int submit_two_gauge */
 
 static int submit_double (const char *host, const char *plugin_inst, /* {{{ */
 		const char *type, const char *type_inst, double d,
 		cdtime_t timestamp, cdtime_t interval)
 {
-	value_t v;
-
-	v.gauge = (gauge_t) d;
-
 	return (submit_values (host, plugin_inst, type, type_inst,
-				&v, 1, timestamp, interval));
+				&(value_t) { .gauge = counter }, 1, timestamp, interval));
 } /* }}} int submit_uint64 */
 
 /* Calculate hit ratio from old and new counters and submit the resulting
@@ -680,7 +697,7 @@ static int submit_cache_ratio (const char *host, /* {{{ */
 		cdtime_t timestamp,
 		cdtime_t interval)
 {
-	value_t v;
+	value_t v = { .gauge = NAN };
 
 	if ((new_hits >= old_hits) && (new_misses >= old_misses)) {
 		uint64_t hits;
@@ -690,8 +707,6 @@ static int submit_cache_ratio (const char *host, /* {{{ */
 		misses = new_misses - old_misses;
 
 		v.gauge = 100.0 * ((gauge_t) hits) / ((gauge_t) (hits + misses));
-	} else {
-		v.gauge = NAN;
 	}
 
 	return (submit_values (host, plugin_inst, "cache_ratio", type_inst,
@@ -700,7 +715,7 @@ static int submit_cache_ratio (const char *host, /* {{{ */
 
 /* 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, int interval)
+		cfg_wafl_t *old_data, const cfg_wafl_t *new_data, cdtime_t interval)
 {
 	/* Submit requested counters */
 	if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_NAME_CACHE | HAVE_WAFL_NAME_CACHE)
@@ -853,7 +868,7 @@ static cdtime_t cna_child_get_cdtime (na_elem_t *data) /* {{{ */
 } /* }}} cdtime_t cna_child_get_cdtime */
 
 
-/* 
+/*
  * Query functions
  *
  * These functions are called with appropriate data returned by the libnetapp
@@ -861,17 +876,14 @@ static cdtime_t cna_child_get_cdtime (na_elem_t *data) /* {{{ */
  */
 /* Data corresponding to <WAFL /> */
 static int cna_handle_wafl_data (const char *hostname, cfg_wafl_t *cfg_wafl, /* {{{ */
-		na_elem_t *data, int interval)
+		na_elem_t *data, cdtime_t interval)
 {
-	cfg_wafl_t perf_data;
+	cfg_wafl_t perf_data = { 0 };
 	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 = cna_child_get_cdtime (data);
 
 	instances = na_elem_child(na_elem_child (data, "instances"), "instance-data");
@@ -894,7 +906,7 @@ static int cna_handle_wafl_data (const char *hostname, cfg_wafl_t *cfg_wafl, /*
 
 	/* Iterate over all counters */
 	counter_iter = na_child_iterator (na_elem_child (instances, "counters"));
-	for (counter = na_iterator_next (&counter_iter);
+	for (na_elem_t *counter = na_iterator_next (&counter_iter);
 			counter != NULL;
 			counter = na_iterator_next (&counter_iter))
 	{
@@ -1014,7 +1026,8 @@ static int cna_query_wafl (host_config_t *host) /* {{{ */
 		return (-1);
 	}
 
-	status = cna_handle_wafl_data (host->name, host->cfg_wafl, data, host->interval);
+	status = cna_handle_wafl_data (host->name, host->cfg_wafl, data,
+			host->cfg_wafl->interval.interval);
 
 	if (status == 0)
 		host->cfg_wafl->interval.last_read = now;
@@ -1029,13 +1042,12 @@ static int cna_handle_disk_data (const char *hostname, /* {{{ */
 {
 	cdtime_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 = cna_child_get_cdtime (data);
 
 	instances = na_elem_child (data, "instances");
@@ -1049,17 +1061,15 @@ static int cna_handle_disk_data (const char *hostname, /* {{{ */
 
 	/* Iterate over all children */
 	instance_iter = na_child_iterator (instances);
-	for (instance = na_iterator_next (&instance_iter);
+	for (na_elem_t *instance = na_iterator_next (&instance_iter);
 			instance != NULL;
 			instance = na_iterator_next(&instance_iter))
 	{
 		disk_t *old_data;
-		disk_t  new_data;
+		disk_t  new_data = { 0 };
 
 		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;
 
@@ -1069,7 +1079,7 @@ static int cna_handle_disk_data (const char *hostname, /* {{{ */
 
 		/* 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);
+		for (na_elem_t *counter = na_iterator_next(&counter_iterator);
 				counter != NULL;
 				counter = na_iterator_next(&counter_iterator))
 		{
@@ -1209,7 +1219,8 @@ static int cna_query_disk (host_config_t *host) /* {{{ */
 		return (-1);
 	}
 
-	status = cna_handle_disk_data (host->name, host->cfg_disk, data, host->interval);
+	status = cna_handle_disk_data (host->name, host->cfg_disk, data,
+			host->cfg_disk->interval.interval);
 
 	if (status == 0)
 		host->cfg_disk->interval.last_read = now;
@@ -1225,8 +1236,7 @@ static int cna_handle_volume_perf_data (const char *hostname, /* {{{ */
 	cdtime_t timestamp;
 	na_elem_t *elem_instances;
 	na_elem_iter_t iter_instances;
-	na_elem_t *elem_instance;
-	
+
 	timestamp = cna_child_get_cdtime (data);
 
 	elem_instances = na_elem_child(data, "instances");
@@ -1239,20 +1249,18 @@ static int cna_handle_volume_perf_data (const char *hostname, /* {{{ */
 	}
 
 	iter_instances = na_child_iterator (elem_instances);
-	for (elem_instance = na_iterator_next(&iter_instances);
+	for (na_elem_t *elem_instance = na_iterator_next(&iter_instances);
 			elem_instance != NULL;
 			elem_instance = na_iterator_next(&iter_instances))
 	{
 		const char *name;
 
-		data_volume_perf_t perf_data;
+		data_volume_perf_t perf_data = { 0 };
 		data_volume_perf_t *v;
 
 		na_elem_t *elem_counters;
 		na_elem_iter_t iter_counters;
-		na_elem_t *elem_counter;
 
-		memset (&perf_data, 0, sizeof (perf_data));
 		perf_data.timestamp = timestamp;
 
 		name = na_child_get_string (elem_instance, "name");
@@ -1269,7 +1277,7 @@ static int cna_handle_volume_perf_data (const char *hostname, /* {{{ */
 			continue;
 
 		iter_counters = na_child_iterator (elem_counters);
-		for (elem_counter = na_iterator_next(&iter_counters);
+		for (na_elem_t *elem_counter = na_iterator_next(&iter_counters);
 				elem_counter != NULL;
 				elem_counter = na_iterator_next(&iter_counters))
 		{
@@ -1380,7 +1388,8 @@ static int cna_query_volume_perf (host_config_t *host) /* {{{ */
 		return (-1);
 	}
 
-	status = cna_handle_volume_perf_data (host->name, host->cfg_volume_perf, data, host->interval);
+	status = cna_handle_volume_perf_data (host->name, host->cfg_volume_perf, data,
+			host->cfg_volume_perf->interval.interval);
 
 	if (status == 0)
 		host->cfg_volume_perf->interval.last_read = now;
@@ -1393,15 +1402,15 @@ static int cna_query_volume_perf (host_config_t *host) /* {{{ */
 static int cna_submit_volume_usage_data (const char *hostname, /* {{{ */
 		cfg_volume_usage_t *cfg_volume, int interval)
 {
-	data_volume_usage_t *v;
-
-	for (v = cfg_volume->volumes; v != NULL; v = v->next)
+	for (data_volume_usage_t *v = cfg_volume->volumes; v != NULL; v = v->next)
 	{
 		char plugin_instance[DATA_MAX_NAME_LEN];
 
 		uint64_t norm_used = v->norm_used;
 		uint64_t norm_free = v->norm_free;
 		uint64_t sis_saved = v->sis_saved;
+		uint64_t compress_saved = v->compress_saved;
+		uint64_t dedup_saved = v->dedup_saved;
 		uint64_t snap_reserve_used = 0;
 		uint64_t snap_reserve_free = v->snap_reserved;
 		uint64_t snap_norm_used = v->snap_used;
@@ -1446,6 +1455,16 @@ static int cna_submit_volume_usage_data (const char *hostname, /* {{{ */
 					"df_complex", "sis_saved",
 					(double) sis_saved, /* timestamp = */ 0, interval);
 
+		if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_COMPRESS_SAVED))
+			submit_double (hostname, /* plugin instance = */ plugin_instance,
+					"df_complex", "compression_saved",
+					(double) compress_saved, /* timestamp = */ 0, interval);
+
+		if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_DEDUP_SAVED))
+			submit_double (hostname, /* plugin instance = */ plugin_instance,
+					"df_complex", "dedup_saved",
+					(double) dedup_saved, /* timestamp = */ 0, interval);
+
 		if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_USED))
 			submit_double (hostname, /* plugin instance = */ plugin_instance,
 					"df_complex", "used",
@@ -1478,9 +1497,8 @@ static int cna_submit_volume_usage_data (const char *hostname, /* {{{ */
 static int cna_change_volume_status (const char *hostname, /* {{{ */
 		data_volume_usage_t *v)
 {
-	notification_t n;
+	notification_t n = { 0 };
 
-	memset (&n, 0, sizeof (&n));
 	n.time = cdtime ();
 	sstrncpy (n.host, hostname, sizeof (n.host));
 	sstrncpy (n.plugin, "netapp", sizeof (n.plugin));
@@ -1505,7 +1523,7 @@ static void cna_handle_volume_snap_usage(const host_config_t *host, /* {{{ */
 		data_volume_usage_t *v)
 {
 	uint64_t snap_used = 0, value;
-	na_elem_t *data, *elem_snap, *elem_snapshots;
+	na_elem_t *data, *elem_snapshots;
 	na_elem_iter_t iter_snap;
 
 	data = na_server_invoke_elem(host->srv, v->snap_query);
@@ -1537,7 +1555,7 @@ static void cna_handle_volume_snap_usage(const host_config_t *host, /* {{{ */
 	}
 
 	iter_snap = na_child_iterator (elem_snapshots);
-	for (elem_snap = na_iterator_next (&iter_snap);
+	for (na_elem_t *elem_snap = na_iterator_next (&iter_snap);
 			elem_snap != NULL;
 			elem_snap = na_iterator_next (&iter_snap))
 	{
@@ -1554,10 +1572,104 @@ static void cna_handle_volume_snap_usage(const host_config_t *host, /* {{{ */
 	v->flags |= HAVE_VOLUME_USAGE_SNAP_USED;
 } /* }}} void cna_handle_volume_snap_usage */
 
+static void cna_handle_volume_sis_data (const host_config_t *host, /* {{{ */
+		data_volume_usage_t *v, na_elem_t *sis)
+{
+	const char *sis_state;
+	uint64_t sis_saved_reported;
+
+	if (na_elem_child(sis, "sis-info"))
+		sis = na_elem_child(sis, "sis-info");
+
+	sis_state = na_child_get_string(sis, "state");
+	if (sis_state == NULL)
+		return;
+
+	/* If SIS is not enabled, there's nothing left to do for this volume. */
+	if (strcmp ("enabled", sis_state) != 0)
+		return;
+
+	sis_saved_reported = na_child_get_uint64(sis, "size-saved", UINT64_MAX);
+	if (sis_saved_reported == UINT64_MAX)
+		return;
+
+	/* size-saved is actually a 32 bit number, so ... time for some guesswork. */
+	if ((sis_saved_reported >> 32) != 0) {
+		/* In case they ever fix this bug. */
+		v->sis_saved = sis_saved_reported;
+		v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED;
+	} 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)
+			return;
+
+		sis_saved_percent = na_child_get_uint64(sis, "percentage-saved", UINT64_MAX);
+		if (sis_saved_percent > 100)
+			return;
+
+		/* The "size-saved" value is a 32bit unsigned integer. This is a bug and
+		 * will hopefully be fixed in later versions. To work around the bug, try
+		 * to figure out how often the 32bit integer wrapped around by using the
+		 * "percentage-saved" value. Because the percentage is in the range
+		 * [0-100], this should work as long as the saved space does not exceed
+		 * 400 GBytes. */
+		/* percentage-saved = size-saved / (size-saved + size-used) */
+		if (sis_saved_percent < 100)
+			sis_saved_guess = v->norm_used * sis_saved_percent / (100 - sis_saved_percent);
+		else
+			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;
+		guess2 = (overflow_guess << 32) + sis_saved_reported;
+		guess3 = ((overflow_guess + 1) << 32) + sis_saved_reported;
+
+		if (sis_saved_guess < guess2) {
+			if ((sis_saved_guess - guess1) < (guess2 - sis_saved_guess))
+				v->sis_saved = guess1;
+			else
+				v->sis_saved = guess2;
+		} else {
+			if ((sis_saved_guess - guess2) < (guess3 - sis_saved_guess))
+				v->sis_saved = guess2;
+			else
+				v->sis_saved = guess3;
+		}
+		v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED;
+	} /* }}} end of 32-bit workaround */
+} /* }}} void cna_handle_volume_sis_data */
+
+/* ONTAP >= 8.1 uses SIS for managing dedup and compression */
+static void cna_handle_volume_sis_saved (const host_config_t *host, /* {{{ */
+		data_volume_usage_t *v, na_elem_t *sis)
+{
+	uint64_t saved;
+
+	if (na_elem_child(sis, "sis-info"))
+		sis = na_elem_child(sis, "sis-info");
+
+	saved = na_child_get_uint64(sis, "compress-saved", UINT64_MAX);
+	if (saved != UINT64_MAX) {
+		v->compress_saved = saved;
+		v->flags |= HAVE_VOLUME_USAGE_COMPRESS_SAVED;
+	}
+
+	saved = na_child_get_uint64(sis, "dedup-saved", UINT64_MAX);
+	if (saved != UINT64_MAX) {
+		v->dedup_saved = saved;
+		v->flags |= HAVE_VOLUME_USAGE_DEDUP_SAVED;
+	}
+} /* }}} void cna_handle_volume_sis_saved */
+
 static int cna_handle_volume_usage_data (const host_config_t *host, /* {{{ */
 		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;
 
@@ -1571,7 +1683,7 @@ static int cna_handle_volume_usage_data (const host_config_t *host, /* {{{ */
 	}
 
 	iter_volume = na_child_iterator (elem_volumes);
-	for (elem_volume = na_iterator_next (&iter_volume);
+	for (na_elem_t *elem_volume = na_iterator_next (&iter_volume);
 			elem_volume != NULL;
 			elem_volume = na_iterator_next (&iter_volume))
 	{
@@ -1581,8 +1693,6 @@ static int cna_handle_volume_usage_data (const host_config_t *host, /* {{{ */
 		uint64_t value;
 
 		na_elem_t *sis;
-		const char *sis_state;
-		uint64_t sis_saved_reported;
 
 		volume_name = na_child_get_string (elem_volume, "name");
 		if (volume_name == NULL)
@@ -1599,7 +1709,7 @@ static int cna_handle_volume_usage_data (const host_config_t *host, /* {{{ */
 
 		if ((v->flags & CFG_VOLUME_USAGE_SNAP) != 0)
 			cna_handle_volume_snap_usage(host, v);
-		
+
 		if ((v->flags & CFG_VOLUME_USAGE_DF) == 0)
 			continue;
 
@@ -1624,77 +1734,14 @@ static int cna_handle_volume_usage_data (const host_config_t *host, /* {{{ */
 		}
 
 		sis = na_elem_child(elem_volume, "sis");
-		if (sis == NULL)
-			continue;
-
-		if (na_elem_child(sis, "sis-info"))
-			sis = na_elem_child(sis, "sis-info");
-		
-		sis_state = na_child_get_string(sis, "state");
-		if (sis_state == NULL)
-			continue;
-
-		/* If SIS is not enabled, there's nothing left to do for this volume. */
-		if (strcmp ("enabled", sis_state) != 0)
-			continue;
-
-		sis_saved_reported = na_child_get_uint64(sis, "size-saved", UINT64_MAX);
-		if (sis_saved_reported == UINT64_MAX)
-			continue;
-
-		/* size-saved is actually a 32 bit number, so ... time for some guesswork. */
-		if ((sis_saved_reported >> 32) != 0) {
-			/* In case they ever fix this bug. */
-			v->sis_saved = sis_saved_reported;
-			v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED;
-		} 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;
-
-			/* The "size-saved" value is a 32bit unsigned integer. This is a bug and
-			 * will hopefully be fixed in later versions. To work around the bug, try
-			 * to figure out how often the 32bit integer wrapped around by using the
-			 * "percentage-saved" value. Because the percentage is in the range
-			 * [0-100], this should work as long as the saved space does not exceed
-			 * 400 GBytes. */
-			/* percentage-saved = size-saved / (size-saved + size-used) */
-			if (sis_saved_percent < 100)
-				sis_saved_guess = v->norm_used * sis_saved_percent / (100 - sis_saved_percent);
-			else
-				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;
-			guess2 = (overflow_guess << 32) + sis_saved_reported;
-			guess3 = ((overflow_guess + 1) << 32) + sis_saved_reported;
-
-			if (sis_saved_guess < guess2) {
-				if ((sis_saved_guess - guess1) < (guess2 - sis_saved_guess))
-					v->sis_saved = guess1;
-				else
-					v->sis_saved = guess2;
-			} else {
-				if ((sis_saved_guess - guess2) < (guess3 - sis_saved_guess))
-					v->sis_saved = guess2;
-				else
-					v->sis_saved = guess3;
-			}
-			v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED;
-		} /* }}} end of 32-bit workaround */
+		if (sis != NULL) {
+			cna_handle_volume_sis_data (host, v, sis);
+			cna_handle_volume_sis_saved (host, v, sis);
+		}
 	} /* for (elem_volume) */
 
-	return (cna_submit_volume_usage_data (host->name, cfg_volume, host->interval));
+	return (cna_submit_volume_usage_data (host->name, cfg_volume,
+				host->cfg_volume_usage->interval.interval));
 } /* }}} int cna_handle_volume_usage_data */
 
 static int cna_setup_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */
@@ -1756,11 +1803,135 @@ static int cna_query_volume_usage (host_config_t *host) /* {{{ */
 	return (status);
 } /* }}} int cna_query_volume_usage */
 
+/* Data corresponding to <Quota /> */
+static int cna_handle_quota_data (const host_config_t *host, /* {{{ */
+		cfg_quota_t *cfg_quota, na_elem_t *data)
+{
+	na_elem_t *elem_quotas;
+	na_elem_iter_t iter_quota;
+
+	elem_quotas = na_elem_child (data, "quotas");
+	if (elem_quotas == NULL)
+	{
+		ERROR ("netapp plugin: cna_handle_quota_data: "
+				"na_elem_child (\"quotas\") failed "
+				"for host %s.", host->name);
+		return (-1);
+	}
+
+	iter_quota = na_child_iterator (elem_quotas);
+	for (na_elem_t *elem_quota = na_iterator_next (&iter_quota);
+			elem_quota != NULL;
+			elem_quota = na_iterator_next (&iter_quota))
+	{
+		const char *quota_type, *volume_name, *tree_name;
+		uint64_t value;
+
+		char plugin_instance[DATA_MAX_NAME_LEN];
+
+		quota_type = na_child_get_string (elem_quota, "quota-type");
+		if (quota_type == NULL)
+			continue;
+
+		/* possible TODO: support other types as well */
+		if (strcmp (quota_type, "tree") != 0)
+			continue;
+
+		tree_name = na_child_get_string (elem_quota, "tree");
+		if ((tree_name == NULL) || (*tree_name == '\0'))
+			continue;
+
+		volume_name = na_child_get_string (elem_quota, "volume");
+		if (volume_name == NULL)
+			continue;
+
+		ssnprintf (plugin_instance, sizeof (plugin_instance),
+				"quota-%s-%s", volume_name, tree_name);
+
+		value = na_child_get_uint64 (elem_quota, "disk-used", UINT64_MAX);
+		if (value != UINT64_MAX) {
+			value *= 1024; /* disk-used reports kilobytes */
+			submit_double (host->name, plugin_instance,
+					/* type = */ "df_complex", /* type instance = */ NULL,
+					(double)value, /* timestamp = */ 0,
+					host->cfg_quota->interval.interval);
+		}
+
+		value = na_child_get_uint64 (elem_quota, "files-used", UINT64_MAX);
+		if (value != UINT64_MAX) {
+			submit_double (host->name, plugin_instance,
+					/* type = */ "files", /* type instance = */ NULL,
+					(double)value, /* timestamp = */ 0,
+					host->cfg_quota->interval.interval);
+		}
+	} /* for (elem_quota) */
+
+	return (0);
+} /* }}} int cna_handle_volume_usage_data */
+
+static int cna_setup_quota (cfg_quota_t *cq) /* {{{ */
+{
+	if (cq == NULL)
+		return (EINVAL);
+
+	if (cq->query != NULL)
+		return (0);
+
+	cq->query = na_elem_new ("quota-report");
+	if (cq->query == NULL)
+	{
+		ERROR ("netapp plugin: na_elem_new failed.");
+		return (-1);
+	}
+
+	return (0);
+} /* }}} int cna_setup_quota */
+
+static int cna_query_quota (host_config_t *host) /* {{{ */
+{
+	na_elem_t *data;
+	int status;
+	cdtime_t now;
+
+	if (host == NULL)
+		return (EINVAL);
+
+	/* If the user did not configure quota statistics, return without
+	 * doing anything. */
+	if (host->cfg_quota == NULL)
+		return (0);
+
+	now = cdtime ();
+	if ((host->cfg_quota->interval.interval + host->cfg_quota->interval.last_read) > now)
+		return (0);
+
+	status = cna_setup_quota (host->cfg_quota);
+	if (status != 0)
+		return (status);
+	assert (host->cfg_quota->query != NULL);
+
+	data = na_server_invoke_elem (host->srv, host->cfg_quota->query);
+	if (na_results_status (data) != NA_OK)
+	{
+		ERROR ("netapp plugin: cna_query_quota: na_server_invoke_elem failed for host %s: %s",
+				host->name, na_results_reason (data));
+		na_elem_free (data);
+		return (-1);
+	}
+
+	status = cna_handle_quota_data (host, host->cfg_quota, data);
+
+	if (status == 0)
+		host->cfg_quota->interval.last_read = now;
+
+	na_elem_free (data);
+	return (status);
+} /* }}} int cna_query_quota */
+
 /* Data corresponding to <SnapVault /> */
 static int cna_handle_snapvault_data (const char *hostname, /* {{{ */
 		cfg_snapvault_t *cfg_snapvault, na_elem_t *data, cdtime_t interval)
 {
-	na_elem_t *status;
 	na_elem_iter_t status_iter;
 
 	status = na_elem_child (data, "status-list");
@@ -1770,7 +1941,7 @@ static int cna_handle_snapvault_data (const char *hostname, /* {{{ */
 	}
 
 	status_iter = na_child_iterator (status);
-	for (status = na_iterator_next (&status_iter);
+	for (na_elem_t *status = na_iterator_next (&status_iter);
 			status != NULL;
 			status = na_iterator_next (&status_iter))
 	{
@@ -1820,7 +1991,6 @@ static int cna_handle_snapvault_iter (host_config_t *host, /* {{{ */
 	const char *tag;
 
 	uint32_t records_count;
-	uint32_t i;
 
 	records_count = na_child_get_uint32 (data, "records", UINT32_MAX);
 	if (records_count == UINT32_MAX)
@@ -1832,7 +2002,7 @@ static int cna_handle_snapvault_iter (host_config_t *host, /* {{{ */
 
 	DEBUG ("netapp plugin: Iterating %u SV records (tag = %s)", records_count, tag);
 
-	for (i = 0; i < records_count; ++i) {
+	for (uint32_t i = 0; i < records_count; ++i) {
 		na_elem_t *elem;
 
 		elem = na_server_invoke (host->srv,
@@ -1848,7 +2018,8 @@ static int cna_handle_snapvault_iter (host_config_t *host, /* {{{ */
 			return (-1);
 		}
 
-		cna_handle_snapvault_data (host->name, host->cfg_snapvault, elem, host->interval);
+		cna_handle_snapvault_data (host->name, host->cfg_snapvault, elem,
+				host->cfg_snapvault->interval.interval);
 		na_elem_free (elem);
 	}
 
@@ -1920,7 +2091,6 @@ static int cna_handle_system_data (const char *hostname, /* {{{ */
 		cfg_system_t *cfg_system, na_elem_t *data, int interval)
 {
 	na_elem_t *instances;
-	na_elem_t *counter;
 	na_elem_iter_t counter_iter;
 
 	derive_t disk_read = 0, disk_written = 0;
@@ -1930,7 +2100,7 @@ static int cna_handle_system_data (const char *hostname, /* {{{ */
 
 	const char *instance;
 	cdtime_t timestamp;
-	
+
 	timestamp = cna_child_get_cdtime (data);
 
 	instances = na_elem_child(na_elem_child (data, "instances"), "instance-data");
@@ -1952,7 +2122,7 @@ static int cna_handle_system_data (const char *hostname, /* {{{ */
 	}
 
 	counter_iter = na_child_iterator (na_elem_child (instances, "counters"));
-	for (counter = na_iterator_next (&counter_iter);
+	for (na_elem_t *counter = na_iterator_next (&counter_iter);
 			counter != NULL;
 			counter = na_iterator_next (&counter_iter))
 	{
@@ -1997,7 +2167,7 @@ static int cna_handle_system_data (const char *hostname, /* {{{ */
 			&& (HAS_ALL_FLAGS (counter_flags, 0x01 | 0x02)))
 		submit_two_derive (hostname, instance, "disk_octets", NULL,
 				disk_read, disk_written, timestamp, interval);
-				
+
 	if ((cfg_system->flags & CFG_SYSTEM_NET)
 			&& (HAS_ALL_FLAGS (counter_flags, 0x04 | 0x08)))
 		submit_two_derive (hostname, instance, "if_octets", NULL,
@@ -2065,7 +2235,8 @@ static int cna_query_system (host_config_t *host) /* {{{ */
 		return (-1);
 	}
 
-	status = cna_handle_system_data (host->name, host->cfg_system, data, host->interval);
+	status = cna_handle_system_data (host->name, host->cfg_system, data,
+			host->cfg_system->interval.interval);
 
 	if (status == 0)
 		host->cfg_system->interval.last_read = now;
@@ -2196,17 +2367,15 @@ static int cna_config_volume_performance (host_config_t *host, /* {{{ */
 		const oconfig_item_t *ci)
 {
 	cfg_volume_perf_t *cfg_volume_perf;
-	int i;
 
 	if ((host == NULL) || (ci == NULL))
 		return (EINVAL);
 
 	if (host->cfg_volume_perf == NULL)
 	{
-		cfg_volume_perf = malloc (sizeof (*cfg_volume_perf));
+		cfg_volume_perf = calloc (1, sizeof (*cfg_volume_perf));
 		if (cfg_volume_perf == NULL)
 			return (ENOMEM);
-		memset (cfg_volume_perf, 0, sizeof (*cfg_volume_perf));
 
 		/* Set default flags */
 		cfg_volume_perf->query = NULL;
@@ -2239,10 +2408,10 @@ static int cna_config_volume_performance (host_config_t *host, /* {{{ */
 		host->cfg_volume_perf = cfg_volume_perf;
 	}
 	cfg_volume_perf = host->cfg_volume_perf;
-	
-	for (i = 0; i < ci->children_num; ++i) {
+
+	for (int 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, "Interval") == 0)
 			cna_config_get_interval (item, &cfg_volume_perf->interval);
@@ -2320,20 +2489,50 @@ static void cna_config_volume_usage_default (cfg_volume_usage_t *cvu, /* {{{ */
 		ignorelist_set_invert (il, /* invert = */ 1);
 } /* }}} void cna_config_volume_usage_default */
 
+/* Corresponds to a <Quota /> block */
+static int cna_config_quota (host_config_t *host, oconfig_item_t *ci) /* {{{ */
+{
+	cfg_quota_t *cfg_quota;
+
+	if ((host == NULL) || (ci == NULL))
+		return (EINVAL);
+
+	if (host->cfg_quota == NULL)
+	{
+		cfg_quota = calloc (1, sizeof (*cfg_quota));
+		if (cfg_quota == NULL)
+			return (ENOMEM);
+		cfg_quota->query = NULL;
+
+		host->cfg_quota = cfg_quota;
+	}
+	cfg_quota = host->cfg_quota;
+
+	for (int i = 0; i < ci->children_num; ++i) {
+		oconfig_item_t *item = ci->children + i;
+
+		if (strcasecmp (item->key, "Interval") == 0)
+			cna_config_get_interval (item, &cfg_quota->interval);
+		else
+			WARNING ("netapp plugin: The option %s is not allowed within "
+					"`Quota' blocks.", item->key);
+	}
+
+	return (0);
+} /* }}} int cna_config_quota */
+
 /* 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));
+		cfg_disk = calloc (1, 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;
@@ -2343,10 +2542,10 @@ static int cna_config_disk(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
 		host->cfg_disk = cfg_disk;
 	}
 	cfg_disk = host->cfg_disk;
-	
-	for (i = 0; i < ci->children_num; ++i) {
+
+	for (int 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, "Interval") == 0)
 			cna_config_get_interval (item, &cfg_disk->interval);
@@ -2369,17 +2568,15 @@ static int cna_config_disk(host_config_t *host, oconfig_item_t *ci) { /* {{{ */
 static int cna_config_wafl(host_config_t *host, oconfig_item_t *ci) /* {{{ */
 {
 	cfg_wafl_t *cfg_wafl;
-	int i;
 
 	if ((host == NULL) || (ci == NULL))
 		return (EINVAL);
 
 	if (host->cfg_wafl == NULL)
 	{
-		cfg_wafl = malloc (sizeof (*cfg_wafl));
+		cfg_wafl = calloc (1, 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;
@@ -2388,9 +2585,9 @@ static int cna_config_wafl(host_config_t *host, oconfig_item_t *ci) /* {{{ */
 	}
 	cfg_wafl = host->cfg_wafl;
 
-	for (i = 0; i < ci->children_num; ++i) {
+	for (int i = 0; i < ci->children_num; ++i) {
 		oconfig_item_t *item = ci->children + i;
-		
+
 		if (strcasecmp(item->key, "Interval") == 0)
 			cna_config_get_interval (item, &cfg_wafl->interval);
 		else if (!strcasecmp(item->key, "GetNameCache"))
@@ -2438,17 +2635,15 @@ static int cna_config_volume_usage(host_config_t *host, /* {{{ */
 		const oconfig_item_t *ci)
 {
 	cfg_volume_usage_t *cfg_volume_usage;
-	int i;
 
 	if ((host == NULL) || (ci == NULL))
 		return (EINVAL);
 
 	if (host->cfg_volume_usage == NULL)
 	{
-		cfg_volume_usage = malloc (sizeof (*cfg_volume_usage));
+		cfg_volume_usage = calloc (1, 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;
@@ -2472,10 +2667,10 @@ static int cna_config_volume_usage(host_config_t *host, /* {{{ */
 		host->cfg_volume_usage = cfg_volume_usage;
 	}
 	cfg_volume_usage = host->cfg_volume_usage;
-	
-	for (i = 0; i < ci->children_num; ++i) {
+
+	for (int 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, "Interval") == 0)
 			cna_config_get_interval (item, &cfg_volume_usage->interval);
@@ -2500,17 +2695,15 @@ static int cna_config_snapvault (host_config_t *host, /* {{{ */
 		const oconfig_item_t *ci)
 {
 	cfg_snapvault_t *cfg_snapvault;
-	int i;
 
 	if ((host == NULL) || (ci == NULL))
 		return EINVAL;
 
 	if (host->cfg_snapvault == NULL)
 	{
-		cfg_snapvault = malloc (sizeof (*cfg_snapvault));
+		cfg_snapvault = calloc (1, sizeof (*cfg_snapvault));
 		if (cfg_snapvault == NULL)
 			return ENOMEM;
-		memset (cfg_snapvault, 0, sizeof (*cfg_snapvault));
 		cfg_snapvault->query = NULL;
 
 		host->cfg_snapvault = cfg_snapvault;
@@ -2518,7 +2711,7 @@ static int cna_config_snapvault (host_config_t *host, /* {{{ */
 
 	cfg_snapvault = host->cfg_snapvault;
 
-	for (i = 0; i < ci->children_num; ++i) {
+	for (int i = 0; i < ci->children_num; ++i) {
 		oconfig_item_t *item = ci->children + i;
 
 		if (strcasecmp (item->key, "Interval") == 0)
@@ -2536,17 +2729,15 @@ static int cna_config_system (host_config_t *host, /* {{{ */
 		oconfig_item_t *ci)
 {
 	cfg_system_t *cfg_system;
-	int i;
-	
+
 	if ((host == NULL) || (ci == NULL))
 		return (EINVAL);
 
 	if (host->cfg_system == NULL)
 	{
-		cfg_system = malloc (sizeof (*cfg_system));
+		cfg_system = calloc (1, 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;
@@ -2556,7 +2747,7 @@ static int cna_config_system (host_config_t *host, /* {{{ */
 	}
 	cfg_system = host->cfg_system;
 
-	for (i = 0; i < ci->children_num; ++i) {
+	for (int i = 0; i < ci->children_num; ++i) {
 		oconfig_item_t *item = ci->children + i;
 
 		if (strcasecmp(item->key, "Interval") == 0) {
@@ -2591,10 +2782,9 @@ static host_config_t *cna_alloc_host (void) /* {{{ */
 {
 	host_config_t *host;
 
-	host = malloc(sizeof(*host));
-	if (! host)
+	host = calloc (1, sizeof (*host));
+	if (host == NULL)
 		return (NULL);
-	memset (host, 0, sizeof (*host));
 
 	host->name = NULL;
 	host->protocol = NA_SERVER_TRANSPORT_HTTPS;
@@ -2607,6 +2797,7 @@ static host_config_t *cna_alloc_host (void) /* {{{ */
 	host->cfg_disk = NULL;
 	host->cfg_volume_perf = NULL;
 	host->cfg_volume_usage = NULL;
+	host->cfg_quota = NULL;
 	host->cfg_snapvault = NULL;
 	host->cfg_system = NULL;
 
@@ -2669,8 +2860,6 @@ static int cna_read (user_data_t *ud);
 static int cna_register_host (host_config_t *host) /* {{{ */
 {
 	char cb_name[256];
-	struct timespec interval;
-	user_data_t ud;
 
 	if (host->vfiler)
 		ssnprintf (cb_name, sizeof (cb_name), "netapp-%s-%s",
@@ -2678,16 +2867,13 @@ static int cna_register_host (host_config_t *host) /* {{{ */
 	else
 		ssnprintf (cb_name, sizeof (cb_name), "netapp-%s", host->name);
 
-	CDTIME_T_TO_TIMESPEC (host->interval, &interval);
-
-	memset (&ud, 0, sizeof (ud));
-	ud.data = host;
-	ud.free_func = (void (*) (void *)) free_host_config;
-
 	plugin_register_complex_read (/* group = */ NULL, cb_name,
 			/* callback  = */ cna_read,
-			/* interval  = */ (host->interval > 0) ? &interval : NULL,
-			/* user data = */ &ud);
+			/* interval  = */ host->interval,
+			&(user_data_t) {
+				.data = host,
+				.free_func = (void *) free_host_config,
+			});
 
 	return (0);
 } /* }}} int cna_register_host */
@@ -2698,7 +2884,6 @@ static int cna_config_host (host_config_t *host, /* {{{ */
 	oconfig_item_t *item;
 	_Bool is_vfiler = 0;
 	int status;
-	int i;
 
 	if (! strcasecmp (ci->key, "VFiler"))
 		is_vfiler = 1;
@@ -2712,7 +2897,7 @@ static int cna_config_host (host_config_t *host, /* {{{ */
 	if (status != 0)
 		return (1);
 
-	for (i = 0; i < ci->children_num; ++i) {
+	for (int i = 0; i < ci->children_num; ++i) {
 		item = ci->children + i;
 
 		status = 0;
@@ -2746,6 +2931,8 @@ static int cna_config_host (host_config_t *host, /* {{{ */
 			cna_config_volume_performance(host, item);
 		} else if (!strcasecmp(item->key, "VolumeUsage")) {
 			cna_config_volume_usage(host, item);
+		} else if (!strcasecmp(item->key, "Quota")) {
+			cna_config_quota(host, item);
 		} else if (!strcasecmp(item->key, "SnapVault")) {
 			cna_config_snapvault(host, item);
 		} else if (!strcasecmp(item->key, "System")) {
@@ -2849,9 +3036,8 @@ static int cna_init_host (host_config_t *host) /* {{{ */
 
 static int cna_init (void) /* {{{ */
 {
-	char err[256];
+	char err[256] = { 0 };
 
-	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);
@@ -2880,6 +3066,10 @@ static int cna_read_internal (host_config_t *host) { /* {{{ */
 	if (status != 0)
 		return (status);
 
+	status = cna_query_quota (host);
+	if (status != 0)
+		return (status);
+
 	status = cna_query_snapvault (host);
 	if (status != 0)
 		return (status);
@@ -2916,10 +3106,9 @@ static int cna_read (user_data_t *ud) { /* {{{ */
 } /* }}} int cna_read */
 
 static int cna_config (oconfig_item_t *ci) { /* {{{ */
-	int i;
 	oconfig_item_t *item;
 
-	for (i = 0; i < ci->children_num; ++i) {
+	for (int i = 0; i < ci->children_num; ++i) {
 		item = ci->children + i;
 
 		if (strcasecmp(item->key, "Host") == 0)