X-Git-Url: https://git.octo.it/?p=collectd.git;a=blobdiff_plain;f=src%2Fnetapp.c;h=f47b0366a13aecdba3d5d2495f58cc4fc2ac4cc1;hp=d5eeb6c1a648b419723d3a843622b9de240a6948;hb=21a2da50cf272a88769e5794f2e3b57ac9256a92;hpb=235e731905fc81a379ba7ba0717dd96a69ac2737 diff --git a/src/netapp.c b/src/netapp.c index d5eeb6c1..f47b0366 100644 --- a/src/netapp.c +++ b/src/netapp.c @@ -21,136 +21,220 @@ * DEALINGS IN THE SOFTWARE. * * Authors: - * Sven Trenkel + * Sven Trenkel **/ #include "collectd.h" #include "common.h" +#include "utils_ignorelist.h" #include +#include + +#define HAS_ALL_FLAGS(has,needs) (((has) & (needs)) == (needs)) typedef struct host_config_s host_config_t; typedef void service_handler_t(host_config_t *host, na_elem_t *result, void *data); -#define PERF_SYSTEM_CPU 0x01 -#define PERF_SYSTEM_NET 0x02 -#define PERF_SYSTEM_OPS 0x04 -#define PERF_SYSTEM_DISK 0x08 -#define PERF_SYSTEM_ALL 0x0F +struct cna_interval_s +{ + time_t interval; + time_t last_read; +}; +typedef struct cna_interval_s cna_interval_t; -/*! - * \brief Persistent data for system performence counters +/*! 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 "cfg_wafl_t" struct therefore contains old counter values along + * with flags, which are set if the counter is valid. + * + * 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 +#define CFG_WAFL_DIR_CACHE 0x0002 +#define CFG_WAFL_BUF_CACHE 0x0004 +#define CFG_WAFL_INODE_CACHE 0x0008 +#define CFG_WAFL_ALL 0x000F +#define HAVE_WAFL_NAME_CACHE_HIT 0x0100 +#define HAVE_WAFL_NAME_CACHE_MISS 0x0200 +#define HAVE_WAFL_NAME_CACHE (HAVE_WAFL_NAME_CACHE_HIT | HAVE_WAFL_NAME_CACHE_MISS) +#define HAVE_WAFL_FIND_DIR_HIT 0x0400 +#define HAVE_WAFL_FIND_DIR_MISS 0x0800 +#define HAVE_WAFL_FIND_DIR (HAVE_WAFL_FIND_DIR_HIT | HAVE_WAFL_FIND_DIR_MISS) +#define HAVE_WAFL_BUF_HASH_HIT 0x1000 +#define HAVE_WAFL_BUF_HASH_MISS 0x2000 +#define HAVE_WAFL_BUF_HASH (HAVE_WAFL_BUF_HASH_HIT | HAVE_WAFL_BUF_HASH_MISS) +#define HAVE_WAFL_INODE_CACHE_HIT 0x4000 +#define HAVE_WAFL_INODE_CACHE_MISS 0x8000 +#define HAVE_WAFL_INODE_CACHE (HAVE_WAFL_INODE_CACHE_HIT | HAVE_WAFL_INODE_CACHE_MISS) +#define HAVE_WAFL_ALL 0xff00 typedef struct { uint32_t flags; - uint64_t last_cpu_busy; - uint64_t last_cpu_total; -} perf_system_data_t; + cna_interval_t interval; + na_elem_t *query; -/*! - * \brief Persistent data for WAFL performence counters. (a.k.a. cache performence) + time_t timestamp; + uint64_t name_cache_hit; + uint64_t name_cache_miss; + uint64_t find_dir_hit; + uint64_t find_dir_miss; + uint64_t buf_hash_hit; + uint64_t buf_hash_miss; + uint64_t inode_cache_hit; + uint64_t inode_cache_miss; +} 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 PERF_WAFL_NAME_CACHE 0x01 -#define PERF_WAFL_DIR_CACHE 0x02 -#define PERF_WAFL_BUF_CACHE 0x04 -#define PERF_WAFL_INODE_CACHE 0x08 -#define PERF_WAFL_ALL 0x0F - -typedef struct { +#define HAVE_DISK_BUSY 0x10 +#define HAVE_DISK_BASE 0x20 +#define HAVE_DISK_ALL 0x30 +typedef struct disk_s { + char *name; uint32_t flags; - uint64_t last_name_cache_hit; - uint64_t last_name_cache_miss; - uint64_t last_find_dir_hit; - uint64_t last_find_dir_miss; - uint64_t last_buf_hash_hit; - uint64_t last_buf_hash_miss; - uint64_t last_inode_cache_hit; - uint64_t last_inode_cache_miss; -} perf_wafl_data_t; - -#define PERF_VOLUME_INIT 0x01 -#define PERF_VOLUME_IO 0x02 -#define PERF_VOLUME_OPS 0x03 -#define PERF_VOLUME_LATENCY 0x08 -#define PERF_VOLUME_ALL 0x0F + 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; -} perf_volume_data_t; + cna_interval_t interval; + na_elem_t *query; + disk_t *disks; +} cfg_disk_t; +/* }}} cfg_disk_t */ -typedef struct { +/*! 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 + * calculate an average per-operation latency. For this, old counters need to + * be stored in the "data_volume_perf_t" structure. The byte-counters are just + * kept for completeness sake. The "flags" member indicates if each counter is + * valid or not. + * + * The "cna_handle_volume_perf_data" function will fill a new struct of this + * type and pass both, old and new data, to "submit_volume_perf_data". In that + * function, the per-operation latency is calculated and dispatched, then the + * old counters are updated. + */ +#define CFG_VOLUME_PERF_INIT 0x0001 +#define CFG_VOLUME_PERF_IO 0x0002 +#define CFG_VOLUME_PERF_OPS 0x0003 +#define CFG_VOLUME_PERF_LATENCY 0x0008 +#define CFG_VOLUME_PERF_ALL 0x000F +#define HAVE_VOLUME_PERF_BYTES_READ 0x0010 +#define HAVE_VOLUME_PERF_BYTES_WRITE 0x0020 +#define HAVE_VOLUME_PERF_OPS_READ 0x0040 +#define HAVE_VOLUME_PERF_OPS_WRITE 0x0080 +#define HAVE_VOLUME_PERF_LATENCY_READ 0x0100 +#define HAVE_VOLUME_PERF_LATENCY_WRITE 0x0200 +#define HAVE_VOLUME_PERF_ALL 0x03F0 +struct data_volume_perf_s; +typedef struct data_volume_perf_s data_volume_perf_t; +struct data_volume_perf_s { + char *name; uint32_t flags; -} volume_data_t; + time_t timestamp; -#define PERF_DISK_BUSIEST 0x01 -#define PERF_DISK_ALL 0x01 + uint64_t read_bytes; + uint64_t write_bytes; + uint64_t read_ops; + uint64_t write_ops; + uint64_t read_latency; + uint64_t write_latency; -typedef struct { - uint32_t flags; -} perf_disk_data_t; + data_volume_perf_t *next; +}; typedef struct { - uint32_t flags; - time_t last_timestamp; - uint64_t last_read_latency; - uint64_t last_write_latency; - uint64_t last_read_ops; - uint64_t last_write_ops; -} per_volume_perf_data_t; + cna_interval_t interval; + na_elem_t *query; -#define VOLUME_INIT 0x01 -#define VOLUME_DF 0x02 -#define VOLUME_SNAP 0x04 + ignorelist_t *il_octets; + ignorelist_t *il_operations; + ignorelist_t *il_latency; -typedef struct { + data_volume_perf_t *volumes; +} cfg_volume_perf_t; +/* }}} data_volume_perf_t */ + +/*! Data types for volume usage statistics {{{ + * + * \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 +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; -} per_volume_data_t; -typedef struct { - time_t last_update; - double last_disk_busy_percent; - uint64_t last_disk_busy; - uint64_t last_base_for_disk_busy; -} per_disk_perf_data_t; + na_elem_t *snap_query; + + uint64_t norm_free; + uint64_t norm_used; + uint64_t snap_reserved; + uint64_t snap_used; + uint64_t sis_saved; -typedef struct service_config_s { + data_volume_usage_t *next; +}; + +typedef struct { + cna_interval_t interval; na_elem_t *query; - service_handler_t *handler; - int multiplier; - int skip_countdown; - int interval; - void *data; - struct service_config_s *next; -} service_config_t; -#define SERVICE_INIT {0, 0, 1, 1, 0, 0, 0} + ignorelist_t *il_capacity; + ignorelist_t *il_snapshot; -typedef struct volume_s { - char *name; - per_volume_perf_data_t perf_data; - per_volume_data_t volume_data; - struct volume_s *next; -} volume_t; + data_volume_usage_t *volumes; +} cfg_volume_usage_t; +/* }}} cfg_volume_usage_t */ -/*! - * \brief A disk in the netapp. +/*! Data types for system statistics {{{ * - * A disk doesn't have any more information than its name atm. - * The name includes the "disk_" prefix. + * \brief Persistent data for system performance counters */ - -typedef struct disk_s { - char *name; - per_disk_perf_data_t perf_data; - struct disk_s *next; -} disk_t; - -#define DISK_INIT {0, {0, 0, 0, 0}, 0} +#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 */ struct host_config_s { - na_server_t *srv; char *name; na_server_transport_t protocol; char *host; @@ -158,1007 +242,2260 @@ struct host_config_s { char *username; char *password; int interval; - service_config_t *services; - disk_t *disks; - volume_t *volumes; + + na_server_t *srv; + cfg_wafl_t *cfg_wafl; + cfg_disk_t *cfg_disk; + cfg_volume_perf_t *cfg_volume_perf; + cfg_volume_usage_t *cfg_volume_usage; + cfg_system_t *cfg_system; + struct host_config_s *next; }; +#define HOST_INIT { NULL, NA_SERVER_TRANSPORT_HTTPS, NULL, 0, NULL, NULL, 0, \ + NULL, NULL, NULL, NULL, NULL, NULL, \ + NULL} -#define HOST_INIT {0, 0, NA_SERVER_TRANSPORT_HTTPS, 0, 0, 0, 0, 10, 0, 0, 0} +static host_config_t *global_host_config; -static host_config_t *host_config; +/* + * Free functions + * + * Used to free the various structures above. + */ +static void free_disk (disk_t *disk) /* {{{ */ +{ + disk_t *next; -static volume_t *get_volume(host_config_t *host, const char *name) { - volume_t *v; - - for (v = host->volumes; v; v = v->next) { - if (!strcmp(v->name/* + 4*/, name)) return v; - } - v = malloc(sizeof(*v)); - v->name = strdup(name); -// v->name = malloc(strlen(name) + 5); -// strcpy(v->name, "vol-"); -// strcpy(v->name + 4, name); - v->perf_data.flags = 0; - v->volume_data.flags = 0; - v->next = host->volumes; - host->volumes = v; - return v; -} + if (disk == NULL) + return; -static disk_t *get_disk(host_config_t *host, const char *name) { - disk_t *v, init = DISK_INIT; - - for (v = host->disks; v; v = v->next) { - if (!strcmp(v->name/* + 5*/, name)) return v; - } - v = malloc(sizeof(*v)); - *v = init; - v->name = strdup(name); -// v->name = malloc(strlen(name) + 6); -// strcpy(v->name, "disk-"); -// strcpy(v->name + 5, name); - v->next = host->disks; - host->disks = v; - return v; -} + next = disk->next; -static void collect_perf_wafl_data(host_config_t *host, na_elem_t *out, void *data) { - perf_wafl_data_t *wafl = data; - uint64_t name_cache_hit = 0, name_cache_miss = 0, find_dir_hit = 0, find_dir_miss = 0, buf_hash_hit = 0, buf_hash_miss = 0, inode_cache_hit = 0, inode_cache_miss = 0; - const char *instance, *name; - time_t timestamp; - na_elem_t *counter; - value_t values[2]; + 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; + + 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_perf (cfg_volume_perf_t *cvp) /* {{{ */ +{ + data_volume_perf_t *data; + + if (cvp == NULL) + return; + + /* Free the ignorelists */ + ignorelist_free (cvp->il_octets); + ignorelist_free (cvp->il_operations); + ignorelist_free (cvp->il_latency); + + /* Free the linked list of volumes */ + data = cvp->volumes; + while (data != NULL) + { + data_volume_perf_t *next = data->next; + sfree (data->name); + sfree (data); + data = next; + } + + if (cvp->query != NULL) + na_elem_free (cvp->query); + + sfree (cvp); +} /* }}} void free_cfg_volume_perf */ + +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); + if (data->snap_query != NULL) + na_elem_free(data->snap_query); + 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_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_disk (hc->cfg_disk); + free_cfg_wafl (hc->cfg_wafl); + free_cfg_volume_perf (hc->cfg_volume_perf); + free_cfg_volume_usage (hc->cfg_volume_usage); + free_cfg_system (hc->cfg_system); + + if (hc->srv != NULL) + na_server_close (hc->srv); + + sfree (hc); + + free_host_config (next); +} /* }}} void free_host_config */ + +/* + * Auxiliary functions + * + * Used to look up volumes and disks or to handle flags. + */ +static disk_t *get_disk(cfg_disk_t *cd, const char *name) /* {{{ */ +{ + disk_t *d; + + if ((cd == NULL) || (name == NULL)) + return (NULL); + + for (d = cd->disks; d != NULL; d = d->next) { + if (strcmp(d->name, name) == 0) + return d; + } + + d = malloc(sizeof(*d)); + if (d == NULL) + return (NULL); + memset (d, 0, sizeof (*d)); + d->next = NULL; + + d->name = strdup(name); + if (d->name == NULL) { + sfree (d); + return (NULL); + } + + d->next = cd->disks; + cd->disks = d; + + 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; + new->snap_query = na_elem_new ("snapshot-list-info"); + na_child_add_string(new->snap_query, "target-type", "volume"); + na_child_add_string(new->snap_query, "target-name", name); + } else { + new->snap_query = NULL; + } + + /* 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 data_volume_perf_t *get_volume_perf (cfg_volume_perf_t *cvp, /* {{{ */ + const char *name) +{ + data_volume_perf_t *last; + data_volume_perf_t *new; + + int ignore_octets = 0; + int ignore_operations = 0; + int ignore_latency = 0; + + if ((cvp == NULL) || (name == NULL)) + return (NULL); + + last = cvp->volumes; + while (last != NULL) + { + if (strcmp (last->name, name) == 0) + return (last); + + if (last->next == NULL) + break; + + last = last->next; + } + + /* Check the ignorelists. If *all three* tell us to ignore a volume, return + * NULL. */ + ignore_octets = ignorelist_match (cvp->il_octets, name); + ignore_operations = ignorelist_match (cvp->il_operations, name); + ignore_latency = ignorelist_match (cvp->il_latency, name); + if ((ignore_octets != 0) || (ignore_operations != 0) + || (ignore_latency != 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_octets == 0) + new->flags |= CFG_VOLUME_PERF_IO; + if (ignore_operations == 0) + new->flags |= CFG_VOLUME_PERF_OPS; + if (ignore_latency == 0) + new->flags |= CFG_VOLUME_PERF_LATENCY; + + /* Add to end of list. */ + if (last == NULL) + cvp->volumes = new; + else + last->next = new; + + return (new); +} /* }}} data_volume_perf_t *get_volume_perf */ + +/* + * 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, + value_t *values, int values_len, + time_t timestamp) +{ value_list_t vl = VALUE_LIST_INIT; + + vl.values = values; + vl.values_len = values_len; + + if (timestamp > 0) + vl.time = timestamp; + + 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)); + sstrncpy (vl.type, type, sizeof (vl.type)); + if (type_inst != NULL) + sstrncpy (vl.type_instance, type_inst, sizeof (vl.type_instance)); + + return (plugin_dispatch_values (&vl)); +} /* }}} int submit_uint64 */ + +static int submit_two_counters (const char *host, const char *plugin_inst, /* {{{ */ + const char *type, const char *type_inst, counter_t val0, counter_t val1, + time_t timestamp) +{ + value_t values[2]; + + values[0].counter = val0; + values[1].counter = val1; + + return (submit_values (host, plugin_inst, type, type_inst, + values, 2, timestamp)); +} /* }}} int submit_two_counters */ + +static int submit_counter (const char *host, const char *plugin_inst, /* {{{ */ + const char *type, const char *type_inst, counter_t counter, time_t timestamp) +{ + value_t v; + + v.counter = counter; + + return (submit_values (host, plugin_inst, type, type_inst, + &v, 1, timestamp)); +} /* }}} int submit_counter */ + +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, + time_t timestamp) +{ + value_t values[2]; + + values[0].gauge = val0; + values[1].gauge = val1; + + return (submit_values (host, plugin_inst, type, type_inst, + values, 2, timestamp)); +} /* }}} int submit_two_gauge */ + +static int submit_double (const char *host, const char *plugin_inst, /* {{{ */ + const char *type, const char *type_inst, double d, time_t timestamp) +{ + value_t v; + + v.gauge = (gauge_t) d; + + return (submit_values (host, plugin_inst, type, type_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, + uint64_t new_hits, + uint64_t new_misses, + uint64_t old_hits, + uint64_t old_misses, + time_t timestamp) +{ + value_t v; + + if ((new_hits >= old_hits) && (new_misses >= old_misses)) { + uint64_t hits; + uint64_t misses; + + hits = new_hits - old_hits; + 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, + &v, 1, timestamp)); +} /* }}} int submit_cache_ratio */ + +/* 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 (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 (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 (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 (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); + + /* Clear old HAVE_* flags */ + old_data->flags &= ~HAVE_WAFL_ALL; + + /* Copy all counters */ + old_data->timestamp = new_data->timestamp; + old_data->name_cache_hit = new_data->name_cache_hit; + old_data->name_cache_miss = new_data->name_cache_miss; + old_data->find_dir_hit = new_data->find_dir_hit; + old_data->find_dir_miss = new_data->find_dir_miss; + old_data->buf_hash_hit = new_data->buf_hash_hit; + old_data->buf_hash_miss = new_data->buf_hash_miss; + old_data->inode_cache_hit = new_data->inode_cache_hit; + old_data->inode_cache_miss = new_data->inode_cache_miss; + + /* Copy HAVE_* flags */ + old_data->flags |= (new_data->flags & HAVE_WAFL_ALL); + + 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 char *hostname, /* {{{ */ + data_volume_perf_t *old_data, + const data_volume_perf_t *new_data) +{ + /* Check for and submit disk-octet values */ + if (HAS_ALL_FLAGS (old_data->flags, CFG_VOLUME_PERF_IO) + && HAS_ALL_FLAGS (new_data->flags, HAVE_VOLUME_PERF_BYTES_READ | HAVE_VOLUME_PERF_BYTES_WRITE)) + { + submit_two_counters (hostname, old_data->name, "disk_octets", /* type instance = */ NULL, + (counter_t) new_data->read_bytes, (counter_t) new_data->write_bytes, new_data->timestamp); + } + + /* Check for and submit disk-operations values */ + if (HAS_ALL_FLAGS (old_data->flags, CFG_VOLUME_PERF_OPS) + && HAS_ALL_FLAGS (new_data->flags, HAVE_VOLUME_PERF_OPS_READ | HAVE_VOLUME_PERF_OPS_WRITE)) + { + submit_two_counters (hostname, old_data->name, "disk_ops", /* type instance = */ NULL, + (counter_t) new_data->read_ops, (counter_t) new_data->write_ops, new_data->timestamp); + } + + /* Check for, calculate and submit disk-latency values */ + if (HAS_ALL_FLAGS (old_data->flags, CFG_VOLUME_PERF_LATENCY + | HAVE_VOLUME_PERF_OPS_READ | HAVE_VOLUME_PERF_OPS_WRITE + | HAVE_VOLUME_PERF_LATENCY_READ | HAVE_VOLUME_PERF_LATENCY_WRITE) + && HAS_ALL_FLAGS (new_data->flags, HAVE_VOLUME_PERF_OPS_READ | HAVE_VOLUME_PERF_OPS_WRITE + | HAVE_VOLUME_PERF_LATENCY_READ | HAVE_VOLUME_PERF_LATENCY_WRITE)) + { + gauge_t latency_per_op_read; + gauge_t latency_per_op_write; + + latency_per_op_read = NAN; + latency_per_op_write = NAN; + + /* Check if a counter wrapped around. */ + if ((new_data->read_ops > old_data->read_ops) + && (new_data->read_latency > old_data->read_latency)) + { + uint64_t diff_ops_read; + uint64_t diff_latency_read; + + diff_ops_read = new_data->read_ops - old_data->read_ops; + diff_latency_read = new_data->read_latency - old_data->read_latency; + + if (diff_ops_read > 0) + latency_per_op_read = ((gauge_t) diff_latency_read) / ((gauge_t) diff_ops_read); + } + + if ((new_data->write_ops > old_data->write_ops) + && (new_data->write_latency > old_data->write_latency)) + { + uint64_t diff_ops_write; + uint64_t diff_latency_write; + + diff_ops_write = new_data->write_ops - old_data->write_ops; + diff_latency_write = new_data->write_latency - old_data->write_latency; + + if (diff_ops_write > 0) + latency_per_op_write = ((gauge_t) diff_latency_write) / ((gauge_t) diff_ops_write); + } + + submit_two_gauge (hostname, old_data->name, "disk_latency", /* type instance = */ NULL, + latency_per_op_read, latency_per_op_write, new_data->timestamp); + } + + /* Clear all HAVE_* flags. */ + old_data->flags &= ~HAVE_VOLUME_PERF_ALL; + + /* Copy all counters */ + old_data->timestamp = new_data->timestamp; + old_data->read_bytes = new_data->read_bytes; + old_data->write_bytes = new_data->write_bytes; + old_data->read_ops = new_data->read_ops; + old_data->write_ops = new_data->write_ops; + old_data->read_latency = new_data->read_latency; + old_data->write_latency = new_data->write_latency; + + /* Copy the HAVE_* flags */ + old_data->flags |= (new_data->flags & HAVE_VOLUME_PERF_ALL); + + return (0); +} /* }}} int submit_volume_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 */ +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)); - 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"); + perf_data.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_wafl_data: " + "na_elem_child (\"instances\") failed."); + return (-1); + } + + plugin_inst = na_child_get_string(instances, "name"); + if (plugin_inst == NULL) + { + ERROR ("netapp plugin: cna_handle_wafl_data: " + "na_child_get_string (\"name\") failed."); + return (-1); + } + + /* Iterate over all counters */ + 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; - 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)) { 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; + if (!strcmp(name, "name_cache_hit")) { - name_cache_hit = na_child_get_uint64(counter, "value", 0); + perf_data.name_cache_hit = value; + perf_data.flags |= HAVE_WAFL_NAME_CACHE_HIT; } else if (!strcmp(name, "name_cache_miss")) { - name_cache_miss = na_child_get_uint64(counter, "value", 0); + perf_data.name_cache_miss = value; + perf_data.flags |= HAVE_WAFL_NAME_CACHE_MISS; } else if (!strcmp(name, "find_dir_hit")) { - find_dir_hit = na_child_get_uint64(counter, "value", 0); + perf_data.find_dir_hit = value; + perf_data.flags |= HAVE_WAFL_FIND_DIR_HIT; } else if (!strcmp(name, "find_dir_miss")) { - find_dir_miss = na_child_get_uint64(counter, "value", 0); + perf_data.find_dir_miss = value; + perf_data.flags |= HAVE_WAFL_FIND_DIR_MISS; } else if (!strcmp(name, "buf_hash_hit")) { - buf_hash_hit = na_child_get_uint64(counter, "value", 0); + perf_data.buf_hash_hit = value; + perf_data.flags |= HAVE_WAFL_BUF_HASH_HIT; } else if (!strcmp(name, "buf_hash_miss")) { - buf_hash_miss = na_child_get_uint64(counter, "value", 0); + perf_data.buf_hash_miss = value; + perf_data.flags |= HAVE_WAFL_BUF_HASH_MISS; } else if (!strcmp(name, "inode_cache_hit")) { - inode_cache_hit = na_child_get_uint64(counter, "value", 0); + perf_data.inode_cache_hit = value; + perf_data.flags |= HAVE_WAFL_INODE_CACHE_HIT; } else if (!strcmp(name, "inode_cache_miss")) { - inode_cache_miss = na_child_get_uint64(counter, "value", 0); + perf_data.inode_cache_miss = value; + perf_data.flags |= HAVE_WAFL_INODE_CACHE_MISS; + } else { + DEBUG("netapp plugin: cna_handle_wafl_data: " + "Found unexpected child: %s", name); } } - if ((wafl->flags & PERF_WAFL_NAME_CACHE) && name_cache_hit && name_cache_miss) { - values[0].gauge = 0; - if (name_cache_miss - wafl->last_name_cache_miss + name_cache_hit - wafl->last_name_cache_hit) values[0].gauge = 100.0 * (name_cache_hit - wafl->last_name_cache_hit) / (name_cache_miss - wafl->last_name_cache_miss + name_cache_hit - wafl->last_name_cache_hit); - vl.values = values; - vl.values_len = 1; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, instance, sizeof(vl.plugin_instance)); - sstrncpy(vl.type_instance, "name_cache_hit", sizeof(vl.type_instance)); - if (wafl->last_name_cache_hit && wafl->last_name_cache_miss) { - DEBUG("%s/netapp-%s/cache_ratio: %lf", host->name, instance, values[0].gauge); - plugin_dispatch_values ("cache_ratio", &vl); - } - wafl->last_name_cache_hit = name_cache_hit; - wafl->last_name_cache_miss = name_cache_miss; - } - if ((wafl->flags & PERF_WAFL_DIR_CACHE) && find_dir_hit && find_dir_miss) { - values[0].gauge = 0; - if (find_dir_miss - wafl->last_find_dir_miss + find_dir_hit - wafl->last_find_dir_hit) values[0].gauge = 100.0 * (find_dir_hit - wafl->last_find_dir_hit) / (find_dir_miss - wafl->last_find_dir_miss + find_dir_hit - wafl->last_find_dir_hit); - vl.values = values; - vl.values_len = 1; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, instance, sizeof(vl.plugin_instance)); - sstrncpy(vl.type_instance, "find_dir_hit", sizeof(vl.type_instance)); - if (wafl->last_find_dir_hit && wafl->last_find_dir_miss) { - DEBUG("%s/netapp-%s/cache_ratio: %lf", host->name, instance, values[0].gauge); - plugin_dispatch_values ("cache_ratio", &vl); - } - wafl->last_find_dir_hit = find_dir_hit; - wafl->last_find_dir_miss = find_dir_miss; - } - if ((wafl->flags & PERF_WAFL_BUF_CACHE) && buf_hash_hit && buf_hash_miss) { - values[0].gauge = 0; - if (buf_hash_miss - wafl->last_buf_hash_miss + buf_hash_hit - wafl->last_buf_hash_hit) values[0].gauge = 100.0 * (buf_hash_hit - wafl->last_buf_hash_hit) / (buf_hash_miss - wafl->last_buf_hash_miss + buf_hash_hit - wafl->last_buf_hash_hit); - vl.values = values; - vl.values_len = 1; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, instance, sizeof(vl.plugin_instance)); - sstrncpy(vl.type_instance, "buf_hash_hit", sizeof(vl.type_instance)); - if (wafl->last_buf_hash_hit && wafl->last_buf_hash_miss) { - DEBUG("%s/netapp-%s/cache_ratio: %lf", host->name, instance, values[0].gauge); - plugin_dispatch_values ("cache_ratio", &vl); - } - wafl->last_buf_hash_hit = buf_hash_hit; - wafl->last_buf_hash_miss = buf_hash_miss; - } - if ((wafl->flags & PERF_WAFL_INODE_CACHE) && inode_cache_hit && inode_cache_miss) { - values[0].gauge = 0; - if (inode_cache_miss - wafl->last_inode_cache_miss + inode_cache_hit - wafl->last_inode_cache_hit) values[0].gauge = 100.0 * (inode_cache_hit - wafl->last_inode_cache_hit) / (inode_cache_miss - wafl->last_inode_cache_miss + inode_cache_hit - wafl->last_inode_cache_hit); - vl.values = values; - vl.values_len = 1; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, instance, sizeof(vl.plugin_instance)); - sstrncpy(vl.type_instance, "inode_cache_hit", sizeof(vl.type_instance)); - if (wafl->last_inode_cache_hit && wafl->last_inode_cache_miss) { - DEBUG("%s/netapp-%s/cache_ratio: %lf", host->name, instance, values[0].gauge); - plugin_dispatch_values ("cache_ratio", &vl); - } - wafl->last_inode_cache_hit = inode_cache_hit; - wafl->last_inode_cache_miss = inode_cache_miss; + + return (submit_wafl_data (hostname, plugin_inst, cfg_wafl, &perf_data)); +} /* }}} void cna_handle_wafl_data */ + +static int cna_setup_wafl (cfg_wafl_t *cw) /* {{{ */ +{ + na_elem_t *e; + + if (cw == NULL) + return (EINVAL); + + if (cw->query != NULL) + return (0); + + cw->query = na_elem_new("perf-object-get-instances"); + if (cw->query == NULL) + { + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); } -} + na_child_add_string (cw->query, "objectname", "wafl"); + + e = na_elem_new("counters"); + if (e == NULL) + { + na_elem_free (cw->query); + cw->query = NULL; + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); + } + na_child_add_string(e, "foo", "name_cache_hit"); + na_child_add_string(e, "foo", "name_cache_miss"); + na_child_add_string(e, "foo", "find_dir_hit"); + na_child_add_string(e, "foo", "find_dir_miss"); + na_child_add_string(e, "foo", "buf_hash_hit"); + na_child_add_string(e, "foo", "buf_hash_miss"); + na_child_add_string(e, "foo", "inode_cache_hit"); + na_child_add_string(e, "foo", "inode_cache_miss"); + + na_child_add(cw->query, e); + + return (0); +} /* }}} int cna_setup_wafl */ + +static int cna_query_wafl (host_config_t *host) /* {{{ */ +{ + na_elem_t *data; + int status; + time_t now; + + if (host == NULL) + return (EINVAL); + + /* If WAFL was not configured, return without doing anything. */ + if (host->cfg_wafl == NULL) + return (0); + + now = time (NULL); + if ((host->cfg_wafl->interval.interval + host->cfg_wafl->interval.last_read) > now) + return (0); + + status = cna_setup_wafl (host->cfg_wafl); + if (status != 0) + return (status); + assert (host->cfg_wafl->query != NULL); + + data = na_server_invoke_elem(host->srv, host->cfg_wafl->query); + if (na_results_status (data) != NA_OK) + { + ERROR ("netapp plugin: cna_query_wafl: na_server_invoke_elem failed: %s", + na_results_reason (data)); + na_elem_free (data); + return (-1); + } + + status = cna_handle_wafl_data (host->name, host->cfg_wafl, data); + + if (status == 0) + host->cfg_wafl->interval.last_read = now; + + na_elem_free (data); + return (status); +} /* }}} int cna_query_wafl */ -static void collect_perf_disk_data(host_config_t *host, na_elem_t *out, void *data) { - perf_disk_data_t *perf = data; - const char *name; +/* Data corresponding to */ +static int cna_handle_disk_data (const char *hostname, /* {{{ */ + cfg_disk_t *cfg_disk, na_elem_t *data) +{ time_t timestamp; - na_elem_t *counter, *inst; - disk_t *disk, *worst_disk = 0; - value_t values[2]; - value_list_t vl = VALUE_LIST_INIT; + na_elem_t *instances; + na_elem_t *instance; + na_elem_iter_t instance_iter; + disk_t *worst_disk = NULL; + + if ((cfg_disk == NULL) || (data == NULL)) + return (EINVAL); - timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0); - out = na_elem_child(out, "instances"); - 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 disk_busy = 0, base_for_disk_busy = 0; - - disk = get_disk(host, na_child_get_string(inst, "name")); - 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)) { + 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 (!strcmp(name, "disk_busy")) { - disk_busy = na_child_get_uint64(counter, "value", 0); - } else if (!strcmp(name, "base_for_disk_busy")) { - base_for_disk_busy = na_child_get_uint64(counter, "value", 0); + if (name == NULL) + continue; + + value = na_child_get_uint64(counter, "value", UINT64_MAX); + if (value == UINT64_MAX) + continue; + + if (strcmp(name, "disk_busy") == 0) + { + new_data.disk_busy = value; + new_data.flags |= HAVE_DISK_BUSY; + } + else if (strcmp(name, "base_for_disk_busy") == 0) + { + 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, + * calculate the busy percentage. Otherwise, the value is initialized to + * NAN at the top of the for-loop. */ + if (HAS_ALL_FLAGS (old_data->flags, HAVE_DISK_BUSY | HAVE_DISK_BASE) + && HAS_ALL_FLAGS (new_data.flags, HAVE_DISK_BUSY | HAVE_DISK_BASE) + && (new_data.disk_busy >= old_data->disk_busy) + && (new_data.base_for_disk_busy > old_data->base_for_disk_busy)) + { + uint64_t busy_diff; + uint64_t base_diff; + + busy_diff = new_data.disk_busy - old_data->disk_busy; + base_diff = new_data.base_for_disk_busy - old_data->base_for_disk_busy; + + new_data.disk_busy_percent = 100.0 + * ((gauge_t) busy_diff) / ((gauge_t) base_diff); } - if (disk_busy && base_for_disk_busy) { - disk->perf_data.last_update = timestamp; - disk->perf_data.last_disk_busy_percent = 0; - if (base_for_disk_busy - disk->perf_data.last_base_for_disk_busy) disk->perf_data.last_disk_busy_percent = 100.0 * (disk_busy - disk->perf_data.last_disk_busy) / (base_for_disk_busy - disk->perf_data.last_base_for_disk_busy); - if (disk->perf_data.last_disk_busy && disk->perf_data.last_base_for_disk_busy && (!worst_disk || worst_disk->perf_data.last_disk_busy_percent < disk->perf_data.last_disk_busy_percent)) worst_disk = disk; - disk->perf_data.last_disk_busy = disk_busy; - disk->perf_data.last_base_for_disk_busy = base_for_disk_busy; + + /* Clear HAVE_* flags */ + old_data->flags &= ~HAVE_DISK_ALL; + + /* Copy data */ + old_data->timestamp = new_data.timestamp; + old_data->disk_busy = new_data.disk_busy; + old_data->base_for_disk_busy = new_data.base_for_disk_busy; + old_data->disk_busy_percent = new_data.disk_busy_percent; + + /* Copy flags */ + old_data->flags |= (new_data.flags & HAVE_DISK_ALL); + + if ((worst_disk == NULL) + || (worst_disk->disk_busy_percent < old_data->disk_busy_percent)) + worst_disk = old_data; + } /* for (all disks) */ + + if ((cfg_disk->flags & CFG_DISK_BUSIEST) && (worst_disk != NULL)) + submit_double (hostname, "system", "percent", "disk_busy", + worst_disk->disk_busy_percent, timestamp); + + return (0); +} /* }}} int cna_handle_disk_data */ + +static int cna_setup_disk (cfg_disk_t *cd) /* {{{ */ +{ + na_elem_t *e; + + if (cd == NULL) + return (EINVAL); + + if (cd->query != NULL) + return (0); + + cd->query = na_elem_new ("perf-object-get-instances"); + if (cd->query == NULL) + { + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); + } + na_child_add_string (cd->query, "objectname", "disk"); + + e = na_elem_new("counters"); + if (e == NULL) + { + na_elem_free (cd->query); + cd->query = NULL; + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); + } + na_child_add_string(e, "foo", "disk_busy"); + na_child_add_string(e, "foo", "base_for_disk_busy"); + na_child_add(cd->query, e); + + return (0); +} /* }}} int cna_setup_disk */ + +static int cna_query_disk (host_config_t *host) /* {{{ */ +{ + na_elem_t *data; + int status; + time_t now; + + if (host == NULL) + return (EINVAL); + + /* If the user did not configure disk statistics, return without doing + * anything. */ + if (host->cfg_disk == NULL) + return (0); + + now = time (NULL); + if ((host->cfg_disk->interval.interval + host->cfg_disk->interval.last_read) > now) + return (0); + + status = cna_setup_disk (host->cfg_disk); + if (status != 0) + return (status); + assert (host->cfg_disk->query != NULL); + + data = na_server_invoke_elem(host->srv, host->cfg_disk->query); + if (na_results_status (data) != NA_OK) + { + ERROR ("netapp plugin: cna_query_disk: na_server_invoke_elem failed: %s", + na_results_reason (data)); + na_elem_free (data); + return (-1); + } + + status = cna_handle_disk_data (host->name, host->cfg_disk, data); + + if (status == 0) + host->cfg_disk->interval.last_read = now; + + na_elem_free (data); + return (status); +} /* }}} int cna_query_disk */ + +/* Data corresponding to */ +static int cna_handle_volume_perf_data (const char *hostname, /* {{{ */ + cfg_volume_perf_t *cvp, na_elem_t *data) +{ + time_t timestamp; + na_elem_t *elem_instances; + na_elem_iter_t iter_instances; + na_elem_t *elem_instance; + + timestamp = (time_t) na_child_get_uint64(data, "timestamp", 0); + + elem_instances = na_elem_child(data, "instances"); + if (elem_instances == NULL) + { + ERROR ("netapp plugin: handle_volume_perf_data: " + "na_elem_child (\"instances\") failed."); + return (-1); + } + + iter_instances = na_child_iterator (elem_instances); + for (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 *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"); + if (name == NULL) + continue; + + /* get_volume_perf may return NULL if this volume is to be ignored. */ + v = get_volume_perf (cvp, name); + if (v == NULL) + continue; + + elem_counters = na_elem_child (elem_instance, "counters"); + if (elem_counters == NULL) + continue; + + iter_counters = na_child_iterator (elem_counters); + for (elem_counter = na_iterator_next(&iter_counters); + elem_counter != NULL; + elem_counter = na_iterator_next(&iter_counters)) + { + const char *name; + uint64_t value; + + name = na_child_get_string (elem_counter, "name"); + if (name == NULL) + continue; + + value = na_child_get_uint64 (elem_counter, "value", UINT64_MAX); + if (value == UINT64_MAX) + continue; + + if (!strcmp(name, "read_data")) { + perf_data.read_bytes = value; + perf_data.flags |= HAVE_VOLUME_PERF_BYTES_READ; + } else if (!strcmp(name, "write_data")) { + perf_data.write_bytes = value; + perf_data.flags |= HAVE_VOLUME_PERF_BYTES_WRITE; + } else if (!strcmp(name, "read_ops")) { + perf_data.read_ops = value; + perf_data.flags |= HAVE_VOLUME_PERF_OPS_READ; + } else if (!strcmp(name, "write_ops")) { + perf_data.write_ops = value; + perf_data.flags |= HAVE_VOLUME_PERF_OPS_WRITE; + } else if (!strcmp(name, "read_latency")) { + perf_data.read_latency = value; + perf_data.flags |= HAVE_VOLUME_PERF_LATENCY_READ; + } else if (!strcmp(name, "write_latency")) { + perf_data.write_latency = value; + perf_data.flags |= HAVE_VOLUME_PERF_LATENCY_WRITE; + } + } /* for (elem_counter) */ + + submit_volume_perf_data (hostname, v, &perf_data); + } /* for (volume) */ + + return (0); +} /* }}} int cna_handle_volume_perf_data */ + +static int cna_setup_volume_perf (cfg_volume_perf_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", "volume"); + + 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); + } + /* "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(cd->query, e); + + return (0); +} /* }}} int cna_setup_volume_perf */ + +static int cna_query_volume_perf (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 performance statistics, return + * without doing anything. */ + if (host->cfg_volume_perf == NULL) + return (0); + + now = time (NULL); + if ((host->cfg_volume_perf->interval.interval + host->cfg_volume_perf->interval.last_read) > now) + return (0); + + status = cna_setup_volume_perf (host->cfg_volume_perf); + if (status != 0) + return (status); + assert (host->cfg_volume_perf->query != NULL); + + data = na_server_invoke_elem (host->srv, host->cfg_volume_perf->query); + if (na_results_status (data) != NA_OK) + { + ERROR ("netapp plugin: cna_query_volume_perf: na_server_invoke_elem failed: %s", + na_results_reason (data)); + na_elem_free (data); + return (-1); + } + + status = cna_handle_volume_perf_data (host->name, host->cfg_volume_perf, data); + + if (status == 0) + host->cfg_volume_perf->interval.last_read = now; + + na_elem_free (data); + return (status); +} /* }}} int cna_query_volume_perf */ + +/* Data corresponding to */ +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) + { + uint64_t norm_used = v->norm_used; + uint64_t norm_free = v->norm_free; + uint64_t sis_saved = v->sis_saved; + uint64_t snap_reserve_used = 0; + uint64_t snap_reserve_free = v->snap_reserved; + uint64_t snap_norm_used = v->snap_used; + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_USED | HAVE_VOLUME_USAGE_SNAP_RSVD)) { + if (v->snap_reserved > v->snap_used) { + snap_reserve_free = v->snap_reserved - v->snap_used; + snap_reserve_used = v->snap_used; + snap_norm_used = 0; + } else { + snap_reserve_free = 0; + snap_reserve_used = v->snap_reserved; + snap_norm_used = v->snap_used - v->snap_reserved; + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_USED) + && (norm_used >= snap_norm_used)) + norm_used -= snap_norm_used; + } } + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_FREE)) + submit_double (hostname, /* plugin instance = */ v->name, + "df_complex", "free", + (double) norm_free, /* 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) sis_saved, /* timestamp = */ 0); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_USED)) + submit_double (hostname, /* plugin instance = */ v->name, + "df_complex", "used", + (double) 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) snap_reserve_free, /* timestamp = */ 0); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_USED | HAVE_VOLUME_USAGE_SNAP_RSVD)) + submit_double (hostname, /* plugin instance = */ v->name, + "df_complex", "snap_reserve_used", + (double) snap_reserve_used, /* timestamp = */ 0); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_USED)) + submit_double (hostname, /* plugin instance = */ v->name, + "df_complex", "snap_normal_used", + (double) snap_norm_used, /* 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 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_iter_t iter_snap; + + data = na_server_invoke_elem(host->srv, v->snap_query); + if (na_results_status(data) != NA_OK) + { + if (na_results_errno(data) != EVOLUMEOFFLINE) + ERROR ("netapp plugin: cna_handle_volume_snap_usage: na_server_invoke_elem for " + "volume \"%s\" failed with error %d: %s", v->name, + na_results_errno(data), na_results_reason(data)); + na_elem_free(data); + return; } - if ((perf->flags & PERF_DISK_BUSIEST) && worst_disk) { - values[0].gauge = worst_disk->perf_data.last_disk_busy_percent; - vl.values = values; - vl.values_len = 1; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, "system", sizeof(vl.plugin_instance)); - sstrncpy(vl.type_instance, "disk_busy", sizeof(vl.type_instance)); - DEBUG("%s/netapp-system/percent-disk_busy: %lf", host->name, worst_disk->perf_data.last_disk_busy_percent); - plugin_dispatch_values ("percent", &vl); + + elem_snapshots = na_elem_child (data, "snapshots"); + if (elem_snapshots == NULL) + { + ERROR ("netapp plugin: cna_handle_volume_snap_usage: " + "na_elem_child (\"snapshots\") failed."); + na_elem_free(data); + return; } + + iter_snap = na_child_iterator (elem_snapshots); + for (elem_snap = na_iterator_next (&iter_snap); + elem_snap != NULL; + elem_snap = na_iterator_next (&iter_snap)) + { + value = na_child_get_uint64(elem_snap, "cumulative-total", 0); + if (value > snap_used) + snap_used = value; + } + na_elem_free (data); + /* snap_used is the total size of the oldest snapshot plus all + * newer ones in blocks (1KB). */ + v->snap_used = snap_used * 1024; + v->flags |= HAVE_VOLUME_USAGE_SNAP_USED; } -static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) { - na_elem_t *inst, *sis; - volume_t *volume; - volume_data_t *volume_data = data; - value_t values[1]; - value_list_t vl = VALUE_LIST_INIT; +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; + + 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, *state; + + data_volume_usage_t *v; + 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) + continue; + + state = na_child_get_string (elem_volume, "state"); + if ((state == NULL) || (strcmp(state, "online") != 0)) + 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 ((v->flags & CFG_VOLUME_USAGE_SNAP) != 0) + cna_handle_volume_snap_usage(host, v); + + if ((v->flags & CFG_VOLUME_USAGE_DF) == 0) + continue; + + /* 2^4 exa-bytes? This will take a while ;) */ + 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 */ + v->snap_reserved = 1024 * value; + v->flags |= HAVE_VOLUME_USAGE_SNAP_RSVD; + } + + sis = na_elem_child(elem_volume, "sis"); + if (sis == NULL) + continue; + + 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; - 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, sis_saved = 0; - volume = get_volume(host, na_child_get_string(inst, "name")); - if (!(volume->volume_data.flags & VOLUME_INIT)) volume->volume_data.flags = volume_data->flags; - if (!(volume->volume_data.flags & VOLUME_DF)) continue; - size_free = na_child_get_uint64(inst, "size-available", 0); - size_used = na_child_get_uint64(inst, "size-used", 0); - snap_reserved = na_child_get_uint64(inst, "snapshot-blocks-reserved", 0) * 1024; - - vl.values_len = 1; - vl.values = values; - vl.time = time(0); - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, volume->name, sizeof(vl.plugin_instance)); - - values[0].gauge = size_used; - sstrncpy(vl.type_instance, "used", sizeof(vl.type_instance)); - DEBUG("%s/netapp-%s/df_complex-used: %llu", host->name, volume->name, size_used); - plugin_dispatch_values ("df_complex", &vl); - - values[0].gauge = size_free; - sstrncpy(vl.type_instance, "free", sizeof(vl.type_instance)); - DEBUG("%s/netapp-%s/df_complex-free: %llu", host->name, volume->name, size_free); - plugin_dispatch_values ("df_complex", &vl); - - if (snap_reserved) { - values[0].gauge = snap_reserved; - sstrncpy(vl.type_instance, "snap_reserved", sizeof(vl.type_instance)); - DEBUG("%s/netapp-%s/df_complex-snap_reserved: %llu", host->name, volume->name, snap_reserved); - plugin_dispatch_values ("df_complex", &vl); - } + 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; - sis = na_elem_child(inst, "sis"); - if (sis && !strcmp(na_child_get_string(sis, "state"), "enabled")) { - uint64_t sis_saved_reported = na_child_get_uint64(sis, "size-saved", 0), sis_saved_percent = na_child_get_uint64(sis, "percentage-saved", 0); - /* size-saved is actually a 32 bit number, so ... time for some guesswork. */ - if (sis_saved_reported >> 32) { - /* In case they ever fix this bug. */ - sis_saved = sis_saved_reported; + /* 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 { - uint64_t real_saved = sis_saved_percent * size_used / (100 - sis_saved_percent); - uint64_t overflow_guess = real_saved >> 32; - uint64_t guess1 = overflow_guess ? ((overflow_guess - 1) << 32) + sis_saved_reported : sis_saved_reported; - uint64_t guess2 = (overflow_guess << 32) + sis_saved_reported; - uint64_t guess3 = ((overflow_guess + 1) << 32) + sis_saved_reported; - - if (real_saved < guess2) { - if (real_saved - guess1 < guess2 - real_saved) sis_saved = guess1; - else sis_saved = guess2; - } else { - if (real_saved - guess2 < guess3 - real_saved) sis_saved = guess2; - else sis_saved = guess3; - } + if ((sis_saved_guess - guess2) < (guess3 - sis_saved_guess)) + v->sis_saved = guess2; + else + v->sis_saved = guess3; } - values[0].gauge = sis_saved; - sstrncpy(vl.type_instance, "sis_saved", sizeof(vl.type_instance)); - DEBUG("%s/netapp-%s/df_complex-sis_saved: %llu", host->name, volume->name, sis_saved); - plugin_dispatch_values ("df_complex", &vl); - } + v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED; + } /* }}} end of 32-bit workaround */ + } /* for (elem_volume) */ + + return (cna_submit_volume_usage_data (host->name, cfg_volume)); +} /* }}} int cna_handle_volume_usage_data */ + +static int cna_setup_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */ +{ + if (cvu == NULL) + return (EINVAL); + + 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); } -} -static void collect_perf_volume_data(host_config_t *host, na_elem_t *out, void *data) { - perf_volume_data_t *perf = data; - const char *name; - time_t timestamp; - na_elem_t *counter, *inst; - volume_t *volume; - value_t values[2]; - value_list_t vl = VALUE_LIST_INIT; - - timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0); - out = na_elem_child(out, "instances"); - 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 read_data = 0, write_data = 0, read_ops = 0, write_ops = 0, read_latency = 0, write_latency = 0; - - volume = get_volume(host, na_child_get_string(inst, "name")); - if (!volume->perf_data.flags) { - volume->perf_data.flags = perf->flags; - volume->perf_data.last_read_latency = volume->perf_data.last_read_ops = 0; - volume->perf_data.last_write_latency = volume->perf_data.last_write_ops = 0; - } - 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)) { - name = na_child_get_string(counter, "name"); - if (!strcmp(name, "read_ops")) { - read_ops = na_child_get_uint64(counter, "value", 0); - } else if (!strcmp(name, "write_ops")) { - write_ops = na_child_get_uint64(counter, "value", 0); - } else if (!strcmp(name, "read_data")) { - read_data = na_child_get_uint64(counter, "value", 0); - } else if (!strcmp(name, "write_data")) { - write_data = na_child_get_uint64(counter, "value", 0); - } else if (!strcmp(name, "read_latency")) { - read_latency = na_child_get_uint64(counter, "value", 0); - } else if (!strcmp(name, "write_latency")) { - write_latency = na_child_get_uint64(counter, "value", 0); - } - } - if (read_ops && write_ops) { - values[0].counter = read_ops; - values[1].counter = write_ops; - vl.values = values; - vl.values_len = 2; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, volume->name, sizeof(vl.plugin_instance)); - vl.type_instance[0] = 0; - if (volume->perf_data.flags & PERF_VOLUME_OPS) { - /* We might need the data even if it wasn't configured to calculate - the latency. Therefore we just skip the dispatch. */ - DEBUG("%s/netapp-%s/disk_ops: %llu %llu", host->name, instance, read_ops, write_ops); - plugin_dispatch_values("disk_ops", &vl); - } - if ((volume->perf_data.flags & PERF_VOLUME_LATENCY) && read_latency && write_latency) { - values[0].gauge = 0; - if (read_ops - volume->perf_data.last_read_ops) values[0].gauge = (read_latency - volume->perf_data.last_read_latency) * (timestamp - volume->perf_data.last_timestamp) / (read_ops - volume->perf_data.last_read_ops); - values[1].gauge = 0; - if (write_ops - volume->perf_data.last_write_ops) values[1].gauge = (write_latency - volume->perf_data.last_write_latency) * (timestamp - volume->perf_data.last_timestamp) / (write_ops - volume->perf_data.last_write_ops); - vl.values = values; - vl.values_len = 2; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, volume->name, sizeof(vl.plugin_instance)); - vl.type_instance[0] = 0; - if (volume->perf_data.last_read_ops && volume->perf_data.last_write_ops) { - DEBUG("%s/netapp-%s/disk_latency: lrlc: %llu ro: %llu lro: %llu rl: %llu lrl: %llu %llu %llu", host->name, instance, volume->perf_data.last_read_latency_counter, read_ops, volume->perf_data.last_read_ops, read_latency, volume->perf_data.last_read_latency, values[0].counter, values[1].counter); - plugin_dispatch_values("disk_latency", &vl); - } - volume->perf_data.last_timestamp = timestamp; - volume->perf_data.last_read_latency = read_latency; - volume->perf_data.last_read_ops = read_ops; - volume->perf_data.last_write_latency = write_latency; - volume->perf_data.last_write_ops = write_ops; - } - } - if ((volume->perf_data.flags & PERF_VOLUME_IO) && read_data && write_data) { - values[0].counter = read_data; - values[1].counter = write_data; - vl.values = values; - vl.values_len = 2; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, volume->name, sizeof(vl.plugin_instance)); - vl.type_instance[0] = 0; - DEBUG("%s/netapp-%s/disk_octets: %llu %llu", host->name, instance, read_data, write_data); - plugin_dispatch_values ("disk_octets", &vl); - } + 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); } -} -static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void *data) { - uint64_t disk_read = 0, disk_written = 0, net_recv = 0, net_sent = 0, cpu_busy = 0, cpu_total = 0; - perf_system_data_t *perf = data; - const char *instance, *name; - time_t timestamp; + status = cna_handle_volume_usage_data (host, 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 */ +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; - value_t values[2]; - value_list_t vl = VALUE_LIST_INIT; + 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; + uint32_t counter_flags = 0; + + const char *instance; + time_t timestamp; - 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); + } + + 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; - 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)) { 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; + if (!strcmp(name, "disk_data_read")) { - disk_read = na_child_get_uint64(counter, "value", 0) * 1024; + disk_read = (counter_t) (value * 1024); + counter_flags |= 0x01; } else if (!strcmp(name, "disk_data_written")) { - disk_written = na_child_get_uint64(counter, "value", 0) * 1024; + disk_written = (counter_t) (value * 1024); + counter_flags |= 0x02; } else if (!strcmp(name, "net_data_recv")) { - net_recv = na_child_get_uint64(counter, "value", 0) * 1024; + net_recv = (counter_t) (value * 1024); + counter_flags |= 0x04; } else if (!strcmp(name, "net_data_sent")) { - net_sent = na_child_get_uint64(counter, "value", 0) * 1024; + net_sent = (counter_t) (value * 1024); + counter_flags |= 0x08; } else if (!strcmp(name, "cpu_busy")) { - cpu_busy = na_child_get_uint64(counter, "value", 0); + cpu_busy = (counter_t) value; + counter_flags |= 0x10; } else if (!strcmp(name, "cpu_elapsed_time")) { - cpu_total = na_child_get_uint64(counter, "value", 0); - } else if ((perf->flags & PERF_SYSTEM_OPS) && strlen(name) > 4 && !strcmp(name + strlen(name) - 4, "_ops")) { - values[0].counter = na_child_get_uint64(counter, "value", 0); - if (!values[0].counter) continue; - vl.values = values; - vl.values_len = 1; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, instance, sizeof(vl.plugin_instance)); - sstrncpy(vl.type_instance, name, sizeof(vl.plugin_instance)); - DEBUG("%s/netapp-%s/disk_ops_complex-%s: %llu", host->name, instance, name, values[0].counter); - plugin_dispatch_values ("disk_ops_complex", &vl); + cpu_total = (counter_t) value; + counter_flags |= 0x20; + } else if ((cfg_system->flags & CFG_SYSTEM_OPS) + && (value > 0) && (strlen(name) > 4) + && (!strcmp(name + strlen(name) - 4, "_ops"))) { + submit_counter (hostname, instance, "disk_ops_complex", name, + (counter_t) value, timestamp); } - } - if ((perf->flags & PERF_SYSTEM_DISK) && disk_read && disk_written) { - values[0].counter = disk_read; - values[1].counter = disk_written; - vl.values = values; - vl.values_len = 2; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, instance, sizeof(vl.plugin_instance)); - vl.type_instance[0] = 0; - DEBUG("%s/netapp-%s/disk_octets: %llu %llu", host->name, instance, disk_read, disk_written); - plugin_dispatch_values ("disk_octets", &vl); - } - if ((perf->flags & PERF_SYSTEM_NET) && net_recv && net_sent) { - values[0].counter = net_recv; - values[1].counter = net_sent; - vl.values = values; - vl.values_len = 2; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, instance, sizeof(vl.plugin_instance)); - vl.type_instance[0] = 0; - DEBUG("%s/netapp-%s/if_octects: %llu %llu", host->name, instance, net_recv, net_sent); - plugin_dispatch_values ("if_octets", &vl); - } - if ((perf->flags & PERF_SYSTEM_CPU) && cpu_busy && cpu_total) { -// values[0].gauge = (double) (cpu_busy - perf->last_cpu_busy) / (cpu_total - perf->last_cpu_total) * 100; - values[0].counter = cpu_busy / 10000; - vl.values = values; - vl.values_len = 1; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, instance, sizeof(vl.plugin_instance)); - sstrncpy(vl.type_instance, "system", sizeof(vl.plugin_instance)); -// if (perf->last_cpu_busy && perf->last_cpu_total) printf("CPU: busy: %lf - idle: %lf\n", values[0].gauge, 100.0 - values[0].gauge); -// if (perf->last_cpu_busy && perf->last_cpu_total) plugin_dispatch_values ("cpu", &vl); - DEBUG("%s/netapp-%s/cpu: busy: %llu - idle: %llu", host->name, instance, cpu_busy / 10000, cpu_total / 10000); - plugin_dispatch_values ("cpu", &vl); - -// values[0].gauge = 100.0 - (double) (cpu_busy - perf->last_cpu_busy) / (cpu_total - perf->last_cpu_total) * 100; - values[0].counter = (cpu_total - cpu_busy) / 10000; - vl.values = values; - vl.values_len = 1; - vl.time = timestamp; - vl.interval = interval_g; - sstrncpy(vl.plugin, "netapp", sizeof(vl.plugin)); - sstrncpy(vl.host, host->name, sizeof(vl.host)); - sstrncpy(vl.plugin_instance, instance, sizeof(vl.plugin_instance)); - sstrncpy(vl.type_instance, "idle", sizeof(vl.plugin_instance)); -// if (perf->last_cpu_busy && perf->last_cpu_total) plugin_dispatch_values ("cpu", &vl); - plugin_dispatch_values ("cpu", &vl); + } /* for (counter) */ - perf->last_cpu_busy = cpu_busy; - perf->last_cpu_total = cpu_total; + if ((cfg_system->flags & CFG_SYSTEM_DISK) + && (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) + && (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) + && (HAS_ALL_FLAGS (counter_flags, 0x10 | 0x20))) + { + submit_counter (hostname, instance, "cpu", "system", + cpu_busy, timestamp); + submit_counter (hostname, instance, "cpu", "idle", + cpu_total - cpu_busy, timestamp); } -} -int config_init() { - char err[256]; - na_elem_t *e; - host_config_t *host; - service_config_t *service; - - if (!host_config) { - WARNING("netapp plugin: Plugin loaded but no hosts defined."); - return 1; + return (0); +} /* }}} int cna_handle_system_data */ + +static int cna_setup_system (cfg_system_t *cs) /* {{{ */ +{ + if (cs == NULL) + return (EINVAL); + + if (cs->query != NULL) + return (0); + + cs->query = na_elem_new ("perf-object-get-instances"); + if (cs->query == NULL) + { + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); + } + na_child_add_string (cs->query, "objectname", "system"); + + return (0); +} /* }}} int cna_setup_system */ + +static int cna_query_system (host_config_t *host) /* {{{ */ +{ + na_elem_t *data; + int status; + time_t now; + + if (host == NULL) + return (EINVAL); + + /* If system statistics were not configured, return without doing anything. */ + if (host->cfg_system == NULL) + return (0); + + now = time (NULL); + if ((host->cfg_system->interval.interval + host->cfg_system->interval.last_read) > now) + return (0); + + status = cna_setup_system (host->cfg_system); + if (status != 0) + return (status); + assert (host->cfg_system->query != NULL); + + data = na_server_invoke_elem(host->srv, host->cfg_system->query); + if (na_results_status (data) != NA_OK) + { + ERROR ("netapp plugin: cna_query_system: na_server_invoke_elem failed: %s", + na_results_reason (data)); + na_elem_free (data); + return (-1); } - if (!na_startup(err, sizeof(err))) { - ERROR("netapp plugin: Error initializing netapp API: %s", err); - return 1; + status = cna_handle_system_data (host->name, host->cfg_system, data); + + if (status == 0) + host->cfg_system->interval.last_read = now; + + na_elem_free (data); + return (status); +} /* }}} int cna_query_system */ + +/* + * Configuration handling + */ +/* 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)) + return (EINVAL); + + if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)) + { + WARNING ("netapp plugin: The %s option needs exactly one boolean argument.", + ci->key); + return (-1); } - 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 == collect_perf_volume_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 == collect_perf_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 == collect_perf_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"); - } - } + if (ci->values[0].value.boolean) + *flags |= flag; + else + *flags &= ~flag; + + return (0); +} /* }}} int cna_config_bool_to_flag */ + +/* Handling of the "Interval" option which is allowed in every block. */ +static int cna_config_get_interval (const oconfig_item_t *ci, /* {{{ */ + cna_interval_t *out_interval) +{ + time_t tmp; + + if ((ci == NULL) || (out_interval == NULL)) + return (EINVAL); + + if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) + { + WARNING ("netapp plugin: The `Interval' option needs exactly one numeric argument."); + return (-1); } - return 0; -} -static void set_global_perf_vol_flag(const host_config_t *host, uint32_t flag, int value) { - volume_t *v; - - for (v = host->volumes; v; v = v->next) { - v->perf_data.flags &= ~flag; - if (value) v->perf_data.flags |= flag; + tmp = (time_t) (ci->values[0].value.number + .5); + if (tmp < 1) + { + WARNING ("netapp plugin: The `Interval' option needs a positive integer argument."); + return (-1); } -} -static void set_global_vol_flag(const host_config_t *host, uint32_t flag, int value) { - volume_t *v; - - for (v = host->volumes; v; v = v->next) { - v->volume_data.flags &= ~flag; - if (value) v->volume_data.flags |= flag; + 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 + * block. */ +static void cna_config_volume_perf_option (cfg_volume_perf_t *cvp, /* {{{ */ + 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; } -} -static void process_perf_volume_flag(host_config_t *host, perf_volume_data_t *perf_volume, const oconfig_item_t *item, uint32_t flag) { - int n; - - for (n = 0; n < item->values_num; ++n) { - int minus = 0; - const char *name = item->values[n].value.string; - volume_t *v; - if (item->values[n].type != OCONFIG_TYPE_STRING) { - WARNING("netapp plugin: Ignoring non-string argument in \"GetVolPerfData\" block for host %s", host->name); - continue; - } - if (name[0] == '+') { - ++name; - } else if (name[0] == '-') { - minus = 1; - ++name; - } - if (!name[0]) { - perf_volume->flags &= ~flag; - if (!minus) perf_volume->flags |= flag; - set_global_perf_vol_flag(host, flag, !minus); - continue; - } - v = get_volume(host, name); - if (!v->perf_data.flags) { - v->perf_data.flags = perf_volume->flags; - v->perf_data.last_read_latency = v->perf_data.last_read_ops = 0; - v->perf_data.last_write_latency = v->perf_data.last_write_ops = 0; - } - v->perf_data.flags &= ~flag; - if (!minus) v->perf_data.flags |= flag; + name = ci->values[0].value.string; + + if (strcasecmp ("GetIO", ci->key) == 0) + il = cvp->il_octets; + else if (strcasecmp ("GetOps", ci->key) == 0) + il = cvp->il_operations; + else if (strcasecmp ("GetLatency", ci->key) == 0) + il = cvp->il_latency; + else + return; + + ignorelist_add (il, name); +} /* }}} void cna_config_volume_perf_option */ + +/* Handling of the "IgnoreSelectedIO", "IgnoreSelectedOps" and + * "IgnoreSelectedLatency" options within a block. */ +static void cna_config_volume_perf_default (cfg_volume_perf_t *cvp, /* {{{ */ + 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; } -} -static void process_volume_flag(host_config_t *host, volume_data_t *volume_data, const oconfig_item_t *item, uint32_t flag) { - int n; - - for (n = 0; n < item->values_num; ++n) { - int minus = 0; - const char *name = item->values[n].value.string; - volume_t *v; - if (item->values[n].type != OCONFIG_TYPE_STRING) { - WARNING("netapp plugin: Ignoring non-string argument in \"GetVolData\" block for host %s", host->name); - continue; + if (strcasecmp ("IgnoreSelectedIO", ci->key) == 0) + il = cvp->il_octets; + else if (strcasecmp ("IgnoreSelectedOps", ci->key) == 0) + il = cvp->il_operations; + else if (strcasecmp ("IgnoreSelectedLatency", ci->key) == 0) + il = cvp->il_latency; + 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_perf_default */ + +/* Corresponds to a block */ +/* + * + * GetIO "vol0" + * GetIO "vol1" + * IgnoreSelectedIO false + * + * GetOps "vol0" + * GetOps "vol2" + * IgnoreSelectedOps false + * + * GetLatency "vol2" + * GetLatency "vol3" + * IgnoreSelectedLatency false + * + */ +/* Corresponds to a block */ +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)); + if (cfg_volume_perf == NULL) + return (ENOMEM); + memset (cfg_volume_perf, 0, sizeof (*cfg_volume_perf)); + + /* Set default flags */ + cfg_volume_perf->query = NULL; + cfg_volume_perf->volumes = NULL; + + cfg_volume_perf->il_octets = ignorelist_create (/* invert = */ 1); + if (cfg_volume_perf->il_octets == NULL) + { + sfree (cfg_volume_perf); + return (ENOMEM); } - if (name[0] == '+') { - ++name; - } else if (name[0] == '-') { - minus = 1; - ++name; + + cfg_volume_perf->il_operations = ignorelist_create (/* invert = */ 1); + if (cfg_volume_perf->il_operations == NULL) + { + ignorelist_free (cfg_volume_perf->il_octets); + sfree (cfg_volume_perf); + return (ENOMEM); } - if (!name[0]) { - volume_data->flags &= ~flag; - if (!minus) volume_data->flags |= flag; - set_global_vol_flag(host, flag, !minus); - continue; + + cfg_volume_perf->il_latency = ignorelist_create (/* invert = */ 1); + if (cfg_volume_perf->il_latency == NULL) + { + ignorelist_free (cfg_volume_perf->il_octets); + ignorelist_free (cfg_volume_perf->il_operations); + sfree (cfg_volume_perf); + return (ENOMEM); } - v = get_volume(host, name); - if (!v->volume_data.flags) v->volume_data.flags = volume_data->flags; - v->volume_data.flags &= ~flag; - if (!minus) v->volume_data.flags |= flag; - } -} -static void build_perf_vol_config(host_config_t *host, const oconfig_item_t *ci) { - int i, had_io = 0, had_ops = 0, had_latency = 0; - service_config_t *service; - perf_volume_data_t *perf_volume; + host->cfg_volume_perf = cfg_volume_perf; + } + cfg_volume_perf = host->cfg_volume_perf; - service = malloc(sizeof(*service)); - service->query = 0; - service->handler = collect_perf_volume_data; - perf_volume = service->data = malloc(sizeof(*perf_volume)); - perf_volume->flags = PERF_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")) { - 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) { - WARNING("netapp plugin: \"Multiplier\" of host %s service GetVolPerfData needs exactly one positive integer argument.", host->name); - continue; - } - service->skip_countdown = service->multiplier = item->values[0].value.number; - } else if (!strcasecmp(item->key, "GetIO")) { - had_io = 1; - process_perf_volume_flag(host, perf_volume, item, PERF_VOLUME_IO); - } else if (!strcasecmp(item->key, "GetOps")) { - had_ops = 1; - process_perf_volume_flag(host, perf_volume, item, PERF_VOLUME_OPS); - } else if (!strcasecmp(item->key, "GetLatency")) { - had_latency = 1; - process_perf_volume_flag(host, perf_volume, item, PERF_VOLUME_LATENCY); - } - } - if (!had_io) { - perf_volume->flags |= PERF_VOLUME_IO; - set_global_perf_vol_flag(host, PERF_VOLUME_IO, 1); + /* if (!item || !item->key || !*item->key) continue; */ + if (strcasecmp(item->key, "Interval") == 0) + cna_config_get_interval (item, &cfg_volume_perf->interval); + else if (!strcasecmp(item->key, "GetIO")) + cna_config_volume_perf_option (cfg_volume_perf, item); + else if (!strcasecmp(item->key, "GetOps")) + cna_config_volume_perf_option (cfg_volume_perf, item); + else if (!strcasecmp(item->key, "GetLatency")) + cna_config_volume_perf_option (cfg_volume_perf, item); + else if (!strcasecmp(item->key, "IgnoreSelectedIO")) + cna_config_volume_perf_default (cfg_volume_perf, item); + else if (!strcasecmp(item->key, "IgnoreSelectedOps")) + cna_config_volume_perf_default (cfg_volume_perf, item); + else if (!strcasecmp(item->key, "IgnoreSelectedLatency")) + cna_config_volume_perf_default (cfg_volume_perf, item); + else + WARNING ("netapp plugin: The option %s is not allowed within " + "`VolumePerf' blocks.", item->key); } - if (!had_ops) { - perf_volume->flags |= PERF_VOLUME_OPS; - set_global_perf_vol_flag(host, PERF_VOLUME_OPS, 1); + + return (0); +} /* }}} int cna_config_volume_performance */ + +/* Handling of the "GetCapacity" and "GetSnapshot" options within a + * 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; } - if (!had_latency) { - perf_volume->flags |= PERF_VOLUME_LATENCY; - set_global_perf_vol_flag(host, PERF_VOLUME_LATENCY, 1); + + name = ci->values[0].value.string; + + if (strcasecmp ("GetCapacity", ci->key) == 0) + il = cvu->il_capacity; + else if (strcasecmp ("GetSnapshot", 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 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; } -} -static void build_volume_config(host_config_t *host, oconfig_item_t *ci) { - int i, had_df = 0; - service_config_t *service; - volume_data_t *volume_data; + 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 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; - volume_data = service->data = malloc(sizeof(*volume_data)); - 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")) { - 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) { - WARNING("netapp plugin: \"Multiplier\" of host %s service GetVolPerfData needs exactly one positive integer argument.", host->name); - continue; - } - service->skip_countdown = service->multiplier = item->values[0].value.number; - } else if (!strcasecmp(item->key, "GetDiskUtil")) { - had_df = 1; - process_volume_flag(host, volume_data, item, VOLUME_DF); - } + /* if (!item || !item->key || !*item->key) continue; */ + 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) { - volume_data->flags |= VOLUME_DF; - set_global_vol_flag(host, VOLUME_DF, 1); + + 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; } -/* service = malloc(sizeof(*service)); - service->query = 0; - service->handler = collect_snapshot_data; - service->data = volume_data; - service->next = temp->services; - temp->services = service;*/ -} -static void build_perf_disk_config(host_config_t *temp, oconfig_item_t *ci) { + return (0); +} /* }}} int cna_config_disk */ + +/* Corresponds to a block */ +static int cna_config_wafl(host_config_t *host, oconfig_item_t *ci) /* {{{ */ +{ + cfg_wafl_t *cfg_wafl; int i; - service_config_t *service; - perf_disk_data_t *perf_disk; - - service = malloc(sizeof(*service)); - service->query = 0; - service->handler = collect_perf_disk_data; - perf_disk = service->data = malloc(sizeof(*perf_disk)); - perf_disk->flags = PERF_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")) { - 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) { - WARNING("netapp plugin: \"Multiplier\" of host %s service GetWaflPerfData needs exactly one positive integer argument.", ci->values[0].value.string); - continue; - } - service->skip_countdown = service->multiplier = item->values[0].value.number; - } else if (!strcasecmp(item->key, "GetBusy")) { - if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) { - WARNING("netapp plugin: \"GetBusy\" of host %s service GetDiskPerfData needs exactly one bool argument.", ci->values[0].value.string); - continue; - } - perf_disk->flags = (perf_disk->flags & ~PERF_SYSTEM_CPU) | (item->values[0].value.boolean ? PERF_DISK_BUSIEST : 0); - } + 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); + } + + 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; } -} -static void build_perf_wafl_config(host_config_t *temp, oconfig_item_t *ci) { + return (0); +} /* }}} int cna_config_wafl */ + +/* + * + * GetCapacity "vol0" + * GetCapacity "vol1" + * GetCapacity "vol2" + * GetCapacity "vol3" + * GetCapacity "vol4" + * IgnoreSelectedCapacity false + * + * GetSnapshot "vol0" + * GetSnapshot "vol3" + * GetSnapshot "vol4" + * GetSnapshot "vol7" + * IgnoreSelectedSnapshot false + * + */ +/* Corresponds to a block */ +static int cna_config_volume_usage(host_config_t *host, /* {{{ */ + const oconfig_item_t *ci) +{ + cfg_volume_usage_t *cfg_volume_usage; int i; - service_config_t *service; - perf_wafl_data_t *perf_wafl; + + 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; - service = malloc(sizeof(*service)); - service->query = 0; - service->handler = collect_perf_wafl_data; - perf_wafl = service->data = malloc(sizeof(*perf_wafl)); - perf_wafl->flags = PERF_WAFL_ALL; - perf_wafl->last_name_cache_hit = 0; - perf_wafl->last_name_cache_miss = 0; - perf_wafl->last_find_dir_hit = 0; - perf_wafl->last_find_dir_miss = 0; - perf_wafl->last_buf_hash_hit = 0; - perf_wafl->last_buf_hash_miss = 0; - perf_wafl->last_inode_cache_hit = 0; - perf_wafl->last_inode_cache_miss = 0; - service->next = temp->services; - temp->services = service; for (i = 0; i < ci->children_num; ++i) { oconfig_item_t *item = ci->children + i; -// if (!item || !item->key || !*item->key) continue; - if (!strcasecmp(item->key, "Multiplier")) { - 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) { - WARNING("netapp plugin: \"Multiplier\" of host %s service GetWaflPerfData needs exactly one positive integer argument.", ci->values[0].value.string); - continue; - } - service->skip_countdown = service->multiplier = item->values[0].value.number; - } else if (!strcasecmp(item->key, "GetNameCache")) { - if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) { - WARNING("netapp plugin: \"GetNameCache\" of host %s service GetWaflPerfData needs exactly one bool argument.", ci->values[0].value.string); - continue; - } - perf_wafl->flags = (perf_wafl->flags & ~PERF_WAFL_NAME_CACHE) | (item->values[0].value.boolean ? PERF_WAFL_NAME_CACHE : 0); - } else if (!strcasecmp(item->key, "GetDirCache")) { - if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) { - WARNING("netapp plugin: \"GetDirChache\" of host %s service GetWaflPerfData needs exactly one bool argument.", ci->values[0].value.string); - continue; - } - perf_wafl->flags = (perf_wafl->flags & ~PERF_WAFL_DIR_CACHE) | (item->values[0].value.boolean ? PERF_WAFL_DIR_CACHE : 0); - } else if (!strcasecmp(item->key, "GetBufCache")) { - if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) { - WARNING("netapp plugin: \"GetBufCache\" of host %s service GetWaflPerfData needs exactly one bool argument.", ci->values[0].value.string); - continue; - } - perf_wafl->flags = (perf_wafl->flags & ~PERF_WAFL_BUF_CACHE) | (item->values[0].value.boolean ? PERF_WAFL_BUF_CACHE : 0); - } else if (!strcasecmp(item->key, "GetInodeCache")) { - if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) { - WARNING("netapp plugin: \"GetInodeCache\" of host %s service GetWaflPerfData needs exactly one bool argument.", ci->values[0].value.string); - continue; - } - perf_wafl->flags = (perf_wafl->flags & ~PERF_WAFL_INODE_CACHE) | (item->values[0].value.boolean ? PERF_WAFL_INODE_CACHE : 0); - } + /* 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, "GetCapacity")) + cna_config_volume_usage_option (cfg_volume_usage, item); + else if (!strcasecmp(item->key, "GetSnapshot")) + 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); + else + WARNING ("netapp plugin: The option %s is not allowed within " + "`VolumeUsage' blocks.", item->key); } -} -static void build_perf_sys_config(host_config_t *temp, oconfig_item_t *ci, const service_config_t *default_service) { + return (0); +} /* }}} int cna_config_volume_usage */ + +/* Corresponds to a block */ +static int cna_config_system (host_config_t *host, /* {{{ */ + oconfig_item_t *ci) +{ + cfg_system_t *cfg_system; int i; - service_config_t *service; - perf_system_data_t *perf_system; - service = malloc(sizeof(*service)); - *service = *default_service; - service->handler = collect_perf_system_data; - perf_system = service->data = malloc(sizeof(*perf_system)); - perf_system->flags = PERF_SYSTEM_ALL; - perf_system->last_cpu_busy = 0; - perf_system->last_cpu_total = 0; - service->next = temp->services; - temp->services = service; + if ((host == NULL) || (ci == NULL)) + return (EINVAL); + + 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; + } + cfg_system = host->cfg_system; + 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")) { - 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) { - WARNING("netapp plugin: \"Multiplier\" of host %s service GetSystemPerfData needs exactly one positive integer argument.", ci->values[0].value.string); - continue; - } - service->skip_countdown = service->multiplier = item->values[0].value.number; + if (strcasecmp(item->key, "Interval") == 0) { + cna_config_get_interval (item, &cfg_system->interval); } else if (!strcasecmp(item->key, "GetCPULoad")) { - if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) { - WARNING("netapp plugin: \"GetCPULoad\" of host %s service GetSystemPerfData needs exactly one bool argument.", ci->values[0].value.string); - continue; - } - perf_system->flags = (perf_system->flags & ~PERF_SYSTEM_CPU) | (item->values[0].value.boolean ? PERF_SYSTEM_CPU : 0); + cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_CPU); } else if (!strcasecmp(item->key, "GetInterfaces")) { - if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) { - WARNING("netapp plugin: \"GetInterfaces\" of host %s service GetSystemPerfData needs exactly one bool argument.", ci->values[0].value.string); - continue; - } - perf_system->flags = (perf_system->flags & ~PERF_SYSTEM_NET) | (item->values[0].value.boolean ? PERF_SYSTEM_NET : 0); + cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_NET); } else if (!strcasecmp(item->key, "GetDiskOps")) { - if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) { - WARNING("netapp plugin: \"GetDiskOps\" of host %s service GetSystemPerfData needs exactly one bool argument.", ci->values[0].value.string); - continue; - } - perf_system->flags = (perf_system->flags & ~PERF_SYSTEM_OPS) | (item->values[0].value.boolean ? PERF_SYSTEM_OPS : 0); + cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_OPS); } else if (!strcasecmp(item->key, "GetDiskIO")) { - if (item->values_num != 1 || item->values[0].type != OCONFIG_TYPE_BOOLEAN) { - WARNING("netapp plugin: \"GetDiskIO\" of host %s service GetSystemPerfData needs exactly one bool argument.", ci->values[0].value.string); - continue; - } - perf_system->flags = (perf_system->flags & ~PERF_SYSTEM_DISK) | (item->values[0].value.boolean ? PERF_SYSTEM_DISK : 0); + cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_DISK); + } else { + WARNING ("netapp plugin: The %s config option is not allowed within " + "`System' blocks.", item->key); } } -} -static host_config_t *build_host_config(const oconfig_item_t *ci, const host_config_t *default_host, const service_config_t *def_def_service) { - int i; + 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 cna_config_system */ + +/* Corresponds to a block. */ +static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */ + const host_config_t *default_host) +{ oconfig_item_t *item; - host_config_t *host, *hc, temp = *default_host; - service_config_t default_service = *def_def_service; + host_config_t *host; + 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; - } 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); -/* if ((item->values_num != 1) || (item->values[0].type != OCONFIG_TYPE_STRING)) { - WARNING("netapp plugin: \"Collect\" needs exactly one string argument. Ignoring collect block for \"%s\".", ci->values[0].value.string); - continue; - } - build_collect_config(&temp, item);*/ - } 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); + 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, "VolumePerf")) { + 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); } else { - WARNING("netapp plugin: Ignoring unknown config option \"%s\" in host block \"%s\".", item->key, ci->values[0].value.string); + 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 *cna_config_host */ + +/* + * Callbacks registered with the daemon + * + * Pretty standard stuff here. + */ +static int cna_init(void) { /* {{{ */ + char err[256]; + host_config_t *host; + + 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 */); + } + return 0; +} /* }}} int cna_init */ -static int build_config (oconfig_item_t *ci) { +static int cna_config (oconfig_item_t *ci) { /* {{{ */ int i; oconfig_item_t *item; host_config_t default_host = HOST_INIT; - service_config_t default_service = SERVICE_INIT; 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); + 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); } } return 0; -} +} /* }}} int cna_config */ -static int netapp_read() { - na_elem_t *out; +static int cna_read (void) { /* {{{ */ host_config_t *host; - service_config_t *service; - for (host = 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; - out = na_server_invoke_elem(host->srv, service->query); - if (na_results_status(out) != NA_OK) { - int netapp_errno = na_results_errno(out); - ERROR("netapp plugin: Error %d from host %s: %s", netapp_errno, host->name, na_results_reason(out)); - na_elem_free(out); - if (netapp_errno == EIO || netapp_errno == ETIMEDOUT) { - // Network problems. Just give up on all other services on this host. - break; - } - continue; - } - service->handler(host, out, service->data); - na_elem_free(out); - } + for (host = global_host_config; host; host = host->next) { + cna_query_wafl (host); + cna_query_disk (host); + cna_query_volume_perf (host); + cna_query_volume_usage (host); + cna_query_system (host); } return 0; -} +} /* }}} int cna_read */ + +static int cna_shutdown (void) /* {{{ */ +{ + free_host_config (global_host_config); + global_host_config = NULL; -void module_register() { - plugin_register_complex_config("netapp", build_config); - plugin_register_init("netapp", config_init); - plugin_register_read("netapp", netapp_read); + return (0); +} /* }}} int cna_shutdown */ + +void module_register(void) { + plugin_register_complex_config("netapp", cna_config); + plugin_register_init("netapp", cna_init); + plugin_register_read("netapp", cna_read); + plugin_register_shutdown("netapp", cna_shutdown); } + +/* vim: set sw=2 ts=2 noet fdm=marker : */