#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-features.h>
#if HAVE_LIMITS_H
#include <limits.h>
#endif
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_FCNTL_H
#include <fcntl.h>
#endif
#include <ctype.h>
#include <signal.h>
#if HAVE_MACHINE_PARAM_H
#include <machine/param.h>
#endif
#if HAVE_SYS_VMMETER_H
#if !defined(bsdi2) && !defined(netbsd1)
#include <sys/vmmeter.h>
#endif
#endif
#if HAVE_SYS_CONF_H
#include <sys/conf.h>
#endif
#if HAVE_SYS_FS_H
#include <sys/fs.h>
#else
#if HAVE_UFS_FS_H
#include <ufs/fs.h>
#else
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_SYS_VNODE_H
#include <sys/vnode.h>
#endif
#ifdef HAVE_UFS_UFS_QUOTA_H
#include <ufs/ufs/quota.h>
#endif
#ifdef HAVE_UFS_UFS_INODE_H
#include <ufs/ufs/inode.h>
#endif
#if HAVE_UFS_FFS_FS_H
#include <ufs/ffs/fs.h>
#endif
#endif
#endif
#if HAVE_MTAB_H
#include <mtab.h>
#endif
#include <sys/stat.h>
#include <errno.h>
#if HAVE_FSTAB_H
#include <fstab.h>
#endif
#if HAVE_SYS_STATVFS_H
#include <sys/statvfs.h>
#endif
#if HAVE_SYS_VFS_H
#include <sys/vfs.h>
#endif
#if (!defined(HAVE_STATVFS)) && defined(HAVE_STATFS)
#if HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#if HAVE_SYS_MOUNT_H
#include <sys/mount.h>
#endif
#if HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
#endif
#define statvfs statfs
#endif
#if HAVE_VM_SWAP_PAGER_H
#include <vm/swap_pager.h>
#endif
#if HAVE_SYS_FIXPOINT_H
#include <sys/fixpoint.h>
#endif
#if HAVE_MALLOC_H
#include <malloc.h>
#endif
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#include <sys/utsname.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/agent/auto_nlist.h>
#include <net-snmp/agent/hardware/cpu.h>
#include "mibdefs.h"
#include "struct.h"
#include "util_funcs/header_generic.h"
#include "vmstat.h"
netsnmp_feature_require(hardware_cpu_load)
FindVarMethod var_extensible_vmstat;
static int has_vmstat = 1;
static int has_cpu_26 = 1;
static time_t cache_time;
#define CACHE_TIMEOUT 5
#define MAX_INT32 0x7fffffff
#define MAX_COUNTER 0xffffffff
#define STAT_FILE "/proc/stat"
#define VMSTAT_FILE "/proc/vmstat"
void
init_vmstat(void)
{
struct variable2 extensible_vmstat_variables[] = {
{MIBINDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {MIBINDEX}},
{ERRORNAME, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {ERRORNAME}},
{SWAPIN, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {SWAPIN}},
{SWAPOUT, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {SWAPOUT}},
{RAWSWAPIN, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {RAWSWAPIN}},
{RAWSWAPOUT, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {RAWSWAPOUT}},
{IOSENT, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {IOSENT}},
{IORECEIVE, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {IORECEIVE}},
{IORAWSENT, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {IORAWSENT}},
{IORAWRECEIVE, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {IORAWRECEIVE}},
{SYSINTERRUPTS, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {SYSINTERRUPTS}},
{SYSCONTEXT, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {SYSCONTEXT}},
{CPUUSER, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPUUSER}},
{CPUSYSTEM, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPUSYSTEM}},
{CPUIDLE, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPUIDLE}},
{CPURAWUSER, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPURAWUSER}},
{CPURAWNICE, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPURAWNICE}},
{CPURAWSYSTEM, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPURAWSYSTEM}},
{CPURAWKERNEL, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPURAWKERNEL}},
{CPURAWIDLE, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPURAWIDLE}},
{SYSRAWINTERRUPTS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {SYSRAWINTERRUPTS}},
{SYSRAWCONTEXT, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {SYSRAWCONTEXT}},
{CPURAWWAIT, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPURAWWAIT}},
{CPURAWINTR, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPURAWINTR}},
{CPURAWSOFTIRQ, ASN_COUNTER, NETSNMP_OLDAPI_RONLY,
var_extensible_vmstat, 1, {CPURAWSOFTIRQ}},
/*
* Future use:
*/
/*
* {ERRORFLAG, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
* var_extensible_vmstat, 1, {ERRORFLAG }},
* {ERRORMSG, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
* var_extensible_vmstat, 1, {ERRORMSG }}
*/
};
/*
* Define the OID pointer to the top of the mib tree that we're
* registering underneath
*/
oid vmstat_variables_oid[] = { NETSNMP_UCDAVIS_MIB, 11 };
/*
* register ourselves with the agent to handle our mib tree
*/
REGISTER_MIB("ucd-snmp/vmstat", extensible_vmstat_variables, variable2,
vmstat_variables_oid);
}
static void
getstat(unsigned long *cuse, unsigned long *cice, unsigned long *csys,
unsigned long *cide, unsigned *pin, unsigned *pout,
unsigned *swpin, unsigned *swpout, unsigned *itot, unsigned *i1,
unsigned *ct, unsigned long *ciow, unsigned long *cirq,
unsigned long *csoft)
{
int statfd, vmstatfd;
static int first = 1;
static char *buff = NULL, *vmbuff = NULL;
static int bsize = 0, vmbsize = 0;
char *b, *c;
time_t now;
unsigned long long cpunum;
unsigned long long cusell = 0, cicell = 0, csysll = 0, cidell = 0,
ciowll = 0, cirqll = 0, csoftll = 0, ctll = 0, itotll = 0, i1ll = 0;
time(&now);
if (cache_time + CACHE_TIMEOUT < now) {
if ((statfd = open(STAT_FILE, O_RDONLY, 0)) == -1) {
snmp_log_perror(STAT_FILE);
return;
}
if (bsize == 0) {
bsize = 256;
buff = malloc(bsize);
}
while (read(statfd, buff, bsize) == bsize) {
bsize += 256;
buff = realloc(buff, bsize);
DEBUGMSGTL(("vmstat", "/proc/stat buffer increased to %d\n", bsize));
close(statfd);
statfd = open(STAT_FILE, O_RDONLY, 0);
}
close(statfd);
if (has_vmstat) {
vmstatfd = open(VMSTAT_FILE, O_RDONLY, 0);
if (vmstatfd == -1) {
snmp_log(LOG_ERR, "cannot open %s\n", VMSTAT_FILE);
has_vmstat = 0;
} else {
if (vmbsize == 0) {
vmbsize = 256;
vmbuff = malloc(vmbsize);
}
while (read(vmstatfd, vmbuff, vmbsize) == vmbsize) {
vmbsize += 256;
vmbuff = realloc(vmbuff, vmbsize);
close(vmstatfd);
vmstatfd = open(VMSTAT_FILE, O_RDONLY, 0);
}
close(vmstatfd);
}
}
cache_time = now;
}
*itot = 0;
*i1 = 1;
c = buff;
while ((c = strstr(c+1, "cpu")) != NULL)
b = c;
sscanf(b, "cpu%llu", &cpunum);
cpunum++;
b = strstr(buff, "cpu ");
if (b) {
if (!has_cpu_26 ||
sscanf(b, "cpu %llu %llu %llu %llu %llu %llu %llu", &cusell,
&cicell, &csysll, &cidell, &ciowll, &cirqll, &csoftll) != 7) {
has_cpu_26 = 0;
sscanf(b, "cpu %llu %llu %llu %llu", &cusell, &cicell, &csysll,
&cidell);
*ciow = *cirq = *csoft = 0;
} else {
*ciow = (unsigned long)(ciowll/cpunum);
*cirq = (unsigned long)(cirqll/cpunum);
*csoft = (unsigned long)(csoftll/cpunum);
}
*cuse = (unsigned long)(cusell/cpunum);
*cice = (unsigned long)(cicell/cpunum);
*csys = (unsigned long)(csysll/cpunum);
*cide = (unsigned long)(cidell/cpunum);
}
else {
if (first)
snmp_log(LOG_ERR, "No cpu line in %s\n", STAT_FILE);
*cuse = *cice = *csys = *cide = *ciow = *cirq = *csoft = 0;
}
if (has_vmstat) {
b = strstr(vmbuff, "pgpgin ");
if (b)
sscanf(b, "pgpgin %u", pin);
else {
if (first)
snmp_log(LOG_ERR, "No pgpgin line in %s\n", VMSTAT_FILE);
*pin = 0;
}
b = strstr(vmbuff, "pgpgout ");
if (b)
sscanf(b, "pgpgout %u", pout);
else {
if (first)
snmp_log(LOG_ERR, "No pgpgout line in %s\n", VMSTAT_FILE);
*pout = 0;
}
b = strstr(vmbuff, "pswpin ");
if (b)
sscanf(b, "pswpin %u", swpin);
else {
if (first)
snmp_log(LOG_ERR, "No pswpin line in %s\n", VMSTAT_FILE);
*swpin = 0;
}
b = strstr(vmbuff, "pswpout ");
if (b)
sscanf(b, "pswpout %u", swpout);
else {
if (first)
snmp_log(LOG_ERR, "No pswpout line in %s\n", VMSTAT_FILE);
*swpout = 0;
}
}
else {
b = strstr(buff, "page ");
if (b)
sscanf(b, "page %u %u", pin, pout);
else {
if (first)
snmp_log(LOG_ERR, "No page line in %s\n", STAT_FILE);
*pin = *pout = 0;
}
b = strstr(buff, "swap ");
if (b)
sscanf(b, "swap %u %u", swpin, swpout);
else {
if (first)
snmp_log(LOG_ERR, "No swap line in %s\n", STAT_FILE);
*swpin = *swpout = 0;
}
}
b = strstr(buff, "intr ");
if (b) {
sscanf(b, "intr %llu %llu", &itotll, &i1ll);
*itot = (unsigned)itotll;
*i1 = (unsigned)i1ll;
}
else {
if (first)
snmp_log(LOG_ERR, "No intr line in %s\n", STAT_FILE);
*itot = 0;
}
b = strstr(buff, "ctxt ");
if (b) {
sscanf(b, "ctxt %llu", &ctll);
*ct = (unsigned long)ctll;
}
else {
if (first)
snmp_log(LOG_ERR, "No ctxt line in %s\n", STAT_FILE);
*ct = 0;
}
first = 0;
}
enum vmstat_index { swapin = 0, swapout,
rawswapin, rawswapout,
iosent, ioreceive,
rawiosent, rawioreceive,
sysinterrupts, syscontext,
cpuuser, cpusystem, cpuidle,
cpurawuser, cpurawnice,
cpurawsystem, cpurawidle,
cpurawinter, cpurawsoft, cpurawwait,
rawinterrupts, rawcontext
};
static unsigned
vmstat(int iindex)
{
double duse, dsys, didl, ddiv, divo2;
double druse, drnic, drsys, dridl;
unsigned int hertz;
double ddiv2;
netsnmp_cpu_info *cpu;
netsnmp_cpu_load();
cpu = netsnmp_cpu_get_byIdx( -1, 0 );
duse = cpu->user_ticks + cpu->nice_ticks;
dsys = cpu->sys_ticks;
didl = cpu->idle_ticks;
ddiv = duse + dsys + didl;
hertz = sysconf(_SC_CLK_TCK); /* get ticks/s from system */
divo2 = ddiv / 2;
druse = cpu->user_ticks;
drnic = cpu->nice_ticks;
drsys = cpu->sys_ticks;
dridl = cpu->idle_ticks;
ddiv2 = ddiv + cpu->wait_ticks
+ cpu->intrpt_ticks
+ cpu->sirq_ticks;
if (cpu->history) {
duse -= (cpu->history[0].user_hist + cpu->history[0].nice_hist);
dsys -= cpu->history[0].sys_hist;
didl -= cpu->history[0].idle_hist;
ddiv2 -= cpu->history[0].total_hist;
}
if (!ddiv) ddiv=1; /* Protect against division-by-0 */
switch (iindex) {
case swapin:
return (cpu->swapIn * 4 * hertz + divo2) / ddiv;
case swapout:
return (cpu->swapOut * 4 * hertz + divo2) / ddiv;
case iosent:
return (cpu->pageIn * hertz + divo2) / ddiv;
case ioreceive:
return (cpu->pageOut * hertz + divo2) / ddiv;
case sysinterrupts:
return (cpu->nInterrupts * hertz + divo2) / ddiv;
case syscontext:
return (cpu->nCtxSwitches * hertz + divo2) / ddiv;
case cpuuser:
return (ddiv2 ? 100 * duse / ddiv2 : 0);
case cpusystem:
return (ddiv2 ? 100 * dsys / ddiv2 : 0);
case cpuidle:
return (ddiv2 ? 100 * didl / ddiv2 : 0);
case cpurawuser:
return druse;
case cpurawnice:
return drnic;
case cpurawsystem:
return drsys;
case cpurawidle:
return dridl;
case rawinterrupts:
return cpu->nInterrupts;
case rawcontext:
return cpu->nCtxSwitches;
case cpurawwait:
return cpu->wait_ticks;
case cpurawinter:
return cpu->intrpt_ticks;
case cpurawsoft:
return cpu->sirq_ticks;
case rawiosent:
return cpu->pageOut*2;
case rawioreceive:
return cpu->pageIn*2;
case rawswapin:
return cpu->swapIn;
case rawswapout:
return cpu->swapOut;
default:
return -1;
}
}
unsigned char *
var_extensible_vmstat(struct variable *vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
static long long_ret;
static char errmsg[300];
long_ret = 0; /* set to 0 as default */
if (header_generic(vp, name, length, exact, var_len, write_method))
return (NULL);
switch (vp->magic) {
case MIBINDEX:
long_ret = 1;
return ((u_char *) (&long_ret));
case ERRORNAME: /* dummy name */
sprintf(errmsg, "systemStats");
*var_len = strlen(errmsg);
return ((u_char *) (errmsg));
case SWAPIN:
long_ret = vmstat(swapin) & MAX_INT32;
return ((u_char *) (&long_ret));
case SWAPOUT:
long_ret = vmstat(swapout) & MAX_INT32;
return ((u_char *) (&long_ret));
case RAWSWAPIN:
long_ret = vmstat(rawswapin) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case RAWSWAPOUT:
long_ret = vmstat(rawswapout) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case IOSENT:
long_ret = vmstat(iosent) & MAX_INT32;
return ((u_char *) (&long_ret));
case IORECEIVE:
long_ret = vmstat(ioreceive) & MAX_INT32;
return ((u_char *) (&long_ret));
case IORAWSENT:
long_ret = vmstat(rawiosent) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case IORAWRECEIVE:
long_ret = vmstat(rawioreceive) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case SYSINTERRUPTS:
long_ret = vmstat(sysinterrupts) & MAX_INT32;
return ((u_char *) (&long_ret));
case SYSCONTEXT:
long_ret = vmstat(syscontext) & MAX_INT32;
return ((u_char *) (&long_ret));
case CPUUSER:
long_ret = vmstat(cpuuser) & MAX_INT32;
return ((u_char *) (&long_ret));
case CPUSYSTEM:
long_ret = vmstat(cpusystem) & MAX_INT32;
return ((u_char *) (&long_ret));
case CPUIDLE:
long_ret = vmstat(cpuidle) & MAX_INT32;
return ((u_char *) (&long_ret));
case CPURAWUSER:
long_ret = vmstat(cpurawuser) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWNICE:
long_ret = vmstat(cpurawnice) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWSYSTEM:
long_ret = (vmstat(cpurawsystem)+vmstat(cpurawinter)+vmstat(cpurawsoft)) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWKERNEL:
long_ret = vmstat(cpurawsystem) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWIDLE:
long_ret = vmstat(cpurawidle) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case SYSRAWINTERRUPTS:
long_ret = vmstat(rawinterrupts) & MAX_COUNTER;
return (u_char *)&long_ret;
case SYSRAWCONTEXT:
long_ret = vmstat(rawcontext) & MAX_COUNTER;
return (u_char *)&long_ret;
case CPURAWWAIT:
if (!has_cpu_26) return NULL;
long_ret = vmstat(cpurawwait) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWINTR:
if (!has_cpu_26) return NULL;
long_ret = vmstat(cpurawinter) & MAX_COUNTER;
return ((u_char *) (&long_ret));
case CPURAWSOFTIRQ:
if (!has_cpu_26) return NULL;
long_ret = vmstat(cpurawsoft) & MAX_COUNTER;
return ((u_char *) (&long_ret));
/*
* reserved for future use
*/
/*
* case ERRORFLAG:
* return((u_char *) (&long_ret));
* case ERRORMSG:
* return((u_char *) (&long_ret));
*/
default:
snmp_log(LOG_ERR, "vmstat.c: don't know how to handle %d request\n",
vp->magic);
}
return NULL;
}