From 54db9562401c26c9ac4522c6edeb12604dc11aaf Mon Sep 17 00:00:00 2001 From: Florian Forster Date: Mon, 6 Dec 2010 11:13:09 +0100 Subject: [PATCH] swap plugin: Implement virtual / physical reporting on Solaris. --- src/collectd.conf.pod | 35 ++++++- src/swap.c | 279 +++++++++++++++++++++++++++++++++++++++++++------- 2 files changed, 277 insertions(+), 37 deletions(-) diff --git a/src/collectd.conf.pod b/src/collectd.conf.pod index acdfa927..5d10b24a 100644 --- a/src/collectd.conf.pod +++ b/src/collectd.conf.pod @@ -4146,7 +4146,7 @@ because all values were added to the internal cache at roughly the same time. =head2 Plugin C -The C uses B to retrieve sensor-values. This means +The I uses B to retrieve sensor-values. This means that all the needed modules have to be loaded and lm_sensors has to be configured (most likely by editing F. Read L for details. @@ -4181,6 +4181,39 @@ Since the configuration of the C is a little more complicated than other plugins, its documentation has been moved to an own manpage, L. Please see there for details. +=head2 Plugin C + +The I collects information about used and available swap space. On +Solaris, it is possible to collect information on physical swap devices and the +view of the virtual memory subsystem on the matter. On I, the +following options are available: + +=over 4 + +=item B B|B|B + +Configures how to report physical swap devices. If B is used (the +default), the summary over all swap devices is reported only, i.e. the globally +used and available space over all devices. If B is configured, the +used and available space of each device will be reported separately. B +deactivates collection of physical swap information (only valid if collection +via L is available). + +This option is only available if the I can use the L +mechanism under I. + +=item B B|B + +Configures whether or not to report the view of the virtual memory subsystem on +swap space. This information is used under Solaris if L is not +available and was the default behavior under I in I4>. + +This option is only available if the I can use L and +L to collect swap statistics under I. It defaults to +B. + +=back + =head2 Plugin C =over 4 diff --git a/src/swap.c b/src/swap.c index 2025533e..03e4eec1 100644 --- a/src/swap.c +++ b/src/swap.c @@ -1,8 +1,9 @@ /** * collectd - src/swap.c - * Copyright (C) 2005-2009 Florian octo Forster + * Copyright (C) 2005-2010 Florian octo Forster * Copyright (C) 2009 Stefan Völkel * Copyright (C) 2009 Manuel Sanmartin + * Copyright (C) 2010 Aurélien Reynaud * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the @@ -18,8 +19,9 @@ * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Authors: - * Florian octo Forster + * Florian octo Forster * Manuel Sanmartin + * Aurélien Reynaud **/ #if HAVE_CONFIG_H @@ -71,14 +73,28 @@ /* No global variables */ /* #endif KERNEL_LINUX */ -#elif HAVE_LIBKSTAT +#elif HAVE_LIBKSTAT || (HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS) static derive_t pagesize; +# if HAVE_LIBKSTAT static kstat_t *ksp; -/* #endif HAVE_LIBKSTAT */ +# endif /* HAVE_LIBKSTAT */ -#elif HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS -static derive_t pagesize; -/* #endif HAVE_SWAPCTL */ +# if HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS +static const char *config_keys[] = +{ +# if HAVE_LIBKSTAT + "ReportVirtual", +# endif + "ReportPhysical" +}; +static int config_keys_num = STATIC_ARRAY_SIZE (config_keys); + +# if HAVE_LIBKSTAT +static _Bool report_virtual = 0; +# endif +static int report_physical = 1; +# endif /* HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS */ +/* #endif HAVE_LIBKSTAT || (HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS) */ #elif defined(VM_SWAPUSAGE) /* No global variables */ @@ -156,7 +172,8 @@ static int swap_init (void) return (0); } -static void swap_submit (const char *type_instance, derive_t value, unsigned type) +static void swap_submit_inst (const char *plugin_instance, /* {{{ */ + const char *type_instance, derive_t value, unsigned type) { value_t values[1]; value_list_t vl = VALUE_LIST_INIT; @@ -180,14 +197,22 @@ static void swap_submit (const char *type_instance, derive_t value, unsigned typ vl.values_len = 1; 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.type_instance, type_instance, sizeof (vl.type_instance)); plugin_dispatch_values (&vl); -} /* void swap_submit */ +} /* }}} void swap_submit_inst */ -static int swap_read (void) +static void swap_submit (const char *type_instance, derive_t value, unsigned type) { + swap_submit_inst (/* plugin instance = */ NULL, + type_instance, value, type); +} + #if KERNEL_LINUX +static int swap_read (void) /* {{{ */ +{ FILE *fh; char buffer[1024]; @@ -290,9 +315,22 @@ static int swap_read (void) 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); + + return (0); +} /* }}} int swap_read */ /* #endif KERNEL_LINUX */ -#elif HAVE_LIBKSTAT +/* Sorry for the amount of preprocessor magic that follows. Under Solaris, two + * mechanisms can be used to read swap statistics, swapctl and kstat. The + * former reads physical space used on a device, the latter reports the view + * from the virtual memory system. The following magic tries to be as flexible + * as possible by allowing either mechanism to be missing and act correctly in + * the event that both are available, i.e. let the user decide what to do. */ +#elif HAVE_LIBKSTAT || (HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS) +# if HAVE_LIBKSTAT +/* kstat-based read function */ +static int swap_read_kstat (void) /* {{{ */ +{ derive_t swap_alloc; derive_t swap_resv; derive_t swap_avail; @@ -336,12 +374,17 @@ static int swap_read (void) swap_submit ("used", swap_alloc, DS_TYPE_GAUGE); swap_submit ("free", swap_avail, DS_TYPE_GAUGE); swap_submit ("reserved", swap_resv, DS_TYPE_GAUGE); -/* #endif HAVE_LIBKSTAT */ -#elif HAVE_SWAPCTL - #if HAVE_SWAPCTL_TWO_ARGS + return (0); +} /* }}} int swap_read_kstat */ +# endif /* HAVE_LIBKSTAT */ + +# if HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS +/* swapctl-based read function */ +static int swap_read_swapctl2 (void) /* {{{ */ +{ swaptbl_t *s; - char strtab[255]; + char *s_paths; int swap_num; int status; int i; @@ -359,54 +402,194 @@ static int swap_read (void) else if (swap_num == 0) return (0); + /* Allocate and initialize the swaptbl_t structure */ s = (swaptbl_t *) smalloc (swap_num * sizeof (swapent_t) + sizeof (struct swaptable)); if (s == NULL) { ERROR ("swap plugin: smalloc failed."); return (-1); } - /* Initialize string pointers. We have them share the same buffer as we don't care - * about the device's name, only its size. This saves memory and alloc/free ops */ - for (i = 0; i < (swap_num + 1); i++) { - s->swt_ent[i].ste_path = strtab; - } - s->swt_n = swap_num + 1; + + /* Memory to store the path names. We only use these paths when the + * separate option has been configured, but it's easier to just + * allocate enough memory in any case. */ + s_paths = calloc (swap_num, PATH_MAX); + if (s_paths == NULL) + { + ERROR ("swap plugin: malloc failed."); + sfree (s); + return (-1); + } + for (i = 0; i < swap_num; i++) + s->swt_ent[i].ste_path = s_paths + (i * PATH_MAX); + s->swt_n = swap_num; + status = swapctl (SC_LIST, s); - if (status != swap_num) + if (status < 0) { - ERROR ("swap plugin: swapctl (SC_LIST) failed with status %i.", - status); + char errbuf[1024]; + ERROR ("swap plugin: swapctl (SC_LIST) failed: %s", + sstrerror (errno, errbuf, sizeof (errbuf))); + sfree (s_paths); sfree (s); return (-1); } + else if (swap_num < status) + { + /* more elements returned than requested */ + ERROR ("swap plugin: I allocated memory for %i structure%s, " + "but swapctl(2) claims to have returned %i. " + "I'm confused and will give up.", + swap_num, (swap_num == 1) ? "" : "s", + status); + sfree (s_paths); + sfree (s); + return (-1); + } + else if (swap_num > status) + /* less elements returned than requested */ + swap_num = status; for (i = 0; i < swap_num; i++) { + char path[PATH_MAX]; + derive_t this_total; + derive_t this_avail; + if ((s->swt_ent[i].ste_flags & ST_INDEL) != 0) continue; - avail += ((derive_t) s->swt_ent[i].ste_free) - * pagesize; - total += ((derive_t) s->swt_ent[i].ste_pages) - * pagesize; - } + this_total = ((derive_t) s->swt_ent[i].ste_pages) * pagesize; + this_avail = ((derive_t) s->swt_ent[i].ste_free) * pagesize; + + /* Shortcut for the "combined" setting (default) */ + if (report_physical != 2) + { + avail += this_avail; + total += this_total; + 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] = '-'; + } + + swap_submit_inst (path, "used", this_total - this_avail, DS_TYPE_GAUGE); + swap_submit_inst (path, "free", this_avail, DS_TYPE_GAUGE); + } /* for (swap_num) */ if (total < avail) { ERROR ("swap plugin: Total swap space (%"PRIi64") " "is less than free swap space (%"PRIi64").", total, avail); + sfree (s_paths); sfree (s); return (-1); } - swap_submit ("used", total - avail, DS_TYPE_GAUGE); - swap_submit ("free", avail, DS_TYPE_GAUGE); + /* If the "separate" option was specified (report_physical == 2), all + * values have already been dispatched from within the loop. */ + if (report_physical != 2) + { + swap_submit ("used", total - avail, DS_TYPE_GAUGE); + swap_submit ("free", avail, DS_TYPE_GAUGE); + } + sfree (s_paths); sfree (s); - /* #endif HAVE_SWAPCTL_TWO_ARGS */ - #elif HAVE_SWAPCTL_THREE_ARGS + return (0); +} /* }}} int swap_read_swapctl2 */ + +/* Configuration: Present when swapctl or both methods are available. */ +static int swap_config (const char *key, const char *value) /* {{{ */ +{ + if (strcasecmp ("ReportPhysical", key) == 0) + { + if (strcasecmp ("combined", value) == 0) + report_physical = 1; + else if (strcasecmp ("separate", value) == 0) + report_physical = 2; +# if HAVE_LIBKSTAT + else if (IS_TRUE (value)) + report_physical = 1; + else if (IS_FALSE (value)) + report_physical = 0; +# endif + else + WARNING ("swap plugin: The value \"%s\" is not " + "recognized by the ReportPhysical option.", + value); + } +# if HAVE_LIBKSTAT + else if (strcasecmp ("ReportVirtual", key) == 0) + { + if (IS_TRUE (value)) + report_physical = 1; + else if (IS_FALSE (value)) + report_physical = 0; + else + WARNING ("swap plugin: The value \"%s\" is not " + "recognized by the ReportVirtual option.", + value); + } +# endif /* HAVE_LIBKSTAT */ + else + { + return (-1); + } + + return (0); +} /* }}} int swap_config */ +# endif /* HAVE_SWAPCTL_TWO_ARGS */ + +/* If both methods are available, check the config variables to decide which + * function to call. Otherwise, add aliases for the functions so we can + * "swap_read" in "module_register". */ +# if HAVE_LIBKSTAT && HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS +static int swap_read (void) /* {{{ */ +{ + int status; + + if (report_physical) + { + status = swap_read_swapctl2 (); + if (status != 0) + return (status); + } + if (report_virtual) + { + status = swap_read_kstat (); + if (status != 0) + return (status); + } + + return (0); +} /* }}} int swap_read */ +# elif HAVE_LIBKSTAT +# define swap_read swap_read_kstat +# else /* if HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS */ +# define swap_read swap_read_swapctl2 +# endif +/* #endif HAVE_LIBKSTAT || (HAVE_SWAPCTL && HAVE_SWAPCTL_TWO_ARGS) */ + +#elif HAVE_SWAPCTL && HAVE_SWAPCTL_THREE_ARGS +static int swap_read (void) /* {{{ */ +{ struct swapent *swap_entries; int swap_num; int status; @@ -470,10 +653,14 @@ static int swap_read (void) swap_submit ("free", total - used, DS_TYPE_GAUGE); sfree (swap_entries); - #endif /* HAVE_SWAPCTL_THREE_ARGS */ + + return (0); +} /* }}} int swap_read */ /* #endif HAVE_SWAPCTL */ #elif defined(VM_SWAPUSAGE) +static int swap_read (void) /* {{{ */ +{ int mib[3]; size_t mib_len; struct xsw_usage sw_usage; @@ -491,9 +678,14 @@ static int swap_read (void) /* 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); + + return (0); +} /* }}} int swap_read */ /* #endif VM_SWAPUSAGE */ #elif HAVE_LIBKVM_GETSWAPINFO +static int swap_read (void) /* {{{ */ +{ struct kvm_swap data_s; int status; @@ -519,9 +711,14 @@ static int swap_read (void) swap_submit ("used", used, DS_TYPE_GAUGE); swap_submit ("free", free, DS_TYPE_GAUGE); + + return (0); +} /* }}} int swap_read */ /* #endif HAVE_LIBKVM_GETSWAPINFO */ #elif HAVE_LIBSTATGRAB +static int swap_read (void) /* {{{ */ +{ sg_swap_stats *swap; swap = sg_get_swap_stats (); @@ -531,9 +728,14 @@ static int swap_read (void) swap_submit ("used", (derive_t) swap->used, DS_TYPE_GAUGE); swap_submit ("free", (derive_t) swap->free, DS_TYPE_GAUGE); + + return (0); +} /* }}} int swap_read */ /* #endif HAVE_LIBSTATGRAB */ #elif HAVE_PERFSTAT +static int swap_read (void) /* {{{ */ +{ if(perfstat_memory_total(NULL, &pmemory, sizeof(perfstat_memory_total_t), 1) < 0) { char errbuf[1024]; @@ -543,13 +745,18 @@ static int swap_read (void) } 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); -#endif /* HAVE_PERFSTAT */ return (0); -} /* int swap_read */ +} /* }}} int swap_read */ +#endif /* HAVE_PERFSTAT */ 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_init ("swap", swap_init); plugin_register_read ("swap", swap_read); } /* void module_register */ + +/* vim: set fdm=marker : */ -- 2.11.0