X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fnetapp.c;h=317b0fe40d51936e924244a23321f7b7f4b29e68;hb=cce136946b879557f91183e4de58e92b81e138c8;hp=83cfe454ff16410288ad63b9832d957d02e85457;hpb=f9238bf523ae35366f4b1a40dc0149b01b7dba8d;p=collectd.git diff --git a/src/netapp.c b/src/netapp.c index 83cfe454..020bfba1 100644 --- a/src/netapp.c +++ b/src/netapp.c @@ -1,6 +1,7 @@ /** * collectd - src/netapp.c - * Copyright (C) 2009 Sven Trenkel + * Copyright (C) 2009,2010 Sven Trenkel + * Copyright (C) 2012-2013 teamix GmbH * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -21,7 +22,8 @@ * DEALINGS IN THE SOFTWARE. * * Authors: - * Sven Trenkel + * Sven Trenkel + * Sebastian 'tokkee' Harl **/ #include "collectd.h" @@ -29,6 +31,7 @@ #include "utils_ignorelist.h" #include +#include #define HAS_ALL_FLAGS(has,needs) (((has) & (needs)) == (needs)) @@ -37,8 +40,8 @@ typedef void service_handler_t(host_config_t *host, na_elem_t *result, void *dat struct cna_interval_s { - time_t interval; - time_t last_read; + cdtime_t interval; + cdtime_t last_read; }; typedef struct cna_interval_s cna_interval_t; @@ -78,7 +81,7 @@ typedef struct { cna_interval_t interval; na_elem_t *query; - time_t timestamp; + cdtime_t timestamp; uint64_t name_cache_hit; uint64_t name_cache_miss; uint64_t find_dir_hit; @@ -103,7 +106,7 @@ typedef struct { typedef struct disk_s { char *name; uint32_t flags; - time_t timestamp; + cdtime_t timestamp; uint64_t disk_busy; uint64_t base_for_disk_busy; double disk_busy_percent; @@ -130,8 +133,8 @@ typedef struct { * kept for completeness sake. The "flags" member indicates if each counter is * valid or not. * - * The "query_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 + * 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. */ @@ -147,46 +150,66 @@ typedef struct { #define HAVE_VOLUME_PERF_LATENCY_READ 0x0100 #define HAVE_VOLUME_PERF_LATENCY_WRITE 0x0200 #define HAVE_VOLUME_PERF_ALL 0x03F0 -typedef struct { +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; -} cfg_volume_perf_t; + cdtime_t timestamp; -typedef struct { - uint32_t flags; - time_t timestamp; uint64_t read_bytes; uint64_t write_bytes; uint64_t read_ops; uint64_t write_ops; uint64_t read_latency; uint64_t write_latency; -} data_volume_perf_t; + + data_volume_perf_t *next; +}; + +typedef struct { + cna_interval_t interval; + na_elem_t *query; + + ignorelist_t *il_octets; + ignorelist_t *il_operations; + ignorelist_t *il_latency; + + 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 +#define CFG_VOLUME_USAGE_DF 0x0002 +#define CFG_VOLUME_USAGE_SNAP 0x0004 +#define CFG_VOLUME_USAGE_ALL 0x0006 +#define HAVE_VOLUME_USAGE_NORM_FREE 0x0010 +#define HAVE_VOLUME_USAGE_NORM_USED 0x0020 +#define HAVE_VOLUME_USAGE_SNAP_RSVD 0x0040 +#define HAVE_VOLUME_USAGE_SNAP_USED 0x0080 +#define HAVE_VOLUME_USAGE_SIS_SAVED 0x0100 +#define HAVE_VOLUME_USAGE_COMPRESS_SAVED 0x0200 +#define HAVE_VOLUME_USAGE_DEDUP_SAVED 0x0400 +#define HAVE_VOLUME_USAGE_ALL 0x07f0 +#define IS_VOLUME_USAGE_OFFLINE 0x0800 struct data_volume_usage_s; typedef struct data_volume_usage_s data_volume_usage_t; struct data_volume_usage_s { char *name; uint32_t flags; + 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; + uint64_t compress_saved; + uint64_t dedup_saved; data_volume_usage_t *next; }; @@ -202,6 +225,26 @@ typedef struct { } cfg_volume_usage_t; /* }}} cfg_volume_usage_t */ +/*! Data types for quota statistics {{{ + * + * \brief Persistent data for quota statistics + */ +typedef struct { + cna_interval_t interval; + na_elem_t *query; +} cfg_quota_t; +/* }}} cfg_quota_t */ + +/*! Data types for SnapVault statistics {{{ + * + * \brief Persistent data for SnapVault(R) statistics + */ +typedef struct { + cna_interval_t interval; + na_elem_t *query; +} cfg_snapvault_t; +/* }}} cfg_snapvault_t */ + /*! Data types for system statistics {{{ * * \brief Persistent data for system performance counters @@ -218,33 +261,6 @@ typedef struct { } cfg_system_t; /* }}} cfg_system_t */ -typedef struct service_config_s { - na_elem_t *query; - service_handler_t *handler; - int multiplier; - int skip_countdown; - int interval; - void *data; - struct service_config_s *next; -} cfg_service_t; -#define SERVICE_INIT {0, 0, 1, 1, 0, 0, 0} - -/*! - * \brief Struct representing a volume. - * - * A volume currently has a name and two sets of values: - * - * - Performance data, such as bytes read/written, number of operations - * performed and average time per operation. - * - * - Usage data, i. e. amount of used and free space in the volume. - */ -typedef struct volume_s { - char *name; - data_volume_perf_t perf_data; - struct volume_s *next; -} volume_t; - struct host_config_s { char *name; na_server_transport_t protocol; @@ -252,44 +268,26 @@ struct host_config_s { int port; char *username; char *password; - int interval; + char *vfiler; + cdtime_t interval; na_server_t *srv; - cfg_service_t *services; 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_quota_t *cfg_quota; + cfg_snapvault_t *cfg_snapvault; cfg_system_t *cfg_system; - volume_t *volumes; 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, \ - NULL} - -static host_config_t *global_host_config; /* * Free functions * * Used to free the various structures above. */ -static void free_volume (volume_t *volume) /* {{{ */ -{ - volume_t *next; - - if (volume == NULL) - return; - - next = volume->next; - - sfree (volume->name); - sfree (volume); - - free_volume (next); -} /* }}} void free_volume */ - static void free_disk (disk_t *disk) /* {{{ */ { disk_t *next; @@ -328,6 +326,34 @@ static void free_cfg_disk (cfg_disk_t *cfg_disk) /* {{{ */ 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; @@ -345,6 +371,8 @@ static void free_cfg_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */ { 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; } @@ -355,33 +383,38 @@ static void free_cfg_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */ sfree (cvu); } /* }}} void free_cfg_volume_usage */ -static void free_cfg_system (cfg_system_t *cs) /* {{{ */ +static void free_cfg_quota (cfg_quota_t *q) /* {{{ */ { - if (cs == NULL) + if (q == NULL) return; - if (cs->query != NULL) - na_elem_free (cs->query); + if (q->query != NULL) + na_elem_free (q->query); - sfree (cs); -} /* }}} void free_cfg_system */ + sfree (q); +} /* }}} void free_cfg_quota */ -static void free_cfg_service (cfg_service_t *service) /* {{{ */ +static void free_cfg_snapvault (cfg_snapvault_t *sv) /* {{{ */ { - cfg_service_t *next; + if (sv == NULL) + return; + + if (sv->query != NULL) + na_elem_free (sv->query); - if (service == NULL) + sfree (sv); +} /* }}} void free_cfg_snapvault */ + +static void free_cfg_system (cfg_system_t *cs) /* {{{ */ +{ + if (cs == NULL) return; - - next = service->next; - /* FIXME: Free service->data? */ - na_elem_free(service->query); - - sfree (service); + if (cs->query != NULL) + na_elem_free (cs->query); - free_cfg_service (next); -} /* }}} void free_cfg_service */ + sfree (cs); +} /* }}} void free_cfg_system */ static void free_host_config (host_config_t *hc) /* {{{ */ { @@ -396,13 +429,18 @@ static void free_host_config (host_config_t *hc) /* {{{ */ sfree (hc->host); sfree (hc->username); sfree (hc->password); + sfree (hc->vfiler); - free_cfg_service (hc->services); 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_quota (hc->cfg_quota); + free_cfg_snapvault (hc->cfg_snapvault); free_cfg_system (hc->cfg_system); - free_volume (hc->volumes); + + if (hc->srv != NULL) + na_server_close (hc->srv); sfree (hc); @@ -414,50 +452,6 @@ static void free_host_config (host_config_t *hc) /* {{{ */ * * Used to look up volumes and disks or to handle flags. */ -static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */ - uint32_t vol_perf_flags) -{ - volume_t *v; - - if (name == NULL) - return (NULL); - - /* Make sure the default flags include the init-bit. */ - if (vol_perf_flags != 0) - vol_perf_flags |= CFG_VOLUME_PERF_INIT; - - for (v = host->volumes; v; v = v->next) { - if (strcmp(v->name, name) != 0) - continue; - - /* Check if the flags have been initialized. */ - if (((v->perf_data.flags & CFG_VOLUME_PERF_INIT) == 0) - && (vol_perf_flags != 0)) - v->perf_data.flags = vol_perf_flags; - - return v; - } - - DEBUG ("netapp plugin: Allocating new entry for volume %s.", name); - v = malloc(sizeof(*v)); - if (v == NULL) - return (NULL); - memset (v, 0, sizeof (*v)); - - v->perf_data.flags = vol_perf_flags; - - v->name = strdup(name); - if (v->name == NULL) { - sfree (v); - return (NULL); - } - - v->next = host->volumes; - host->volumes = v; - - return v; -} /* }}} volume_t *get_volume */ - static disk_t *get_disk(cfg_disk_t *cd, const char *name) /* {{{ */ { disk_t *d; @@ -534,8 +528,14 @@ static data_volume_usage_t *get_volume_usage (cfg_volume_usage_t *cvu, /* {{{ */ if (ignore_capacity == 0) new->flags |= CFG_VOLUME_USAGE_DF; - if (ignore_snapshot == 0) + 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) @@ -546,18 +546,69 @@ static data_volume_usage_t *get_volume_usage (cfg_volume_usage_t *cvu, /* {{{ */ return (new); } /* }}} data_volume_usage_t *get_volume_usage */ -static void host_set_all_perf_data_flags(const host_config_t *host, /* {{{ */ - uint32_t flag, _Bool set) +static data_volume_perf_t *get_volume_perf (cfg_volume_perf_t *cvp, /* {{{ */ + const char *name) { - volume_t *v; - - for (v = host->volumes; v; v = v->next) { - if (set) - v->perf_data.flags |= flag; - else /* if (!set) */ - v->perf_data.flags &= ~flag; + 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); } -} /* }}} void host_set_all_perf_data_flags */ + + 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. @@ -569,7 +620,7 @@ 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) + cdtime_t timestamp, cdtime_t interval) { value_list_t vl = VALUE_LIST_INIT; @@ -579,6 +630,9 @@ static int submit_values (const char *host, /* {{{ */ if (timestamp > 0) vl.time = timestamp; + if (interval > 0) + vl.interval = interval; + if (host != NULL) sstrncpy (vl.host, host, sizeof (vl.host)); else @@ -593,33 +647,34 @@ static int submit_values (const char *host, /* {{{ */ 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) +static int submit_two_derive (const char *host, const char *plugin_inst, /* {{{ */ + const char *type, const char *type_inst, derive_t val0, derive_t val1, + cdtime_t timestamp, cdtime_t interval) { value_t values[2]; - values[0].counter = val0; - values[1].counter = val1; + values[0].derive = val0; + values[1].derive = val1; return (submit_values (host, plugin_inst, type, type_inst, - values, 2, timestamp)); -} /* }}} int submit_two_counters */ + values, 2, timestamp, interval)); +} /* }}} int submit_two_derive */ -static int submit_counter (const char *host, const char *plugin_inst, /* {{{ */ - const char *type, const char *type_inst, counter_t counter, time_t timestamp) +static int submit_derive (const char *host, const char *plugin_inst, /* {{{ */ + const char *type, const char *type_inst, derive_t counter, + cdtime_t timestamp, cdtime_t interval) { value_t v; - v.counter = counter; + v.derive = counter; return (submit_values (host, plugin_inst, type, type_inst, - &v, 1, timestamp)); -} /* }}} int submit_counter */ + &v, 1, timestamp, interval)); +} /* }}} int submit_derive */ static int submit_two_gauge (const char *host, const char *plugin_inst, /* {{{ */ const char *type, const char *type_inst, gauge_t val0, gauge_t val1, - time_t timestamp) + cdtime_t timestamp, cdtime_t interval) { value_t values[2]; @@ -627,18 +682,19 @@ static int submit_two_gauge (const char *host, const char *plugin_inst, /* {{{ * values[1].gauge = val1; return (submit_values (host, plugin_inst, type, type_inst, - values, 2, timestamp)); + values, 2, timestamp, interval)); } /* }}} int submit_two_gauge */ static int submit_double (const char *host, const char *plugin_inst, /* {{{ */ - const char *type, const char *type_inst, double d, time_t timestamp) + const char *type, const char *type_inst, double d, + cdtime_t timestamp, cdtime_t interval) { value_t v; v.gauge = (gauge_t) d; return (submit_values (host, plugin_inst, type, type_inst, - &v, 1, timestamp)); + &v, 1, timestamp, interval)); } /* }}} int submit_uint64 */ /* Calculate hit ratio from old and new counters and submit the resulting @@ -650,7 +706,8 @@ static int submit_cache_ratio (const char *host, /* {{{ */ uint64_t new_misses, uint64_t old_hits, uint64_t old_misses, - time_t timestamp) + cdtime_t timestamp, + cdtime_t interval) { value_t v; @@ -667,12 +724,12 @@ static int submit_cache_ratio (const char *host, /* {{{ */ } return (submit_values (host, plugin_inst, "cache_ratio", type_inst, - &v, 1, timestamp)); + &v, 1, timestamp, interval)); } /* }}} 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) + cfg_wafl_t *old_data, const cfg_wafl_t *new_data, cdtime_t interval) { /* Submit requested counters */ if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_NAME_CACHE | HAVE_WAFL_NAME_CACHE) @@ -680,28 +737,28 @@ static int submit_wafl_data (const char *hostname, const char *instance, /* {{{ 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); + new_data->timestamp, interval); 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); + new_data->timestamp, interval); 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); + new_data->timestamp, interval); 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); + new_data->timestamp, interval); /* Clear old HAVE_* flags */ old_data->flags &= ~HAVE_WAFL_ALL; @@ -725,28 +782,36 @@ static int submit_wafl_data (const char *hostname, const char *instance, /* {{{ /* Submits volume performance data to the daemon, taking care to honor and * update flags appropriately. */ -static int submit_volume_perf_data (const host_config_t *host, /* {{{ */ - volume_t *volume, - const data_volume_perf_t *new_data) +static int submit_volume_perf_data (const char *hostname, /* {{{ */ + data_volume_perf_t *old_data, + const data_volume_perf_t *new_data, int interval) { + char plugin_instance[DATA_MAX_NAME_LEN]; + + if ((hostname == NULL) || (old_data == NULL) || (new_data == NULL)) + return (-1); + + ssnprintf (plugin_instance, sizeof (plugin_instance), + "volume-%s", old_data->name); + /* Check for and submit disk-octet values */ - if (HAS_ALL_FLAGS (volume->perf_data.flags, CFG_VOLUME_PERF_IO) + 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 (host->name, volume->name, "disk_octets", /* type instance = */ NULL, - (counter_t) new_data->read_bytes, (counter_t) new_data->write_bytes, new_data->timestamp); + submit_two_derive (hostname, plugin_instance, "disk_octets", /* type instance = */ NULL, + (derive_t) new_data->read_bytes, (derive_t) new_data->write_bytes, new_data->timestamp, interval); } /* Check for and submit disk-operations values */ - if (HAS_ALL_FLAGS (volume->perf_data.flags, CFG_VOLUME_PERF_OPS) + 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 (host->name, volume->name, "disk_ops", /* type instance = */ NULL, - (counter_t) new_data->read_ops, (counter_t) new_data->write_ops, new_data->timestamp); + submit_two_derive (hostname, plugin_instance, "disk_ops", /* type instance = */ NULL, + (derive_t) new_data->read_ops, (derive_t) new_data->write_ops, new_data->timestamp, interval); } /* Check for, calculate and submit disk-latency values */ - if (HAS_ALL_FLAGS (volume->perf_data.flags, CFG_VOLUME_PERF_LATENCY + 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 @@ -759,54 +824,64 @@ static int submit_volume_perf_data (const host_config_t *host, /* {{{ */ latency_per_op_write = NAN; /* Check if a counter wrapped around. */ - if ((new_data->read_ops > volume->perf_data.read_ops) - && (new_data->read_latency > volume->perf_data.read_latency)) + 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 - volume->perf_data.read_ops; - diff_latency_read = new_data->read_latency - volume->perf_data.read_latency; + 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 > volume->perf_data.write_ops) - && (new_data->write_latency > volume->perf_data.write_latency)) + 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 - volume->perf_data.write_ops; - diff_latency_write = new_data->write_latency - volume->perf_data.write_latency; + 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 (host->name, volume->name, "disk_latency", /* type instance = */ NULL, - latency_per_op_read, latency_per_op_write, new_data->timestamp); + submit_two_gauge (hostname, plugin_instance, "disk_latency", /* type instance = */ NULL, + latency_per_op_read, latency_per_op_write, new_data->timestamp, interval); } /* Clear all HAVE_* flags. */ - volume->perf_data.flags &= ~HAVE_VOLUME_PERF_ALL; + old_data->flags &= ~HAVE_VOLUME_PERF_ALL; /* Copy all counters */ - volume->perf_data.timestamp = new_data->timestamp; - volume->perf_data.read_bytes = new_data->read_bytes; - volume->perf_data.write_bytes = new_data->write_bytes; - volume->perf_data.read_ops = new_data->read_ops; - volume->perf_data.write_ops = new_data->write_ops; - volume->perf_data.read_latency = new_data->read_latency; - volume->perf_data.write_latency = new_data->write_latency; + 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 */ - volume->perf_data.flags |= (new_data->flags & HAVE_VOLUME_PERF_ALL); + old_data->flags |= (new_data->flags & HAVE_VOLUME_PERF_ALL); return (0); } /* }}} int submit_volume_perf_data */ +static cdtime_t cna_child_get_cdtime (na_elem_t *data) /* {{{ */ +{ + time_t t; + + t = (time_t) na_child_get_uint64 (data, "timestamp", /* default = */ 0); + + return (TIME_T_TO_CDTIME_T (t)); +} /* }}} cdtime_t cna_child_get_cdtime */ + + /* * Query functions * @@ -815,7 +890,7 @@ static int submit_volume_perf_data (const host_config_t *host, /* {{{ */ */ /* Data corresponding to */ static int cna_handle_wafl_data (const char *hostname, cfg_wafl_t *cfg_wafl, /* {{{ */ - na_elem_t *data) + na_elem_t *data, cdtime_t interval) { cfg_wafl_t perf_data; const char *plugin_inst; @@ -826,13 +901,14 @@ static int cna_handle_wafl_data (const char *hostname, cfg_wafl_t *cfg_wafl, /* memset (&perf_data, 0, sizeof (perf_data)); - perf_data.timestamp = (time_t) na_child_get_uint64 (data, "timestamp", 0); + perf_data.timestamp = cna_child_get_cdtime (data); 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."); + "na_elem_child (\"instances\") failed " + "for host %s.", hostname); return (-1); } @@ -840,7 +916,8 @@ static int cna_handle_wafl_data (const char *hostname, cfg_wafl_t *cfg_wafl, /* if (plugin_inst == NULL) { ERROR ("netapp plugin: cna_handle_wafl_data: " - "na_child_get_string (\"name\") failed."); + "na_child_get_string (\"name\") failed " + "for host %s.", hostname); return (-1); } @@ -887,11 +964,12 @@ static int cna_handle_wafl_data (const char *hostname, cfg_wafl_t *cfg_wafl, /* perf_data.flags |= HAVE_WAFL_INODE_CACHE_MISS; } else { DEBUG("netapp plugin: cna_handle_wafl_data: " - "Found unexpected child: %s", name); + "Found unexpected child: %s " + "for host %s.", name, hostname); } } - return (submit_wafl_data (hostname, plugin_inst, cfg_wafl, &perf_data)); + return (submit_wafl_data (hostname, plugin_inst, cfg_wafl, &perf_data, interval)); } /* }}} void cna_handle_wafl_data */ static int cna_setup_wafl (cfg_wafl_t *cw) /* {{{ */ @@ -920,14 +998,14 @@ static int cna_setup_wafl (cfg_wafl_t *cw) /* {{{ */ 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_string(e, "counter", "name_cache_hit"); + na_child_add_string(e, "counter", "name_cache_miss"); + na_child_add_string(e, "counter", "find_dir_hit"); + na_child_add_string(e, "counter", "find_dir_miss"); + na_child_add_string(e, "counter", "buf_hash_hit"); + na_child_add_string(e, "counter", "buf_hash_miss"); + na_child_add_string(e, "counter", "inode_cache_hit"); + na_child_add_string(e, "counter", "inode_cache_miss"); na_child_add(cw->query, e); @@ -938,7 +1016,7 @@ static int cna_query_wafl (host_config_t *host) /* {{{ */ { na_elem_t *data; int status; - time_t now; + cdtime_t now; if (host == NULL) return (EINVAL); @@ -947,7 +1025,7 @@ static int cna_query_wafl (host_config_t *host) /* {{{ */ if (host->cfg_wafl == NULL) return (0); - now = time (NULL); + now = cdtime (); if ((host->cfg_wafl->interval.interval + host->cfg_wafl->interval.last_read) > now) return (0); @@ -959,13 +1037,14 @@ static int cna_query_wafl (host_config_t *host) /* {{{ */ 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)); + ERROR ("netapp plugin: cna_query_wafl: na_server_invoke_elem failed for host %s: %s", + host->name, na_results_reason (data)); na_elem_free (data); return (-1); } - status = cna_handle_wafl_data (host->name, host->cfg_wafl, data); + status = cna_handle_wafl_data (host->name, host->cfg_wafl, data, + host->cfg_wafl->interval.interval); if (status == 0) host->cfg_wafl->interval.last_read = now; @@ -976,9 +1055,9 @@ static int cna_query_wafl (host_config_t *host) /* {{{ */ /* Data corresponding to */ static int cna_handle_disk_data (const char *hostname, /* {{{ */ - cfg_disk_t *cfg_disk, na_elem_t *data) + cfg_disk_t *cfg_disk, na_elem_t *data, cdtime_t interval) { - time_t timestamp; + cdtime_t timestamp; na_elem_t *instances; na_elem_t *instance; na_elem_iter_t instance_iter; @@ -987,13 +1066,14 @@ static int cna_handle_disk_data (const char *hostname, /* {{{ */ if ((cfg_disk == NULL) || (data == NULL)) return (EINVAL); - timestamp = (time_t) na_child_get_uint64(data, "timestamp", 0); + timestamp = cna_child_get_cdtime (data); instances = na_elem_child (data, "instances"); if (instances == NULL) { ERROR ("netapp plugin: cna_handle_disk_data: " - "na_elem_child (\"instances\") failed."); + "na_elem_child (\"instances\") failed " + "for host %s.", hostname); return (-1); } @@ -1089,7 +1169,7 @@ static int cna_handle_disk_data (const char *hostname, /* {{{ */ if ((cfg_disk->flags & CFG_DISK_BUSIEST) && (worst_disk != NULL)) submit_double (hostname, "system", "percent", "disk_busy", - worst_disk->disk_busy_percent, timestamp); + worst_disk->disk_busy_percent, timestamp, interval); return (0); } /* }}} int cna_handle_disk_data */ @@ -1120,8 +1200,8 @@ static int cna_setup_disk (cfg_disk_t *cd) /* {{{ */ 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_string(e, "counter", "disk_busy"); + na_child_add_string(e, "counter", "base_for_disk_busy"); na_child_add(cd->query, e); return (0); @@ -1131,7 +1211,7 @@ static int cna_query_disk (host_config_t *host) /* {{{ */ { na_elem_t *data; int status; - time_t now; + cdtime_t now; if (host == NULL) return (EINVAL); @@ -1141,7 +1221,7 @@ static int cna_query_disk (host_config_t *host) /* {{{ */ if (host->cfg_disk == NULL) return (0); - now = time (NULL); + now = cdtime (); if ((host->cfg_disk->interval.interval + host->cfg_disk->interval.last_read) > now) return (0); @@ -1153,13 +1233,14 @@ static int cna_query_disk (host_config_t *host) /* {{{ */ 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)); + ERROR ("netapp plugin: cna_query_disk: na_server_invoke_elem failed for host %s: %s", + host->name, na_results_reason (data)); na_elem_free (data); return (-1); } - status = cna_handle_disk_data (host->name, host->cfg_disk, data); + status = cna_handle_disk_data (host->name, host->cfg_disk, data, + host->cfg_disk->interval.interval); if (status == 0) host->cfg_disk->interval.last_read = now; @@ -1168,179 +1249,526 @@ static int cna_query_disk (host_config_t *host) /* {{{ */ return (status); } /* }}} int cna_query_disk */ -/* 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) - { - if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_FREE)) - submit_double (hostname, /* plugin instance = */ v->name, - "df_complex", "free", - (double) v->norm_free, /* timestamp = */ 0); - - if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_USED)) - submit_double (hostname, /* plugin instance = */ v->name, - "df_complex", "used", - (double) v->norm_used, /* timestamp = */ 0); - - if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_RSVD)) - submit_double (hostname, /* plugin instance = */ v->name, - "df_complex", "snap_reserved", - (double) v->snap_reserved, /* timestamp = */ 0); - - if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_USED)) - submit_double (hostname, /* plugin instance = */ v->name, - "df_complex", "snap_used", - (double) v->snap_used, /* timestamp = */ 0); - - if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SIS_SAVED)) - submit_double (hostname, /* plugin instance = */ v->name, - "df_complex", "sis_saved", - (double) v->sis_saved, /* timestamp = */ 0); - - /* Clear all the HAVE_* flags */ - v->flags &= ~HAVE_VOLUME_USAGE_ALL; - } /* for (v = cfg_volume->volumes) */ - - return (0); -} /* }}} int cna_submit_volume_usage_data */ - -static int cna_handle_volume_usage_data (const char *hostname, /* {{{ */ - cfg_volume_usage_t *cfg_volume, na_elem_t *data) +/* Data corresponding to */ +static int cna_handle_volume_perf_data (const char *hostname, /* {{{ */ + cfg_volume_perf_t *cvp, na_elem_t *data, cdtime_t interval) { - na_elem_t *elem_volume; - na_elem_t *elem_volumes; - na_elem_iter_t iter_volume; + cdtime_t timestamp; + na_elem_t *elem_instances; + na_elem_iter_t iter_instances; + na_elem_t *elem_instance; + + timestamp = cna_child_get_cdtime (data); - elem_volumes = na_elem_child (data, "volumes"); - if (elem_volumes == NULL) + elem_instances = na_elem_child(data, "instances"); + if (elem_instances == NULL) { - ERROR ("netapp plugin: cna_handle_volume_usage_data: " - "na_elem_child (\"volumes\") failed."); + ERROR ("netapp plugin: handle_volume_perf_data: " + "na_elem_child (\"instances\") failed " + "for host %s.", hostname); 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)) + 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 *volume_name; + const char *name; - data_volume_usage_t *v; - uint64_t value; + data_volume_perf_t perf_data; + data_volume_perf_t *v; - na_elem_t *sis; - const char *sis_state; - uint64_t sis_saved_reported; - uint64_t sis_saved; + na_elem_t *elem_counters; + na_elem_iter_t iter_counters; + na_elem_t *elem_counter; - volume_name = na_child_get_string (elem_volume, "name"); - if (volume_name == NULL) + 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_usage may return NULL if the volume is to be ignored. */ - v = get_volume_usage (cfg_volume, volume_name); + /* get_volume_perf may return NULL if this volume is to be ignored. */ + v = get_volume_perf (cvp, name); if (v == NULL) continue; - if ((v->flags & CFG_VOLUME_USAGE_DF) == 0) + elem_counters = na_elem_child (elem_instance, "counters"); + if (elem_counters == NULL) 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; - } + 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; - 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; - } + name = na_child_get_string (elem_counter, "name"); + if (name == NULL) + continue; - 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->norm_used = 1024 * value; - v->flags |= HAVE_VOLUME_USAGE_SNAP_RSVD; - } + value = na_child_get_uint64 (elem_counter, "value", UINT64_MAX); + if (value == UINT64_MAX) + continue; - sis = na_elem_child(elem_volume, "sis"); - if (sis == NULL) - 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) */ - sis_state = na_child_get_string(sis, "state"); - if (sis_state == NULL) - continue; + submit_volume_perf_data (hostname, v, &perf_data, interval); + } /* for (volume) */ - /* If SIS is not enabled, set the HAVE_VOLUME_USAGE_SIS_SAVED flag and set - * sis_saved to UINT64_MAX to signal this condition to the submit function. */ - if (strcmp ("enabled", sis_state) != 0) { - v->sis_saved = UINT64_MAX; - v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED; - continue; - } + return (0); +} /* }}} int cna_handle_volume_perf_data */ - sis_saved_reported = na_child_get_uint64(sis, "size-saved", UINT64_MAX); - if (sis_saved_reported == UINT64_MAX) - continue; +static int cna_setup_volume_perf (cfg_volume_perf_t *cd) /* {{{ */ +{ + na_elem_t *e; - /* 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. */ - sis_saved = sis_saved_reported; - } 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; + if (cd == NULL) + return (EINVAL); - sis_saved_percent = na_child_get_uint64(sis, "percentage-saved", UINT64_MAX); - if (sis_saved_percent > 100) - continue; + if (cd->query != NULL) + return (0); - /* 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)) - sis_saved = guess1; - else - sis_saved = guess2; + 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); + } + na_child_add_string(e, "counter", "read_ops"); + na_child_add_string(e, "counter", "write_ops"); + na_child_add_string(e, "counter", "read_data"); + na_child_add_string(e, "counter", "write_data"); + na_child_add_string(e, "counter", "read_latency"); + na_child_add_string(e, "counter", "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; + cdtime_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 = cdtime (); + 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 for host %s: %s", + host->name, na_results_reason (data)); + na_elem_free (data); + return (-1); + } + + status = cna_handle_volume_perf_data (host->name, host->cfg_volume_perf, data, + host->cfg_volume_perf->interval.interval); + + if (status == 0) + host->cfg_volume_perf->interval.last_read = now; + + 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, int interval) +{ + data_volume_usage_t *v; + + for (v = cfg_volume->volumes; v != NULL; v = v->next) + { + char plugin_instance[DATA_MAX_NAME_LEN]; + + uint64_t norm_used = v->norm_used; + uint64_t norm_free = v->norm_free; + uint64_t sis_saved = v->sis_saved; + uint64_t compress_saved = v->compress_saved; + uint64_t dedup_saved = v->dedup_saved; + uint64_t snap_reserve_used = 0; + uint64_t snap_reserve_free = v->snap_reserved; + uint64_t snap_norm_used = v->snap_used; + + ssnprintf (plugin_instance, sizeof (plugin_instance), + "volume-%s", v->name); + + 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 { - if ((sis_saved_guess - guess2) < (guess3 - sis_saved_guess)) - sis_saved = guess2; - else - sis_saved = guess3; + snap_reserve_free = 0; + snap_reserve_used = v->snap_reserved; + snap_norm_used = v->snap_used - v->snap_reserved; } - } /* }}} end of 32-bit workaround */ + } + + /* The space used by snapshots but not reserved for them is included in + * both, norm_used and snap_norm_used. If possible, subtract this here. */ + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_USED | HAVE_VOLUME_USAGE_SNAP_USED)) + { + if (norm_used >= snap_norm_used) + norm_used -= snap_norm_used; + else + { + ERROR ("netapp plugin: (norm_used = %"PRIu64") < (snap_norm_used = " + "%"PRIu64") for host %s. Invalidating both.", + norm_used, snap_norm_used, hostname); + v->flags &= ~(HAVE_VOLUME_USAGE_NORM_USED | HAVE_VOLUME_USAGE_SNAP_USED); + } + } + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_FREE)) + submit_double (hostname, /* plugin instance = */ plugin_instance, + "df_complex", "free", + (double) norm_free, /* timestamp = */ 0, interval); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SIS_SAVED)) + submit_double (hostname, /* plugin instance = */ plugin_instance, + "df_complex", "sis_saved", + (double) sis_saved, /* timestamp = */ 0, interval); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_COMPRESS_SAVED)) + submit_double (hostname, /* plugin instance = */ plugin_instance, + "df_complex", "compression_saved", + (double) compress_saved, /* timestamp = */ 0, interval); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_DEDUP_SAVED)) + submit_double (hostname, /* plugin instance = */ plugin_instance, + "df_complex", "dedup_saved", + (double) dedup_saved, /* timestamp = */ 0, interval); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_NORM_USED)) + submit_double (hostname, /* plugin instance = */ plugin_instance, + "df_complex", "used", + (double) norm_used, /* timestamp = */ 0, interval); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_RSVD)) + submit_double (hostname, /* plugin instance = */ plugin_instance, + "df_complex", "snap_reserved", + (double) snap_reserve_free, /* timestamp = */ 0, interval); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_USED | HAVE_VOLUME_USAGE_SNAP_RSVD)) + submit_double (hostname, /* plugin instance = */ plugin_instance, + "df_complex", "snap_reserve_used", + (double) snap_reserve_used, /* timestamp = */ 0, interval); + + if (HAS_ALL_FLAGS (v->flags, HAVE_VOLUME_USAGE_SNAP_USED)) + submit_double (hostname, /* plugin instance = */ plugin_instance, + "df_complex", "snap_normal_used", + (double) snap_norm_used, /* timestamp = */ 0, interval); + + /* Clear all the HAVE_* flags */ + v->flags &= ~HAVE_VOLUME_USAGE_ALL; + } /* for (v = cfg_volume->volumes) */ + + return (0); +} /* }}} int cna_submit_volume_usage_data */ + +/* Switch the state of a volume between online and offline and send out a + * notification. */ +static int cna_change_volume_status (const char *hostname, /* {{{ */ + data_volume_usage_t *v) +{ + notification_t n; + + memset (&n, 0, sizeof (&n)); + n.time = cdtime (); + sstrncpy (n.host, hostname, sizeof (n.host)); + sstrncpy (n.plugin, "netapp", sizeof (n.plugin)); + sstrncpy (n.plugin_instance, v->name, sizeof (n.plugin_instance)); + + if ((v->flags & IS_VOLUME_USAGE_OFFLINE) != 0) { + n.severity = NOTIF_OKAY; + ssnprintf (n.message, sizeof (n.message), + "Volume %s is now online.", v->name); + v->flags &= ~IS_VOLUME_USAGE_OFFLINE; + } else { + n.severity = NOTIF_WARNING; + ssnprintf (n.message, sizeof (n.message), + "Volume %s is now offline.", v->name); + v->flags |= IS_VOLUME_USAGE_OFFLINE; + } + + return (plugin_dispatch_notification (&n)); +} /* }}} int cna_change_volume_status */ + +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) { + if ((v->flags & IS_VOLUME_USAGE_OFFLINE) == 0) + cna_change_volume_status (host->name, v); + } else { + ERROR ("netapp plugin: cna_handle_volume_snap_usage: na_server_invoke_elem for " + "volume \"%s\" on host %s failed with error %d: %s", v->name, + host->name, na_results_errno(data), na_results_reason(data)); + } + na_elem_free(data); + return; + } + + if ((v->flags & IS_VOLUME_USAGE_OFFLINE) != 0) + cna_change_volume_status (host->name, v); + + elem_snapshots = na_elem_child (data, "snapshots"); + if (elem_snapshots == NULL) + { + ERROR ("netapp plugin: cna_handle_volume_snap_usage: " + "na_elem_child (\"snapshots\") failed " + "for host %s.", host->name); + 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); + /* "cumulative-total" is the total size of the oldest snapshot plus all + * newer ones in blocks (1KB). We therefore are looking for the highest + * number of all snapshots - that's the size required for the snapshots. */ + if (value > snap_used) + snap_used = value; + } + na_elem_free (data); + /* snap_used is in 1024 byte blocks */ + v->snap_used = snap_used * 1024; + v->flags |= HAVE_VOLUME_USAGE_SNAP_USED; +} /* }}} void cna_handle_volume_snap_usage */ + +static void cna_handle_volume_sis_data (const host_config_t *host, /* {{{ */ + data_volume_usage_t *v, na_elem_t *sis) +{ + const char *sis_state; + uint64_t sis_saved_reported; + + if (na_elem_child(sis, "sis-info")) + sis = na_elem_child(sis, "sis-info"); + + sis_state = na_child_get_string(sis, "state"); + if (sis_state == NULL) + return; + + /* If SIS is not enabled, there's nothing left to do for this volume. */ + if (strcmp ("enabled", sis_state) != 0) + return; + + sis_saved_reported = na_child_get_uint64(sis, "size-saved", UINT64_MAX); + if (sis_saved_reported == UINT64_MAX) + return; + + /* size-saved is actually a 32 bit number, so ... time for some guesswork. */ + if ((sis_saved_reported >> 32) != 0) { + /* In case they ever fix this bug. */ + v->sis_saved = sis_saved_reported; + v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED; + } else { /* really hacky work-around code. {{{ */ + uint64_t sis_saved_percent; + uint64_t sis_saved_guess; + uint64_t overflow_guess; + uint64_t guess1, guess2, guess3; + + /* Check if we have v->norm_used. Without it, we cannot calculate + * sis_saved_guess. */ + if ((v->flags & HAVE_VOLUME_USAGE_NORM_USED) == 0) + return; + + sis_saved_percent = na_child_get_uint64(sis, "percentage-saved", UINT64_MAX); + if (sis_saved_percent > 100) + return; + + /* The "size-saved" value is a 32bit unsigned integer. This is a bug and + * will hopefully be fixed in later versions. To work around the bug, try + * to figure out how often the 32bit integer wrapped around by using the + * "percentage-saved" value. Because the percentage is in the range + * [0-100], this should work as long as the saved space does not exceed + * 400 GBytes. */ + /* percentage-saved = size-saved / (size-saved + size-used) */ + if (sis_saved_percent < 100) + sis_saved_guess = v->norm_used * sis_saved_percent / (100 - sis_saved_percent); + else + sis_saved_guess = v->norm_used; + + overflow_guess = sis_saved_guess >> 32; + guess1 = overflow_guess ? ((overflow_guess - 1) << 32) + sis_saved_reported : sis_saved_reported; + guess2 = (overflow_guess << 32) + sis_saved_reported; + guess3 = ((overflow_guess + 1) << 32) + sis_saved_reported; + + if (sis_saved_guess < guess2) { + if ((sis_saved_guess - guess1) < (guess2 - sis_saved_guess)) + v->sis_saved = guess1; + else + v->sis_saved = guess2; + } else { + if ((sis_saved_guess - guess2) < (guess3 - sis_saved_guess)) + v->sis_saved = guess2; + else + v->sis_saved = guess3; + } + v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED; + } /* }}} end of 32-bit workaround */ +} /* }}} void cna_handle_volume_sis_data */ + +/* ONTAP >= 8.1 uses SIS for managing dedup and compression */ +static void cna_handle_volume_sis_saved (const host_config_t *host, /* {{{ */ + data_volume_usage_t *v, na_elem_t *sis) +{ + uint64_t saved; + + if (na_elem_child(sis, "sis-info")) + sis = na_elem_child(sis, "sis-info"); + + saved = na_child_get_uint64(sis, "compress-saved", UINT64_MAX); + if (saved != UINT64_MAX) { + v->compress_saved = saved; + v->flags |= HAVE_VOLUME_USAGE_COMPRESS_SAVED; + } + + saved = na_child_get_uint64(sis, "dedup-saved", UINT64_MAX); + if (saved != UINT64_MAX) { + v->dedup_saved = saved; + v->flags |= HAVE_VOLUME_USAGE_DEDUP_SAVED; + } +} /* }}} void cna_handle_volume_sis_saved */ + +static int cna_handle_volume_usage_data (const host_config_t *host, /* {{{ */ + cfg_volume_usage_t *cfg_volume, na_elem_t *data) +{ + na_elem_t *elem_volume; + na_elem_t *elem_volumes; + na_elem_iter_t iter_volume; + + elem_volumes = na_elem_child (data, "volumes"); + if (elem_volumes == NULL) + { + ERROR ("netapp plugin: cna_handle_volume_usage_data: " + "na_elem_child (\"volumes\") failed " + "for host %s.", host->name); + 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; + + 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) { + cna_handle_volume_sis_data (host, v, sis); + cna_handle_volume_sis_saved (host, v, sis); + } } /* for (elem_volume) */ - return (cna_submit_volume_usage_data (hostname, cfg_volume)); + return (cna_submit_volume_usage_data (host->name, cfg_volume, + host->cfg_volume_usage->interval.interval)); } /* }}} int cna_handle_volume_usage_data */ static int cna_setup_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */ @@ -1358,8 +1786,6 @@ static int cna_setup_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */ return (-1); } - /* TODO: cvu->snap_query = na_elem_new("snapshot-list-info"); */ - return (0); } /* }}} int cna_setup_volume_usage */ @@ -1367,7 +1793,7 @@ static int cna_query_volume_usage (host_config_t *host) /* {{{ */ { na_elem_t *data; int status; - time_t now; + cdtime_t now; if (host == NULL) return (EINVAL); @@ -1377,7 +1803,7 @@ static int cna_query_volume_usage (host_config_t *host) /* {{{ */ if (host->cfg_volume_usage == NULL) return (0); - now = time (NULL); + now = cdtime (); if ((host->cfg_volume_usage->interval.interval + host->cfg_volume_usage->interval.last_read) > now) return (0); @@ -1389,13 +1815,13 @@ static int cna_query_volume_usage (host_config_t *host) /* {{{ */ 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)); + ERROR ("netapp plugin: cna_query_volume_usage: na_server_invoke_elem failed for host %s: %s", + host->name, na_results_reason (data)); na_elem_free (data); return (-1); } - status = cna_handle_volume_usage_data (host->name, host->cfg_volume_usage, data); + status = cna_handle_volume_usage_data (host, host->cfg_volume_usage, data); if (status == 0) host->cfg_volume_usage->interval.last_read = now; @@ -1404,89 +1830,316 @@ static int cna_query_volume_usage (host_config_t *host) /* {{{ */ return (status); } /* }}} int cna_query_volume_usage */ -/* Data corresponding to */ -static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ - cfg_volume_perf_t *cfg_volume_perf = data; - time_t timestamp; - na_elem_t *counter, *inst; - - timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0); +/* Data corresponding to */ +static int cna_handle_quota_data (const host_config_t *host, /* {{{ */ + cfg_quota_t *cfg_quota, na_elem_t *data) +{ + na_elem_t *elem_quota; + na_elem_t *elem_quotas; + na_elem_iter_t iter_quota; - 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)) { - data_volume_perf_t perf_data; - volume_t *volume; + elem_quotas = na_elem_child (data, "quotas"); + if (elem_quotas == NULL) + { + ERROR ("netapp plugin: cna_handle_quota_data: " + "na_elem_child (\"quotas\") failed " + "for host %s.", host->name); + return (-1); + } - memset (&perf_data, 0, sizeof (perf_data)); - perf_data.timestamp = timestamp; + iter_quota = na_child_iterator (elem_quotas); + for (elem_quota = na_iterator_next (&iter_quota); + elem_quota != NULL; + elem_quota = na_iterator_next (&iter_quota)) + { + const char *quota_type, *volume_name, *tree_name; + uint64_t value; + + char plugin_instance[DATA_MAX_NAME_LEN]; - volume = get_volume(host, na_child_get_string(inst, "name"), - cfg_volume_perf->flags); - if (volume == NULL) + quota_type = na_child_get_string (elem_quota, "quota-type"); + if (quota_type == NULL) continue; - na_elem_iter_t count_iter = na_child_iterator(na_elem_child(inst, "counters")); - for (counter = na_iterator_next(&count_iter); counter; counter = na_iterator_next(&count_iter)) { - const char *name; - uint64_t value; + /* possible TODO: support other types as well */ + if (strcmp (quota_type, "tree") != 0) + continue; - name = na_child_get_string(counter, "name"); - if (name == NULL) - continue; + tree_name = na_child_get_string (elem_quota, "tree"); + if ((tree_name == NULL) || (*tree_name == '\0')) + continue; - value = na_child_get_uint64(counter, "value", UINT64_MAX); - if (value == UINT64_MAX) - continue; + volume_name = na_child_get_string (elem_quota, "volume"); + if (volume_name == NULL) + 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; - } + ssnprintf (plugin_instance, sizeof (plugin_instance), + "quota-%s-%s", volume_name, tree_name); + + value = na_child_get_uint64 (elem_quota, "disk-used", UINT64_MAX); + if (value != UINT64_MAX) { + value *= 1024; /* disk-used reports kilobytes */ + submit_double (host->name, plugin_instance, + /* type = */ "df_complex", /* type instance = */ NULL, + (double)value, /* timestamp = */ 0, + host->cfg_quota->interval.interval); } - submit_volume_perf_data (host, volume, &perf_data); - } /* for (volume) */ -} /* }}} void query_volume_perf_data */ + value = na_child_get_uint64 (elem_quota, "files-used", UINT64_MAX); + if (value != UINT64_MAX) { + submit_double (host->name, plugin_instance, + /* type = */ "files", /* type instance = */ NULL, + (double)value, /* timestamp = */ 0, + host->cfg_quota->interval.interval); + } + } /* for (elem_quota) */ + + return (0); +} /* }}} int cna_handle_volume_usage_data */ + +static int cna_setup_quota (cfg_quota_t *cq) /* {{{ */ +{ + if (cq == NULL) + return (EINVAL); + + if (cq->query != NULL) + return (0); + + cq->query = na_elem_new ("quota-report"); + if (cq->query == NULL) + { + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); + } + + return (0); +} /* }}} int cna_setup_quota */ + +static int cna_query_quota (host_config_t *host) /* {{{ */ +{ + na_elem_t *data; + int status; + cdtime_t now; + + if (host == NULL) + return (EINVAL); + + /* If the user did not configure quota statistics, return without + * doing anything. */ + if (host->cfg_quota == NULL) + return (0); + + now = cdtime (); + if ((host->cfg_quota->interval.interval + host->cfg_quota->interval.last_read) > now) + return (0); + + status = cna_setup_quota (host->cfg_quota); + if (status != 0) + return (status); + assert (host->cfg_quota->query != NULL); + + data = na_server_invoke_elem (host->srv, host->cfg_quota->query); + if (na_results_status (data) != NA_OK) + { + ERROR ("netapp plugin: cna_query_quota: na_server_invoke_elem failed for host %s: %s", + host->name, na_results_reason (data)); + na_elem_free (data); + return (-1); + } + + status = cna_handle_quota_data (host, host->cfg_quota, data); + + if (status == 0) + host->cfg_quota->interval.last_read = now; + + na_elem_free (data); + return (status); +} /* }}} int cna_query_quota */ + +/* Data corresponding to */ +static int cna_handle_snapvault_data (const char *hostname, /* {{{ */ + cfg_snapvault_t *cfg_snapvault, na_elem_t *data, cdtime_t interval) +{ + na_elem_t *status; + na_elem_iter_t status_iter; + + status = na_elem_child (data, "status-list"); + if (! status) { + ERROR ("netapp plugin: SnapVault status record missing status-list"); + return (0); + } + + status_iter = na_child_iterator (status); + for (status = na_iterator_next (&status_iter); + status != NULL; + status = na_iterator_next (&status_iter)) + { + const char *dest_sys, *dest_path, *src_sys, *src_path; + char plugin_instance[DATA_MAX_NAME_LEN]; + uint64_t value; + + dest_sys = na_child_get_string (status, "destination-system"); + dest_path = na_child_get_string (status, "destination-path"); + src_sys = na_child_get_string (status, "source-system"); + src_path = na_child_get_string (status, "source-path"); + + if ((! dest_sys) || (! dest_path) || (! src_sys) || (! src_path)) + continue; + + value = na_child_get_uint64 (status, "lag-time", UINT64_MAX); + if (value == UINT64_MAX) /* no successful baseline transfer yet */ + continue; + + /* possible TODO: make plugin instance configurable */ + ssnprintf (plugin_instance, sizeof (plugin_instance), + "snapvault-%s", dest_path); + submit_double (hostname, plugin_instance, /* type = */ "delay", NULL, + (double)value, /* timestamp = */ 0, interval); + + value = na_child_get_uint64 (status, "last-transfer-duration", UINT64_MAX); + if (value != UINT64_MAX) + submit_double (hostname, plugin_instance, /* type = */ "duration", "last_transfer", + (double)value, /* timestamp = */ 0, interval); + + value = na_child_get_uint64 (status, "transfer-progress", UINT64_MAX); + if (value == UINT64_MAX) + value = na_child_get_uint64 (status, "last-transfer-size", UINT64_MAX); + if (value != UINT64_MAX) { + value *= 1024; /* this is kilobytes */ + submit_derive (hostname, plugin_instance, /* type = */ "if_rx_octets", "transferred", + value, /* timestamp = */ 0, interval); + } + } /* for (status) */ + + return (0); +} /* }}} int cna_handle_snapvault_data */ + +static int cna_handle_snapvault_iter (host_config_t *host, /* {{{ */ + na_elem_t *data) +{ + const char *tag; + + uint32_t records_count; + uint32_t i; + + records_count = na_child_get_uint32 (data, "records", UINT32_MAX); + if (records_count == UINT32_MAX) + return 0; + + tag = na_child_get_string (data, "tag"); + if (! tag) + return 0; + + DEBUG ("netapp plugin: Iterating %u SV records (tag = %s)", records_count, tag); + + for (i = 0; i < records_count; ++i) { + na_elem_t *elem; + + elem = na_server_invoke (host->srv, + "snapvault-secondary-relationship-status-list-iter-next", + "maximum", "1", "tag", tag, NULL); + + if (na_results_status (elem) != NA_OK) + { + ERROR ("netapp plugin: cna_handle_snapvault_iter: " + "na_server_invoke failed for host %s: %s", + host->name, na_results_reason (data)); + na_elem_free (elem); + return (-1); + } + + cna_handle_snapvault_data (host->name, host->cfg_snapvault, elem, + host->cfg_snapvault->interval.interval); + na_elem_free (elem); + } + + na_elem_free (na_server_invoke (host->srv, + "snapvault-secondary-relationship-status-list-iter-end", + "tag", tag, NULL)); + return (0); +} /* }}} int cna_handle_snapvault_iter */ + +static int cna_setup_snapvault (cfg_snapvault_t *sv) /* {{{ */ +{ + if (sv == NULL) + return (EINVAL); + + if (sv->query != NULL) + return (0); + + sv->query = na_elem_new ("snapvault-secondary-relationship-status-list-iter-start"); + if (sv->query == NULL) + { + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); + } + + return (0); +} /* }}} int cna_setup_snapvault */ + +static int cna_query_snapvault (host_config_t *host) /* {{{ */ +{ + na_elem_t *data; + int status; + cdtime_t now; + + if (host == NULL) + return EINVAL; + + if (host->cfg_snapvault == NULL) + return 0; + + now = cdtime (); + if ((host->cfg_snapvault->interval.interval + host->cfg_snapvault->interval.last_read) > now) + return (0); + + status = cna_setup_snapvault (host->cfg_snapvault); + if (status != 0) + return (status); + assert (host->cfg_snapvault->query != NULL); + + data = na_server_invoke_elem (host->srv, host->cfg_snapvault->query); + if (na_results_status (data) != NA_OK) + { + ERROR ("netapp plugin: cna_query_snapvault: na_server_invoke_elem failed for host %s: %s", + host->name, na_results_reason (data)); + na_elem_free (data); + return (-1); + } + + status = cna_handle_snapvault_iter (host, data); + + if (status == 0) + host->cfg_snapvault->interval.last_read = now; + + na_elem_free (data); + return (status); +} /* }}} int cna_query_snapvault */ /* Data corresponding to */ static int cna_handle_system_data (const char *hostname, /* {{{ */ - cfg_system_t *cfg_system, na_elem_t *data) + cfg_system_t *cfg_system, na_elem_t *data, int interval) { na_elem_t *instances; na_elem_t *counter; na_elem_iter_t counter_iter; - counter_t disk_read = 0, disk_written = 0; - counter_t net_recv = 0, net_sent = 0; - counter_t cpu_busy = 0, cpu_total = 0; + derive_t disk_read = 0, disk_written = 0; + derive_t net_recv = 0, net_sent = 0; + derive_t cpu_busy = 0, cpu_total = 0; uint32_t counter_flags = 0; const char *instance; - time_t timestamp; + cdtime_t timestamp; - timestamp = (time_t) na_child_get_uint64 (data, "timestamp", 0); + timestamp = cna_child_get_cdtime (data); 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."); + "na_elem_child (\"instances\") failed " + "for host %s.", hostname); return (-1); } @@ -1494,7 +2147,8 @@ static int cna_handle_system_data (const char *hostname, /* {{{ */ if (instance == NULL) { ERROR ("netapp plugin: cna_handle_system_data: " - "na_child_get_string (\"name\") failed."); + "na_child_get_string (\"name\") failed " + "for host %s.", hostname); return (-1); } @@ -1515,48 +2169,48 @@ static int cna_handle_system_data (const char *hostname, /* {{{ */ continue; if (!strcmp(name, "disk_data_read")) { - disk_read = (counter_t) (value * 1024); + disk_read = (derive_t) (value * 1024); counter_flags |= 0x01; } else if (!strcmp(name, "disk_data_written")) { - disk_written = (counter_t) (value * 1024); + disk_written = (derive_t) (value * 1024); counter_flags |= 0x02; } else if (!strcmp(name, "net_data_recv")) { - net_recv = (counter_t) (value * 1024); + net_recv = (derive_t) (value * 1024); counter_flags |= 0x04; } else if (!strcmp(name, "net_data_sent")) { - net_sent = (counter_t) (value * 1024); + net_sent = (derive_t) (value * 1024); counter_flags |= 0x08; } else if (!strcmp(name, "cpu_busy")) { - cpu_busy = (counter_t) value; + cpu_busy = (derive_t) value; counter_flags |= 0x10; } else if (!strcmp(name, "cpu_elapsed_time")) { - cpu_total = (counter_t) value; + cpu_total = (derive_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); + submit_derive (hostname, instance, "disk_ops_complex", name, + (derive_t) value, timestamp, interval); } } /* for (counter) */ 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); + submit_two_derive (hostname, instance, "disk_octets", NULL, + disk_read, disk_written, timestamp, interval); if ((cfg_system->flags & CFG_SYSTEM_NET) && (HAS_ALL_FLAGS (counter_flags, 0x04 | 0x08))) - submit_two_counters (hostname, instance, "if_octets", NULL, - net_recv, net_sent, timestamp); + submit_two_derive (hostname, instance, "if_octets", NULL, + net_recv, net_sent, timestamp, interval); 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); + submit_derive (hostname, instance, "cpu", "system", + cpu_busy, timestamp, interval); + submit_derive (hostname, instance, "cpu", "idle", + cpu_total - cpu_busy, timestamp, interval); } return (0); @@ -1585,7 +2239,7 @@ static int cna_query_system (host_config_t *host) /* {{{ */ { na_elem_t *data; int status; - time_t now; + cdtime_t now; if (host == NULL) return (EINVAL); @@ -1594,7 +2248,7 @@ static int cna_query_system (host_config_t *host) /* {{{ */ if (host->cfg_system == NULL) return (0); - now = time (NULL); + now = cdtime (); if ((host->cfg_system->interval.interval + host->cfg_system->interval.last_read) > now) return (0); @@ -1606,13 +2260,14 @@ static int cna_query_system (host_config_t *host) /* {{{ */ 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)); + ERROR ("netapp plugin: cna_query_system: na_server_invoke_elem failed for host %s: %s", + host->name, na_results_reason (data)); na_elem_free (data); return (-1); } - status = cna_handle_system_data (host->name, host->cfg_system, data); + status = cna_handle_system_data (host->name, host->cfg_system, data, + host->cfg_system->interval.interval); if (status == 0) host->cfg_system->interval.last_read = now; @@ -1647,157 +2302,174 @@ static int cna_config_bool_to_flag (const oconfig_item_t *ci, /* {{{ */ return (0); } /* }}} int cna_config_bool_to_flag */ -/* Handling of the "Multiplier" option which is allowed in every block. */ -static int cna_config_get_multiplier (const oconfig_item_t *ci, /* {{{ */ - cfg_service_t *service) +/* 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) { - int tmp; + cdtime_t tmp = 0; + int status; - if ((ci == NULL) || (service == NULL)) - return (EINVAL); + status = cf_util_get_cdtime (ci, &tmp); + if (status != 0) + return (status); + + 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; + } + + 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 */ - if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) - { - WARNING ("netapp plugin: The `Multiplier' option needs exactly one numeric argument."); - return (-1); - } +/* 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; - tmp = (int) (ci->values[0].value.number + .5); - if (tmp < 1) + if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)) { - WARNING ("netapp plugin: The `Multiplier' option needs a positive integer argument."); - return (-1); + WARNING ("netapp plugin: The %s option requires exactly one string argument.", + ci->key); + return; } - service->multiplier = tmp; - service->skip_countdown = tmp; + 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; - return (0); -} /* }}} int cna_config_get_multiplier */ + 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 */ -/* 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) +/* 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) { - time_t tmp; + cfg_volume_perf_t *cfg_volume_perf; + int i; - if ((ci == NULL) || (out_interval == NULL)) + if ((host == NULL) || (ci == NULL)) return (EINVAL); - if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_NUMBER)) - { - WARNING ("netapp plugin: The `Multiplier' option needs exactly one numeric argument."); - return (-1); - } - - tmp = (time_t) (ci->values[0].value.number + .5); - if (tmp < 1) + if (host->cfg_volume_perf == NULL) { - WARNING ("netapp plugin: The `Multiplier' option needs a positive integer argument."); - return (-1); - } - - out_interval->interval = tmp; - out_interval->last_read = 0; - - return (0); -} /* }}} int cna_config_get_interval */ + cfg_volume_perf = malloc (sizeof (*cfg_volume_perf)); + if (cfg_volume_perf == NULL) + return (ENOMEM); + memset (cfg_volume_perf, 0, sizeof (*cfg_volume_perf)); -/* Handling of the "GetIO", "GetOps" and "GetLatency" options within a - * block. */ -static void cna_config_volume_performance_option (host_config_t *host, /* {{{ */ - cfg_volume_perf_t *perf_volume, const oconfig_item_t *item, - uint32_t flag) -{ - int i; - - for (i = 0; i < item->values_num; ++i) { - const char *name; - volume_t *v; - _Bool set = true; + /* Set default flags */ + cfg_volume_perf->query = NULL; + cfg_volume_perf->volumes = NULL; - if (item->values[i].type != OCONFIG_TYPE_STRING) { - WARNING("netapp plugin: Ignoring non-string argument in " - "\"GetVolumePerfData\" block for host %s", host->name); - continue; + cfg_volume_perf->il_octets = ignorelist_create (/* invert = */ 1); + if (cfg_volume_perf->il_octets == NULL) + { + sfree (cfg_volume_perf); + return (ENOMEM); } - name = item->values[i].value.string; - if (name[0] == '+') { - set = true; - ++name; - } else if (name[0] == '-') { - set = false; - ++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]) { - if (set) - perf_volume->flags |= flag; - else /* if (!set) */ - perf_volume->flags &= ~flag; - - host_set_all_perf_data_flags(host, flag, set); - 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, perf_volume->flags); - if (v == NULL) - continue; - - if (set) - v->perf_data.flags |= flag; - else /* if (!set) */ - v->perf_data.flags &= ~flag; - } /* for (i = 0 .. item->values_num) */ -} /* }}} void cna_config_volume_performance_option */ - -/* Corresponds to a block */ -static void cna_config_volume_performance(host_config_t *host, const oconfig_item_t *ci) { /* {{{ */ - int i, had_io = 0, had_ops = 0, had_latency = 0; - cfg_service_t *service; - cfg_volume_perf_t *perf_volume; + host->cfg_volume_perf = cfg_volume_perf; + } + cfg_volume_perf = host->cfg_volume_perf; - service = malloc(sizeof(*service)); - service->query = 0; - service->handler = query_volume_perf_data; - perf_volume = service->data = malloc(sizeof(*perf_volume)); - perf_volume->flags = CFG_VOLUME_PERF_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")) { - cna_config_get_multiplier (item, service); - } else if (!strcasecmp(item->key, "GetIO")) { - had_io = 1; - cna_config_volume_performance_option(host, perf_volume, item, CFG_VOLUME_PERF_IO); - } else if (!strcasecmp(item->key, "GetOps")) { - had_ops = 1; - cna_config_volume_performance_option(host, perf_volume, item, CFG_VOLUME_PERF_OPS); - } else if (!strcasecmp(item->key, "GetLatency")) { - had_latency = 1; - cna_config_volume_performance_option(host, perf_volume, item, CFG_VOLUME_PERF_LATENCY); - } - } - if (!had_io) { - perf_volume->flags |= CFG_VOLUME_PERF_IO; - host_set_all_perf_data_flags(host, CFG_VOLUME_PERF_IO, /* set = */ true); - } - if (!had_ops) { - perf_volume->flags |= CFG_VOLUME_PERF_OPS; - host_set_all_perf_data_flags(host, CFG_VOLUME_PERF_OPS, /* set = */ true); - } - if (!had_latency) { - perf_volume->flags |= CFG_VOLUME_PERF_LATENCY; - host_set_all_perf_data_flags(host, CFG_VOLUME_PERF_LATENCY, /* set = */ true); + 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); } -} /* }}} void cna_config_volume_performance */ -/* Handling of the "Capacity" and "Snapshot" options within a - * block. */ + 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) { @@ -1813,9 +2485,9 @@ static void cna_config_volume_usage_option (cfg_volume_usage_t *cvu, /* {{{ */ name = ci->values[0].value.string; - if (strcasecmp ("Capacity", ci->key) == 0) + if (strcasecmp ("GetCapacity", ci->key) == 0) il = cvu->il_capacity; - else if (strcasecmp ("Snapshot", ci->key) == 0) + else if (strcasecmp ("GetSnapshot", ci->key) == 0) il = cvu->il_snapshot; else return; @@ -1850,6 +2522,40 @@ static void cna_config_volume_usage_default (cfg_volume_usage_t *cvu, /* {{{ */ ignorelist_set_invert (il, /* invert = */ 1); } /* }}} void cna_config_volume_usage_default */ +/* Corresponds to a block */ +static int cna_config_quota (host_config_t *host, oconfig_item_t *ci) /* {{{ */ +{ + cfg_quota_t *cfg_quota; + int i; + + if ((host == NULL) || (ci == NULL)) + return (EINVAL); + + if (host->cfg_quota == NULL) + { + cfg_quota = malloc (sizeof (*cfg_quota)); + if (cfg_quota == NULL) + return (ENOMEM); + memset (cfg_quota, 0, sizeof (*cfg_quota)); + cfg_quota->query = NULL; + + host->cfg_quota = cfg_quota; + } + cfg_quota = host->cfg_quota; + + for (i = 0; i < ci->children_num; ++i) { + oconfig_item_t *item = ci->children + i; + + if (strcasecmp (item->key, "Interval") == 0) + cna_config_get_interval (item, &cfg_quota->interval); + else + WARNING ("netapp plugin: The option %s is not allowed within " + "`Quota' blocks.", item->key); + } + + return (0); +} /* }}} int cna_config_quota */ + /* Corresponds to a block */ static int cna_config_disk(host_config_t *host, oconfig_item_t *ci) { /* {{{ */ cfg_disk_t *cfg_disk; @@ -1949,22 +2655,24 @@ static int cna_config_wafl(host_config_t *host, oconfig_item_t *ci) /* {{{ */ /* * - * Capacity "vol0" - * Capacity "vol1" - * Capacity "vol2" - * Capacity "vol3" - * Capacity "vol4" + * GetCapacity "vol0" + * GetCapacity "vol1" + * GetCapacity "vol2" + * GetCapacity "vol3" + * GetCapacity "vol4" * IgnoreSelectedCapacity false * - * Snapshot "vol0" - * Snapshot "vol3" - * Snapshot "vol4" - * Snapshot "vol7" + * GetSnapshot "vol0" + * GetSnapshot "vol3" + * GetSnapshot "vol4" + * GetSnapshot "vol7" * IgnoreSelectedSnapshot false * */ /* Corresponds to a block */ -static int cna_config_volume_usage(host_config_t *host, oconfig_item_t *ci) { /* {{{ */ +static int cna_config_volume_usage(host_config_t *host, /* {{{ */ + const oconfig_item_t *ci) +{ cfg_volume_usage_t *cfg_volume_usage; int i; @@ -2007,22 +2715,61 @@ static int cna_config_volume_usage(host_config_t *host, oconfig_item_t *ci) { /* /* if (!item || !item->key || !*item->key) continue; */ if (strcasecmp(item->key, "Interval") == 0) cna_config_get_interval (item, &cfg_volume_usage->interval); - else if (!strcasecmp(item->key, "Capacity")) + else if (!strcasecmp(item->key, "GetCapacity")) cna_config_volume_usage_option (cfg_volume_usage, item); - else if (!strcasecmp(item->key, "Snapshot")) + 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); } return (0); } /* }}} int cna_config_volume_usage */ +/* Corresponds to a block */ +static int cna_config_snapvault (host_config_t *host, /* {{{ */ + const oconfig_item_t *ci) +{ + cfg_snapvault_t *cfg_snapvault; + int i; + + if ((host == NULL) || (ci == NULL)) + return EINVAL; + + if (host->cfg_snapvault == NULL) + { + cfg_snapvault = malloc (sizeof (*cfg_snapvault)); + if (cfg_snapvault == NULL) + return ENOMEM; + memset (cfg_snapvault, 0, sizeof (*cfg_snapvault)); + cfg_snapvault->query = NULL; + + host->cfg_snapvault = cfg_snapvault; + } + + cfg_snapvault = host->cfg_snapvault; + + for (i = 0; i < ci->children_num; ++i) { + oconfig_item_t *item = ci->children + i; + + if (strcasecmp (item->key, "Interval") == 0) + cna_config_get_interval (item, &cfg_snapvault->interval); + else + WARNING ("netapp plugin: The option %s is not allowed within " + "`SnapVault' blocks.", item->key); + } + + return 0; +} /* }}} int cna_config_snapvault */ + /* Corresponds to a block */ static int cna_config_system (host_config_t *host, /* {{{ */ - oconfig_item_t *ci, const cfg_service_t *default_service) + oconfig_item_t *ci) { cfg_system_t *cfg_system; int i; @@ -2076,29 +2823,128 @@ static int cna_config_system (host_config_t *host, /* {{{ */ } /* }}} 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, const cfg_service_t *def_def_service) +static host_config_t *cna_alloc_host (void) /* {{{ */ { - oconfig_item_t *item; host_config_t *host; - cfg_service_t default_service = *def_def_service; + + host = malloc(sizeof(*host)); + if (! host) + return (NULL); + memset (host, 0, sizeof (*host)); + + host->name = NULL; + host->protocol = NA_SERVER_TRANSPORT_HTTPS; + host->host = NULL; + host->username = NULL; + host->password = NULL; + host->vfiler = NULL; + host->srv = NULL; + host->cfg_wafl = NULL; + host->cfg_disk = NULL; + host->cfg_volume_perf = NULL; + host->cfg_volume_usage = NULL; + host->cfg_quota = NULL; + host->cfg_snapvault = NULL; + host->cfg_system = NULL; + + return (host); +} /* }}} host_config_t *cna_alloc_host */ + +static host_config_t *cna_shallow_clone_host (host_config_t *host) /* {{{ */ +{ + host_config_t *clone; + + if (host == NULL) + return (NULL); + + clone = cna_alloc_host (); + if (clone == NULL) + return (NULL); + + if (host->name != NULL) { + clone->name = strdup (host->name); + if (clone->name == NULL) { + free_host_config (clone); + return NULL; + } + } + + clone->protocol = host->protocol; + + if (host->host != NULL) { + clone->host = strdup (host->host); + if (clone->host == NULL) { + free_host_config (clone); + return NULL; + } + } + + clone->port = host->port; + + if (host->username != NULL) { + clone->username = strdup (host->username); + if (clone->username == NULL) { + free_host_config (clone); + return NULL; + } + } + if (host->password != NULL) { + clone->password = strdup (host->password); + if (clone->password == NULL) { + free_host_config (clone); + return NULL; + } + } + + clone->interval = host->interval; + + return (clone); +} /* }}} host_config_t *cna_shallow_clone_host */ + +static int cna_read (user_data_t *ud); + +static int cna_register_host (host_config_t *host) /* {{{ */ +{ + char cb_name[256]; + user_data_t ud; + + if (host->vfiler) + ssnprintf (cb_name, sizeof (cb_name), "netapp-%s-%s", + host->name, host->vfiler); + else + ssnprintf (cb_name, sizeof (cb_name), "netapp-%s", host->name); + + memset (&ud, 0, sizeof (ud)); + ud.data = host; + ud.free_func = (void (*) (void *)) free_host_config; + + plugin_register_complex_read (/* group = */ NULL, cb_name, + /* callback = */ cna_read, + /* interval = */ host->interval, + /* user data = */ &ud); + + return (0); +} /* }}} int cna_register_host */ + +static int cna_config_host (host_config_t *host, /* {{{ */ + const oconfig_item_t *ci) +{ + oconfig_item_t *item; + _Bool is_vfiler = 0; int status; int i; - + + if (! strcasecmp (ci->key, "VFiler")) + is_vfiler = 1; + 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; + WARNING ("netapp plugin: \"%s\" needs exactly one string argument. Ignoring host block.", ci->key); + return (1); } - 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); - } + return (1); for (i = 0; i < ci->children_num; ++i) { item = ci->children + i; @@ -2116,7 +2962,7 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */ } 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; + return (1); } if (!strcasecmp(item->values[0].value.string, "http")) host->protocol = NA_SERVER_TRANSPORT_HTTP; else host->protocol = NA_SERVER_TRANSPORT_HTTPS; @@ -2125,24 +2971,41 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */ } 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; - } - host->interval = item->values[0].value.number; + status = cf_util_get_cdtime (item, &host->interval); } else if (!strcasecmp(item->key, "WAFL")) { cna_config_wafl(host, item); } else if (!strcasecmp(item->key, "Disks")) { cna_config_disk(host, item); - } else if (!strcasecmp(item->key, "GetVolumePerfData")) { + } 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, "Quota")) { + cna_config_quota(host, item); + } else if (!strcasecmp(item->key, "SnapVault")) { + cna_config_snapvault(host, item); } else if (!strcasecmp(item->key, "System")) { - cna_config_system(host, item, &default_service); + cna_config_system(host, item); + } else if ((!strcasecmp(item->key, "VFiler")) && (! is_vfiler)) { + host_config_t *vfiler; + + vfiler = cna_shallow_clone_host (host); + if (! vfiler) { + ERROR ("netapp plugin: Failed to allocate host object for vfiler."); + continue; + } + + if (cna_config_host (vfiler, item)) { + free_host_config (vfiler); + continue; + } + + cna_register_host (vfiler); + } else if ((!strcasecmp(item->key, "VFilerName")) && is_vfiler) { + status = cf_util_get_string (item, &host->vfiler); } 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 %s block \"%s\".", + item->key, is_vfiler ? "vfiler" : "host", ci->values[0].value.string); } if (status != 0) @@ -2152,6 +3015,9 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */ if (host->host == NULL) host->host = strdup (host->name); + if (is_vfiler && (! host->vfiler)) + host->vfiler = strdup (host->name); + if (host->host == NULL) status = -1; @@ -2165,12 +3031,9 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */ } if (status != 0) - { - free_host_config (host); - return (NULL); - } + return status; - return host; + return (0); } /* }}} host_config_t *cna_config_host */ /* @@ -2178,17 +3041,52 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */ * * Pretty standard stuff here. */ -static int cna_init(void) { /* {{{ */ - char err[256]; - na_elem_t *e; - host_config_t *host; - cfg_service_t *service; - - if (!global_host_config) { - WARNING("netapp plugin: Plugin loaded but no hosts defined."); - return 1; +static int cna_init_host (host_config_t *host) /* {{{ */ +{ + /* Request version 1.1 of the ONTAP API */ + int major_version = 1, minor_version = 1; + + if (host == NULL) + return (EINVAL); + + if (host->srv != NULL) + return (0); + + if (host->vfiler != NULL) /* Request version 1.7 of the ONTAP API */ + minor_version = 7; + + host->srv = na_server_open (host->host, major_version, minor_version); + if (host->srv == NULL) { + ERROR ("netapp plugin: na_server_open (%s) failed.", host->host); + return (-1); + } + + 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 */); + + if (host->vfiler != NULL) { + if (! na_server_set_vfiler (host->srv, host->vfiler)) { + ERROR ("netapp plugin: Failed to connect to VFiler '%s' on host '%s'.", + host->vfiler, host->host); + return (-1); + } + else { + INFO ("netapp plugin: Connected to VFiler '%s' on host '%s'.", + host->vfiler, host->host); + } } + return (0); +} /* }}} int cna_init_host */ + +static int cna_init (void) /* {{{ */ +{ + char err[256]; + memset (err, 0, sizeof (err)); if (!na_startup(err, sizeof(err))) { err[sizeof (err) - 1] = 0; @@ -2196,123 +3094,111 @@ static int cna_init(void) { /* {{{ */ 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; - } + return (0); +} /* }}} cna_init */ - if (host->interval < interval_g) - host->interval = interval_g; - - na_server_set_transport_type(host->srv, host->protocol, - /* transportarg = */ NULL); - na_server_set_port(host->srv, host->port); - na_server_style(host->srv, NA_STYLE_LOGIN_PASSWORD); - na_server_adminuser(host->srv, host->username, host->password); - na_server_set_timeout(host->srv, 5 /* seconds */); - - for (service = host->services; service; service = service->next) { - service->interval = host->interval * service->multiplier; - - if (service->handler == query_volume_perf_data) { - service->query = na_elem_new("perf-object-get-instances"); - na_child_add_string(service->query, "objectname", "volume"); - e = na_elem_new("counters"); - /* "foo" means: This string has to be here but - the content doesn't matter. */ - na_child_add_string(e, "foo", "read_ops"); - na_child_add_string(e, "foo", "write_ops"); - na_child_add_string(e, "foo", "read_data"); - na_child_add_string(e, "foo", "write_data"); - na_child_add_string(e, "foo", "read_latency"); - na_child_add_string(e, "foo", "write_latency"); - na_child_add(service->query, e); - } - } /* for (host->services) */ +static int cna_read_internal (host_config_t *host) { /* {{{ */ + int status; + + status = cna_query_wafl (host); + if (status != 0) + return (status); + + status = cna_query_disk (host); + if (status != 0) + return (status); + + status = cna_query_volume_perf (host); + if (status != 0) + return (status); + + status = cna_query_volume_usage (host); + if (status != 0) + return (status); + + status = cna_query_quota (host); + if (status != 0) + return (status); + + status = cna_query_snapvault (host); + if (status != 0) + return (status); + + status = cna_query_system (host); + if (status != 0) + return (status); + + return 0; +} /* }}} int cna_read_internal */ + +static int cna_read (user_data_t *ud) { /* {{{ */ + host_config_t *host; + int status; + + if ((ud == NULL) || (ud->data == NULL)) + return (-1); + + host = ud->data; + + status = cna_init_host (host); + if (status != 0) + return (status); + + status = cna_read_internal (host); + if (status != 0) + { + if (host->srv != NULL) + na_server_close (host->srv); + host->srv = NULL; } + return 0; -} /* }}} int cna_init */ +} /* }}} int cna_read */ static int cna_config (oconfig_item_t *ci) { /* {{{ */ int i; oconfig_item_t *item; - host_config_t default_host = HOST_INIT; - cfg_service_t default_service = SERVICE_INIT; - + for (i = 0; i < ci->children_num; ++i) { item = ci->children + i; - if (!strcasecmp(item->key, "Host")) { + if (strcasecmp(item->key, "Host") == 0) + { host_config_t *host; - host_config_t *tmp; - host = cna_config_host(item, &default_host, &default_service); - if (host == NULL) + host = cna_alloc_host (); + if (host == NULL) { + ERROR ("netapp plugin: Failed to allocate host object."); 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; + if (cna_config_host (host, item) != 0) { + free_host_config (host); + continue; } - host->next = NULL; - if (tmp == NULL) - global_host_config = host; - else - tmp->next = host; - } else { + cna_register_host (host); + } + else /* if (item->key != "Host") */ + { WARNING("netapp plugin: Ignoring unknown config option \"%s\".", item->key); } } return 0; } /* }}} int cna_config */ -static int cna_read(void) { /* {{{ */ - na_elem_t *out; - host_config_t *host; - cfg_service_t *service; - - for (host = global_host_config; host; host = host->next) { - for (service = host->services; service; service = service->next) { - if (--service->skip_countdown > 0) continue; - service->skip_countdown = service->multiplier; - 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->services) */ +static int cna_shutdown (void) /* {{{ */ +{ + /* Clean up system resources and stuff. */ + na_shutdown (); - cna_query_wafl (host); - cna_query_disk (host); - cna_query_volume_usage (host); - cna_query_system (host); - } - return 0; -} /* }}} int cna_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 : */