X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fswap.c;h=a8276c7dd4267a0887a07a7547451a0a6eb76bf6;hb=f2daf5deea1d50dbb834cffa0c8106b5456c9d82;hp=30daa4b118329f7556d0d578a9ec0d0369dfc787;hpb=9e7b3a035836474cb4af253b248de30d5eb97f4d;p=collectd.git

diff --git a/src/swap.c b/src/swap.c
index 30daa4b1..a8276c7d 100644
--- a/src/swap.c
+++ b/src/swap.c
@@ -1,6 +1,6 @@
 /**
  * collectd - src/swap.c
- * Copyright (C) 2005-2010  Florian octo Forster
+ * Copyright (C) 2005-2014  Florian octo Forster
  * Copyright (C) 2009       Stefan Völkel
  * Copyright (C) 2009       Manuel Sanmartin
  * Copyright (C) 2010       Aurélien Reynaud
@@ -70,18 +70,15 @@
 #define MAX(x,y) ((x) > (y) ? (x) : (y))
 
 #if KERNEL_LINUX
-/* No global variables */
+# define SWAP_HAVE_REPORT_BY_DEVICE 1
+static derive_t pagesize;
+static _Bool report_bytes = 0;
+static _Bool report_by_device = 0;
 /* #endif KERNEL_LINUX */
 
 #elif HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS
+# define SWAP_HAVE_REPORT_BY_DEVICE 1
 static derive_t pagesize;
-
-static const char *config_keys[] =
-{
-	"ReportByDevice"
-};
-static int config_keys_num = STATIC_ARRAY_SIZE (config_keys);
-
 static _Bool report_by_device = 0;
 /* #endif HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS */
 
@@ -100,17 +97,54 @@ int kvm_pagesize;
 
 #elif HAVE_PERFSTAT
 static int pagesize;
-static perfstat_memory_total_t pmemory;
 /*# endif HAVE_PERFSTAT */
 
 #else
 # error "No applicable input method."
 #endif /* HAVE_LIBSTATGRAB */
 
-static int swap_init (void)
+static _Bool values_absolute = 1;
+static _Bool values_percentage = 0;
+
+static int swap_config (oconfig_item_t *ci) /* {{{ */
 {
+	int i;
+
+	for (i = 0; i < ci->children_num; i++)
+	{
+		oconfig_item_t *child = ci->children + i;
+		if (strcasecmp ("ReportBytes", child->key) == 0)
 #if KERNEL_LINUX
-	/* No init stuff */
+			cf_util_get_boolean (child, &report_bytes);
+#else
+			WARNING ("swap plugin: The \"ReportBytes\" option "
+					"is only valid under Linux. "
+					"The option is going to be ignored.");
+#endif
+		else if (strcasecmp ("ReportByDevice", child->key) == 0)
+#if SWAP_HAVE_REPORT_BY_DEVICE
+			cf_util_get_boolean (child, &report_by_device);
+#else
+			WARNING ("swap plugin: The \"ReportByDevice\" option "
+					"is not supported on this platform. "
+					"The option is going to be ignored.");
+#endif /* SWAP_HAVE_REPORT_BY_DEVICE */
+		else if (strcasecmp ("ValuesAbsolute", child->key) == 0)
+			cf_util_get_boolean (child, &values_absolute);
+		else if (strcasecmp ("ValuesPercentage", child->key) == 0)
+			cf_util_get_boolean (child, &values_percentage);
+		else
+			WARNING ("swap plugin: Unknown config option: \"%s\"",
+					child->key);
+	}
+
+	return (0);
+} /* }}} int swap_config */
+
+static int swap_init (void) /* {{{ */
+{
+#if KERNEL_LINUX
+	pagesize = (derive_t) sysconf (_SC_PAGESIZE);
 /* #endif KERNEL_LINUX */
 
 #elif HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS
@@ -123,6 +157,8 @@ static int swap_init (void)
 /* #endif defined(VM_SWAPUSAGE) */
 
 #elif HAVE_LIBKVM_GETSWAPINFO
+	char errbuf[_POSIX2_LINE_MAX];
+
 	if (kvm_obj != NULL)
 	{
 		kvm_close (kvm_obj);
@@ -131,14 +167,11 @@ static int swap_init (void)
 
 	kvm_pagesize = getpagesize ();
 
-	if ((kvm_obj = kvm_open (NULL, /* execfile */
-					NULL, /* corefile */
-					NULL, /* swapfile */
-					O_RDONLY, /* flags */
-					NULL)) /* errstr */
-			== NULL)
+	kvm_obj = kvm_openfiles (NULL, "/dev/null", NULL, O_RDONLY, errbuf);
+
+	if (kvm_obj == NULL)
 	{
-		ERROR ("swap plugin: kvm_open failed.");
+		ERROR ("swap plugin: kvm_openfiles failed, %s", errbuf);
 		return (-1);
 	}
 /* #endif HAVE_LIBKVM_GETSWAPINFO */
@@ -152,102 +185,183 @@ static int swap_init (void)
 #endif /* HAVE_PERFSTAT */
 
 	return (0);
-}
+} /* }}} int swap_init */
 
-static void swap_submit_inst (const char *plugin_instance, /* {{{ */
-		const char *type_instance, derive_t value, unsigned type)
+static void swap_submit_usage (char const *plugin_instance, /* {{{ */
+		gauge_t used, gauge_t free,
+		char const *other_name, gauge_t other_value)
 {
-	value_t values[1];
+	value_t v[1];
 	value_list_t vl = VALUE_LIST_INIT;
 
-	switch (type)
-	{
-		case DS_TYPE_GAUGE:
-			values[0].gauge = (gauge_t) value;
-			sstrncpy (vl.type, "swap", sizeof (vl.type));
-			break;
-		case DS_TYPE_DERIVE:
-			values[0].derive = value;
-			sstrncpy (vl.type, "swap_io", sizeof (vl.type));
-			break;
-		default:
-			ERROR ("swap plugin: swap_submit called with wrong"
-				" type");
-	}
-
-	vl.values = values;
-	vl.values_len = 1;
+	vl.values = v;
+	vl.values_len = STATIC_ARRAY_SIZE (v);
 	sstrncpy (vl.host, hostname_g, sizeof (vl.host));
 	sstrncpy (vl.plugin, "swap", sizeof (vl.plugin));
 	if (plugin_instance != NULL)
-		sstrncpy (vl.plugin_instance, plugin_instance, sizeof (vl.plugin_instance));
+		sstrncpy (vl.plugin_instance, plugin_instance,
+				sizeof (vl.plugin_instance));
+	sstrncpy (vl.type, "swap", sizeof (vl.type));
+
+	if (values_absolute)
+		plugin_dispatch_multivalue (&vl, 0, DS_TYPE_GAUGE,
+				"used", used, "free", free,
+				other_name, other_value, NULL);
+	if (values_percentage)
+		plugin_dispatch_multivalue (&vl, 1, DS_TYPE_GAUGE,
+				"used", used, "free", free,
+				other_name, other_value, NULL);
+} /* }}} void swap_submit_usage */
+
+#if KERNEL_LINUX || HAVE_PERFSTAT
+__attribute__((nonnull(1)))
+static void swap_submit_derive (char const *type_instance, /* {{{ */
+		derive_t value)
+{
+	value_list_t vl = VALUE_LIST_INIT;
+	value_t v[1];
+
+	v[0].derive = value;
+
+	vl.values = v;
+	vl.values_len = STATIC_ARRAY_SIZE (v);
+	sstrncpy (vl.host, hostname_g, sizeof (vl.host));
+	sstrncpy (vl.plugin, "swap", sizeof (vl.plugin));
+	sstrncpy (vl.type, "swap_io", sizeof (vl.type));
 	sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
 
 	plugin_dispatch_values (&vl);
-} /* }}} void swap_submit_inst */
-
-static void swap_submit (const char *type_instance, derive_t value, unsigned type)
-{
-	swap_submit_inst (/* plugin instance = */ NULL,
-			type_instance, value, type);
-}
+} /* }}} void swap_submit_derive */
+#endif
 
 #if KERNEL_LINUX
-static int swap_read (void) /* {{{ */
+static int swap_read_separate (void) /* {{{ */
 {
 	FILE *fh;
 	char buffer[1024];
 
-	char *fields[8];
-	int numfields;
+	fh = fopen ("/proc/swaps", "r");
+	if (fh == NULL)
+	{
+		char errbuf[1024];
+		WARNING ("swap plugin: fopen (/proc/swaps) failed: %s",
+				sstrerror (errno, errbuf, sizeof (errbuf)));
+		return (-1);
+	}
 
-	_Bool old_kernel=0;
+	while (fgets (buffer, sizeof (buffer), fh) != NULL)
+	{
+		char *fields[8];
+		int numfields;
+		char *endptr;
 
-	derive_t swap_used   = 0;
-	derive_t swap_cached = 0;
-	derive_t swap_free   = 0;
-	derive_t swap_total  = 0;
-	derive_t swap_in     = 0;
-	derive_t swap_out    = 0;
+		char path[PATH_MAX];
+		gauge_t total;
+		gauge_t used;
 
-	if ((fh = fopen ("/proc/meminfo", "r")) == NULL)
+		numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields));
+		if (numfields != 5)
+			continue;
+
+		sstrncpy (path, fields[0], sizeof (path));
+		escape_slashes (path, sizeof (path));
+
+		errno = 0;
+		endptr = NULL;
+		total = strtod (fields[2], &endptr);
+		if ((endptr == fields[2]) || (errno != 0))
+			continue;
+
+		errno = 0;
+		endptr = NULL;
+		used = strtod (fields[3], &endptr);
+		if ((endptr == fields[3]) || (errno != 0))
+			continue;
+
+		if (total < used)
+			continue;
+
+		swap_submit_usage (path, used, total - used, NULL, NAN);
+	}
+
+	fclose (fh);
+
+	return (0);
+} /* }}} int swap_read_separate */
+
+static int swap_read_combined (void) /* {{{ */
+{
+	FILE *fh;
+	char buffer[1024];
+
+	gauge_t swap_used   = NAN;
+	gauge_t swap_cached = NAN;
+	gauge_t swap_free   = NAN;
+	gauge_t swap_total  = NAN;
+
+	fh = fopen ("/proc/meminfo", "r");
+	if (fh == NULL)
 	{
 		char errbuf[1024];
-		WARNING ("memory: fopen: %s",
+		WARNING ("swap plugin: fopen (/proc/meminfo) failed: %s",
 				sstrerror (errno, errbuf, sizeof (errbuf)));
 		return (-1);
 	}
 
 	while (fgets (buffer, sizeof (buffer), fh) != NULL)
 	{
+		char *fields[8];
+		int numfields;
+
 		numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields));
 		if (numfields < 2)
 			continue;
 
 		if (strcasecmp (fields[0], "SwapTotal:") == 0)
-			strtoderive (fields[1], &swap_total);
+			strtogauge (fields[1], &swap_total);
 		else if (strcasecmp (fields[0], "SwapFree:") == 0)
-			strtoderive (fields[1], &swap_free);
+			strtogauge (fields[1], &swap_free);
 		else if (strcasecmp (fields[0], "SwapCached:") == 0)
-			strtoderive (fields[1], &swap_cached);
+			strtogauge (fields[1], &swap_cached);
 	}
 
-	if (fclose (fh))
-	{
-		char errbuf[1024];
-		WARNING ("memory: fclose: %s",
-				sstrerror (errno, errbuf, sizeof (errbuf)));
-	}
+	fclose (fh);
 
-	if ((swap_free + swap_cached) > swap_total)
-		return (-1);
+	if (isnan (swap_total) || isnan (swap_free))
+		return (ENOENT);
+
+	/* Some systems, OpenVZ for example, don't provide SwapCached. */
+	if (isnan (swap_cached))
+		swap_used = swap_total - swap_free;
+	else
+		swap_used = swap_total - (swap_free + swap_cached);
+	assert (!isnan (swap_used));
+
+	if (swap_used < 0.0)
+		return (EINVAL);
 
-	swap_used = swap_total - (swap_free + swap_cached);
+	swap_submit_usage (NULL, swap_used, swap_free,
+			isnan (swap_cached) ? NULL : "cached", swap_cached);
+	return (0);
+} /* }}} int swap_read_combined */
 
-	if ((fh = fopen ("/proc/vmstat", "r")) == NULL)
+static int swap_read_io (void) /* {{{ */
+{
+	FILE *fh;
+	char buffer[1024];
+
+	_Bool old_kernel = 0;
+
+	uint8_t have_data = 0;
+	derive_t swap_in  = 0;
+	derive_t swap_out = 0;
+
+	fh = fopen ("/proc/vmstat", "r");
+	if (fh == NULL)
 	{
-		// /proc/vmstat does not exist in kernels <2.6
-		if ((fh = fopen ("/proc/stat", "r")) == NULL )
+		/* /proc/vmstat does not exist in kernels <2.6 */
+		fh = fopen ("/proc/stat", "r");
+		if (fh == NULL)
 		{
 			char errbuf[1024];
 			WARNING ("swap: fopen: %s",
@@ -260,6 +374,9 @@ static int swap_read (void) /* {{{ */
 
 	while (fgets (buffer, sizeof (buffer), fh) != NULL)
 	{
+		char *fields[8];
+		int numfields;
+
 		numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields));
 
 		if (!old_kernel)
@@ -268,9 +385,15 @@ static int swap_read (void) /* {{{ */
 				continue;
 
 			if (strcasecmp ("pswpin", fields[0]) == 0)
+			{
 				strtoderive (fields[1], &swap_in);
+				have_data |= 0x01;
+			}
 			else if (strcasecmp ("pswpout", fields[0]) == 0)
+			{
 				strtoderive (fields[1], &swap_out);
+				have_data |= 0x02;
+			}
 		}
 		else /* if (old_kernel) */
 		{
@@ -285,18 +408,31 @@ static int swap_read (void) /* {{{ */
 		}
 	} /* while (fgets) */
 
-	if (fclose (fh))
+	fclose (fh);
+
+	if (have_data != 0x03)
+		return (ENOENT);
+
+	if (report_bytes)
 	{
-		char errbuf[1024];
-		WARNING ("swap: fclose: %s",
-				sstrerror (errno, errbuf, sizeof (errbuf)));
+		swap_in = swap_in * pagesize;
+		swap_out = swap_out * pagesize;
 	}
 
-	swap_submit ("used",   1024 * swap_used,   DS_TYPE_GAUGE);
-	swap_submit ("free",   1024 * swap_free,   DS_TYPE_GAUGE);
-	swap_submit ("cached", 1024 * swap_cached, DS_TYPE_GAUGE);
-	swap_submit ("in",  swap_in,  DS_TYPE_DERIVE);
-	swap_submit ("out", swap_out, DS_TYPE_DERIVE);
+	swap_submit_derive ("in",  swap_in);
+	swap_submit_derive ("out", swap_out);
+
+	return (0);
+} /* }}} int swap_read_io */
+
+static int swap_read (void) /* {{{ */
+{
+	if (report_by_device)
+		swap_read_separate ();
+	else
+		swap_read_combined ();
+
+	swap_read_io ();
 
 	return (0);
 } /* }}} int swap_read */
@@ -315,9 +451,9 @@ static int swap_read (void) /* {{{ */
 /* kstat-based read function */
 static int swap_read_kstat (void) /* {{{ */
 {
-	derive_t swap_alloc;
-	derive_t swap_resv;
-	derive_t swap_avail;
+	gauge_t swap_alloc;
+	gauge_t swap_resv;
+	gauge_t swap_avail;
 
 	struct anoninfo ai;
 
@@ -350,15 +486,11 @@ static int swap_read_kstat (void) /* {{{ */
 	 * swap_alloc = pagesize * ( ai.ani_max - ai.ani_free );
 	 * can suffer from a 32bit overflow.
 	 */
-	swap_alloc  = (derive_t) ((ai.ani_max - ai.ani_free) * pagesize);
-	swap_resv   = (derive_t) ((ai.ani_resv + ai.ani_free - ai.ani_max)
-			* pagesize);
-	swap_avail  = (derive_t) ((ai.ani_max - ai.ani_resv) * pagesize);
-
-	swap_submit ("used", swap_alloc, DS_TYPE_GAUGE);
-	swap_submit ("free", swap_avail, DS_TYPE_GAUGE);
-	swap_submit ("reserved", swap_resv, DS_TYPE_GAUGE);
+	swap_alloc = (gauge_t) ((ai.ani_max - ai.ani_free) * pagesize);
+	swap_resv  = (gauge_t) ((ai.ani_resv + ai.ani_free - ai.ani_max) * pagesize);
+	swap_avail = (gauge_t) ((ai.ani_max - ai.ani_resv) * pagesize);
 
+	swap_submit_usage (NULL, swap_alloc, swap_avail, "reserved", swap_resv);
 	return (0);
 } /* }}} int swap_read_kstat */
 /* #endif 0 && HAVE_LIBKSTAT */
@@ -373,8 +505,8 @@ static int swap_read (void) /* {{{ */
         int status;
         int i;
 
-        derive_t avail = 0;
-        derive_t total = 0;
+        gauge_t avail = 0;
+        gauge_t total = 0;
 
         swap_num = swapctl (SC_GETNSWP, NULL);
         if (swap_num < 0)
@@ -437,14 +569,14 @@ static int swap_read (void) /* {{{ */
         for (i = 0; i < swap_num; i++)
         {
 		char path[PATH_MAX];
-		derive_t this_total;
-		derive_t this_avail;
+		gauge_t this_total;
+		gauge_t this_avail;
 
                 if ((s->swt_ent[i].ste_flags & ST_INDEL) != 0)
                         continue;
 
-		this_total = ((derive_t) s->swt_ent[i].ste_pages) * pagesize;
-		this_avail = ((derive_t) s->swt_ent[i].ste_free)  * pagesize;
+		this_total = (gauge_t) (s->swt_ent[i].ste_pages * pagesize);
+		this_avail = (gauge_t) (s->swt_ent[i].ste_free  * pagesize);
 
 		/* Shortcut for the "combined" setting (default) */
 		if (!report_by_device)
@@ -454,67 +586,31 @@ static int swap_read (void) /* {{{ */
 			continue;
 		}
 
-		/* Okay, using "/" as swap device would be super-weird, but
-		 * we'll handle it anyway to cover all cases. */
-		if (strcmp ("/", s->swt_ent[i].ste_path) == 0)
-			sstrncpy (path, "root", sizeof (path));
-		else
-		{
-			int j;
-
-			s->swt_ent[i].ste_path[PATH_MAX - 1] = 0;
-			/* Don't copy the leading slash */
-			sstrncpy (path, &s->swt_ent[i].ste_path[1], sizeof (path));
-			/* Convert slashes to dashes, just like the "df" plugin. */
-			for (j = 0; path[j] != 0; j++)
-				if (path[j] == '/')
-					path[j] = '-';
-		}
+		sstrncpy (path, s->swt_ent[i].ste_path, sizeof (path));
+		escape_slashes (path, sizeof (path));
 
-		swap_submit_inst (path, "used", this_total - this_avail, DS_TYPE_GAUGE);
-		swap_submit_inst (path, "free", this_avail, DS_TYPE_GAUGE);
+		swap_submit_usage (path, this_total - this_avail, this_avail,
+				NULL, NAN);
         } /* for (swap_num) */
 
         if (total < avail)
         {
-                ERROR ("swap plugin: Total swap space (%"PRIi64") "
-                                "is less than free swap space (%"PRIi64").",
+                ERROR ("swap plugin: Total swap space (%g) is less than free swap space (%g).",
                                 total, avail);
 		sfree (s_paths);
                 sfree (s);
                 return (-1);
         }
 
-	/* If the "separate" option was specified (report_by_device == 2), all
+	/* If the "separate" option was specified (report_by_device == 1), all
 	 * values have already been dispatched from within the loop. */
 	if (!report_by_device)
-	{
-		swap_submit ("used", total - avail, DS_TYPE_GAUGE);
-		swap_submit ("free", avail, DS_TYPE_GAUGE);
-	}
+		swap_submit_usage (NULL, total - avail, avail, NULL, NAN);
 
 	sfree (s_paths);
         sfree (s);
 	return (0);
 } /* }}} int swap_read */
-
-/* Configuration: Present when swapctl or both methods are available. */
-static int swap_config (const char *key, const char *value) /* {{{ */
-{
-	if (strcasecmp ("ReportByDevice", key) == 0)
-	{
-		if (IS_TRUE (value))
-			report_by_device = 1;
-		else
-			report_by_device = 0;
-	}
-	else
-	{
-		return (-1);
-	}
-
-	return (0);
-} /* }}} int swap_config */
 /* #endif HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS */
 
 #elif HAVE_SWAPCTL && HAVE_SWAPCTL_THREE_ARGS
@@ -525,8 +621,8 @@ static int swap_read (void) /* {{{ */
 	int status;
 	int i;
 
-	derive_t used  = 0;
-	derive_t total = 0;
+	gauge_t used  = 0;
+	gauge_t total = 0;
 
 	swap_num = swapctl (SWAP_NSWAP, NULL, 0);
 	if (swap_num < 0)
@@ -555,35 +651,32 @@ static int swap_read (void) /* {{{ */
 	}
 
 #if defined(DEV_BSIZE) && (DEV_BSIZE > 0)
-# define C_SWAP_BLOCK_SIZE ((derive_t) DEV_BSIZE)
+# define C_SWAP_BLOCK_SIZE ((gauge_t) DEV_BSIZE)
 #else
-# define C_SWAP_BLOCK_SIZE ((derive_t) 512)
+# define C_SWAP_BLOCK_SIZE 512.0
 #endif
 
+	/* TODO: Report per-device stats. The path name is available from
+	 * swap_entries[i].se_path */
 	for (i = 0; i < swap_num; i++)
 	{
 		if ((swap_entries[i].se_flags & SWF_ENABLE) == 0)
 			continue;
 
-		used  += ((derive_t) swap_entries[i].se_inuse)
-			* C_SWAP_BLOCK_SIZE;
-		total += ((derive_t) swap_entries[i].se_nblks)
-			* C_SWAP_BLOCK_SIZE;
+		used  += ((gauge_t) swap_entries[i].se_inuse) * C_SWAP_BLOCK_SIZE;
+		total += ((gauge_t) swap_entries[i].se_nblks) * C_SWAP_BLOCK_SIZE;
 	}
 
 	if (total < used)
 	{
-		ERROR ("swap plugin: Total swap space (%"PRIu64") "
-				"is less than used swap space (%"PRIu64").",
+		ERROR ("swap plugin: Total swap space (%g) is less than used swap space (%g).",
 				total, used);
 		return (-1);
 	}
 
-	swap_submit ("used", used, DS_TYPE_GAUGE);
-	swap_submit ("free", total - used, DS_TYPE_GAUGE);
+	swap_submit_usage (NULL, used, total - used, NULL, NAN);
 
 	sfree (swap_entries);
-
 	return (0);
 } /* }}} int swap_read */
 /* #endif HAVE_SWAPCTL && HAVE_SWAPCTL_THREE_ARGS */
@@ -606,8 +699,9 @@ static int swap_read (void) /* {{{ */
 		return (-1);
 
 	/* The returned values are bytes. */
-	swap_submit ("used", (derive_t) sw_usage.xsu_used, DS_TYPE_GAUGE);
-	swap_submit ("free", (derive_t) sw_usage.xsu_avail, DS_TYPE_GAUGE);
+	swap_submit_usage (NULL,
+			(gauge_t) sw_usage.xsu_used, (gauge_t) sw_usage.xsu_avail,
+			NULL, NAN);
 
 	return (0);
 } /* }}} int swap_read */
@@ -619,9 +713,8 @@ static int swap_read (void) /* {{{ */
 	struct kvm_swap data_s;
 	int             status;
 
-	derive_t used;
-	derive_t free;
-	derive_t total;
+	gauge_t used;
+	gauge_t total;
 
 	if (kvm_obj == NULL)
 		return (-1);
@@ -631,16 +724,13 @@ static int swap_read (void) /* {{{ */
 	if (status == -1)
 		return (-1);
 
-	total = (derive_t) data_s.ksw_total;
-	used  = (derive_t) data_s.ksw_used;
-
-	total *= (derive_t) kvm_pagesize;
-	used  *= (derive_t) kvm_pagesize;
+	total = (gauge_t) data_s.ksw_total;
+	used  = (gauge_t) data_s.ksw_used;
 
-	free = total - used;
+	total *= (gauge_t) kvm_pagesize;
+	used  *= (gauge_t) kvm_pagesize;
 
-	swap_submit ("used", used, DS_TYPE_GAUGE);
-	swap_submit ("free", free, DS_TYPE_GAUGE);
+	swap_submit_usage (NULL, used, total - used, NULL, NAN);
 
 	return (0);
 } /* }}} int swap_read */
@@ -652,12 +742,11 @@ static int swap_read (void) /* {{{ */
 	sg_swap_stats *swap;
 
 	swap = sg_get_swap_stats ();
-
 	if (swap == NULL)
 		return (-1);
 
-	swap_submit ("used", (derive_t) swap->used, DS_TYPE_GAUGE);
-	swap_submit ("free", (derive_t) swap->free, DS_TYPE_GAUGE);
+	swap_submit_usage (NULL, (gauge_t) swap->used, (gauge_t) swap->free,
+			NULL, NAN);
 
 	return (0);
 } /* }}} int swap_read */
@@ -666,15 +755,30 @@ static int swap_read (void) /* {{{ */
 #elif HAVE_PERFSTAT
 static int swap_read (void) /* {{{ */
 {
-        if(perfstat_memory_total(NULL, &pmemory, sizeof(perfstat_memory_total_t), 1) < 0)
+	perfstat_memory_total_t pmemory;
+	int status;
+
+	gauge_t total;
+	gauge_t free;
+	gauge_t reserved;
+
+	memset (&pmemory, 0, sizeof (pmemory));
+        status = perfstat_memory_total (NULL, &pmemory, sizeof(perfstat_memory_total_t), 1);
+	if (status < 0)
 	{
                 char errbuf[1024];
-                WARNING ("memory plugin: perfstat_memory_total failed: %s",
+                WARNING ("swap plugin: perfstat_memory_total failed: %s",
                         sstrerror (errno, errbuf, sizeof (errbuf)));
                 return (-1);
         }
-	swap_submit ("used", (derive_t) (pmemory.pgsp_total - pmemory.pgsp_free) * pagesize, DS_TYPE_GAUGE);
-	swap_submit ("free", (derive_t) pmemory.pgsp_free * pagesize , DS_TYPE_GAUGE);
+
+	total    = (gauge_t) (pmemory.pgsp_total * pagesize);
+	free     = (gauge_t) (pmemory.pgsp_free * pagesize);
+	reserved = (gauge_t) (pmemory.pgsp_rsvd * pagesize);
+
+	swap_submit_usage (NULL, total - free, free, "reserved", reserved);
+	swap_submit_derive ("in",  (derive_t) pmemory.pgspins * pagesize);
+	swap_submit_derive ("out", (derive_t) pmemory.pgspouts * pagesize);
 
 	return (0);
 } /* }}} int swap_read */
@@ -682,9 +786,7 @@ static int swap_read (void) /* {{{ */
 
 void module_register (void)
 {
-#if HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS
-	plugin_register_config ("swap", swap_config, config_keys, config_keys_num);
-#endif
+	plugin_register_complex_config ("swap", swap_config);
 	plugin_register_init ("swap", swap_init);
 	plugin_register_read ("swap", swap_read);
 } /* void module_register */