static int zh_read (void)
{
gauge_t arc_hits, arc_misses, l2_hits, l2_misses;
value_t zfs_io[2];
kstat_t *ksp = NULL;
get_kstat (&ksp, "unix", 0, "vopstats_zfs");
if (ksp == NULL)
{
ERROR ("zfs_health plugin: Cannot find unix:0:vopstats_zfs kstat.");
return (-1);
}
/* Sizes */
/* zh_read_gauge (ksp, "size", "cache_size", "arc");
* zh_read_gauge (ksp, "l2_size", "cache_size", "L2");
*/
/* Operations */
/* zh_read_derive (ksp, "allocated","cache_operation", "allocated");
* zh_read_derive (ksp, "deleted", "cache_operation", "deleted");
* zh_read_derive (ksp, "stolen", "cache_operation", "stolen");
*/
/* I/O */
zfs_io[0].derive = get_kstat_value(ksp, "read_bytes");
zfs_io[1].derive = get_kstat_value(ksp, "write_bytes");
zh_submit ("io_octets", "ZFS", zfs_io, /* num values = */ 2);
return (0);
} /* int zh_read */
static int interface_init (void)
{
kstat_t *ksp_chain;
numif = 0;
if (kc == NULL)
return (-1);
for (numif = 0, ksp_chain = kc->kc_chain;
(numif < MAX_NUMIF) && (ksp_chain != NULL);
ksp_chain = ksp_chain->ks_next)
{
if (strncmp (ksp_chain->ks_class, "net", 3))
continue;
if (ksp_chain->ks_type != KSTAT_TYPE_NAMED)
continue;
if (kstat_read (kc, ksp_chain, NULL) == -1)
continue;
if (get_kstat_value (ksp_chain, "obytes") == -1LL)
continue;
ksp[numif++] = ksp_chain;
}
return (0);
} /* int interface_init */
static int zh_read_gauge (kstat_t *ksp, const char *kstat_value,
const char *type, const char *type_instance)
{
long long tmp;
value_t v;
tmp = get_kstat_value (ksp, (char *)kstat_value);
if (tmp == -1LL)
{
ERROR ("zfs_health plugin: Reading kstat value \"%s\" failed.", kstat_value);
return (-1);
}
v.gauge = (gauge_t) tmp;
zh_submit (type, type_instance, /* values = */ &v, /* values_num = */ 1);
return (0);
}
static long long get_zfs_value(kstat_t *ksp, char *name)
{
return (get_kstat_value(ksp, name));
}
static int interface_read (void)
{
#if HAVE_GETIFADDRS
struct ifaddrs *if_list;
struct ifaddrs *if_ptr;
/* Darwin/Mac OS X and possible other *BSDs */
#if HAVE_STRUCT_IF_DATA
# define IFA_DATA if_data
# define IFA_RX_BYTES ifi_ibytes
# define IFA_TX_BYTES ifi_obytes
# define IFA_RX_PACKT ifi_ipackets
# define IFA_TX_PACKT ifi_opackets
# define IFA_RX_ERROR ifi_ierrors
# define IFA_TX_ERROR ifi_oerrors
/* #endif HAVE_STRUCT_IF_DATA */
#elif HAVE_STRUCT_NET_DEVICE_STATS
# define IFA_DATA net_device_stats
# define IFA_RX_BYTES rx_bytes
# define IFA_TX_BYTES tx_bytes
# define IFA_RX_PACKT rx_packets
# define IFA_TX_PACKT tx_packets
# define IFA_RX_ERROR rx_errors
# define IFA_TX_ERROR tx_errors
#else
# error "No suitable type for `struct ifaddrs->ifa_data' found."
#endif
struct IFA_DATA *if_data;
if (getifaddrs (&if_list) != 0)
return (-1);
for (if_ptr = if_list; if_ptr != NULL; if_ptr = if_ptr->ifa_next)
{
if (if_ptr->ifa_addr != NULL && if_ptr->ifa_addr->sa_family == AF_LINK) {
if_data = (struct IFA_DATA *) if_ptr->ifa_data;
if_submit (if_ptr->ifa_name, "if_octets",
if_data->IFA_RX_BYTES,
if_data->IFA_TX_BYTES);
if_submit (if_ptr->ifa_name, "if_packets",
if_data->IFA_RX_PACKT,
if_data->IFA_TX_PACKT);
if_submit (if_ptr->ifa_name, "if_errors",
if_data->IFA_RX_ERROR,
if_data->IFA_TX_ERROR);
}
}
freeifaddrs (if_list);
/* #endif HAVE_GETIFADDRS */
#elif KERNEL_LINUX
FILE *fh;
char buffer[1024];
derive_t incoming, outgoing;
char *device;
char *dummy;
char *fields[16];
int numfields;
if ((fh = fopen ("/proc/net/dev", "r")) == NULL)
{
char errbuf[1024];
WARNING ("interface plugin: fopen: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
while (fgets (buffer, 1024, fh) != NULL)
{
if (!(dummy = strchr(buffer, ':')))
continue;
dummy[0] = '\0';
dummy++;
device = buffer;
while (device[0] == ' ')
device++;
if (device[0] == '\0')
continue;
numfields = strsplit (dummy, fields, 16);
if (numfields < 11)
continue;
incoming = atoll (fields[0]);
outgoing = atoll (fields[8]);
if_submit (device, "if_octets", incoming, outgoing);
incoming = atoll (fields[1]);
outgoing = atoll (fields[9]);
if_submit (device, "if_packets", incoming, outgoing);
incoming = atoll (fields[2]);
outgoing = atoll (fields[10]);
if_submit (device, "if_errors", incoming, outgoing);
incoming = atoll (fields[3]);
outgoing = atoll (fields[11]);
if_submit (device, "if_dropped", incoming, outgoing);
}
fclose (fh);
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
int i;
derive_t rx;
derive_t tx;
char iname[DATA_MAX_NAME_LEN];
if (kc == NULL)
return (-1);
for (i = 0; i < numif; i++)
{
if (kstat_read (kc, ksp[i], NULL) == -1)
continue;
if (unique_name)
ssnprintf(iname, sizeof(iname), "%s_%d_%s", ksp[i]->ks_module, ksp[i]->ks_instance, ksp[i]->ks_name);
else
sstrncpy(iname, ksp[i]->ks_name, sizeof(iname));
/* try to get 64bit counters */
rx = get_kstat_value (ksp[i], "rbytes64");
tx = get_kstat_value (ksp[i], "obytes64");
/* or fallback to 32bit */
if (rx == -1LL)
rx = get_kstat_value (ksp[i], "rbytes");
if (tx == -1LL)
tx = get_kstat_value (ksp[i], "obytes");
if ((rx != -1LL) || (tx != -1LL))
if_submit (iname, "if_octets", rx, tx);
/* try to get 64bit counters */
rx = get_kstat_value (ksp[i], "ipackets64");
tx = get_kstat_value (ksp[i], "opackets64");
/* or fallback to 32bit */
if (rx == -1LL)
rx = get_kstat_value (ksp[i], "ipackets");
if (tx == -1LL)
tx = get_kstat_value (ksp[i], "opackets");
if ((rx != -1LL) || (tx != -1LL))
if_submit (iname, "if_packets", rx, tx);
/* no 64bit error counters yet */
rx = get_kstat_value (ksp[i], "ierrors");
tx = get_kstat_value (ksp[i], "oerrors");
if ((rx != -1LL) || (tx != -1LL))
if_submit (iname, "if_errors", rx, tx);
}
/* #endif HAVE_LIBKSTAT */
#elif defined(HAVE_LIBSTATGRAB)
sg_network_io_stats *ios;
int i, num;
ios = sg_get_network_io_stats (&num);
for (i = 0; i < num; i++)
if_submit (ios[i].interface_name, "if_octets", ios[i].rx, ios[i].tx);
/* #endif HAVE_LIBSTATGRAB */
#elif defined(HAVE_PERFSTAT)
perfstat_id_t id;
int i, ifs;
if ((nif = perfstat_netinterface(NULL, NULL, sizeof(perfstat_netinterface_t), 0)) < 0)
{
char errbuf[1024];
WARNING ("interface plugin: perfstat_netinterface: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
if (pnif != nif || ifstat == NULL)
{
free(ifstat);
ifstat = malloc(nif * sizeof (*ifstat));
}
pnif = nif;
id.name[0]='\0';
if ((ifs = perfstat_netinterface(&id, ifstat, sizeof(perfstat_netinterface_t), nif)) < 0)
{
char errbuf[1024];
WARNING ("interface plugin: perfstat_netinterface (interfaces=%d): %s",
nif, sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
for (i = 0; i < ifs; i++)
{
if_submit (ifstat[i].name, "if_octets", ifstat[i].ibytes, ifstat[i].obytes);
if_submit (ifstat[i].name, "if_packets", ifstat[i].ipackets ,ifstat[i].opackets);
if_submit (ifstat[i].name, "if_errors", ifstat[i].ierrors, ifstat[i].oerrors );
}
#endif /* HAVE_PERFSTAT */
return (0);
} /* int interface_read */
static int memory_read_internal(value_list_t *vl) {
#if HAVE_HOST_STATISTICS
kern_return_t status;
vm_statistics_data_t vm_data;
mach_msg_type_number_t vm_data_len;
gauge_t wired;
gauge_t active;
gauge_t inactive;
gauge_t free;
if (!port_host || !pagesize)
return -1;
vm_data_len = sizeof(vm_data) / sizeof(natural_t);
if ((status = host_statistics(port_host, HOST_VM_INFO, (host_info_t)&vm_data,
&vm_data_len)) != KERN_SUCCESS) {
ERROR("memory-plugin: host_statistics failed and returned the value %i",
(int)status);
return -1;
}
/*
* From <http://docs.info.apple.com/article.html?artnum=107918>:
*
* Wired memory
* This information can't be cached to disk, so it must stay in RAM.
* The amount depends on what applications you are using.
*
* Active memory
* This information is currently in RAM and actively being used.
*
* Inactive memory
* This information is no longer being used and has been cached to
* disk, but it will remain in RAM until another application needs
* the space. Leaving this information in RAM is to your advantage if
* you (or a client of your computer) come back to it later.
*
* Free memory
* This memory is not being used.
*/
wired = (gauge_t)(((uint64_t)vm_data.wire_count) * ((uint64_t)pagesize));
active = (gauge_t)(((uint64_t)vm_data.active_count) * ((uint64_t)pagesize));
inactive =
(gauge_t)(((uint64_t)vm_data.inactive_count) * ((uint64_t)pagesize));
free = (gauge_t)(((uint64_t)vm_data.free_count) * ((uint64_t)pagesize));
MEMORY_SUBMIT("wired", wired, "active", active, "inactive", inactive, "free",
free);
/* #endif HAVE_HOST_STATISTICS */
#elif HAVE_SYSCTLBYNAME
/*
* vm.stats.vm.v_page_size: 4096
* vm.stats.vm.v_page_count: 246178
* vm.stats.vm.v_free_count: 28760
* vm.stats.vm.v_wire_count: 37526
* vm.stats.vm.v_active_count: 55239
* vm.stats.vm.v_inactive_count: 113730
* vm.stats.vm.v_cache_count: 10809
*/
const char *sysctl_keys[8] = {
"vm.stats.vm.v_page_size", "vm.stats.vm.v_page_count",
"vm.stats.vm.v_free_count", "vm.stats.vm.v_wire_count",
"vm.stats.vm.v_active_count", "vm.stats.vm.v_inactive_count",
"vm.stats.vm.v_cache_count", NULL};
double sysctl_vals[8];
for (int i = 0; sysctl_keys[i] != NULL; i++) {
int value;
size_t value_len = sizeof(value);
if (sysctlbyname(sysctl_keys[i], (void *)&value, &value_len, NULL, 0) ==
0) {
sysctl_vals[i] = value;
DEBUG("memory plugin: %26s: %g", sysctl_keys[i], sysctl_vals[i]);
} else {
sysctl_vals[i] = NAN;
}
} /* for (sysctl_keys) */
/* multiply all all page counts with the pagesize */
for (int i = 1; sysctl_keys[i] != NULL; i++)
if (!isnan(sysctl_vals[i]))
sysctl_vals[i] *= sysctl_vals[0];
MEMORY_SUBMIT("free", (gauge_t)sysctl_vals[2], "wired",
(gauge_t)sysctl_vals[3], "active", (gauge_t)sysctl_vals[4],
"inactive", (gauge_t)sysctl_vals[5], "cache",
(gauge_t)sysctl_vals[6]);
/* #endif HAVE_SYSCTLBYNAME */
#elif KERNEL_LINUX
FILE *fh;
char buffer[1024];
char *fields[8];
int numfields;
bool detailed_slab_info = false;
gauge_t mem_total = 0;
gauge_t mem_used = 0;
gauge_t mem_buffered = 0;
gauge_t mem_cached = 0;
gauge_t mem_free = 0;
gauge_t mem_slab_total = 0;
gauge_t mem_slab_reclaimable = 0;
gauge_t mem_slab_unreclaimable = 0;
if ((fh = fopen("/proc/meminfo", "r")) == NULL) {
WARNING("memory: fopen: %s", STRERRNO);
return -1;
}
while (fgets(buffer, sizeof(buffer), fh) != NULL) {
gauge_t *val = NULL;
if (strncasecmp(buffer, "MemTotal:", 9) == 0)
val = &mem_total;
else if (strncasecmp(buffer, "MemFree:", 8) == 0)
val = &mem_free;
else if (strncasecmp(buffer, "Buffers:", 8) == 0)
val = &mem_buffered;
else if (strncasecmp(buffer, "Cached:", 7) == 0)
val = &mem_cached;
else if (strncasecmp(buffer, "Slab:", 5) == 0)
val = &mem_slab_total;
else if (strncasecmp(buffer, "SReclaimable:", 13) == 0) {
val = &mem_slab_reclaimable;
detailed_slab_info = true;
} else if (strncasecmp(buffer, "SUnreclaim:", 11) == 0) {
val = &mem_slab_unreclaimable;
detailed_slab_info = true;
} else
continue;
numfields = strsplit(buffer, fields, STATIC_ARRAY_SIZE(fields));
if (numfields < 2)
continue;
*val = 1024.0 * atof(fields[1]);
}
if (fclose(fh)) {
WARNING("memory: fclose: %s", STRERRNO);
}
if (mem_total < (mem_free + mem_buffered + mem_cached + mem_slab_total))
return -1;
mem_used =
mem_total - (mem_free + mem_buffered + mem_cached + mem_slab_total);
/* SReclaimable and SUnreclaim were introduced in kernel 2.6.19
* They sum up to the value of Slab, which is available on older & newer
* kernels. So SReclaimable/SUnreclaim are submitted if available, and Slab
* if not. */
if (detailed_slab_info)
MEMORY_SUBMIT("used", mem_used, "buffered", mem_buffered, "cached",
mem_cached, "free", mem_free, "slab_unrecl",
mem_slab_unreclaimable, "slab_recl", mem_slab_reclaimable);
else
MEMORY_SUBMIT("used", mem_used, "buffered", mem_buffered, "cached",
mem_cached, "free", mem_free, "slab", mem_slab_total);
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
/* Most of the additions here were taken as-is from the k9toolkit from
* Brendan Gregg and are subject to change I guess */
long long mem_used;
long long mem_free;
long long mem_lock;
long long mem_kern;
long long mem_unus;
long long arcsize;
long long pp_kernel;
long long physmem;
long long availrmem;
if (ksp == NULL)
return -1;
if (ksz == NULL)
return -1;
mem_used = get_kstat_value(ksp, "pagestotal");
mem_free = get_kstat_value(ksp, "pagesfree");
mem_lock = get_kstat_value(ksp, "pageslocked");
arcsize = get_kstat_value(ksz, "size");
pp_kernel = get_kstat_value(ksp, "pp_kernel");
physmem = get_kstat_value(ksp, "physmem");
availrmem = get_kstat_value(ksp, "availrmem");
mem_kern = 0;
mem_unus = 0;
if ((mem_used < 0LL) || (mem_free < 0LL) || (mem_lock < 0LL)) {
WARNING("memory plugin: one of used, free or locked is negative.");
return -1;
}
mem_unus = physmem - mem_used;
if (mem_used < (mem_free + mem_lock)) {
/* source: http://wesunsolve.net/bugid/id/4909199
* this seems to happen when swap space is small, e.g. 2G on a 32G system
* we will make some assumptions here
* educated solaris internals help welcome here */
DEBUG("memory plugin: pages total is smaller than \"free\" "
"+ \"locked\". This is probably due to small "
"swap space");
mem_free = availrmem;
mem_used = 0;
} else {
mem_used -= mem_free + mem_lock;
}
/* mem_kern is accounted for in mem_lock */
if (pp_kernel < mem_lock) {
mem_kern = pp_kernel;
mem_lock -= pp_kernel;
} else {
mem_kern = mem_lock;
mem_lock = 0;
}
mem_used *= pagesize; /* If this overflows you have some serious */
mem_free *= pagesize; /* memory.. Why not call me up and give me */
mem_lock *= pagesize; /* some? ;) */
mem_kern *= pagesize; /* it's 2011 RAM is cheap */
mem_unus *= pagesize;
mem_kern -= arcsize;
MEMORY_SUBMIT("used", (gauge_t)mem_used, "free", (gauge_t)mem_free, "locked",
(gauge_t)mem_lock, "kernel", (gauge_t)mem_kern, "arc",
(gauge_t)arcsize, "unusable", (gauge_t)mem_unus);
/* #endif HAVE_LIBKSTAT */
#elif HAVE_SYSCTL
int mib[] = {CTL_VM, VM_METER};
struct vmtotal vmtotal = {0};
gauge_t mem_active;
gauge_t mem_inactive;
gauge_t mem_free;
size_t size;
size = sizeof(vmtotal);
if (sysctl(mib, 2, &vmtotal, &size, NULL, 0) < 0) {
WARNING("memory plugin: sysctl failed: %s", STRERRNO);
return -1;
}
assert(pagesize > 0);
mem_active = (gauge_t)(vmtotal.t_arm * pagesize);
mem_inactive = (gauge_t)((vmtotal.t_rm - vmtotal.t_arm) * pagesize);
mem_free = (gauge_t)(vmtotal.t_free * pagesize);
MEMORY_SUBMIT("active", mem_active, "inactive", mem_inactive, "free",
mem_free);
/* #endif HAVE_SYSCTL */
#elif HAVE_LIBSTATGRAB
sg_mem_stats *ios;
ios = sg_get_mem_stats();
if (ios == NULL)
return -1;
MEMORY_SUBMIT("used", (gauge_t)ios->used, "cached", (gauge_t)ios->cache,
"free", (gauge_t)ios->free);
/* #endif HAVE_LIBSTATGRAB */
#elif HAVE_PERFSTAT
perfstat_memory_total_t pmemory = {0};
if (perfstat_memory_total(NULL, &pmemory, sizeof(pmemory), 1) < 0) {
WARNING("memory plugin: perfstat_memory_total failed: %s", STRERRNO);
return -1;
}
/* Unfortunately, the AIX documentation is not very clear on how these
* numbers relate to one another. The only thing is states explcitly
* is:
* real_total = real_process + real_free + numperm + real_system
*
* Another segmentation, which would be closer to the numbers reported
* by the "svmon" utility, would be:
* real_total = real_free + real_inuse
* real_inuse = "active" + real_pinned + numperm
*/
MEMORY_SUBMIT("free", (gauge_t)(pmemory.real_free * pagesize), "cached",
(gauge_t)(pmemory.numperm * pagesize), "system",
(gauge_t)(pmemory.real_system * pagesize), "user",
(gauge_t)(pmemory.real_process * pagesize));
#endif /* HAVE_PERFSTAT */
return 0;
} /* }}} int memory_read_internal */
static void nfs2_read_kstat (kstat_t *ksp, char *inst)
{
unsigned long long values[18];
values[0] = get_kstat_value (ksp, "null");
values[1] = get_kstat_value (ksp, "getattr");
values[2] = get_kstat_value (ksp, "setattr");
values[3] = get_kstat_value (ksp, "root");
values[4] = get_kstat_value (ksp, "lookup");
values[5] = get_kstat_value (ksp, "readlink");
values[6] = get_kstat_value (ksp, "read");
values[7] = get_kstat_value (ksp, "wrcache");
values[8] = get_kstat_value (ksp, "write");
values[9] = get_kstat_value (ksp, "create");
values[10] = get_kstat_value (ksp, "remove");
values[11] = get_kstat_value (ksp, "rename");
values[12] = get_kstat_value (ksp, "link");
values[13] = get_kstat_value (ksp, "symlink");
values[14] = get_kstat_value (ksp, "mkdir");
values[15] = get_kstat_value (ksp, "rmdir");
values[16] = get_kstat_value (ksp, "readdir");
values[17] = get_kstat_value (ksp, "statfs");
nfs2_procedures_submit (values, inst);
}
static int za_read (void)
{
gauge_t arcsize, targetsize, minlimit, maxlimit, hits, misses, l2_size, l2_hits, l2_misses;
counter_t demand_data_hits, demand_metadata_hits, prefetch_data_hits, prefetch_metadata_hits;
counter_t demand_data_misses, demand_metadata_misses, prefetch_data_misses, prefetch_metadata_misses;
counter_t l2_read_bytes, l2_write_bytes;
get_kstat (&ksp, "zfs", 0, "arcstats");
if (ksp == NULL)
{
ERROR ("zfs_arc plugin: Cannot find zfs:0:arcstats kstat.");
return (-1);
}
arcsize = get_kstat_value(ksp, "size");
targetsize = get_kstat_value(ksp, "c");
minlimit = get_kstat_value(ksp, "c_min");
maxlimit = get_kstat_value(ksp, "c_max");
demand_data_hits = get_kstat_value(ksp, "demand_data_hits");
demand_metadata_hits = get_kstat_value(ksp, "demand_metadata_hits");
prefetch_data_hits = get_kstat_value(ksp, "prefetch_data_hits");
prefetch_metadata_hits = get_kstat_value(ksp, "prefetch_metadata_hits");
demand_data_misses = get_kstat_value(ksp, "demand_data_misses");
demand_metadata_misses = get_kstat_value(ksp, "demand_metadata_misses");
prefetch_data_misses = get_kstat_value(ksp, "prefetch_data_misses");
prefetch_metadata_misses = get_kstat_value(ksp, "prefetch_metadata_misses");
hits = get_kstat_value(ksp, "hits");
misses = get_kstat_value(ksp, "misses");
l2_size = get_kstat_value(ksp, "l2_size");
l2_read_bytes = get_kstat_value(ksp, "l2_read_bytes");
l2_write_bytes = get_kstat_value(ksp, "l2_write_bytes");
l2_hits = get_kstat_value(ksp, "l2_hits");
l2_misses = get_kstat_value(ksp, "l2_misses");
za_submit_size (arcsize, targetsize, minlimit, maxlimit);
za_submit_gauge ("arc_l2_size", "", l2_size);
za_submit_counts ("hits", demand_data_hits, demand_metadata_hits,
prefetch_data_hits, prefetch_metadata_hits);
za_submit_counts ("misses", demand_data_misses, demand_metadata_misses,
prefetch_data_misses, prefetch_metadata_misses);
za_submit_gauge ("arc_ratio", "L1", hits / (hits + misses));
za_submit_gauge ("arc_ratio", "L2", l2_hits / (l2_hits + l2_misses));
za_submit_bytes (l2_read_bytes, l2_write_bytes);
return (0);
}
static int interface_read (void)
{
#if HAVE_GETIFADDRS
struct ifaddrs *if_list;
struct ifaddrs *if_ptr;
/* Darin/Mac OS X and possible other *BSDs */
#if HAVE_STRUCT_IF_DATA
# define IFA_DATA if_data
# define IFA_RX_BYTES ifi_ibytes
# define IFA_TX_BYTES ifi_obytes
# define IFA_RX_PACKT ifi_ipackets
# define IFA_TX_PACKT ifi_opackets
# define IFA_RX_ERROR ifi_ierrors
# define IFA_TX_ERROR ifi_oerrors
/* #endif HAVE_STRUCT_IF_DATA */
#elif HAVE_STRUCT_NET_DEVICE_STATS
# define IFA_DATA net_device_stats
# define IFA_RX_BYTES rx_bytes
# define IFA_TX_BYTES tx_bytes
# define IFA_RX_PACKT rx_packets
# define IFA_TX_PACKT tx_packets
# define IFA_RX_ERROR rx_errors
# define IFA_TX_ERROR tx_errors
#else
# error "No suitable type for `struct ifaddrs->ifa_data' found."
#endif
struct IFA_DATA *if_data;
if (getifaddrs (&if_list) != 0)
return (-1);
for (if_ptr = if_list; if_ptr != NULL; if_ptr = if_ptr->ifa_next)
{
if ((if_data = (struct IFA_DATA *) if_ptr->ifa_data) == NULL)
continue;
if_submit (if_ptr->ifa_name, "if_octets",
if_data->IFA_RX_BYTES,
if_data->IFA_TX_BYTES);
if_submit (if_ptr->ifa_name, "if_packets",
if_data->IFA_RX_PACKT,
if_data->IFA_TX_PACKT);
if_submit (if_ptr->ifa_name, "if_errors",
if_data->IFA_RX_ERROR,
if_data->IFA_TX_ERROR);
}
freeifaddrs (if_list);
/* #endif HAVE_GETIFADDRS */
#elif KERNEL_LINUX
FILE *fh;
char buffer[1024];
unsigned long long incoming, outgoing;
char *device;
char *dummy;
char *fields[16];
int numfields;
if ((fh = fopen ("/proc/net/dev", "r")) == NULL)
{
char errbuf[1024];
WARNING ("interface plugin: fopen: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
while (fgets (buffer, 1024, fh) != NULL)
{
if (!(dummy = strchr(buffer, ':')))
continue;
dummy[0] = '\0';
dummy++;
device = buffer;
while (device[0] == ' ')
device++;
if (device[0] == '\0')
continue;
numfields = strsplit (dummy, fields, 16);
if (numfields < 11)
continue;
incoming = atoll (fields[0]);
outgoing = atoll (fields[8]);
if_submit (device, "if_octets", incoming, outgoing);
incoming = atoll (fields[1]);
outgoing = atoll (fields[9]);
if_submit (device, "if_packets", incoming, outgoing);
incoming = atoll (fields[2]);
outgoing = atoll (fields[10]);
if_submit (device, "if_errors", incoming, outgoing);
}
fclose (fh);
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
int i;
unsigned long long rx;
unsigned long long tx;
if (kc == NULL)
return (-1);
for (i = 0; i < numif; i++)
{
if (kstat_read (kc, ksp[i], NULL) == -1)
continue;
rx = get_kstat_value (ksp[i], "rbytes");
tx = get_kstat_value (ksp[i], "obytes");
if ((rx != -1LL) || (tx != -1LL))
if_submit (ksp[i]->ks_name, "if_octets", rx, tx);
rx = get_kstat_value (ksp[i], "ipackets");
tx = get_kstat_value (ksp[i], "opackets");
if ((rx != -1LL) || (tx != -1LL))
if_submit (ksp[i]->ks_name, "if_packets", rx, tx);
rx = get_kstat_value (ksp[i], "ierrors");
tx = get_kstat_value (ksp[i], "oerrors");
if ((rx != -1LL) || (tx != -1LL))
if_submit (ksp[i]->ks_name, "if_errors", rx, tx);
}
/* #endif HAVE_LIBKSTAT */
#elif defined(HAVE_LIBSTATGRAB)
sg_network_io_stats *ios;
int i, num;
ios = sg_get_network_io_stats (&num);
for (i = 0; i < num; i++)
if_submit (ios[i].interface_name, "if_octets", ios[i].rx, ios[i].tx);
#endif /* HAVE_LIBSTATGRAB */
return (0);
} /* int interface_read */
static int memory_read (void)
{
#if HAVE_HOST_STATISTICS
kern_return_t status;
vm_statistics_data_t vm_data;
mach_msg_type_number_t vm_data_len;
gauge_t wired;
gauge_t active;
gauge_t inactive;
gauge_t free;
if (!port_host || !pagesize)
return (-1);
vm_data_len = sizeof (vm_data) / sizeof (natural_t);
if ((status = host_statistics (port_host, HOST_VM_INFO,
(host_info_t) &vm_data,
&vm_data_len)) != KERN_SUCCESS)
{
ERROR ("memory-plugin: host_statistics failed and returned the value %i", (int) status);
return (-1);
}
/*
* From <http://docs.info.apple.com/article.html?artnum=107918>:
*
* Wired memory
* This information can't be cached to disk, so it must stay in RAM.
* The amount depends on what applications you are using.
*
* Active memory
* This information is currently in RAM and actively being used.
*
* Inactive memory
* This information is no longer being used and has been cached to
* disk, but it will remain in RAM until another application needs
* the space. Leaving this information in RAM is to your advantage if
* you (or a client of your computer) come back to it later.
*
* Free memory
* This memory is not being used.
*/
wired = (gauge_t) (((uint64_t) vm_data.wire_count) * ((uint64_t) pagesize));
active = (gauge_t) (((uint64_t) vm_data.active_count) * ((uint64_t) pagesize));
inactive = (gauge_t) (((uint64_t) vm_data.inactive_count) * ((uint64_t) pagesize));
free = (gauge_t) (((uint64_t) vm_data.free_count) * ((uint64_t) pagesize));
memory_submit ("wired", wired);
memory_submit ("active", active);
memory_submit ("inactive", inactive);
memory_submit ("free", free);
/* #endif HAVE_HOST_STATISTICS */
#elif HAVE_SYSCTLBYNAME
/*
* vm.stats.vm.v_page_size: 4096
* vm.stats.vm.v_page_count: 246178
* vm.stats.vm.v_free_count: 28760
* vm.stats.vm.v_wire_count: 37526
* vm.stats.vm.v_active_count: 55239
* vm.stats.vm.v_inactive_count: 113730
* vm.stats.vm.v_cache_count: 10809
*/
char *sysctl_keys[8] =
{
"vm.stats.vm.v_page_size",
"vm.stats.vm.v_page_count",
"vm.stats.vm.v_free_count",
"vm.stats.vm.v_wire_count",
"vm.stats.vm.v_active_count",
"vm.stats.vm.v_inactive_count",
"vm.stats.vm.v_cache_count",
NULL
};
double sysctl_vals[8];
int i;
for (i = 0; sysctl_keys[i] != NULL; i++)
{
int value;
size_t value_len = sizeof (value);
if (sysctlbyname (sysctl_keys[i], (void *) &value, &value_len,
NULL, 0) == 0)
{
sysctl_vals[i] = value;
DEBUG ("memory plugin: %26s: %g", sysctl_keys[i], sysctl_vals[i]);
}
else
{
sysctl_vals[i] = NAN;
}
} /* for (sysctl_keys) */
/* multiply all all page counts with the pagesize */
for (i = 1; sysctl_keys[i] != NULL; i++)
if (!isnan (sysctl_vals[i]))
sysctl_vals[i] *= sysctl_vals[0];
memory_submit ("free", sysctl_vals[2]);
memory_submit ("wired", sysctl_vals[3]);
memory_submit ("active", sysctl_vals[4]);
memory_submit ("inactive", sysctl_vals[5]);
memory_submit ("cache", sysctl_vals[6]);
/* #endif HAVE_SYSCTLBYNAME */
#elif KERNEL_LINUX
FILE *fh;
char buffer[1024];
char *fields[8];
int numfields;
long long mem_used = 0;
long long mem_buffered = 0;
long long mem_cached = 0;
long long mem_free = 0;
if ((fh = fopen ("/proc/meminfo", "r")) == NULL)
{
char errbuf[1024];
WARNING ("memory: fopen: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
while (fgets (buffer, 1024, fh) != NULL)
{
long long *val = NULL;
if (strncasecmp (buffer, "MemTotal:", 9) == 0)
val = &mem_used;
else if (strncasecmp (buffer, "MemFree:", 8) == 0)
val = &mem_free;
else if (strncasecmp (buffer, "Buffers:", 8) == 0)
val = &mem_buffered;
else if (strncasecmp (buffer, "Cached:", 7) == 0)
val = &mem_cached;
else
continue;
numfields = strsplit (buffer, fields, 8);
if (numfields < 2)
continue;
*val = atoll (fields[1]) * 1024LL;
}
if (fclose (fh))
{
char errbuf[1024];
WARNING ("memory: fclose: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
}
if (mem_used >= (mem_free + mem_buffered + mem_cached))
{
mem_used -= mem_free + mem_buffered + mem_cached;
memory_submit ("used", mem_used);
memory_submit ("buffered", mem_buffered);
memory_submit ("cached", mem_cached);
memory_submit ("free", mem_free);
}
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
/* Most of the additions here were taken as-is from the k9toolkit from
* Brendan Gregg and are subject to change I guess */
long long mem_used;
long long mem_free;
long long mem_lock;
long long mem_kern;
long long mem_unus;
long long pp_kernel;
long long physmem;
long long availrmem;
if (ksp == NULL)
return (-1);
mem_used = get_kstat_value (ksp, "pagestotal");
mem_free = get_kstat_value (ksp, "pagesfree");
mem_lock = get_kstat_value (ksp, "pageslocked");
mem_kern = 0;
mem_unus = 0;
pp_kernel = get_kstat_value (ksp, "pp_kernel");
physmem = get_kstat_value (ksp, "physmem");
availrmem = get_kstat_value (ksp, "availrmem");
if ((mem_used < 0LL) || (mem_free < 0LL) || (mem_lock < 0LL))
{
WARNING ("memory plugin: one of used, free or locked is negative.");
return (-1);
}
mem_unus = physmem - mem_used;
if (mem_used < (mem_free + mem_lock))
{
/* source: http://wesunsolve.net/bugid/id/4909199
* this seems to happen when swap space is small, e.g. 2G on a 32G system
* we will make some assumptions here
* educated solaris internals help welcome here */
DEBUG ("memory plugin: pages total is smaller than \"free\" "
"+ \"locked\". This is probably due to small "
"swap space");
mem_free = availrmem;
mem_used = 0;
}
else
{
mem_used -= mem_free + mem_lock;
}
/* mem_kern is accounted for in mem_lock */
if ( pp_kernel < mem_lock )
{
mem_kern = pp_kernel;
mem_lock -= pp_kernel;
}
else
{
mem_kern = mem_lock;
mem_lock = 0;
}
mem_used *= pagesize; /* If this overflows you have some serious */
mem_free *= pagesize; /* memory.. Why not call me up and give me */
mem_lock *= pagesize; /* some? ;) */
mem_kern *= pagesize; /* it's 2011 RAM is cheap */
mem_unus *= pagesize;
memory_submit ("used", mem_used);
memory_submit ("free", mem_free);
memory_submit ("locked", mem_lock);
memory_submit ("kernel", mem_kern);
memory_submit ("unusable", mem_unus);
/* #endif HAVE_LIBKSTAT */
#elif HAVE_SYSCTL
int mib[] = {CTL_VM, VM_METER};
struct vmtotal vmtotal;
size_t size;
memset (&vmtotal, 0, sizeof (vmtotal));
size = sizeof (vmtotal);
if (sysctl (mib, 2, &vmtotal, &size, NULL, 0) < 0) {
char errbuf[1024];
WARNING ("memory plugin: sysctl failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
assert (pagesize > 0);
memory_submit ("active", vmtotal.t_arm * pagesize);
memory_submit ("inactive", (vmtotal.t_rm - vmtotal.t_arm) * pagesize);
memory_submit ("free", vmtotal.t_free * pagesize);
/* #endif HAVE_SYSCTL */
#elif HAVE_LIBSTATGRAB
sg_mem_stats *ios;
if ((ios = sg_get_mem_stats ()) != NULL)
{
memory_submit ("used", ios->used);
memory_submit ("cached", ios->cache);
memory_submit ("free", ios->free);
}
/* #endif HAVE_LIBSTATGRAB */
#elif HAVE_PERFSTAT
if (perfstat_memory_total(NULL, &pmemory, sizeof(perfstat_memory_total_t), 1) < 0)
{
char errbuf[1024];
WARNING ("memory plugin: perfstat_memory_total failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
memory_submit ("used", pmemory.real_inuse * pagesize);
memory_submit ("free", pmemory.real_free * pagesize);
memory_submit ("cached", pmemory.numperm * pagesize);
memory_submit ("system", pmemory.real_system * pagesize);
memory_submit ("user", pmemory.real_process * pagesize);
#endif /* HAVE_PERFSTAT */
return (0);
}
