From: Florian Forster Date: Thu, 24 Sep 2009 12:03:53 +0000 (+0200) Subject: netapp plugin: Changed some type names. X-Git-Tag: collectd-4.9.0~73^2~39 X-Git-Url: https://git.octo.it/?p=collectd.git;a=commitdiff_plain;h=08c46c90bbea6949ee9e5d4e38fa4395d865878c netapp plugin: Changed some type names. The structure is roughly like this: Structs that only hold flags to tell the functions what data to submit are prefixed with "cfg_". Structs that hold old values for counters are prefixed with "data_". The "disk_t" type now included flags, too, to indicate valid / invalid values. The "query_submit_disk_data" function has been changed to honor those flags. Various "volume_data" stuff has been renamed to "volume_usage" to make it more distinguishable from "volume_performance". Various defines are now also prefixed with "CFG_" to show which flags are used for configuration and which are used do mark counters valid. The latter use the "HAVE_" prefix. --- diff --git a/src/netapp.c b/src/netapp.c index edae48a4..d04be5ca 100644 --- a/src/netapp.c +++ b/src/netapp.c @@ -34,30 +34,35 @@ typedef struct host_config_s host_config_t; typedef void service_handler_t(host_config_t *host, na_elem_t *result, void *data); -#define PERF_SYSTEM_CPU 0x01 -#define PERF_SYSTEM_NET 0x02 -#define PERF_SYSTEM_OPS 0x04 -#define PERF_SYSTEM_DISK 0x08 -#define PERF_SYSTEM_ALL 0x0F - /*! - * \brief Persistent data for system performence counters + * \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; -} perf_system_data_t; +} cfg_system_t; /*! - * \brief Persistent data for WAFL performence counters. (a.k.a. cache performence) + * \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. + * + * 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 + * updates the old counter values for the next iteration. */ - -#define CFG_WAFL_NAME_CACHE 0x01 -#define CFG_WAFL_DIR_CACHE 0x02 -#define CFG_WAFL_BUF_CACHE 0x04 -#define CFG_WAFL_INODE_CACHE 0x08 -#define CFG_WAFL_ALL 0x0F - +#define CFG_WAFL_NAME_CACHE 0x0001 +#define CFG_WAFL_DIR_CACHE 0x0002 +#define CFG_WAFL_BUF_CACHE 0x0004 +#define CFG_WAFL_INODE_CACHE 0x0008 +#define CFG_WAFL_ALL 0x000F #define HAVE_WAFL_NAME_CACHE_HIT 0x0100 #define HAVE_WAFL_NAME_CACHE_MISS 0x0200 #define HAVE_WAFL_NAME_CACHE (HAVE_WAFL_NAME_CACHE_HIT | HAVE_WAFL_NAME_CACHE_MISS) @@ -71,7 +76,6 @@ typedef struct { #define HAVE_WAFL_INODE_CACHE_MISS 0x8000 #define HAVE_WAFL_INODE_CACHE (HAVE_WAFL_INODE_CACHE_HIT | HAVE_WAFL_INODE_CACHE_MISS) #define HAVE_WAFL_ALL 0xff00 - typedef struct { uint32_t flags; time_t timestamp; @@ -83,29 +87,27 @@ typedef struct { uint64_t buf_hash_miss; uint64_t inode_cache_hit; uint64_t inode_cache_miss; -} perf_wafl_data_t; +} data_wafl_t; +/*! + * \brief Persistent data for volume performance data. + * + * The code below uses the difference of the operations and latency counters to + * calculate an average per-operation latency. For this, old counters need to + * be stored in the "data_volume_perf_t" structure. The byte-counters are just + * kept for completeness sake. The "flags" member indicates if each counter is + * valid or not. + * + * The "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 + * function, the per-operation latency is calculated and dispatched, then the + * old counters are updated. + */ #define CFG_VOLUME_PERF_INIT 0x0001 #define CFG_VOLUME_PERF_IO 0x0002 #define CFG_VOLUME_PERF_OPS 0x0003 #define CFG_VOLUME_PERF_LATENCY 0x0008 #define CFG_VOLUME_PERF_ALL 0x000F - -typedef struct { - uint32_t flags; -} cfg_volume_perf_t; - -typedef struct { - uint32_t flags; -} cfg_volume_data_t; - -#define PERF_DISK_BUSIEST 0x01 -#define PERF_DISK_ALL 0x01 - -typedef struct { - uint32_t flags; -} perf_disk_data_t; - #define HAVE_VOLUME_PERF_BYTES_READ 0x0010 #define HAVE_VOLUME_PERF_BYTES_WRITE 0x0020 #define HAVE_VOLUME_PERF_OPS_READ 0x0040 @@ -115,6 +117,10 @@ typedef struct { #define HAVE_VOLUME_PERF_ALL 0x03F0 typedef struct { uint32_t flags; +} cfg_volume_perf_t; + +typedef struct { + uint32_t flags; time_t timestamp; uint64_t read_bytes; uint64_t write_bytes; @@ -122,22 +128,17 @@ typedef struct { uint64_t write_ops; uint64_t read_latency; uint64_t write_latency; -} per_volume_perf_data_t; +} data_volume_perf_t; +/*! + * \brief Configuration struct for volume usage data (free / used). + */ #define VOLUME_INIT 0x01 #define VOLUME_DF 0x02 #define VOLUME_SNAP 0x04 - typedef struct { uint32_t flags; -} per_volume_data_t; - -typedef struct { - time_t last_update; - double last_disk_busy_percent; - uint64_t last_disk_busy; - uint64_t last_base_for_disk_busy; -} per_disk_perf_data_t; +} cfg_volume_usage_t; typedef struct service_config_s { na_elem_t *query; @@ -147,32 +148,51 @@ typedef struct service_config_s { int interval; void *data; struct service_config_s *next; -} service_config_t; - +} 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; - per_volume_perf_data_t perf_data; - per_volume_data_t volume_data; + data_volume_perf_t perf_data; + cfg_volume_usage_t cfg_volume_usage; struct volume_s *next; } volume_t; +#define CFG_DISK_BUSIEST 0x01 +#define CFG_DISK_ALL 0x01 +#define HAVE_DISK_BUSY 0x10 +#define HAVE_DISK_BASE 0x20 +#define HAVE_DISK_ALL 0x30 +typedef struct { + uint32_t flags; +} cfg_disk_t; + /*! - * \brief A disk in the netapp. + * \brief A disk in the NetApp. * - * A disk doesn't have any more information than its name atm. + * A disk doesn't have any more information than its name at the moment. * The name includes the "disk_" prefix. */ - typedef struct disk_s { char *name; - per_disk_perf_data_t perf_data; + 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 DISK_INIT {0, {0, 0, 0, 0}, 0} - struct host_config_s { na_server_t *srv; char *name; @@ -182,18 +202,17 @@ struct host_config_s { char *username; char *password; int interval; - service_config_t *services; + cfg_service_t *services; disk_t *disks; volume_t *volumes; struct host_config_s *next; }; - -#define HOST_INIT {0, 0, NA_SERVER_TRANSPORT_HTTPS, 0, 0, 0, 0, 10, 0, 0, 0} +#define HOST_INIT {NULL, NULL, NA_SERVER_TRANSPORT_HTTPS, NULL, 0, NULL, NULL, 10, NULL, NULL, NULL, NULL} static host_config_t *host_config; static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */ - uint32_t vol_data_flags, uint32_t vol_perf_flags) + uint32_t vol_usage_flags, uint32_t vol_perf_flags) { volume_t *v; @@ -201,8 +220,8 @@ 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_data_flags != 0) - vol_data_flags |= VOLUME_INIT; + if (vol_usage_flags != 0) + vol_usage_flags |= VOLUME_INIT; if (vol_perf_flags != 0) vol_perf_flags |= CFG_VOLUME_PERF_INIT; @@ -211,9 +230,9 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */ continue; /* Check if the flags have been initialized. */ - if (((v->volume_data.flags & VOLUME_INIT) == 0) - && (vol_data_flags != 0)) - v->volume_data.flags = vol_data_flags; + 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; @@ -227,7 +246,7 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */ return (NULL); memset (v, 0, sizeof (*v)); - v->volume_data.flags = vol_data_flags; + v->cfg_volume_usage.flags = vol_usage_flags; v->perf_data.flags = vol_perf_flags; v->name = strdup(name); @@ -244,7 +263,7 @@ static volume_t *get_volume (host_config_t *host, const char *name, /* {{{ */ static disk_t *get_disk(host_config_t *host, const char *name) /* {{{ */ { - disk_t *v, init = DISK_INIT; + disk_t *v; if (name == NULL) return (NULL); @@ -256,8 +275,9 @@ static disk_t *get_disk(host_config_t *host, const char *name) /* {{{ */ v = malloc(sizeof(*v)); if (v == NULL) return (NULL); + memset (v, 0, sizeof (*v)); + v->next = NULL; - *v = init; v->name = strdup(name); if (v->name == NULL) { sfree (v); @@ -374,7 +394,7 @@ static int submit_cache_ratio (const char *host, /* {{{ */ } /* }}} int submit_cache_ratio */ static int submit_wafl_data (const host_config_t *host, const char *instance, /* {{{ */ - perf_wafl_data_t *old_data, const perf_wafl_data_t *new_data) + data_wafl_t *old_data, const data_wafl_t *new_data) { /* Submit requested counters */ if (HAS_ALL_FLAGS (old_data->flags, CFG_WAFL_NAME_CACHE | HAVE_WAFL_NAME_CACHE) @@ -427,7 +447,7 @@ static int submit_wafl_data (const host_config_t *host, const char *instance, /* static int submit_volume_perf_data (const host_config_t *host, /* {{{ */ volume_t *volume, - const per_volume_perf_data_t *new_data) + const data_volume_perf_t *new_data) { /* Check for and submit disk-octet values */ if (HAS_ALL_FLAGS (volume->perf_data.flags, CFG_VOLUME_PERF_IO) @@ -508,8 +528,8 @@ static int submit_volume_perf_data (const host_config_t *host, /* {{{ */ } /* }}} int submit_volume_perf_data */ static void query_wafl_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ - perf_wafl_data_t *wafl = data; - perf_wafl_data_t perf_data; + data_wafl_t *wafl = data; + data_wafl_t perf_data; const char *plugin_inst; na_elem_t *counter; @@ -518,7 +538,12 @@ static void query_wafl_data(host_config_t *host, na_elem_t *out, void *data) { / perf_data.timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0); out = na_elem_child(na_elem_child(out, "instances"), "instance-data"); + if (out == NULL) + return; + plugin_inst = na_child_get_string(out, "name"); + if (plugin_inst == NULL) + return; /* Iterate over all counters */ na_elem_iter_t iter = na_child_iterator(na_elem_child(out, "counters")); @@ -559,19 +584,19 @@ 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: Found unexpected child: %s", name); + DEBUG("netapp plugin: query_wafl_data: Found unexpected child: %s", + name); } } submit_wafl_data (host, plugin_inst, wafl, &perf_data); } /* }}} void query_wafl_data */ -static void collect_perf_disk_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ - perf_disk_data_t *perf = data; - const char *name; +static void query_submit_disk_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ + cfg_disk_t *cfg_disk = data; time_t timestamp; na_elem_t *counter, *inst; - disk_t *disk, *worst_disk = 0; + disk_t *worst_disk = 0; timestamp = (time_t) na_child_get_uint64(out, "timestamp", 0); out = na_elem_child(out, "instances"); @@ -579,71 +604,87 @@ static void collect_perf_disk_data(host_config_t *host, na_elem_t *out, void *da /* Iterate over all children */ na_elem_iter_t inst_iter = na_child_iterator(out); for (inst = na_iterator_next(&inst_iter); inst; inst = na_iterator_next(&inst_iter)) { - uint64_t disk_busy = 0; - uint64_t base_for_disk_busy = 0; + disk_t *old_data; + disk_t new_data; + + memset (&new_data, 0, sizeof (new_data)); + new_data.timestamp = timestamp; + new_data.disk_busy_percent = NAN; - disk = get_disk(host, na_child_get_string(inst, "name")); - if (disk == NULL) + old_data = get_disk(host, na_child_get_string(inst, "name")); + if (old_data == NULL) continue; /* Look for the "disk_busy" and "base_for_disk_busy" counters */ 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; + name = na_child_get_string(counter, "name"); if (name == NULL) continue; + value = na_child_get_uint64(counter, "value", UINT64_MAX); + if (value == UINT64_MAX) + continue; + if (strcmp(name, "disk_busy") == 0) - disk_busy = na_child_get_uint64(counter, "value", UINT64_MAX); + { + new_data.disk_busy = value; + new_data.flags |= HAVE_DISK_BUSY; + } else if (strcmp(name, "base_for_disk_busy") == 0) - base_for_disk_busy = na_child_get_uint64(counter, "value", UINT64_MAX); - } - - if ((disk_busy == UINT64_MAX) || (base_for_disk_busy == UINT64_MAX)) - { - disk->perf_data.last_disk_busy = 0; - disk->perf_data.last_base_for_disk_busy = 0; - continue; + { + new_data.base_for_disk_busy = value; + new_data.flags |= HAVE_DISK_BASE; + } } - disk->perf_data.last_update = timestamp; - if ((disk_busy >= disk->perf_data.last_disk_busy) - && (base_for_disk_busy >= disk->perf_data.last_base_for_disk_busy)) + /* If all required counters are available and did not just wrap around, + * calculate the busy percentage. Otherwise, the value is initialized to + * NAN at the top of the for-loop. */ + if (HAS_ALL_FLAGS (old_data->flags, HAVE_DISK_BUSY | HAVE_DISK_BASE) + && HAS_ALL_FLAGS (new_data.flags, HAVE_DISK_BUSY | HAVE_DISK_BASE) + && (new_data.disk_busy >= old_data->disk_busy) + && (new_data.base_for_disk_busy > old_data->base_for_disk_busy)) { - uint64_t disk_busy_diff; + uint64_t busy_diff; uint64_t base_diff; - disk_busy_diff = disk_busy - disk->perf_data.last_disk_busy; - base_diff = base_for_disk_busy - disk->perf_data.last_base_for_disk_busy; + busy_diff = new_data.disk_busy - old_data->disk_busy; + base_diff = new_data.base_for_disk_busy - old_data->base_for_disk_busy; - if (base_diff == 0) - disk->perf_data.last_disk_busy_percent = NAN; - else - disk->perf_data.last_disk_busy_percent = 100.0 - * ((gauge_t) disk_busy_diff) / ((gauge_t) base_diff); - } - else - { - disk->perf_data.last_disk_busy_percent = NAN; + new_data.disk_busy_percent = 100.0 + * ((gauge_t) busy_diff) / ((gauge_t) base_diff); } - disk->perf_data.last_disk_busy = disk_busy; - disk->perf_data.last_base_for_disk_busy = base_for_disk_busy; + /* Clear HAVE_* flags */ + old_data->flags &= ~HAVE_DISK_ALL; + + /* Copy data */ + old_data->timestamp = new_data.timestamp; + old_data->disk_busy = new_data.disk_busy; + old_data->base_for_disk_busy = new_data.base_for_disk_busy; + old_data->disk_busy_percent = new_data.disk_busy_percent; + + /* Copy flags */ + old_data->flags |= (new_data.flags & HAVE_DISK_ALL); if ((worst_disk == NULL) - || (worst_disk->perf_data.last_disk_busy_percent < disk->perf_data.last_disk_busy_percent)) - worst_disk = disk; - } + || (worst_disk->disk_busy_percent < old_data->disk_busy_percent)) + worst_disk = old_data; + } /* for (all disks) */ - if ((perf->flags & PERF_DISK_BUSIEST) && (worst_disk != NULL)) + if ((cfg_disk->flags & CFG_DISK_BUSIEST) && (worst_disk != NULL)) submit_double (host->name, "system", "percent", "disk_busy", - worst_disk->perf_data.last_disk_busy_percent, timestamp); -} /* }}} void collect_perf_disk_data */ + worst_disk->disk_busy_percent, timestamp); +} /* }}} void query_submit_disk_data */ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ na_elem_t *inst; volume_t *volume; - cfg_volume_data_t *cfg_volume_data = data; + cfg_volume_usage_t *cfg_volume_data = data; out = na_elem_child(out, "volumes"); na_elem_iter_t inst_iter = na_child_iterator(out); @@ -660,7 +701,7 @@ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) if (volume == NULL) continue; - if (!(volume->volume_data.flags & VOLUME_DF)) + if (!(volume->cfg_volume_usage.flags & VOLUME_DF)) continue; /* 2^4 exa-bytes? This will take a while ;) */ @@ -743,7 +784,7 @@ static void collect_volume_data(host_config_t *host, na_elem_t *out, void *data) } /* }}} void collect_volume_data */ static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *data) { /* {{{ */ - cfg_volume_perf_t *perf = data; + cfg_volume_perf_t *cfg_volume_perf = data; time_t timestamp; na_elem_t *counter, *inst; @@ -752,14 +793,14 @@ static void query_volume_perf_data(host_config_t *host, na_elem_t *out, void *da 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)) { - per_volume_perf_data_t perf_data; + data_volume_perf_t perf_data; volume_t *volume; memset (&perf_data, 0, sizeof (perf_data)); perf_data.timestamp = timestamp; volume = get_volume(host, na_child_get_string(inst, "name"), - /* data_flags = */ 0, perf->flags); + /* data_flags = */ 0, cfg_volume_perf->flags); if (volume == NULL) continue; @@ -807,7 +848,7 @@ static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void * counter_t cpu_busy = 0, cpu_total = 0; unsigned int counter_flags = 0; - perf_system_data_t *perf = data; + cfg_system_t *cfg_system = data; const char *instance; time_t timestamp; na_elem_t *counter; @@ -847,7 +888,7 @@ static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void * } else if (!strcmp(name, "cpu_elapsed_time")) { cpu_total = (counter_t) value; counter_flags |= 0x20; - } else if ((perf->flags & PERF_SYSTEM_OPS) + } else if ((cfg_system->flags & CFG_SYSTEM_OPS) && (strlen(name) > 4) && (!strcmp(name + strlen(name) - 4, "_ops"))) { submit_counter (host->name, instance, "disk_ops_complex", name, @@ -855,17 +896,17 @@ static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void * } } /* for (counter) */ - if ((perf->flags & PERF_SYSTEM_DISK) + if ((cfg_system->flags & CFG_SYSTEM_DISK) && ((counter_flags & 0x03) == 0x03)) submit_two_counters (host->name, instance, "disk_octets", NULL, disk_read, disk_written, timestamp); - if ((perf->flags & PERF_SYSTEM_NET) + if ((cfg_system->flags & CFG_SYSTEM_NET) && ((counter_flags & 0x0c) == 0x0c)) submit_two_counters (host->name, instance, "if_octets", NULL, net_recv, net_sent, timestamp); - if ((perf->flags & PERF_SYSTEM_CPU) + if ((cfg_system->flags & CFG_SYSTEM_CPU) && ((counter_flags & 0x30) == 0x30)) { submit_counter (host->name, instance, "cpu", "system", cpu_busy, timestamp); @@ -874,11 +915,11 @@ static void collect_perf_system_data(host_config_t *host, na_elem_t *out, void * } } /* }}} void collect_perf_system_data */ -static int config_init(void) { /* {{{ */ +static int cna_init(void) { /* {{{ */ char err[256]; na_elem_t *e; host_config_t *host; - service_config_t *service; + cfg_service_t *service; if (!host_config) { WARNING("netapp plugin: Plugin loaded but no hosts defined."); @@ -934,7 +975,7 @@ static int config_init(void) { /* {{{ */ /* na_child_add_string(e, "foo", "inode_eject_time"); */ /* na_child_add_string(e, "foo", "buf_eject_time"); */ na_child_add(service->query, e); - } else if (service->handler == collect_perf_disk_data) { + } else if (service->handler == query_submit_disk_data) { service->query = na_elem_new("perf-object-get-instances"); na_child_add_string(service->query, "objectname", "disk"); e = na_elem_new("counters"); @@ -950,7 +991,7 @@ static int config_init(void) { /* {{{ */ } } return 0; -} /* }}} int config_init */ +} /* }}} int cna_init */ static int config_bool_to_flag (const oconfig_item_t *ci, /* {{{ */ uint32_t *flags, uint32_t flag) @@ -974,7 +1015,7 @@ static int config_bool_to_flag (const oconfig_item_t *ci, /* {{{ */ } /* }}} int config_bool_to_flag */ static int config_get_multiplier (const oconfig_item_t *ci, /* {{{ */ - service_config_t *service) + cfg_service_t *service) { int tmp; @@ -1019,9 +1060,9 @@ static void set_global_vol_flag(const host_config_t *host, /* {{{ */ for (v = host->volumes; v; v = v->next) { if (set) - v->volume_data.flags |= flag; + v->cfg_volume_usage.flags |= flag; else /* if (!set) */ - v->volume_data.flags &= ~flag; + v->cfg_volume_usage.flags &= ~flag; } } /* }}} void set_global_vol_flag */ @@ -1073,7 +1114,7 @@ static void process_perf_volume_flag (host_config_t *host, /* {{{ */ } /* }}} void process_perf_volume_flag */ static void process_volume_flag (host_config_t *host, /* {{{ */ - cfg_volume_data_t *cfg_volume_data, const oconfig_item_t *item, uint32_t flag) + cfg_volume_usage_t *cfg_volume_data, const oconfig_item_t *item, uint32_t flag) { int i; @@ -1111,19 +1152,19 @@ static void process_volume_flag (host_config_t *host, /* {{{ */ if (v == NULL) continue; - if (!v->volume_data.flags) - v->volume_data.flags = cfg_volume_data->flags; + if (!v->cfg_volume_usage.flags) + v->cfg_volume_usage.flags = cfg_volume_data->flags; if (set) - v->volume_data.flags |= flag; + v->cfg_volume_usage.flags |= flag; else /* if (!set) */ - v->volume_data.flags &= ~flag; + v->cfg_volume_usage.flags &= ~flag; } } /* }}} void process_volume_flag */ static void build_perf_vol_config(host_config_t *host, const oconfig_item_t *ci) { int i, had_io = 0, had_ops = 0, had_latency = 0; - service_config_t *service; + cfg_service_t *service; cfg_volume_perf_t *perf_volume; service = malloc(sizeof(*service)); @@ -1166,8 +1207,8 @@ static void build_perf_vol_config(host_config_t *host, const oconfig_item_t *ci) static void build_volume_config(host_config_t *host, oconfig_item_t *ci) { int i, had_df = 0; - service_config_t *service; - cfg_volume_data_t *cfg_volume_data; + cfg_service_t *service; + cfg_volume_usage_t *cfg_volume_data; service = malloc(sizeof(*service)); service->query = 0; @@ -1195,14 +1236,14 @@ static void build_volume_config(host_config_t *host, oconfig_item_t *ci) { static void build_perf_disk_config(host_config_t *temp, oconfig_item_t *ci) { int i; - service_config_t *service; - perf_disk_data_t *perf_disk; + cfg_service_t *service; + cfg_disk_t *cfg_disk; service = malloc(sizeof(*service)); service->query = 0; - service->handler = collect_perf_disk_data; - perf_disk = service->data = malloc(sizeof(*perf_disk)); - perf_disk->flags = PERF_DISK_ALL; + service->handler = query_submit_disk_data; + cfg_disk = service->data = malloc(sizeof(*cfg_disk)); + cfg_disk->flags = CFG_DISK_ALL; service->next = temp->services; temp->services = service; for (i = 0; i < ci->children_num; ++i) { @@ -1212,15 +1253,15 @@ static void build_perf_disk_config(host_config_t *temp, oconfig_item_t *ci) { if (!strcasecmp(item->key, "Multiplier")) { config_get_multiplier (item, service); } else if (!strcasecmp(item->key, "GetBusy")) { - config_bool_to_flag (item, &perf_disk->flags, PERF_SYSTEM_CPU); + config_bool_to_flag (item, &cfg_disk->flags, CFG_SYSTEM_CPU); } } } static void build_perf_wafl_config(host_config_t *host, oconfig_item_t *ci) { /* {{{ */ int i; - service_config_t *service; - perf_wafl_data_t *perf_wafl; + cfg_service_t *service; + data_wafl_t *perf_wafl; service = malloc(sizeof(*service)); if (service == NULL) @@ -1256,11 +1297,11 @@ static void build_perf_wafl_config(host_config_t *host, oconfig_item_t *ci) { /* } /* }}} void build_perf_wafl_config */ static int build_perf_sys_config (host_config_t *host, /* {{{ */ - oconfig_item_t *ci, const service_config_t *default_service) + oconfig_item_t *ci, const cfg_service_t *default_service) { int i; - service_config_t *service; - perf_system_data_t *perf_system; + cfg_service_t *service; + cfg_system_t *cfg_system; service = malloc(sizeof(*service)); if (service == NULL) @@ -1269,14 +1310,14 @@ static int build_perf_sys_config (host_config_t *host, /* {{{ */ *service = *default_service; service->handler = collect_perf_system_data; - perf_system = malloc(sizeof(*perf_system)); - if (perf_system == NULL) { + cfg_system = malloc(sizeof(*cfg_system)); + if (cfg_system == NULL) { sfree (service); return (-1); } - memset (perf_system, 0, sizeof (*perf_system)); - perf_system->flags = PERF_SYSTEM_ALL; - service->data = perf_system; + memset (cfg_system, 0, sizeof (*cfg_system)); + cfg_system->flags = CFG_SYSTEM_ALL; + service->data = cfg_system; for (i = 0; i < ci->children_num; ++i) { oconfig_item_t *item = ci->children + i; @@ -1284,13 +1325,13 @@ static int build_perf_sys_config (host_config_t *host, /* {{{ */ if (!strcasecmp(item->key, "Multiplier")) { config_get_multiplier (item, service); } else if (!strcasecmp(item->key, "GetCPULoad")) { - config_bool_to_flag (item, &perf_system->flags, PERF_SYSTEM_CPU); + config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_CPU); } else if (!strcasecmp(item->key, "GetInterfaces")) { - config_bool_to_flag (item, &perf_system->flags, PERF_SYSTEM_NET); + config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_NET); } else if (!strcasecmp(item->key, "GetDiskOps")) { - config_bool_to_flag (item, &perf_system->flags, PERF_SYSTEM_OPS); + config_bool_to_flag (item, &cfg_system->flags, CFG_SYSTEM_OPS); } else if (!strcasecmp(item->key, "GetDiskIO")) { - config_bool_to_flag (item, &perf_system->flags, PERF_SYSTEM_DISK); + 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); @@ -1303,11 +1344,11 @@ static int build_perf_sys_config (host_config_t *host, /* {{{ */ return (0); } /* }}} int build_perf_sys_config */ -static host_config_t *build_host_config(const oconfig_item_t *ci, const host_config_t *default_host, const service_config_t *def_def_service) { +static host_config_t *build_host_config(const oconfig_item_t *ci, const host_config_t *default_host, const cfg_service_t *def_def_service) { int i; oconfig_item_t *item; host_config_t *host, *hc, temp = *default_host; - service_config_t default_service = *def_def_service; + cfg_service_t default_service = *def_def_service; if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) { WARNING("netapp plugin: \"Host\" needs exactly one string argument. Ignoring host block."); @@ -1388,11 +1429,11 @@ static host_config_t *build_host_config(const oconfig_item_t *ci, const host_con return host; } -static int build_config (oconfig_item_t *ci) { +static int cna_config (oconfig_item_t *ci) { int i; oconfig_item_t *item; host_config_t default_host = HOST_INIT; - service_config_t default_service = SERVICE_INIT; + cfg_service_t default_service = SERVICE_INIT; for (i = 0; i < ci->children_num; ++i) { item = ci->children + i; @@ -1407,10 +1448,10 @@ static int build_config (oconfig_item_t *ci) { return 0; } -static int netapp_read() { +static int cna_read(void) { na_elem_t *out; host_config_t *host; - service_config_t *service; + cfg_service_t *service; for (host = host_config; host; host = host->next) { for (service = host->services; service; service = service->next) { @@ -1434,10 +1475,10 @@ static int netapp_read() { return 0; } -void module_register() { - plugin_register_complex_config("netapp", build_config); - plugin_register_init("netapp", config_init); - plugin_register_read("netapp", netapp_read); +void module_register(void) { + plugin_register_complex_config("netapp", cna_config); + plugin_register_init("netapp", cna_init); + plugin_register_read("netapp", cna_read); } /* vim: set sw=2 ts=2 noet fdm=marker : */