X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fnetapp.c;h=1e0834b8175042464b417a27b75f751225eba9a8;hb=7344a21b9e2099e2ed0e841af21e6044dec41b6a;hp=62e206a75a29b368a3609a340a7307006af1ed3d;hpb=2cd802b86c3fbf7f67fc8a874a28fde87fbf6cab;p=collectd.git diff --git a/src/netapp.c b/src/netapp.c index 62e206a7..1e0834b8 100644 --- a/src/netapp.c +++ b/src/netapp.c @@ -21,11 +21,12 @@ * DEALINGS IN THE SOFTWARE. * * Authors: - * Sven Trenkel + * Sven Trenkel **/ #include "collectd.h" #include "common.h" +#include "utils_ignorelist.h" #include @@ -41,28 +42,17 @@ struct cna_interval_s }; typedef struct cna_interval_s cna_interval_t; -/*! - * \brief Persistent data for system performance counters - */ -#define CFG_SYSTEM_CPU 0x01 -#define CFG_SYSTEM_NET 0x02 -#define CFG_SYSTEM_OPS 0x04 -#define CFG_SYSTEM_DISK 0x08 -#define CFG_SYSTEM_ALL 0x0F -typedef struct { - uint32_t flags; -} cfg_system_t; - -/*! +/*! Data types for WAFL statistics {{{ + * * \brief Persistent data for WAFL performance counters. (a.k.a. cache performance) * * The cache counters use old counter values to calculate a hit ratio for each - * counter. The "data_wafl_t" struct therefore contains old counter values - * along with flags, which are set if the counter is valid. + * counter. The "cfg_wafl_t" struct therefore contains old counter values along + * with flags, which are set if the counter is valid. * - * The function "query_wafl_data" will fill a new structure of this kind with - * new values, then pass both, new and old data, to "submit_wafl_data". That - * function calculates the hit ratios, submits the calculated values and + * The function "cna_handle_wafl_data" will fill a new structure of this kind + * with new values, then pass both, new and old data, to "submit_wafl_data". + * That function calculates the hit ratios, submits the calculated values and * updates the old counter values for the next iteration. */ #define CFG_WAFL_NAME_CACHE 0x0001 @@ -85,6 +75,9 @@ typedef struct { #define HAVE_WAFL_ALL 0xff00 typedef struct { uint32_t flags; + cna_interval_t interval; + na_elem_t *query; + time_t timestamp; uint64_t name_cache_hit; uint64_t name_cache_miss; @@ -94,9 +87,41 @@ typedef struct { uint64_t buf_hash_miss; uint64_t inode_cache_hit; uint64_t inode_cache_miss; -} data_wafl_t; +} cfg_wafl_t; +/* }}} cfg_wafl_t */ -/*! +/*! Data types for disk statistics {{{ + * + * \brief A disk in the NetApp. + * + * A disk doesn't have any more information than its name at the moment. + * The name includes the "disk_" prefix. + */ +#define HAVE_DISK_BUSY 0x10 +#define HAVE_DISK_BASE 0x20 +#define HAVE_DISK_ALL 0x30 +typedef struct disk_s { + char *name; + uint32_t flags; + time_t timestamp; + uint64_t disk_busy; + uint64_t base_for_disk_busy; + double disk_busy_percent; + struct disk_s *next; +} disk_t; + +#define CFG_DISK_BUSIEST 0x01 +#define CFG_DISK_ALL 0x01 +typedef struct { + uint32_t flags; + cna_interval_t interval; + na_elem_t *query; + disk_t *disks; +} cfg_disk_t; +/* }}} cfg_disk_t */ + +/*! Data types for volume performance statistics {{{ + * * \brief Persistent data for volume performance data. * * The code below uses the difference of the operations and latency counters to @@ -136,16 +161,62 @@ typedef struct { uint64_t read_latency; uint64_t write_latency; } data_volume_perf_t; +/* }}} data_volume_perf_t */ -/*! +/*! Data types for volume usage statistics {{{ + * * \brief Configuration struct for volume usage data (free / used). */ -#define VOLUME_INIT 0x01 -#define VOLUME_DF 0x02 -#define VOLUME_SNAP 0x04 -typedef struct { +#define CFG_VOLUME_USAGE_DF 0x0002 +#define CFG_VOLUME_USAGE_SNAP 0x0004 +#define CFG_VOLUME_USAGE_ALL 0x0006 +#define HAVE_VOLUME_USAGE_NORM_FREE 0x0010 +#define HAVE_VOLUME_USAGE_NORM_USED 0x0020 +#define HAVE_VOLUME_USAGE_SNAP_RSVD 0x0040 +#define HAVE_VOLUME_USAGE_SNAP_USED 0x0080 +#define HAVE_VOLUME_USAGE_SIS_SAVED 0x0100 +#define HAVE_VOLUME_USAGE_ALL 0x01f0 +struct data_volume_usage_s; +typedef struct data_volume_usage_s data_volume_usage_t; +struct data_volume_usage_s { + char *name; uint32_t flags; + + uint64_t norm_free; + uint64_t norm_used; + uint64_t snap_reserved; + uint64_t snap_used; + uint64_t sis_saved; + + data_volume_usage_t *next; +}; + +typedef struct { + cna_interval_t interval; + na_elem_t *query; + + ignorelist_t *il_capacity; + ignorelist_t *il_snapshot; + + data_volume_usage_t *volumes; } cfg_volume_usage_t; +/* }}} cfg_volume_usage_t */ + +/*! Data types for system statistics {{{ + * + * \brief Persistent data for system performance counters + */ +#define CFG_SYSTEM_CPU 0x01 +#define CFG_SYSTEM_NET 0x02 +#define CFG_SYSTEM_OPS 0x04 +#define CFG_SYSTEM_DISK 0x08 +#define CFG_SYSTEM_ALL 0x0F +typedef struct { + uint32_t flags; + cna_interval_t interval; + na_elem_t *query; +} cfg_system_t; +/* }}} cfg_system_t */ typedef struct service_config_s { na_elem_t *query; @@ -171,38 +242,9 @@ typedef struct service_config_s { typedef struct volume_s { char *name; data_volume_perf_t perf_data; - cfg_volume_usage_t cfg_volume_usage; struct volume_s *next; } volume_t; -/*! - * \brief A disk in the NetApp. - * - * A disk doesn't have any more information than its name at the moment. - * The name includes the "disk_" prefix. - */ -#define HAVE_DISK_BUSY 0x10 -#define HAVE_DISK_BASE 0x20 -#define HAVE_DISK_ALL 0x30 -typedef struct disk_s { - char *name; - uint32_t flags; - time_t timestamp; - uint64_t disk_busy; - uint64_t base_for_disk_busy; - double disk_busy_percent; - struct disk_s *next; -} disk_t; - -#define CFG_DISK_BUSIEST 0x01 -#define CFG_DISK_ALL 0x01 -typedef struct { - uint32_t flags; - cna_interval_t interval; - na_elem_t *query; - disk_t *disks; -} cfg_disk_t; - struct host_config_s { char *name; na_server_transport_t protocol; @@ -214,13 +256,16 @@ struct host_config_s { na_server_t *srv; cfg_service_t *services; + cfg_wafl_t *cfg_wafl; cfg_disk_t *cfg_disk; + cfg_volume_usage_t *cfg_volume_usage; + 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, NULL, NULL, NULL, \ NULL} static host_config_t *global_host_config; @@ -234,6 +279,9 @@ static void free_volume (volume_t *volume) /* {{{ */ { volume_t *next; + if (volume == NULL) + return; + next = volume->next; sfree (volume->name); @@ -246,6 +294,9 @@ static void free_disk (disk_t *disk) /* {{{ */ { disk_t *next; + if (disk == NULL) + return; + next = disk->next; sfree (disk->name); @@ -254,22 +305,79 @@ static void free_disk (disk_t *disk) /* {{{ */ free_disk (next); } /* }}} void free_disk */ +static void free_cfg_wafl (cfg_wafl_t *cw) /* {{{ */ +{ + if (cw == NULL) + return; + + if (cw->query != NULL) + na_elem_free (cw->query); + + sfree (cw); +} /* }}} void free_cfg_wafl */ + static void free_cfg_disk (cfg_disk_t *cfg_disk) /* {{{ */ { if (cfg_disk == NULL) return; + if (cfg_disk->query != NULL) + na_elem_free (cfg_disk->query); + free_disk (cfg_disk->disks); sfree (cfg_disk); } /* }}} void free_cfg_disk */ +static void free_cfg_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */ +{ + data_volume_usage_t *data; + + if (cvu == NULL) + return; + + /* Free the ignorelists */ + ignorelist_free (cvu->il_capacity); + ignorelist_free (cvu->il_snapshot); + + /* Free the linked list of volumes */ + data = cvu->volumes; + while (data != NULL) + { + data_volume_usage_t *next = data->next; + sfree (data->name); + sfree (data); + data = next; + } + + if (cvu->query != NULL) + na_elem_free (cvu->query); + + sfree (cvu); +} /* }}} void free_cfg_volume_usage */ + +static void free_cfg_system (cfg_system_t *cs) /* {{{ */ +{ + if (cs == NULL) + return; + + if (cs->query != NULL) + na_elem_free (cs->query); + + sfree (cs); +} /* }}} void free_cfg_system */ + static void free_cfg_service (cfg_service_t *service) /* {{{ */ { cfg_service_t *next; + if (service == NULL) + return; + next = service->next; /* FIXME: Free service->data? */ + na_elem_free(service->query); + sfree (service); free_cfg_service (next); @@ -291,6 +399,9 @@ static void free_host_config (host_config_t *hc) /* {{{ */ free_cfg_service (hc->services); free_cfg_disk (hc->cfg_disk); + free_cfg_wafl (hc->cfg_wafl); + free_cfg_volume_usage (hc->cfg_volume_usage); + free_cfg_system (hc->cfg_system); free_volume (hc->volumes); sfree (hc); @@ -304,7 +415,7 @@ 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_usage_flags, uint32_t vol_perf_flags) + uint32_t vol_perf_flags) { volume_t *v; @@ -312,8 +423,6 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */ return (NULL); /* Make sure the default flags include the init-bit. */ - if (vol_usage_flags != 0) - vol_usage_flags |= VOLUME_INIT; if (vol_perf_flags != 0) vol_perf_flags |= CFG_VOLUME_PERF_INIT; @@ -322,9 +431,6 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */ continue; /* Check if the flags have been initialized. */ - if (((v->cfg_volume_usage.flags & VOLUME_INIT) == 0) - && (vol_usage_flags != 0)) - v->cfg_volume_usage.flags = vol_usage_flags; if (((v->perf_data.flags & CFG_VOLUME_PERF_INIT) == 0) && (vol_perf_flags != 0)) v->perf_data.flags = vol_perf_flags; @@ -338,7 +444,6 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */ return (NULL); memset (v, 0, sizeof (*v)); - v->cfg_volume_usage.flags = vol_usage_flags; v->perf_data.flags = vol_perf_flags; v->name = strdup(name); @@ -383,6 +488,64 @@ static disk_t *get_disk(cfg_disk_t *cd, const char *name) /* {{{ */ return d; } /* }}} disk_t *get_disk */ +static data_volume_usage_t *get_volume_usage (cfg_volume_usage_t *cvu, /* {{{ */ + const char *name) +{ + data_volume_usage_t *last; + data_volume_usage_t *new; + + int ignore_capacity = 0; + int ignore_snapshot = 0; + + if ((cvu == NULL) || (name == NULL)) + return (NULL); + + last = cvu->volumes; + while (last != NULL) + { + if (strcmp (last->name, name) == 0) + return (last); + + if (last->next == NULL) + break; + + last = last->next; + } + + /* Check the ignorelists. If *both* tell us to ignore a volume, return NULL. */ + ignore_capacity = ignorelist_match (cvu->il_capacity, name); + ignore_snapshot = ignorelist_match (cvu->il_snapshot, name); + if ((ignore_capacity != 0) && (ignore_snapshot != 0)) + return (NULL); + + /* Not found: allocate. */ + new = malloc (sizeof (*new)); + if (new == NULL) + return (NULL); + memset (new, 0, sizeof (*new)); + new->next = NULL; + + new->name = strdup (name); + if (new->name == NULL) + { + sfree (new); + return (NULL); + } + + if (ignore_capacity == 0) + new->flags |= CFG_VOLUME_USAGE_DF; + if (ignore_snapshot == 0) + new->flags |= CFG_VOLUME_USAGE_SNAP; + + /* Add to end of list. */ + if (last == NULL) + cvu->volumes = new; + else + last->next = new; + + return (new); +} /* }}} data_volume_usage_t *get_volume_usage */ + static void host_set_all_perf_data_flags(const host_config_t *host, /* {{{ */ uint32_t flag, _Bool set) { @@ -396,18 +559,6 @@ static void host_set_all_perf_data_flags(const host_config_t *host, /* {{{ */ } } /* }}} void host_set_all_perf_data_flags */ -static void host_set_all_cfg_volume_usage_flags(const host_config_t *host, /* {{{ */ - uint32_t flag, _Bool set) { - volume_t *v; - - for (v = host->volumes; v; v = v->next) { - if (set) - v->cfg_volume_usage.flags |= flag; - else /* if (!set) */ - v->cfg_volume_usage.flags &= ~flag; - } -} /* }}} void host_set_all_cfg_volume_usage_flags */ - /* * Various submit functions. * @@ -520,34 +671,34 @@ static int submit_cache_ratio (const char *host, /* {{{ */ } /* }}} int submit_cache_ratio */ /* Submits all the caches used by WAFL. Uses "submit_cache_ratio". */ -static int submit_wafl_data (const host_config_t *host, const char *instance, /* {{{ */ - data_wafl_t *old_data, const data_wafl_t *new_data) +static int submit_wafl_data (const char *hostname, const char *instance, /* {{{ */ + cfg_wafl_t *old_data, const cfg_wafl_t *new_data) { /* Submit requested counters */ if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_NAME_CACHE | HAVE_WAFL_NAME_CACHE) && HAS_ALL_FLAGS (new_data->flags, HAVE_WAFL_NAME_CACHE)) - submit_cache_ratio (host->name, instance, "name_cache_hit", + submit_cache_ratio (hostname, instance, "name_cache_hit", new_data->name_cache_hit, new_data->name_cache_miss, old_data->name_cache_hit, old_data->name_cache_miss, new_data->timestamp); if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_DIR_CACHE | HAVE_WAFL_FIND_DIR) && HAS_ALL_FLAGS (new_data->flags, HAVE_WAFL_FIND_DIR)) - submit_cache_ratio (host->name, instance, "find_dir_hit", + submit_cache_ratio (hostname, instance, "find_dir_hit", new_data->find_dir_hit, new_data->find_dir_miss, old_data->find_dir_hit, old_data->find_dir_miss, new_data->timestamp); if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_BUF_CACHE | HAVE_WAFL_BUF_HASH) && HAS_ALL_FLAGS (new_data->flags, HAVE_WAFL_BUF_HASH)) - submit_cache_ratio (host->name, instance, "buf_hash_hit", + submit_cache_ratio (hostname, instance, "buf_hash_hit", new_data->buf_hash_hit, new_data->buf_hash_miss, old_data->buf_hash_hit, old_data->buf_hash_miss, new_data->timestamp); if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_INODE_CACHE | HAVE_WAFL_INODE_CACHE) && HAS_ALL_FLAGS (new_data->flags, HAVE_WAFL_INODE_CACHE)) - submit_cache_ratio (host->name, instance, "inode_cache_hit", + 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); @@ -662,28 +813,43 @@ static int submit_volume_perf_data (const host_config_t *host, /* {{{ */ * These functions are called with appropriate data returned by the libnetapp * interface which is parsed and submitted with the above functions. */ -/* Data corresponding to */ -static void query_wafl_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ - data_wafl_t *wafl = data; - data_wafl_t perf_data; +/* Data corresponding to */ +static int cna_handle_wafl_data (const char *hostname, cfg_wafl_t *cfg_wafl, /* {{{ */ + na_elem_t *data) +{ + cfg_wafl_t perf_data; const char *plugin_inst; + + na_elem_t *instances; na_elem_t *counter; + na_elem_iter_t counter_iter; memset (&perf_data, 0, sizeof (perf_data)); - perf_data.timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0); + perf_data.timestamp = (time_t) na_child_get_uint64 (data, "timestamp", 0); - out = na_elem_child(na_elem_child(out, "instances"), "instance-data"); - if (out == NULL) - return; + instances = na_elem_child(na_elem_child (data, "instances"), "instance-data"); + if (instances == NULL) + { + ERROR ("netapp plugin: cna_handle_wafl_data: " + "na_elem_child (\"instances\") failed."); + return (-1); + } - plugin_inst = na_child_get_string(out, "name"); + plugin_inst = na_child_get_string(instances, "name"); if (plugin_inst == NULL) - return; + { + ERROR ("netapp plugin: cna_handle_wafl_data: " + "na_child_get_string (\"name\") failed."); + return (-1); + } /* Iterate over all counters */ - na_elem_iter_t iter = na_child_iterator(na_elem_child(out, "counters")); - for (counter = na_iterator_next(&iter); counter; counter = na_iterator_next(&iter)) { + counter_iter = na_child_iterator (na_elem_child (instances, "counters")); + for (counter = na_iterator_next (&counter_iter); + counter != NULL; + counter = na_iterator_next (&counter_iter)) + { const char *name; uint64_t value; @@ -720,13 +886,93 @@ static void query_wafl_data(host_config_t *host, na_elem_t *out, void *data) { / perf_data.inode_cache_miss = value; perf_data.flags |= HAVE_WAFL_INODE_CACHE_MISS; } else { - DEBUG("netapp plugin: query_wafl_data: Found unexpected child: %s", - name); + DEBUG("netapp plugin: cna_handle_wafl_data: " + "Found unexpected child: %s", name); } } - submit_wafl_data (host, plugin_inst, wafl, &perf_data); -} /* }}} void query_wafl_data */ + return (submit_wafl_data (hostname, plugin_inst, cfg_wafl, &perf_data)); +} /* }}} void cna_handle_wafl_data */ + +static int cna_setup_wafl (cfg_wafl_t *cw) /* {{{ */ +{ + na_elem_t *e; + + if (cw == NULL) + return (EINVAL); + + if (cw->query != NULL) + return (0); + + cw->query = na_elem_new("perf-object-get-instances"); + if (cw->query == NULL) + { + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); + } + na_child_add_string (cw->query, "objectname", "wafl"); + + e = na_elem_new("counters"); + if (e == NULL) + { + na_elem_free (cw->query); + cw->query = NULL; + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); + } + na_child_add_string(e, "foo", "name_cache_hit"); + na_child_add_string(e, "foo", "name_cache_miss"); + na_child_add_string(e, "foo", "find_dir_hit"); + na_child_add_string(e, "foo", "find_dir_miss"); + na_child_add_string(e, "foo", "buf_hash_hit"); + na_child_add_string(e, "foo", "buf_hash_miss"); + na_child_add_string(e, "foo", "inode_cache_hit"); + na_child_add_string(e, "foo", "inode_cache_miss"); + + na_child_add(cw->query, e); + + return (0); +} /* }}} int cna_setup_wafl */ + +static int cna_query_wafl (host_config_t *host) /* {{{ */ +{ + na_elem_t *data; + int status; + time_t now; + + if (host == NULL) + return (EINVAL); + + /* If WAFL was not configured, return without doing anything. */ + if (host->cfg_wafl == NULL) + return (0); + + now = time (NULL); + if ((host->cfg_wafl->interval.interval + host->cfg_wafl->interval.last_read) > now) + return (0); + + status = cna_setup_wafl (host->cfg_wafl); + if (status != 0) + return (status); + assert (host->cfg_wafl->query != NULL); + + data = na_server_invoke_elem(host->srv, host->cfg_wafl->query); + if (na_results_status (data) != NA_OK) + { + ERROR ("netapp plugin: cna_query_wafl: na_server_invoke_elem failed: %s", + na_results_reason (data)); + na_elem_free (data); + return (-1); + } + + status = cna_handle_wafl_data (host->name, host->cfg_wafl, data); + + if (status == 0) + host->cfg_wafl->interval.last_read = now; + + na_elem_free (data); + return (status); +} /* }}} int cna_query_wafl */ /* Data corresponding to */ static int cna_handle_disk_data (const char *hostname, /* {{{ */ @@ -890,6 +1136,8 @@ static int cna_query_disk (host_config_t *host) /* {{{ */ if (host == NULL) return (EINVAL); + /* If the user did not configure disk statistics, return without doing + * anything. */ if (host->cfg_disk == NULL) return (0); @@ -920,55 +1168,122 @@ static int cna_query_disk (host_config_t *host) /* {{{ */ return (status); } /* }}} int cna_query_disk */ -/* Data corresponding to */ -static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ - na_elem_t *inst; - volume_t *volume; - cfg_volume_usage_t *cfg_volume_data = data; +/* 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) */ - out = na_elem_child(out, "volumes"); - na_elem_iter_t inst_iter = na_child_iterator(out); - for (inst = na_iterator_next(&inst_iter); inst; inst = na_iterator_next(&inst_iter)) { - uint64_t size_free = 0, size_used = 0, snap_reserved = 0; + 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) +{ + na_elem_t *elem_volume; + na_elem_t *elem_volumes; + na_elem_iter_t iter_volume; + + elem_volumes = na_elem_child (data, "volumes"); + if (elem_volumes == NULL) + { + ERROR ("netapp plugin: cna_handle_volume_usage_data: " + "na_elem_child (\"volumes\") failed."); + return (-1); + } + + iter_volume = na_child_iterator (elem_volumes); + for (elem_volume = na_iterator_next (&iter_volume); + elem_volume != NULL; + elem_volume = na_iterator_next (&iter_volume)) + { + const char *volume_name; + + data_volume_usage_t *v; + uint64_t value; na_elem_t *sis; const char *sis_state; uint64_t sis_saved_reported; - uint64_t sis_saved; - volume = get_volume(host, na_child_get_string(inst, "name"), - cfg_volume_data->flags, /* perf_flags = */ 0); - if (volume == NULL) + volume_name = na_child_get_string (elem_volume, "name"); + if (volume_name == NULL) + 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 (!(volume->cfg_volume_usage.flags & VOLUME_DF)) + if ((v->flags & CFG_VOLUME_USAGE_DF) == 0) continue; /* 2^4 exa-bytes? This will take a while ;) */ - size_free = na_child_get_uint64(inst, "size-available", UINT64_MAX); - if (size_free != UINT64_MAX) - submit_double (host->name, volume->name, "df_complex", "used", - (double) size_used, /* time = */ 0); - - size_used = na_child_get_uint64(inst, "size-used", UINT64_MAX); - if (size_free != UINT64_MAX) - submit_double (host->name, volume->name, "df_complex", "free", - (double) size_free, /* time = */ 0); - - snap_reserved = na_child_get_uint64(inst, "snapshot-blocks-reserved", UINT64_MAX); - if (snap_reserved != UINT64_MAX) + 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 */ - submit_double (host->name, volume->name, "df_complex", "snap_reserved", - (double) (1024 * snap_reserved), /* time = */ 0); + v->norm_used = 1024 * value; + v->flags |= HAVE_VOLUME_USAGE_SNAP_RSVD; + } - sis = na_elem_child(inst, "sis"); + sis = na_elem_child(elem_volume, "sis"); if (sis == NULL) continue; sis_state = na_child_get_string(sis, "state"); - if ((sis_state == NULL) - || (strcmp ("enabled", sis_state) != 0)) + if (sis_state == NULL) + continue; + + /* 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; + } sis_saved_reported = na_child_get_uint64(sis, "size-saved", UINT64_MAX); if (sis_saved_reported == UINT64_MAX) @@ -977,13 +1292,19 @@ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) /* 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 { + v->sis_saved = sis_saved_reported; + v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED; + } else { /* really hacky work-around code. {{{ */ uint64_t sis_saved_percent; uint64_t sis_saved_guess; uint64_t overflow_guess; uint64_t guess1, guess2, guess3; + /* Check if we have v->norm_used. Without it, we cannot calculate + * sis_saved_guess. */ + if ((v->flags & HAVE_VOLUME_USAGE_NORM_USED) == 0) + continue; + sis_saved_percent = na_child_get_uint64(sis, "percentage-saved", UINT64_MAX); if (sis_saved_percent > 100) continue; @@ -996,9 +1317,9 @@ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) * 400 GBytes. */ /* percentage-saved = size-saved / (size-saved + size-used) */ if (sis_saved_percent < 100) - sis_saved_guess = size_used * sis_saved_percent / (100 - sis_saved_percent); + sis_saved_guess = v->norm_used * sis_saved_percent / (100 - sis_saved_percent); else - sis_saved_guess = size_used; + 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; @@ -1007,21 +1328,82 @@ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) if (sis_saved_guess < guess2) { if ((sis_saved_guess - guess1) < (guess2 - sis_saved_guess)) - sis_saved = guess1; + v->sis_saved = guess1; else - sis_saved = guess2; + v->sis_saved = guess2; } else { if ((sis_saved_guess - guess2) < (guess3 - sis_saved_guess)) - sis_saved = guess2; + v->sis_saved = guess2; else - sis_saved = guess3; + v->sis_saved = guess3; } - } /* end of 32-bit workaround */ + v->flags |= HAVE_VOLUME_USAGE_SIS_SAVED; + } /* }}} end of 32-bit workaround */ + } /* for (elem_volume) */ + + return (cna_submit_volume_usage_data (hostname, cfg_volume)); +} /* }}} int cna_handle_volume_usage_data */ + +static int cna_setup_volume_usage (cfg_volume_usage_t *cvu) /* {{{ */ +{ + if (cvu == NULL) + return (EINVAL); + + if (cvu->query != NULL) + return (0); - submit_double (host->name, volume->name, "df_complex", "sis_saved", - (double) sis_saved, /* time = */ 0); + cvu->query = na_elem_new ("volume-list-info"); + if (cvu->query == NULL) + { + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); } -} /* }}} void collect_volume_data */ + + /* TODO: cvu->snap_query = na_elem_new("snapshot-list-info"); */ + + return (0); +} /* }}} int cna_setup_volume_usage */ + +static int cna_query_volume_usage (host_config_t *host) /* {{{ */ +{ + na_elem_t *data; + int status; + time_t now; + + if (host == NULL) + return (EINVAL); + + /* If the user did not configure volume_usage statistics, return without + * doing anything. */ + if (host->cfg_volume_usage == NULL) + return (0); + + now = time (NULL); + if ((host->cfg_volume_usage->interval.interval + host->cfg_volume_usage->interval.last_read) > now) + return (0); + + status = cna_setup_volume_usage (host->cfg_volume_usage); + if (status != 0) + return (status); + assert (host->cfg_volume_usage->query != NULL); + + data = na_server_invoke_elem(host->srv, host->cfg_volume_usage->query); + if (na_results_status (data) != NA_OK) + { + ERROR ("netapp plugin: cna_query_volume_usage: na_server_invoke_elem failed: %s", + na_results_reason (data)); + na_elem_free (data); + return (-1); + } + + status = cna_handle_volume_usage_data (host->name, host->cfg_volume_usage, data); + + if (status == 0) + host->cfg_volume_usage->interval.last_read = now; + + na_elem_free (data); + return (status); +} /* }}} int cna_query_volume_usage */ /* Data corresponding to */ static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ @@ -1041,7 +1423,7 @@ static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *da perf_data.timestamp = timestamp; volume = get_volume(host, na_child_get_string(inst, "name"), - /* data_flags = */ 0, cfg_volume_perf->flags); + cfg_volume_perf->flags); if (volume == NULL) continue; @@ -1083,24 +1465,45 @@ static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *da } /* for (volume) */ } /* }}} void query_volume_perf_data */ -/* Data corresponding to */ -static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ +/* Data corresponding to */ +static int cna_handle_system_data (const char *hostname, /* {{{ */ + cfg_system_t *cfg_system, na_elem_t *data) +{ + na_elem_t *instances; + na_elem_t *counter; + 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; - unsigned int counter_flags = 0; + uint32_t counter_flags = 0; - cfg_system_t *cfg_system = data; const char *instance; time_t timestamp; - na_elem_t *counter; - timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0); - out = na_elem_child(na_elem_child(out, "instances"), "instance-data"); - instance = na_child_get_string(out, "name"); + timestamp = (time_t) na_child_get_uint64 (data, "timestamp", 0); + + instances = na_elem_child(na_elem_child (data, "instances"), "instance-data"); + if (instances == NULL) + { + ERROR ("netapp plugin: cna_handle_system_data: " + "na_elem_child (\"instances\") failed."); + return (-1); + } + + instance = na_child_get_string (instances, "name"); + if (instance == NULL) + { + ERROR ("netapp plugin: cna_handle_system_data: " + "na_child_get_string (\"name\") failed."); + return (-1); + } - na_elem_iter_t iter = na_child_iterator(na_elem_child(out, "counters")); - for (counter = na_iterator_next(&iter); counter; counter = na_iterator_next(&iter)) { + counter_iter = na_child_iterator (na_elem_child (instances, "counters")); + for (counter = na_iterator_next (&counter_iter); + counter != NULL; + counter = na_iterator_next (&counter_iter)) + { const char *name; uint64_t value; @@ -1131,31 +1534,93 @@ static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void * cpu_total = (counter_t) value; counter_flags |= 0x20; } else if ((cfg_system->flags & CFG_SYSTEM_OPS) - && (strlen(name) > 4) + && (value > 0) && (strlen(name) > 4) && (!strcmp(name + strlen(name) - 4, "_ops"))) { - submit_counter (host->name, instance, "disk_ops_complex", name, + submit_counter (hostname, instance, "disk_ops_complex", name, (counter_t) value, timestamp); } } /* for (counter) */ if ((cfg_system->flags & CFG_SYSTEM_DISK) - && ((counter_flags & 0x03) == 0x03)) - submit_two_counters (host->name, instance, "disk_octets", NULL, + && (HAS_ALL_FLAGS (counter_flags, 0x01 | 0x02))) + submit_two_counters (hostname, instance, "disk_octets", NULL, disk_read, disk_written, timestamp); if ((cfg_system->flags & CFG_SYSTEM_NET) - && ((counter_flags & 0x0c) == 0x0c)) - submit_two_counters (host->name, instance, "if_octets", NULL, + && (HAS_ALL_FLAGS (counter_flags, 0x04 | 0x08))) + submit_two_counters (hostname, instance, "if_octets", NULL, net_recv, net_sent, timestamp); if ((cfg_system->flags & CFG_SYSTEM_CPU) - && ((counter_flags & 0x30) == 0x30)) { - submit_counter (host->name, instance, "cpu", "system", + && (HAS_ALL_FLAGS (counter_flags, 0x10 | 0x20))) + { + submit_counter (hostname, instance, "cpu", "system", cpu_busy, timestamp); - submit_counter (host->name, instance, "cpu", "idle", + submit_counter (hostname, instance, "cpu", "idle", cpu_total - cpu_busy, timestamp); } -} /* }}} void collect_perf_system_data */ + + return (0); +} /* }}} int cna_handle_system_data */ + +static int cna_setup_system (cfg_system_t *cs) /* {{{ */ +{ + if (cs == NULL) + return (EINVAL); + + if (cs->query != NULL) + return (0); + + cs->query = na_elem_new ("perf-object-get-instances"); + if (cs->query == NULL) + { + ERROR ("netapp plugin: na_elem_new failed."); + return (-1); + } + na_child_add_string (cs->query, "objectname", "system"); + + return (0); +} /* }}} int cna_setup_system */ + +static int cna_query_system (host_config_t *host) /* {{{ */ +{ + na_elem_t *data; + int status; + time_t now; + + if (host == NULL) + return (EINVAL); + + /* If system statistics were not configured, return without doing anything. */ + if (host->cfg_system == NULL) + return (0); + + now = time (NULL); + if ((host->cfg_system->interval.interval + host->cfg_system->interval.last_read) > now) + return (0); + + status = cna_setup_system (host->cfg_system); + if (status != 0) + return (status); + assert (host->cfg_system->query != NULL); + + data = na_server_invoke_elem(host->srv, host->cfg_system->query); + if (na_results_status (data) != NA_OK) + { + ERROR ("netapp plugin: cna_query_system: na_server_invoke_elem failed: %s", + na_results_reason (data)); + na_elem_free (data); + return (-1); + } + + status = cna_handle_system_data (host->name, host->cfg_system, data); + + if (status == 0) + host->cfg_system->interval.last_read = now; + + na_elem_free (data); + return (status); +} /* }}} int cna_query_system */ /* * Configuration handling @@ -1277,7 +1742,7 @@ static void cna_config_volume_performance_option (host_config_t *host, /* {{{ */ continue; } - v = get_volume (host, name, /* data_flags = */ 0, perf_volume->flags); + v = get_volume (host, name, perf_volume->flags); if (v == NULL) continue; @@ -1332,85 +1797,59 @@ static void cna_config_volume_performance(host_config_t *host, const oconfig_ite } } /* }}} void cna_config_volume_performance */ -/* Handling of the "GetDiskUtil" option within a block. */ -static void cna_config_volume_usage_option (host_config_t *host, /* {{{ */ - cfg_volume_usage_t *cfg_volume_data, const oconfig_item_t *item, uint32_t flag) +/* Handling of the "Capacity" and "Snapshot" options within a + * block. */ +static void cna_config_volume_usage_option (cfg_volume_usage_t *cvu, /* {{{ */ + const oconfig_item_t *ci) { - int i; - - for (i = 0; i < item->values_num; ++i) { - const char *name; - volume_t *v; - _Bool set = true; + char *name; + ignorelist_t * il; - if (item->values[i].type != OCONFIG_TYPE_STRING) { - WARNING("netapp plugin: Ignoring non-string argument in \"GetVolData\"" - "block for host %s", host->name); - continue; - } + 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 = item->values[i].value.string; - if (name[0] == '+') { - set = true; - ++name; - } else if (name[0] == '-') { - set = false; - ++name; - } + name = ci->values[0].value.string; - if (!name[0]) { - if (set) - cfg_volume_data->flags |= flag; - else /* if (!set) */ - cfg_volume_data->flags &= ~flag; - - host_set_all_cfg_volume_usage_flags(host, flag, set); - continue; - } + if (strcasecmp ("Capacity", ci->key) == 0) + il = cvu->il_capacity; + else if (strcasecmp ("Snapshot", ci->key) == 0) + il = cvu->il_snapshot; + else + return; - v = get_volume(host, name, cfg_volume_data->flags, /* perf_flags = */ 0); - if (v == NULL) - continue; + ignorelist_add (il, name); +} /* }}} void cna_config_volume_usage_option */ - if (!v->cfg_volume_usage.flags) - v->cfg_volume_usage.flags = cfg_volume_data->flags; +/* Handling of the "IgnoreSelectedCapacity" and "IgnoreSelectedSnapshot" + * options within a block. */ +static void cna_config_volume_usage_default (cfg_volume_usage_t *cvu, /* {{{ */ + const oconfig_item_t *ci) +{ + ignorelist_t *il; - if (set) - v->cfg_volume_usage.flags |= flag; - else /* if (!set) */ - v->cfg_volume_usage.flags &= ~flag; + if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_BOOLEAN)) + { + WARNING ("netapp plugin: The %s option requires exactly one string argument.", + ci->key); + return; } -} /* }}} void cna_config_volume_usage_option */ -/* Corresponds to a block */ -static void cna_config_volume_usage(host_config_t *host, oconfig_item_t *ci) { /* {{{ */ - int i, had_df = 0; - cfg_service_t *service; - cfg_volume_usage_t *cfg_volume_data; - - service = malloc(sizeof(*service)); - service->query = 0; - service->handler = collect_volume_data; - cfg_volume_data = service->data = malloc(sizeof(*cfg_volume_data)); - cfg_volume_data->flags = VOLUME_INIT; - service->next = host->services; - host->services = service; - for (i = 0; i < ci->children_num; ++i) { - oconfig_item_t *item = ci->children + i; - - /* if (!item || !item->key || !*item->key) continue; */ - if (!strcasecmp(item->key, "Multiplier")) { - cna_config_get_multiplier (item, service); - } else if (!strcasecmp(item->key, "GetDiskUtil")) { - had_df = 1; - cna_config_volume_usage_option(host, cfg_volume_data, item, VOLUME_DF); - } - } - if (!had_df) { - cfg_volume_data->flags |= VOLUME_DF; - host_set_all_cfg_volume_usage_flags(host, VOLUME_DF, /* set = */ true); - } -} /* }}} void cna_config_volume_usage */ + if (strcasecmp ("IgnoreSelectedCapacity", ci->key) == 0) + il = cvu->il_capacity; + else if (strcasecmp ("IgnoreSelectedSnapshot", ci->key) == 0) + il = cvu->il_snapshot; + else + return; + + if (ci->values[0].value.boolean) + ignorelist_set_invert (il, /* invert = */ 0); + else + ignorelist_set_invert (il, /* invert = */ 1); +} /* }}} void cna_config_volume_usage_default */ /* Corresponds to a block */ static int cna_config_disk(host_config_t *host, oconfig_item_t *ci) { /* {{{ */ @@ -1446,77 +1885,172 @@ static int cna_config_disk(host_config_t *host, oconfig_item_t *ci) { /* {{{ */ cna_config_bool_to_flag (item, &cfg_disk->flags, CFG_DISK_BUSIEST); } + if ((cfg_disk->flags & CFG_DISK_ALL) == 0) + { + NOTICE ("netapp plugin: All disk related values have been disabled. " + "Collection of per-disk data will be disabled entirely."); + free_cfg_disk (host->cfg_disk); + host->cfg_disk = NULL; + } + return (0); } /* }}} int cna_config_disk */ -/* Corresponds to a block */ -static void cna_config_wafl(host_config_t *host, oconfig_item_t *ci) { /* {{{ */ +/* Corresponds to a block */ +static int cna_config_wafl(host_config_t *host, oconfig_item_t *ci) /* {{{ */ +{ + cfg_wafl_t *cfg_wafl; int i; - cfg_service_t *service; - data_wafl_t *perf_wafl; - - service = malloc(sizeof(*service)); - if (service == NULL) - return; - memset (service, 0, sizeof (*service)); - service->query = 0; - service->handler = query_wafl_data; - perf_wafl = service->data = malloc(sizeof(*perf_wafl)); - perf_wafl->flags = CFG_WAFL_ALL; + if ((host == NULL) || (ci == NULL)) + return (EINVAL); + + if (host->cfg_wafl == NULL) + { + cfg_wafl = malloc (sizeof (*cfg_wafl)); + if (cfg_wafl == NULL) + return (ENOMEM); + memset (cfg_wafl, 0, sizeof (*cfg_wafl)); + + /* Set default flags */ + cfg_wafl->flags = CFG_WAFL_ALL; + + host->cfg_wafl = cfg_wafl; + } + cfg_wafl = host->cfg_wafl; for (i = 0; i < ci->children_num; ++i) { oconfig_item_t *item = ci->children + i; - if (!strcasecmp(item->key, "Multiplier")) { - cna_config_get_multiplier (item, service); - } else if (!strcasecmp(item->key, "GetNameCache")) { - cna_config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_NAME_CACHE); - } else if (!strcasecmp(item->key, "GetDirCache")) { - cna_config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_DIR_CACHE); - } else if (!strcasecmp(item->key, "GetBufCache")) { - cna_config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_BUF_CACHE); - } else if (!strcasecmp(item->key, "GetInodeCache")) { - cna_config_bool_to_flag (item, &perf_wafl->flags, CFG_WAFL_INODE_CACHE); - } else { + if (strcasecmp(item->key, "Interval") == 0) + cna_config_get_interval (item, &cfg_wafl->interval); + else if (!strcasecmp(item->key, "GetNameCache")) + cna_config_bool_to_flag (item, &cfg_wafl->flags, CFG_WAFL_NAME_CACHE); + else if (!strcasecmp(item->key, "GetDirCache")) + cna_config_bool_to_flag (item, &cfg_wafl->flags, CFG_WAFL_DIR_CACHE); + else if (!strcasecmp(item->key, "GetBufferCache")) + cna_config_bool_to_flag (item, &cfg_wafl->flags, CFG_WAFL_BUF_CACHE); + else if (!strcasecmp(item->key, "GetInodeCache")) + cna_config_bool_to_flag (item, &cfg_wafl->flags, CFG_WAFL_INODE_CACHE); + else WARNING ("netapp plugin: The %s config option is not allowed within " - "`GetWaflPerfData' blocks.", item->key); + "`WAFL' blocks.", item->key); + } + + if ((cfg_wafl->flags & CFG_WAFL_ALL) == 0) + { + NOTICE ("netapp plugin: All WAFL related values have been disabled. " + "Collection of WAFL data will be disabled entirely."); + free_cfg_wafl (host->cfg_wafl); + host->cfg_wafl = NULL; + } + + return (0); +} /* }}} int cna_config_wafl */ + +/* + * + * Capacity "vol0" + * Capacity "vol1" + * Capacity "vol2" + * Capacity "vol3" + * Capacity "vol4" + * IgnoreSelectedCapacity false + * + * Snapshot "vol0" + * Snapshot "vol3" + * Snapshot "vol4" + * Snapshot "vol7" + * IgnoreSelectedSnapshot false + * + */ +/* Corresponds to a block */ +static int cna_config_volume_usage(host_config_t *host, oconfig_item_t *ci) { /* {{{ */ + cfg_volume_usage_t *cfg_volume_usage; + int i; + + if ((host == NULL) || (ci == NULL)) + return (EINVAL); + + if (host->cfg_volume_usage == NULL) + { + cfg_volume_usage = malloc (sizeof (*cfg_volume_usage)); + if (cfg_volume_usage == NULL) + return (ENOMEM); + memset (cfg_volume_usage, 0, sizeof (*cfg_volume_usage)); + + /* Set default flags */ + cfg_volume_usage->query = NULL; + cfg_volume_usage->volumes = NULL; + + cfg_volume_usage->il_capacity = ignorelist_create (/* invert = */ 1); + if (cfg_volume_usage->il_capacity == NULL) + { + sfree (cfg_volume_usage); + return (ENOMEM); } + + cfg_volume_usage->il_snapshot = ignorelist_create (/* invert = */ 1); + if (cfg_volume_usage->il_snapshot == NULL) + { + ignorelist_free (cfg_volume_usage->il_capacity); + sfree (cfg_volume_usage); + return (ENOMEM); + } + + host->cfg_volume_usage = cfg_volume_usage; + } + cfg_volume_usage = host->cfg_volume_usage; + + 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, "Interval") == 0) + cna_config_get_interval (item, &cfg_volume_usage->interval); + else if (!strcasecmp(item->key, "Capacity")) + cna_config_volume_usage_option (cfg_volume_usage, item); + else if (!strcasecmp(item->key, "Snapshot")) + 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); } - service->next = host->services; - host->services = service; -} /* }}} void cna_config_wafl */ + return (0); +} /* }}} int cna_config_volume_usage */ -/* Corresponds to a block */ +/* Corresponds to a block */ static int cna_config_system (host_config_t *host, /* {{{ */ oconfig_item_t *ci, const cfg_service_t *default_service) { - int i; - cfg_service_t *service; cfg_system_t *cfg_system; + int i; - service = malloc(sizeof(*service)); - if (service == NULL) - return (-1); - memset (service, 0, sizeof (*service)); - *service = *default_service; - service->handler = collect_perf_system_data; + if ((host == NULL) || (ci == NULL)) + return (EINVAL); - cfg_system = malloc(sizeof(*cfg_system)); - if (cfg_system == NULL) { - sfree (service); - return (-1); + if (host->cfg_system == NULL) + { + cfg_system = malloc (sizeof (*cfg_system)); + if (cfg_system == NULL) + return (ENOMEM); + memset (cfg_system, 0, sizeof (*cfg_system)); + + /* Set default flags */ + cfg_system->flags = CFG_SYSTEM_ALL; + cfg_system->query = NULL; + + host->cfg_system = cfg_system; } - memset (cfg_system, 0, sizeof (*cfg_system)); - cfg_system->flags = CFG_SYSTEM_ALL; - service->data = cfg_system; + cfg_system = host->cfg_system; for (i = 0; i < ci->children_num; ++i) { oconfig_item_t *item = ci->children + i; - if (!strcasecmp(item->key, "Multiplier")) { - cna_config_get_multiplier (item, service); + if (strcasecmp(item->key, "Interval") == 0) { + cna_config_get_interval (item, &cfg_system->interval); } else if (!strcasecmp(item->key, "GetCPULoad")) { cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_CPU); } else if (!strcasecmp(item->key, "GetInterfaces")) { @@ -1527,12 +2061,17 @@ static int cna_config_system (host_config_t *host, /* {{{ */ cna_config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_DISK); } else { WARNING ("netapp plugin: The %s config option is not allowed within " - "`GetSystemPerfData' blocks.", item->key); + "`System' blocks.", item->key); } } - service->next = host->services; - host->services = service; + if ((cfg_system->flags & CFG_SYSTEM_ALL) == 0) + { + NOTICE ("netapp plugin: All system related values have been disabled. " + "Collection of system data will be disabled entirely."); + free_cfg_system (host->cfg_system); + host->cfg_system = NULL; + } return (0); } /* }}} int cna_config_system */ @@ -1542,7 +2081,7 @@ 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) { oconfig_item_t *item; - host_config_t *host, *hc; + host_config_t *host; cfg_service_t default_service = *def_def_service; int status; int i; @@ -1592,16 +2131,16 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */ continue; } host->interval = item->values[0].value.number; - } else if (!strcasecmp(item->key, "GetVolumePerfData")) { - cna_config_volume_performance(host, item); - } else if (!strcasecmp(item->key, "GetSystemPerfData")) { - cna_config_system(host, item, &default_service); - } else if (!strcasecmp(item->key, "GetWaflPerfData")) { + } 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, "GetVolumeData")) { + } else if (!strcasecmp(item->key, "GetVolumePerfData")) { + cna_config_volume_performance(host, item); + } else if (!strcasecmp(item->key, "VolumeUsage")) { cna_config_volume_usage(host, item); + } else if (!strcasecmp(item->key, "System")) { + cna_config_system(host, item, &default_service); } else { WARNING("netapp plugin: Ignoring unknown config option \"%s\" in host block \"%s\".", item->key, ci->values[0].value.string); @@ -1632,9 +2171,6 @@ static host_config_t *cna_config_host (const oconfig_item_t *ci, /* {{{ */ return (NULL); } - for (hc = global_host_config; hc; hc = hc->next) { - if (!strcasecmp(hc->name, host->name)) WARNING("netapp plugin: Duplicate definition of host \"%s\". This is probably a bad idea.", hc->name); - } return host; } /* }}} host_config_t *cna_config_host */ @@ -1683,13 +2219,12 @@ static int cna_init(void) { /* {{{ */ for (service = host->services; service; service = service->next) { service->interval = host->interval * service->multiplier; - if (service->handler == collect_perf_system_data) { - service->query = na_elem_new("perf-object-get-instances"); - na_child_add_string(service->query, "objectname", "system"); - } else if (service->handler == query_volume_perf_data) { + 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"); @@ -1697,26 +2232,6 @@ static int cna_init(void) { /* {{{ */ na_child_add_string(e, "foo", "read_latency"); na_child_add_string(e, "foo", "write_latency"); na_child_add(service->query, e); - } else if (service->handler == query_wafl_data) { - service->query = na_elem_new("perf-object-get-instances"); - na_child_add_string(service->query, "objectname", "wafl"); - e = na_elem_new("counters"); - na_child_add_string(e, "foo", "name_cache_hit"); - na_child_add_string(e, "foo", "name_cache_miss"); - na_child_add_string(e, "foo", "find_dir_hit"); - na_child_add_string(e, "foo", "find_dir_miss"); - na_child_add_string(e, "foo", "buf_hash_hit"); - na_child_add_string(e, "foo", "buf_hash_miss"); - na_child_add_string(e, "foo", "inode_cache_hit"); - na_child_add_string(e, "foo", "inode_cache_miss"); - /* na_child_add_string(e, "foo", "inode_eject_time"); */ - /* na_child_add_string(e, "foo", "buf_eject_time"); */ - na_child_add(service->query, e); - } else if (service->handler == collect_volume_data) { - service->query = na_elem_new("volume-list-info"); - /* na_child_add_string(service->query, "objectname", "volume"); */ - /* } else if (service->handler == collect_snapshot_data) { */ - /* service->query = na_elem_new("snapshot-list-info"); */ } } /* for (host->services) */ } @@ -1732,7 +2247,6 @@ static int cna_config (oconfig_item_t *ci) { /* {{{ */ for (i = 0; i < ci->children_num; ++i) { item = ci->children + i; - /* if (!item || !item->key || !*item->key) continue; */ if (!strcasecmp(item->key, "Host")) { host_config_t *host; host_config_t *tmp; @@ -1788,7 +2302,10 @@ static int cna_read(void) { /* {{{ */ na_elem_free(out); } /* for (host->services) */ + cna_query_wafl (host); cna_query_disk (host); + cna_query_volume_usage (host); + cna_query_system (host); } return 0; } /* }}} int cna_read */