static int
process_station (int sk, const char *dev, struct ieee80211req_sta_info *si)
{
struct iwreq iwr;
static char mac[DATA_MAX_NAME_LEN];
struct ieee80211req_sta_stats stats;
const struct ieee80211_nodestats *ns = &stats.is_stats;
int status;
macaddr_to_str (mac, sizeof (mac), si->isi_macaddr);
if (item_watched (STAT_NODE_TX_RATE))
submit_gauge (dev, "node_tx_rate", mac, NULL,
(si->isi_rates[si->isi_txrate] & IEEE80211_RATE_VAL) / 2);
if (item_watched (STAT_NODE_RSSI))
submit_gauge (dev, "node_rssi", mac, NULL, si->isi_rssi);
memset (&iwr, 0, sizeof (iwr));
sstrncpy(iwr.ifr_name, dev, sizeof (iwr.ifr_name));
iwr.u.data.pointer = (void *) &stats;
iwr.u.data.length = sizeof (stats);
memcpy(stats.is_u.macaddr, si->isi_macaddr, IEEE80211_ADDR_LEN);
status = ioctl(sk, IEEE80211_IOCTL_STA_STATS, &iwr);
if (status < 0)
{
/* Silent, because not all interfaces support all ioctls. */
DEBUG ("madwifi plugin: Sending IO-control "
"IEEE80211_IOCTL_STA_STATS to device %s "
"failed with status %i.",
dev, status);
return (status);
}
/* These two stats are handled as a special case as they are
a pair of 64bit values */
if (item_watched (STAT_NODE_OCTETS))
submit_derive2 (dev, "node_octets", mac, NULL,
ns->ns_rx_bytes, ns->ns_tx_bytes);
/* This stat is handled as a special case, because it is stored
as uin64_t, but we will ignore upper half */
if (item_watched (STAT_NS_RX_BEACONS))
submit_derive (dev, "node_stat", "ns_rx_beacons", mac,
(ns->ns_rx_beacons & 0xFFFFFFFF));
/* All other node statistics */
process_stat_struct (NOD_STAT, ns, dev, mac, "node_stat", "ns_misc");
return (0);
}
static int
lv_read (void)
{
time_t t;
int i;
if (conn == NULL) {
/* `conn_string == NULL' is acceptable. */
conn = virConnectOpenReadOnly (conn_string);
if (conn == NULL) {
c_complain (LOG_ERR, &conn_complain,
PLUGIN_NAME " plugin: Unable to connect: "
"virConnectOpenReadOnly failed.");
return -1;
}
}
c_release (LOG_NOTICE, &conn_complain,
PLUGIN_NAME " plugin: Connection established.");
time (&t);
/* Need to refresh domain or device lists? */
if ((last_refresh == (time_t) 0) ||
((interval > 0) && ((last_refresh + interval) <= t))) {
if (refresh_lists () != 0) {
if (conn != NULL)
virConnectClose (conn);
conn = NULL;
return -1;
}
last_refresh = t;
}
#if 0
for (i = 0; i < nr_domains; ++i)
fprintf (stderr, "domain %s\n", virDomainGetName (domains[i]));
for (i = 0; i < nr_block_devices; ++i)
fprintf (stderr, "block device %d %s:%s\n",
i, virDomainGetName (block_devices[i].dom),
block_devices[i].path);
for (i = 0; i < nr_interface_devices; ++i)
fprintf (stderr, "interface device %d %s:%s\n",
i, virDomainGetName (interface_devices[i].dom),
interface_devices[i].path);
#endif
/* Get CPU usage, memory, VCPU usage for each domain. */
for (i = 0; i < nr_domains; ++i) {
virDomainInfo info;
virVcpuInfoPtr vinfo = NULL;
virDomainMemoryStatPtr minfo = NULL;
int status;
int j;
status = virDomainGetInfo (domains[i], &info);
if (status != 0)
{
ERROR (PLUGIN_NAME " plugin: virDomainGetInfo failed with status %i.",
status);
continue;
}
if (info.state != VIR_DOMAIN_RUNNING)
{
/* only gather stats for running domains */
continue;
}
cpu_submit (info.cpuTime, domains[i], "virt_cpu_total");
memory_submit ((gauge_t) info.memory * 1024, domains[i]);
vinfo = malloc (info.nrVirtCpu * sizeof (vinfo[0]));
if (vinfo == NULL) {
ERROR (PLUGIN_NAME " plugin: malloc failed.");
continue;
}
status = virDomainGetVcpus (domains[i], vinfo, info.nrVirtCpu,
/* cpu map = */ NULL, /* cpu map length = */ 0);
if (status < 0)
{
ERROR (PLUGIN_NAME " plugin: virDomainGetVcpus failed with status %i.",
status);
sfree (vinfo);
continue;
}
for (j = 0; j < info.nrVirtCpu; ++j)
vcpu_submit (vinfo[j].cpuTime,
domains[i], vinfo[j].number, "virt_vcpu");
sfree (vinfo);
minfo = malloc (VIR_DOMAIN_MEMORY_STAT_NR * sizeof (virDomainMemoryStatStruct));
if (minfo == NULL) {
ERROR ("virt plugin: malloc failed.");
continue;
}
status = virDomainMemoryStats (domains[i], minfo, VIR_DOMAIN_MEMORY_STAT_NR, 0);
if (status < 0) {
ERROR ("virt plugin: virDomainMemoryStats failed with status %i.",
status);
sfree (minfo);
continue;
}
for (j = 0; j < status; j++) {
memory_stats_submit ((gauge_t) minfo[j].val * 1024, domains[i], minfo[j].tag);
}
sfree (minfo);
}
/* Get block device stats for each domain. */
for (i = 0; i < nr_block_devices; ++i) {
struct _virDomainBlockStats stats;
if (virDomainBlockStats (block_devices[i].dom, block_devices[i].path,
&stats, sizeof stats) != 0)
continue;
if ((stats.rd_req != -1) && (stats.wr_req != -1))
submit_derive2 ("disk_ops",
(derive_t) stats.rd_req, (derive_t) stats.wr_req,
block_devices[i].dom, block_devices[i].path);
if ((stats.rd_bytes != -1) && (stats.wr_bytes != -1))
submit_derive2 ("disk_octets",
(derive_t) stats.rd_bytes, (derive_t) stats.wr_bytes,
block_devices[i].dom, block_devices[i].path);
} /* for (nr_block_devices) */
/* Get interface stats for each domain. */
for (i = 0; i < nr_interface_devices; ++i) {
struct _virDomainInterfaceStats stats;
char *display_name = NULL;
switch (interface_format) {
case if_address:
display_name = interface_devices[i].address;
break;
case if_number:
display_name = interface_devices[i].number;
break;
case if_name:
default:
display_name = interface_devices[i].path;
}
if (virDomainInterfaceStats (interface_devices[i].dom,
interface_devices[i].path,
&stats, sizeof stats) != 0)
continue;
if ((stats.rx_bytes != -1) && (stats.tx_bytes != -1))
submit_derive2 ("if_octets",
(derive_t) stats.rx_bytes, (derive_t) stats.tx_bytes,
interface_devices[i].dom, display_name);
if ((stats.rx_packets != -1) && (stats.tx_packets != -1))
submit_derive2 ("if_packets",
(derive_t) stats.rx_packets, (derive_t) stats.tx_packets,
interface_devices[i].dom, display_name);
if ((stats.rx_errs != -1) && (stats.tx_errs != -1))
submit_derive2 ("if_errors",
(derive_t) stats.rx_errs, (derive_t) stats.tx_errs,
interface_devices[i].dom, display_name);
if ((stats.rx_drop != -1) && (stats.tx_drop != -1))
submit_derive2 ("if_dropped",
(derive_t) stats.rx_drop, (derive_t) stats.tx_drop,
interface_devices[i].dom, display_name);
} /* for (nr_interface_devices) */
return 0;
}
static int memcached_read (user_data_t *user_data)
{
char buf[4096];
char *fields[3];
char *ptr;
char *line;
char *saveptr;
int fields_num;
gauge_t bytes_used = NAN;
gauge_t bytes_total = NAN;
gauge_t hits = NAN;
gauge_t gets = NAN;
gauge_t incr_hits = NAN;
derive_t incr = 0;
gauge_t decr_hits = NAN;
derive_t decr = 0;
derive_t rusage_user = 0;
derive_t rusage_syst = 0;
derive_t octets_rx = 0;
derive_t octets_tx = 0;
memcached_t *st;
st = user_data->data;
/* get data from daemon */
if (memcached_query_daemon (buf, sizeof (buf), st) < 0) {
return -1;
}
#define FIELD_IS(cnst) \
(((sizeof(cnst) - 1) == name_len) && (strcmp (cnst, fields[1]) == 0))
ptr = buf;
saveptr = NULL;
while ((line = strtok_r (ptr, "\n\r", &saveptr)) != NULL)
{
int name_len;
ptr = NULL;
fields_num = strsplit(line, fields, 3);
if (fields_num != 3)
continue;
name_len = strlen(fields[1]);
if (name_len == 0)
continue;
/*
* For an explanation on these fields please refer to
* <https://github.com/memcached/memcached/blob/master/doc/protocol.txt>
*/
/*
* CPU time consumed by the memcached process
*/
if (FIELD_IS ("rusage_user"))
{
rusage_user = atoll (fields[2]);
}
else if (FIELD_IS ("rusage_system"))
{
rusage_syst = atoll(fields[2]);
}
/*
* Number of threads of this instance
*/
else if (FIELD_IS ("threads"))
{
submit_gauge2 ("ps_count", NULL, NAN, atof (fields[2]), st);
}
/*
* Number of items stored
*/
else if (FIELD_IS ("curr_items"))
{
submit_gauge ("memcached_items", "current", atof (fields[2]), st);
}
/*
* Number of bytes used and available (total - used)
*/
else if (FIELD_IS ("bytes"))
{
bytes_used = atof (fields[2]);
}
else if (FIELD_IS ("limit_maxbytes"))
{
bytes_total = atof(fields[2]);
}
/*
* Connections
*/
else if (FIELD_IS ("curr_connections"))
{
submit_gauge ("memcached_connections", "current", atof (fields[2]), st);
}
else if (FIELD_IS ("listen_disabled_num"))
{
submit_derive ("memcached_connections", "listen_disabled", atof (fields[2]), st);
}
/*
* Commands
*/
else if ((name_len > 4) && (strncmp (fields[1], "cmd_", 4) == 0))
{
const char *name = fields[1] + 4;
submit_derive ("memcached_command", name, atoll (fields[2]), st);
if (strcmp (name, "get") == 0)
gets = atof (fields[2]);
}
/*
* Increment/Decrement
*/
else if (FIELD_IS("incr_misses"))
{
derive_t incr_count = atoll (fields[2]);
submit_derive ("memcached_ops", "incr_misses", incr_count, st);
incr += incr_count;
}
else if (FIELD_IS ("incr_hits"))
{
derive_t incr_count = atoll (fields[2]);
submit_derive ("memcached_ops", "incr_hits", incr_count, st);
incr_hits = atof (fields[2]);
incr += incr_count;
}
else if (FIELD_IS ("decr_misses"))
{
derive_t decr_count = atoll (fields[2]);
submit_derive ("memcached_ops", "decr_misses", decr_count, st);
decr += decr_count;
}
else if (FIELD_IS ("decr_hits"))
{
derive_t decr_count = atoll (fields[2]);
submit_derive ("memcached_ops", "decr_hits", decr_count, st);
decr_hits = atof (fields[2]);
decr += decr_count;
}
/*
* Operations on the cache, i. e. cache hits, cache misses and evictions of items
*/
else if (FIELD_IS ("get_hits"))
{
submit_derive ("memcached_ops", "hits", atoll (fields[2]), st);
hits = atof (fields[2]);
}
else if (FIELD_IS ("get_misses"))
{
submit_derive ("memcached_ops", "misses", atoll (fields[2]), st);
}
else if (FIELD_IS ("evictions"))
{
submit_derive ("memcached_ops", "evictions", atoll (fields[2]), st);
}
/*
* Network traffic
*/
else if (FIELD_IS ("bytes_read"))
{
octets_rx = atoll (fields[2]);
}
else if (FIELD_IS ("bytes_written"))
{
octets_tx = atoll (fields[2]);
}
} /* while ((line = strtok_r (ptr, "\n\r", &saveptr)) != NULL) */
if (!isnan (bytes_used) && !isnan (bytes_total) && (bytes_used <= bytes_total))
submit_gauge2 ("df", "cache", bytes_used, bytes_total - bytes_used, st);
if ((rusage_user != 0) || (rusage_syst != 0))
submit_derive2 ("ps_cputime", NULL, rusage_user, rusage_syst, st);
if ((octets_rx != 0) || (octets_tx != 0))
submit_derive2 ("memcached_octets", NULL, octets_rx, octets_tx, st);
if (!isnan (gets) && !isnan (hits))
{
gauge_t rate = NAN;
if (gets != 0.0)
rate = 100.0 * hits / gets;
submit_gauge ("percent", "hitratio", rate, st);
}
if (!isnan (incr_hits) && incr != 0)
{
gauge_t incr_rate = 100.0 * incr_hits / incr;
submit_gauge ("percent", "incr_hitratio", incr_rate, st);
submit_derive ("memcached_ops", "incr", incr, st);
}
if (!isnan (decr_hits) && decr != 0)
{
gauge_t decr_rate = 100.0 * decr_hits / decr;
submit_gauge ("percent", "decr_hitratio", decr_rate, st);
submit_derive ("memcached_ops", "decr", decr, st);
}
return 0;
} /* int memcached_read */
static int
lv_read (void)
{
time_t t;
int i;
if (conn == NULL) {
/* `conn_string == NULL' is acceptable. */
conn = virConnectOpenReadOnly (conn_string);
if (conn == NULL) {
c_complain (LOG_ERR, &conn_complain,
"libvirt plugin: Unable to connect: "
"virConnectOpenReadOnly failed.");
return -1;
}
}
c_release (LOG_NOTICE, &conn_complain,
"libvirt plugin: Connection established.");
time (&t);
/* Need to refresh domain or device lists? */
if ((last_refresh == (time_t) 0) ||
((interval > 0) && ((last_refresh + interval) <= t))) {
if (refresh_lists () != 0) {
if (conn != NULL)
virConnectClose (conn);
conn = NULL;
return -1;
}
last_refresh = t;
}
#if 0
for (i = 0; i < nr_domains; ++i)
fprintf (stderr, "domain %s\n", virDomainGetName (domains[i]));
for (i = 0; i < nr_block_devices; ++i)
fprintf (stderr, "block device %d %s:%s\n",
i, virDomainGetName (block_devices[i].dom),
block_devices[i].path);
for (i = 0; i < nr_interface_devices; ++i)
fprintf (stderr, "interface device %d %s:%s\n",
i, virDomainGetName (interface_devices[i].dom),
interface_devices[i].path);
#endif
/* Get CPU usage, VCPU usage for each domain. */
for (i = 0; i < nr_domains; ++i) {
virDomainInfo info;
virVcpuInfoPtr vinfo = NULL;
int j;
if (virDomainGetInfo (domains[i], &info) != 0)
continue;
cpu_submit (info.cpuTime, domains[i], "virt_cpu_total");
vinfo = malloc (info.nrVirtCpu * sizeof vinfo[0]);
if (vinfo == NULL) {
ERROR ("libvirt plugin: malloc failed.");
continue;
}
if (virDomainGetVcpus (domains[i], vinfo, info.nrVirtCpu,
NULL, 0) != 0) {
sfree (vinfo);
continue;
}
for (j = 0; j < info.nrVirtCpu; ++j)
vcpu_submit (vinfo[j].cpuTime,
domains[i], vinfo[j].number, "virt_vcpu");
sfree (vinfo);
}
/* Get block device stats for each domain. */
for (i = 0; i < nr_block_devices; ++i) {
struct _virDomainBlockStats stats;
if (virDomainBlockStats (block_devices[i].dom, block_devices[i].path,
&stats, sizeof stats) != 0)
continue;
if ((stats.rd_req != -1) && (stats.wr_req != -1))
submit_derive2 ("disk_ops",
(derive_t) stats.rd_req, (derive_t) stats.wr_req,
block_devices[i].dom, block_devices[i].path);
if ((stats.rd_bytes != -1) && (stats.wr_bytes != -1))
submit_derive2 ("disk_octets",
(derive_t) stats.rd_bytes, (derive_t) stats.wr_bytes,
block_devices[i].dom, block_devices[i].path);
} /* for (nr_block_devices) */
/* Get interface stats for each domain. */
for (i = 0; i < nr_interface_devices; ++i) {
struct _virDomainInterfaceStats stats;
char *display_name = interface_devices[i].path;
if (interface_format == if_address)
display_name = interface_devices[i].address;
if (virDomainInterfaceStats (interface_devices[i].dom,
interface_devices[i].path,
&stats, sizeof stats) != 0)
continue;
if ((stats.rx_bytes != -1) && (stats.tx_bytes != -1))
submit_derive2 ("if_octets",
(derive_t) stats.rx_bytes, (derive_t) stats.tx_bytes,
interface_devices[i].dom, display_name);
if ((stats.rx_packets != -1) && (stats.tx_packets != -1))
submit_derive2 ("if_packets",
(derive_t) stats.rx_packets, (derive_t) stats.tx_packets,
interface_devices[i].dom, display_name);
if ((stats.rx_errs != -1) && (stats.tx_errs != -1))
submit_derive2 ("if_errors",
(derive_t) stats.rx_errs, (derive_t) stats.tx_errs,
interface_devices[i].dom, display_name);
if ((stats.rx_drop != -1) && (stats.tx_drop != -1))
submit_derive2 ("if_dropped",
(derive_t) stats.rx_drop, (derive_t) stats.tx_drop,
interface_devices[i].dom, display_name);
} /* for (nr_interface_devices) */
return 0;
}
