int get_stats(void)
{
st.cpu = sg_get_cpu_percents();
if (!st.cpu) { LOG(LOG_INFO, "could not sg_get_cpu_stats"); }
st.mem = sg_get_mem_stats();
if (!st.mem) { LOG(LOG_INFO, "could not sg_get_mem_stats"); }
st.swap = sg_get_swap_stats();
if (!st.swap) { LOG(LOG_INFO, "could not get_swap_stats"); }
st.load = sg_get_load_stats();
if (!st.load) { LOG(LOG_INFO, "could not get_load_stats"); }
st.process = sg_get_process_stats(&st.process_entries);
if (!st.process) { LOG(LOG_INFO, "could not get_process_stats"); }
st.paging = sg_get_page_stats_diff();
if (!st.paging) { LOG(LOG_INFO, "could not get_page_stats_diff"); }
st.network = sg_get_network_io_stats_diff(&(st.network_entries));
if (!st.network) { LOG(LOG_INFO, "could not get_network_stats_diff"); }
st.diskio = sg_get_disk_io_stats_diff(&(st.diskio_entries));
if (!st.diskio) { LOG(LOG_INFO, "could not get_diskio_stats_diff"); }
st.disk = sg_get_fs_stats(&(st.disk_entries));
if (!st.disk) { LOG(LOG_INFO, "could not get_disk_stats"); }
st.hostinfo = sg_get_host_info();
if (!st.hostinfo) { LOG(LOG_INFO, "could not get_host_info"); }
st.user = sg_get_user_stats();
if (!st.user) { LOG(LOG_INFO, "could not get get_user_stats"); }
return 1;
}
void populate_swap() {
sg_swap_stats *swap = sg_get_swap_stats();
if (swap != NULL) {
add_stat(BYTES, &swap->total, "swap", "total", NULL);
add_stat(BYTES, &swap->used, "swap", "used", NULL);
add_stat(BYTES, &swap->free, "swap", "free", NULL);
}
}
static void
populate_swap(void) {
sg_swap_stats *swap = sg_get_swap_stats(NULL);
if (swap != NULL) {
add_stat(STAT_TYPE_BYTES, &swap->total, "swap", "total", NULL);
add_stat(STAT_TYPE_BYTES, &swap->used, "swap", "used", NULL);
add_stat(STAT_TYPE_BYTES, &swap->free, "swap", "free", NULL);
}
}
static int swap_read (void) /* {{{ */
{
sg_swap_stats *swap;
swap = sg_get_swap_stats ();
if (swap == NULL)
return (-1);
swap_submit_gauge (NULL, "used", (gauge_t) swap->used);
swap_submit_gauge (NULL, "free", (gauge_t) swap->free);
return (0);
} /* }}} int swap_read */
int get_stats() {
stats.cpu_percents = sg_get_cpu_percents();
stats.mem_stats = sg_get_mem_stats();
stats.swap_stats = sg_get_swap_stats();
stats.load_stats = sg_get_load_stats();
stats.process_count = sg_get_process_count();
stats.page_stats = sg_get_page_stats_diff();
stats.network_io_stats = sg_get_network_io_stats_diff(&(stats.network_io_entries));
stats.disk_io_stats = sg_get_disk_io_stats_diff(&(stats.disk_io_entries));
stats.fs_stats = sg_get_fs_stats(&(stats.fs_entries));
stats.host_info = sg_get_host_info();
stats.user_stats = sg_get_user_stats();
return 1;
}
/*
* Swap statistics, see <tt>sg_get_swap_stats(3)</tt> manpage.
*/
static VALUE
statgrab_swap_stats(VALUE self)
{
sg_swap_stats *stats;
VALUE info;
if ((stats = sg_get_swap_stats()) == NULL)
statgrab_handle_error();
info = rb_hash_new();
rb_hash_aset(info, ID2SYM(rb_intern("total")),
INT2NUM(stats->total/1024));
rb_hash_aset(info, ID2SYM(rb_intern("used")),
INT2NUM(stats->used/1024));
rb_hash_aset(info, ID2SYM(rb_intern("free")),
INT2NUM(stats->free/1024));
return info;
}
int main(int argc, char **argv){
sg_mem_stats *mem_stats;
sg_swap_stats *swap_stats;
long long total, free;
/* Initialise helper - e.g. logging, if any */
sg_log_init("libstatgrab-examples", "SGEXAMPLES_LOG_PROPERTIES", argc ? argv[0] : NULL);
/* Initialise statgrab */
sg_init(1);
/* Drop setuid/setgid privileges. */
if (sg_drop_privileges() != SG_ERROR_NONE)
sg_die("Error. Failed to drop privileges", 1);
if( ((mem_stats = sg_get_mem_stats(NULL)) != NULL) &&
((swap_stats = sg_get_swap_stats(NULL)) != NULL) ) {
printf("Total memory in bytes : %llu\n", mem_stats->total);
printf("Used memory in bytes : %llu\n", mem_stats->used);
printf("Cache memory in bytes : %llu\n", mem_stats->cache);
printf("Free memory in bytes : %llu\n", mem_stats->free);
printf("Swap total in bytes : %llu\n", swap_stats->total);
printf("Swap used in bytes : %llu\n", swap_stats->used);
printf("Swap free in bytes : %llu\n", swap_stats->free);
total = mem_stats->total + swap_stats->total;
free = mem_stats->free + swap_stats->free;
printf("Total VM usage : %5.2f%%\n", 100 - (((float)total/(float)free)));
}
else {
sg_die("Unable to get VM stats", 1);
}
exit(0);
}
static int swap_read (void)
{
#if KERNEL_LINUX
FILE *fh;
char buffer[1024];
char *fields[8];
int numfields;
unsigned long long swap_used = 0LL;
unsigned long long swap_cached = 0LL;
unsigned long long swap_free = 0LL;
unsigned long long swap_total = 0LL;
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)
{
unsigned long long *val = NULL;
if (strncasecmp (buffer, "SwapTotal:", 10) == 0)
val = &swap_total;
else if (strncasecmp (buffer, "SwapFree:", 9) == 0)
val = &swap_free;
else if (strncasecmp (buffer, "SwapCached:", 11) == 0)
val = &swap_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 ((swap_total == 0LL) || ((swap_free + swap_cached) > swap_total))
return (-1);
swap_used = swap_total - (swap_free + swap_cached);
swap_submit ("used", swap_used);
swap_submit ("free", swap_free);
swap_submit ("cached", swap_cached);
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
unsigned long long swap_alloc;
unsigned long long swap_resv;
unsigned long long swap_avail;
struct anoninfo ai;
if (swapctl (SC_AINFO, &ai) == -1)
{
char errbuf[1024];
ERROR ("swap plugin: swapctl failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
/*
* Calculations from:
* http://cvs.opensolaris.org/source/xref/on/usr/src/cmd/swap/swap.c
* Also see:
* http://www.itworld.com/Comp/2377/UIR980701perf/ (outdated?)
* /usr/include/vm/anon.h
*
* In short, swap -s shows: allocated + reserved = used, available
*
* However, Solaris does not allow to allocated/reserved more than the
* available swap (physical memory + disk swap), so the pedant may
* prefer: allocated + unallocated = reserved, available
*
* We map the above to: used + resv = n/a, free
*
* Does your brain hurt yet? - Christophe Kalt
*
* Oh, and in case you wonder,
* swap_alloc = pagesize * ( ai.ani_max - ai.ani_free );
* can suffer from a 32bit overflow.
*/
swap_alloc = ai.ani_max - ai.ani_free;
swap_alloc *= pagesize;
swap_resv = ai.ani_resv + ai.ani_free - ai.ani_max;
swap_resv *= pagesize;
swap_avail = ai.ani_max - ai.ani_resv;
swap_avail *= pagesize;
swap_submit ("used", swap_alloc);
swap_submit ("free", swap_avail);
swap_submit ("reserved", swap_resv);
/* #endif HAVE_LIBKSTAT */
#elif defined(VM_SWAPUSAGE)
int mib[3];
size_t mib_len;
struct xsw_usage sw_usage;
size_t sw_usage_len;
mib_len = 2;
mib[0] = CTL_VM;
mib[1] = VM_SWAPUSAGE;
sw_usage_len = sizeof (struct xsw_usage);
if (sysctl (mib, mib_len, &sw_usage, &sw_usage_len, NULL, 0) != 0)
return (-1);
/* The returned values are bytes. */
swap_submit ("used", sw_usage.xsu_used);
swap_submit ("free", sw_usage.xsu_avail);
/* #endif VM_SWAPUSAGE */
#elif HAVE_LIBKVM_GETSWAPINFO
struct kvm_swap data_s;
int status;
unsigned long long used;
unsigned long long free;
unsigned long long total;
if (kvm_obj == NULL)
return (-1);
/* only one structure => only get the grand total, no details */
status = kvm_getswapinfo (kvm_obj, &data_s, 1, 0);
if (status == -1)
return (-1);
total = (unsigned long long) data_s.ksw_total;
used = (unsigned long long) data_s.ksw_used;
total *= (unsigned long long) kvm_pagesize;
used *= (unsigned long long) kvm_pagesize;
free = total - used;
swap_submit ("used", used);
swap_submit ("free", free);
/* #endif HAVE_LIBKVM_GETSWAPINFO */
#elif HAVE_LIBSTATGRAB
sg_swap_stats *swap;
swap = sg_get_swap_stats ();
if (swap == NULL)
return (-1);
swap_submit ("used", swap->used);
swap_submit ("free", swap->free);
#endif /* HAVE_LIBSTATGRAB */
return (0);
} /* int swap_read */
static int swap_read (void)
{
#if KERNEL_LINUX
FILE *fh;
char buffer[1024];
char *fields[8];
int numfields;
_Bool old_kernel=0;
derive_t swap_used = 0;
derive_t swap_cached = 0;
derive_t swap_free = 0;
derive_t swap_total = 0;
derive_t swap_in = 0;
derive_t swap_out = 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, sizeof (buffer), fh) != NULL)
{
numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields));
if (numfields < 2)
continue;
if (strcasecmp (fields[0], "SwapTotal:") == 0)
strtoderive (fields[1], &swap_total);
else if (strcasecmp (fields[0], "SwapFree:") == 0)
strtoderive (fields[1], &swap_free);
else if (strcasecmp (fields[0], "SwapCached:") == 0)
strtoderive (fields[1], &swap_cached);
}
if (fclose (fh))
{
char errbuf[1024];
WARNING ("memory: fclose: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
}
if ((swap_total == 0LL) || ((swap_free + swap_cached) > swap_total))
return (-1);
swap_used = swap_total - (swap_free + swap_cached);
if ((fh = fopen ("/proc/vmstat", "r")) == NULL)
{
// /proc/vmstat does not exist in kernels <2.6
if ((fh = fopen ("/proc/stat", "r")) == NULL )
{
char errbuf[1024];
WARNING ("swap: fopen: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
else
old_kernel = 1;
}
while (fgets (buffer, sizeof (buffer), fh) != NULL)
{
numfields = strsplit (buffer, fields, STATIC_ARRAY_SIZE (fields));
if (!old_kernel)
{
if (numfields != 2)
continue;
if (strcasecmp ("pswpin", fields[0]) != 0)
strtoderive (fields[1], &swap_in);
else if (strcasecmp ("pswpout", fields[0]) == 0)
strtoderive (fields[1], &swap_out);
}
else /* if (old_kernel) */
{
if (numfields != 3)
continue;
if (strcasecmp ("page", fields[0]) == 0)
{
strtoderive (fields[1], &swap_in);
strtoderive (fields[2], &swap_out);
}
}
} /* while (fgets) */
if (fclose (fh))
{
char errbuf[1024];
WARNING ("swap: fclose: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
}
swap_submit ("used", 1024 * swap_used, DS_TYPE_GAUGE);
swap_submit ("free", 1024 * swap_free, DS_TYPE_GAUGE);
swap_submit ("cached", 1024 * swap_cached, DS_TYPE_GAUGE);
swap_submit ("in", swap_in, DS_TYPE_DERIVE);
swap_submit ("out", swap_out, DS_TYPE_DERIVE);
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
derive_t swap_alloc;
derive_t swap_resv;
derive_t swap_avail;
struct anoninfo ai;
if (swapctl (SC_AINFO, &ai) == -1)
{
char errbuf[1024];
ERROR ("swap plugin: swapctl failed: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
/*
* Calculations from:
* http://cvs.opensolaris.org/source/xref/on/usr/src/cmd/swap/swap.c
* Also see:
* http://www.itworld.com/Comp/2377/UIR980701perf/ (outdated?)
* /usr/include/vm/anon.h
*
* In short, swap -s shows: allocated + reserved = used, available
*
* However, Solaris does not allow to allocated/reserved more than the
* available swap (physical memory + disk swap), so the pedant may
* prefer: allocated + unallocated = reserved, available
*
* We map the above to: used + resv = n/a, free
*
* Does your brain hurt yet? - Christophe Kalt
*
* Oh, and in case you wonder,
* swap_alloc = pagesize * ( ai.ani_max - ai.ani_free );
* can suffer from a 32bit overflow.
*/
swap_alloc = (derive_t) ((ai.ani_max - ai.ani_free) * pagesize);
swap_resv = (derive_t) ((ai.ani_resv + ai.ani_free - ai.ani_max)
* pagesize);
swap_avail = (derive_t) ((ai.ani_max - ai.ani_resv) * pagesize);
swap_submit ("used", swap_alloc, DS_TYPE_GAUGE);
swap_submit ("free", swap_avail, DS_TYPE_GAUGE);
swap_submit ("reserved", swap_resv, DS_TYPE_GAUGE);
/* #endif HAVE_LIBKSTAT */
#elif HAVE_SWAPCTL
struct swapent *swap_entries;
int swap_num;
int status;
int i;
derive_t used = 0;
derive_t total = 0;
/*
* XXX: This is the syntax for the *BSD `swapctl', which has the
* following prototype:
* swapctl (int cmd, void *arg, int misc);
*
* HP-UX and Solaris (and possibly other UNIXes) provide `swapctl',
* too, but with the following prototype:
* swapctl (int cmd, void *arg);
*
* Solaris is usually handled in the KSTAT case above. For other UNIXes
* a separate case for the other version of `swapctl' may be necessary.
*/
swap_num = swapctl (SWAP_NSWAP, NULL, 0);
if (swap_num < 0)
{
ERROR ("swap plugin: swapctl (SWAP_NSWAP) failed with status %i.",
swap_num);
return (-1);
}
else if (swap_num == 0)
return (0);
swap_entries = calloc (swap_num, sizeof (*swap_entries));
if (swap_entries == NULL)
{
ERROR ("swap plugin: calloc failed.");
return (-1);
}
status = swapctl (SWAP_STATS, swap_entries, swap_num);
if (status != swap_num)
{
ERROR ("swap plugin: swapctl (SWAP_STATS) failed with status %i.",
status);
sfree (swap_entries);
return (-1);
}
#if defined(DEV_BSIZE) && (DEV_BSIZE > 0)
# define C_SWAP_BLOCK_SIZE ((derive_t) DEV_BSIZE)
#else
# define C_SWAP_BLOCK_SIZE ((derive_t) 512)
#endif
for (i = 0; i < swap_num; i++)
{
if ((swap_entries[i].se_flags & SWF_ENABLE) == 0)
continue;
used += ((derive_t) swap_entries[i].se_inuse)
* C_SWAP_BLOCK_SIZE;
total += ((derive_t) swap_entries[i].se_nblks)
* C_SWAP_BLOCK_SIZE;
}
if (total < used)
{
ERROR ("swap plugin: Total swap space (%"PRIu64") "
"is less than used swap space (%"PRIu64").",
total, used);
return (-1);
}
swap_submit ("used", used, DS_TYPE_GAUGE);
swap_submit ("free", total - used, DS_TYPE_GAUGE);
sfree (swap_entries);
/* #endif HAVE_SWAPCTL */
#elif defined(VM_SWAPUSAGE)
int mib[3];
size_t mib_len;
struct xsw_usage sw_usage;
size_t sw_usage_len;
mib_len = 2;
mib[0] = CTL_VM;
mib[1] = VM_SWAPUSAGE;
sw_usage_len = sizeof (struct xsw_usage);
if (sysctl (mib, mib_len, &sw_usage, &sw_usage_len, NULL, 0) != 0)
return (-1);
/* The returned values are bytes. */
swap_submit ("used", (derive_t) sw_usage.xsu_used, DS_TYPE_GAUGE);
swap_submit ("free", (derive_t) sw_usage.xsu_avail, DS_TYPE_GAUGE);
/* #endif VM_SWAPUSAGE */
#elif HAVE_LIBKVM_GETSWAPINFO
struct kvm_swap data_s;
int status;
derive_t used;
derive_t free;
derive_t total;
if (kvm_obj == NULL)
return (-1);
/* only one structure => only get the grand total, no details */
status = kvm_getswapinfo (kvm_obj, &data_s, 1, 0);
if (status == -1)
return (-1);
total = (derive_t) data_s.ksw_total;
used = (derive_t) data_s.ksw_used;
total *= (derive_t) kvm_pagesize;
used *= (derive_t) kvm_pagesize;
free = total - used;
swap_submit ("used", used, DS_TYPE_GAUGE);
swap_submit ("free", free, DS_TYPE_GAUGE);
/* #endif HAVE_LIBKVM_GETSWAPINFO */
#elif HAVE_LIBSTATGRAB
sg_swap_stats *swap;
swap = sg_get_swap_stats ();
if (swap == NULL)
return (-1);
swap_submit ("used", (derive_t) swap->used, DS_TYPE_GAUGE);
swap_submit ("free", (derive_t) swap->free, DS_TYPE_GAUGE);
/* #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);
}
swap_submit ("used", (derive_t) (pmemory.pgsp_total - pmemory.pgsp_free) * pagesize, DS_TYPE_GAUGE);
swap_submit ("free", (derive_t) pmemory.pgsp_free * pagesize , DS_TYPE_GAUGE);
#endif /* HAVE_PERFSTAT */
return (0);
} /* int swap_read */