#include <net-snmp/net-snmp-config.h>
#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 <signal.h>
#if HAVE_MACHINE_PARAM_H
#include <machine/param.h>
#endif
#if HAVE_SYS_PARAM_H
#include <sys/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_ASM_PAGE_H
#include <asm/page.h>
#endif
#if HAVE_SYS_SWAP_H
#include <sys/swap.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
#if !defined(dragonfly)
#ifdef HAVE_SYS_VNODE_H
#include <sys/vnode.h>
#endif
#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 <errno.h>
#if HAVE_FSTAB_H
#include <fstab.h>
#endif
#if HAVE_SYS_STATFS_H
#include <sys/statfs.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_MOUNT_H
#include <sys/mount.h>
#endif
#if HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
#endif
#define statvfs statfs
#endif
#if HAVE_VM_VM_H
#include <vm/vm.h>
#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_SYS_LOADAVG_H
#include <sys/loadavg.h>
#endif
#if HAVE_MALLOC_H
#include <malloc.h>
#endif
#if HAVE_STRING_H
#include <string.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
#ifdef dynix
#include <sys/mc_vmparam.h>
#endif
#if defined(hpux10) || defined(hpux11)
#include <sys/pstat.h>
#endif
#if defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7)
#ifdef HAVE_SYS_PROTOSW_H
#include <sys/protosw.h>
#endif
#include <libperfstat.h>
#endif
#if HAVE_SYS_SYSGET_H
#include <sys/sysget.h>
#endif
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/agent/auto_nlist.h>
#include "struct.h"
#include "loadave.h"
#include "util_funcs/header_simple_table.h"
#include "kernel.h"
static double maxload[3];
static int laConfigSet = 0;
static int
loadave_store_config(int a, int b, void *c, void *d)
{
char line[SNMP_MAXBUF_SMALL];
if (laConfigSet > 0) {
snprintf(line, SNMP_MAXBUF_SMALL, "pload %.02f %.02f %.02f", maxload[0], maxload[1], maxload[2]);
snmpd_store_config(line);
}
return SNMPERR_SUCCESS;
}
void
init_loadave(void)
{
/*
* define the structure we're going to ask the agent to register our
* information at
*/
struct variable2 extensible_loadave_variables[] = {
{MIBINDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_loadave, 1, {MIBINDEX}},
{ERRORNAME, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_extensible_loadave, 1, {ERRORNAME}},
{LOADAVE, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_extensible_loadave, 1, {LOADAVE}},
{LOADMAXVAL, ASN_OCTET_STR, NETSNMP_OLDAPI_RWRITE,
var_extensible_loadave, 1, {LOADMAXVAL}},
{LOADAVEINT, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_loadave, 1, {LOADAVEINT}},
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
{LOADAVEFLOAT, ASN_OPAQUE_FLOAT, NETSNMP_OLDAPI_RONLY,
var_extensible_loadave, 1, {LOADAVEFLOAT}},
#endif
{ERRORFLAG, ASN_INTEGER, NETSNMP_OLDAPI_RONLY,
var_extensible_loadave, 1, {ERRORFLAG}},
{ERRORMSG, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY,
var_extensible_loadave, 1, {ERRORMSG}}
};
/*
* Define the OID pointer to the top of the mib tree that we're
* registering underneath
*/
oid loadave_variables_oid[] =
{ NETSNMP_UCDAVIS_MIB, NETSNMP_LOADAVEMIBNUM, 1 };
/*
* register ourselves with the agent to handle our mib tree
*/
REGISTER_MIB("ucd-snmp/loadave", extensible_loadave_variables,
variable2, loadave_variables_oid);
laConfigSet = 0;
snmpd_register_config_handler("load", loadave_parse_config,
loadave_free_config,
"max1 [max5] [max15]");
snmpd_register_config_handler("pload",
loadave_parse_config, NULL, NULL);
/*
* we need to be called back later
*/
snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
loadave_store_config, NULL);
}
void
loadave_parse_config(const char *token, char *cptr)
{
int i;
if (strcmp(token, "pload") == 0) {
if (laConfigSet < 0) {
snmp_log(LOG_WARNING,
"ignoring attempted override of read-only load\n");
return;
} else {
laConfigSet++;
}
} else {
if (laConfigSet > 0) {
snmp_log(LOG_WARNING,
"ignoring attempted override of read-only load\n");
/*
* Fall through and copy in this value.
*/
}
laConfigSet = -1;
}
for (i = 0; i <= 2; i++) {
if (cptr != NULL)
maxload[i] = atof(cptr);
else
maxload[i] = maxload[i - 1];
cptr = skip_not_white(cptr);
cptr = skip_white(cptr);
}
}
void
loadave_free_config(void)
{
int i;
for (i = 0; i <= 2; i++)
maxload[i] = NETSNMP_DEFMAXLOADAVE;
}
/*
* try to get load average
* Inputs: pointer to array of doubles, number of elements in array
* Returns: 0=array has values, -1=error occurred.
*/
int
try_getloadavg(double *r_ave, size_t s_ave)
{
#ifndef HAVE_GETLOADAVG
#ifdef HAVE_SYS_FIXPOINT_H
fix favenrun[3];
#endif
#if (defined(ultrix) || defined(sun) || defined(__alpha) || defined(dynix))
int i;
#if (defined(sun) || defined(__alpha) || defined(dynix))
long favenrun[3];
if (s_ave > 3) /* bounds check */
return (-1);
#define FIX_TO_DBL(_IN) (((double) _IN)/((double) FSCALE))
#endif
#endif
#if defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7)
perfstat_cpu_total_t cs;
#endif
#if defined(hpux10) || defined(hpux11)
struct pst_dynamic pst_buf;
#endif
#ifdef irix6
int i, favenrun[3];
sgt_cookie_t cookie;
#endif
#endif /* !HAVE_GETLOADAVG */
#ifdef HAVE_GETLOADAVG
if (getloadavg(r_ave, s_ave) == -1)
return (-1);
#elif defined(linux)
{
FILE *in = fopen("/proc/loadavg", "r");
if (!in) {
NETSNMP_LOGONCE((LOG_ERR, "snmpd: cannot open /proc/loadavg\n"));
return (-1);
}
fscanf(in, "%lf %lf %lf", r_ave, (r_ave + 1), (r_ave + 2));
fclose(in);
}
#elif (defined(ultrix) || defined(sun) || defined(__alpha) || defined(dynix))
if (auto_nlist(LOADAVE_SYMBOL, (char *) favenrun, sizeof(favenrun)) ==
0)
return (-1);
for (i = 0; i < s_ave; i++)
*(r_ave + i) = FIX_TO_DBL(favenrun[i]);
#elif defined(hpux10) || defined(hpux11)
if (pstat_getdynamic(&pst_buf, sizeof(struct pst_dynamic), 1, 0) < 0)
return(-1);
r_ave[0] = pst_buf.psd_avg_1_min;
r_ave[1] = pst_buf.psd_avg_5_min;
r_ave[2] = pst_buf.psd_avg_15_min;
#elif defined(aix4) || defined(aix5) || defined(aix6) || defined(aix7)
if(perfstat_cpu_total((perfstat_id_t *)NULL, &cs, sizeof(perfstat_cpu_total_t), 1) > 0) {
r_ave[0] = cs.loadavg[0] / 65536.0;
r_ave[1] = cs.loadavg[1] / 65536.0;
r_ave[2] = cs.loadavg[2] / 65536.0;
}
#elif defined(irix6)
SGT_COOKIE_INIT(&cookie);
SGT_COOKIE_SET_KSYM(&cookie, "avenrun");
sysget(SGT_KSYM, (char*)favenrun, sizeof(favenrun), SGT_READ, &cookie);
for (i = 0; i < s_ave; i++)
r_ave[i] = favenrun[i] / 1000.0;
DEBUGMSGTL(("ucd-snmp/loadave", "irix6: %d %d %d\n", favenrun[0], favenrun[1], favenrun[2]));
#elif !defined(cygwin)
#if defined(NETSNMP_CAN_USE_NLIST) && defined(LOADAVE_SYMBOL)
if (auto_nlist(LOADAVE_SYMBOL, (char *) r_ave, sizeof(double) * s_ave)
== 0)
#endif
return (-1);
#endif
/*
* XXX
* To calculate this, we need to compare
* successive values of the kernel array
* '_cp_times', and calculate the resulting
* percentage changes.
* This calculation needs to be performed
* regularly - perhaps as a background process.
*
* See the source to 'top' for full details.
*
* The linux SNMP HostRes implementation
* uses 'avenrun[0]*100' as an approximation.
* This is less than accurate, but has the
* advantage of being simple to implement!
*
* I'm also assuming a single processor
*/
return 0;
}
static int
write_laConfig(int action,
u_char * var_val,
u_char var_val_type,
size_t var_val_len,
u_char * statP, oid * name, size_t name_len)
{
static double laConfig = 0;
switch (action) {
case RESERVE1: /* Check values for acceptability */
if (var_val_type != ASN_OCTET_STR) {
DEBUGMSGTL(("ucd-snmp/loadave",
"write to laConfig not ASN_OCTET_STR\n"));
return SNMP_ERR_WRONGTYPE;
}
if (var_val_len > 8 || var_val_len <= 0) {
DEBUGMSGTL(("ucd-snmp/loadave",
"write to laConfig: bad length\n"));
return SNMP_ERR_WRONGLENGTH;
}
if (laConfigSet < 0) {
/*
* The object is set in a read-only configuration file.
*/
return SNMP_ERR_NOTWRITABLE;
}
break;
case RESERVE2: /* Allocate memory and similar resources */
{
char buf[8];
int old_errno = errno;
double val;
char *endp;
sprintf(buf, "%.*s", (int) var_val_len, (char *)var_val);
val = strtod(buf, &endp);
if (errno == ERANGE || *endp != '\0' || val < 0 || val > 65536.00) {
errno = old_errno;
DEBUGMSGTL(("ucd-snmp/loadave",
"write to laConfig: invalid value\n"));
return SNMP_ERR_WRONGVALUE;
}
errno = old_errno;
laConfig = val;
}
break;
case COMMIT:
{
int idx = name[name_len - 1] - 1;
maxload[idx] = laConfig;
laConfigSet = 1;
}
}
return SNMP_ERR_NOERROR;
}
u_char *
var_extensible_loadave(struct variable * vp,
oid * name,
size_t * length,
int exact,
size_t * var_len, WriteMethod ** write_method)
{
static long long_ret;
static float float_ret;
static char errmsg[300];
double avenrun[3];
if (header_simple_table
(vp, name, length, exact, var_len, write_method, 3))
return (NULL);
switch (vp->magic) {
case MIBINDEX:
long_ret = name[*length - 1];
return ((u_char *) (&long_ret));
case LOADMAXVAL:
/* setup write method, but don't return yet */
*write_method = write_laConfig;
break;
case ERRORNAME:
sprintf(errmsg, "Load-%d", ((name[*length - 1] == 1) ? 1 :
((name[*length - 1] == 2) ? 5 : 15)));
*var_len = strlen(errmsg);
return ((u_char *) (errmsg));
}
if (try_getloadavg(&avenrun[0], sizeof(avenrun) / sizeof(avenrun[0]))
== -1)
return NULL;
switch (vp->magic) {
case LOADAVE:
sprintf(errmsg, "%.2f", avenrun[name[*length - 1] - 1]);
*var_len = strlen(errmsg);
return ((u_char *) (errmsg));
case LOADMAXVAL:
sprintf(errmsg, "%.2f", maxload[name[*length - 1] - 1]);
*var_len = strlen(errmsg);
return ((u_char *) (errmsg));
case LOADAVEINT:
long_ret = (u_long) (avenrun[name[*length - 1] - 1] * 100);
return ((u_char *) (&long_ret));
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
case LOADAVEFLOAT:
float_ret = (float) avenrun[name[*length - 1] - 1];
*var_len = sizeof(float_ret);
return ((u_char *) (&float_ret));
#endif
case ERRORFLAG:
long_ret = (maxload[name[*length - 1] - 1] != 0 &&
avenrun[name[*length - 1] - 1] >=
maxload[name[*length - 1] - 1]) ? 1 : 0;
return ((u_char *) (&long_ret));
case ERRORMSG:
if (maxload[name[*length - 1] - 1] != 0 &&
avenrun[name[*length - 1] - 1] >=
maxload[name[*length - 1] - 1]) {
snprintf(errmsg, sizeof(errmsg),
"%d min Load Average too high (= %.2f)",
(name[*length - 1] ==
1) ? 1 : ((name[*length - 1] == 2) ? 5 : 15),
avenrun[name[*length - 1] - 1]);
errmsg[sizeof(errmsg) - 1] = '\0';
} else {
errmsg[0] = 0;
}
*var_len = strlen(errmsg);
return ((u_char *) errmsg);
}
return NULL;
}