From e4531699f5865eb6086b61d06a638b99bbd716b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20=C5=A0afr=C3=A1nek?= Date: Wed, 14 Nov 2007 14:30:41 +0000 Subject: [PATCH] add support of lm_sensors v3 Resolves: #351991 --- net-snmp-5.4.1-sensors3.patch | 1326 +++++++++++++++++++++++++++++++++ net-snmp.spec | 11 +- 2 files changed, 1334 insertions(+), 3 deletions(-) create mode 100644 net-snmp-5.4.1-sensors3.patch diff --git a/net-snmp-5.4.1-sensors3.patch b/net-snmp-5.4.1-sensors3.patch new file mode 100644 index 0000000..99443e3 --- /dev/null +++ b/net-snmp-5.4.1-sensors3.patch @@ -0,0 +1,1326 @@ +351991: Port net-snmp to lm_sensors-3.x.x +Source: upstream, svn diff -r 16736:16739 +Reviewed-By: Jan Safranek + +Index: configure +=================================================================== +--- configure (revision 16736) ++++ configure (revision 16739) +@@ -32628,7 +32628,7 @@ + fi + + # LM-SENSORS-MIB support +-echo " $module_list " | grep " ucd-snmp/lmSensors " > /dev/null ++echo " $module_list " | $GREP -i "ucd-snmp/lmsensor" > /dev/null + if test $? -eq 0 ; then + { echo "$as_me:$LINENO: checking for sensors support" >&5 + echo $ECHO_N "checking for sensors support... $ECHO_C" >&6; } +Index: include/net-snmp/agent/hardware/sensors.h +=================================================================== +--- include/net-snmp/agent/hardware/sensors.h (revision 0) ++++ include/net-snmp/agent/hardware/sensors.h (revision 16739) +@@ -0,0 +1,48 @@ ++/* ++ * Hardware Abstraction Layer - Sensors module ++ * ++ * Public interface ++ */ ++ ++#define NETSNMP_SENSOR_TYPE_OTHER 1 ++#define NETSNMP_SENSOR_TYPE_VOLTAGE_AC 3 ++#define NETSNMP_SENSOR_TYPE_VOLTAGE_DC 4 ++#define NETSNMP_SENSOR_TYPE_CURRENT 5 ++#define NETSNMP_SENSOR_TYPE_POWER 6 ++#define NETSNMP_SENSOR_TYPE_FREQUENCY 7 ++#define NETSNMP_SENSOR_TYPE_TEMPERATURE 8 ++#define NETSNMP_SENSOR_TYPE_HUMIDITY 9 ++#define NETSNMP_SENSOR_TYPE_RPM 10 ++#define NETSNMP_SENSOR_TYPE_VOLUME 11 ++#define NETSNMP_SENSOR_TYPE_BOOLEAN 12 ++ ++ ++#define NETSNMP_SENSOR_FLAG_ACTIVE 0x01 ++#define NETSNMP_SENSOR_FLAG_NAVAIL 0x02 ++#define NETSNMP_SENSOR_FLAG_BROKEN 0x04 ++#define NETSNMP_SENSOR_FLAG_DISABLE 0x08 ++ ++#define NETSNMP_SENSOR_MASK_STATUS 0x06 /* NAVAIL|BROKEN */ ++ ++ ++#define NETSNMP_SENSOR_FIND_CREATE 1 /* or use one of the sensor type values */ ++#define NETSNMP_SENSOR_FIND_EXIST 0 ++ ++typedef struct netsnmp_sensor_info_s netsnmp_sensor_info; ++struct netsnmp_sensor_info_s { ++ ++ netsnmp_index idx; ++ /* int idx; */ ++ char name[256]; ++ ++ int type; ++ float value; ++ char descr[256]; ++ long flags; ++}; ++ ++netsnmp_container *get_sensor_container( void ); ++netsnmp_cache *get_sensor_cache( void ); ++netsnmp_sensor_info *sensor_by_name( char *, int ); ++NetsnmpCacheLoad netsnmp_sensor_load; ++NetsnmpCacheFree netsnmp_sensor_free; +Index: configure.in +=================================================================== +--- configure.in (revision 16736) ++++ configure.in (revision 16739) +@@ -2885,7 +2885,7 @@ + fi + + # LM-SENSORS-MIB support +-echo " $module_list " | grep " ucd-snmp/lmSensors " > /dev/null ++echo " $module_list " | $GREP -i "ucd-snmp/lmsensor" > /dev/null + if test $? -eq 0 ; then + AC_MSG_CHECKING([for sensors support]) + case $target_os in +Index: agent/mibgroup/ucd-snmp/lmsensorsMib.c +=================================================================== +--- agent/mibgroup/ucd-snmp/lmsensorsMib.c (revision 0) ++++ agent/mibgroup/ucd-snmp/lmsensorsMib.c (revision 16739) +@@ -0,0 +1,205 @@ ++#include ++#include ++#include ++#include ++#include "ucd-snmp/lmsensorsMib.h" ++ ++netsnmp_container *sensorContainer = NULL; ++ ++void initialize_lmSensorsTable(const char *tableName, oid *tableOID, ++ netsnmp_container_op *filter, int mult ); ++ ++int _sensor_filter_temp( netsnmp_container *c, const void *v ); ++int _sensor_filter_fan( netsnmp_container *c, const void *v ); ++int _sensor_filter_volt( netsnmp_container *c, const void *v ); ++int _sensor_filter_misc( netsnmp_container *c, const void *v ); ++ ++static oid lmTempSensorsTable_oid[] = {1,3,6,1,4,1,2021,13,16,2}; ++static oid lmFanSensorsTable_oid[] = {1,3,6,1,4,1,2021,13,16,3}; ++static oid lmVoltSensorsTable_oid[] = {1,3,6,1,4,1,2021,13,16,4}; ++static oid lmMiscSensorsTable_oid[] = {1,3,6,1,4,1,2021,13,16,5}; ++ /* All the tables have the same length root OID */ ++size_t lmSensorsTables_oid_len = OID_LENGTH(lmMiscSensorsTable_oid); ++ ++ ++/* Initialise the LM Sensors MIB module */ ++void ++init_lmsensorsMib(void) ++{ ++ DEBUGMSGTL(("ucd-snmp/lmsensorsMib","Initializing LM-SENSORS-MIB tables\n")); ++ ++ /* ++ * Initialise the four LM-SENSORS-MIB tables ++ * ++ * They are almost identical, so we can use the same registration code. ++ */ ++ initialize_lmSensorsTable( "lmTempSensorsTable", lmTempSensorsTable_oid, ++ _sensor_filter_temp, 1000 ); /* MIB asks for mC */ ++ initialize_lmSensorsTable( "lmFanSensorsTable", lmFanSensorsTable_oid, ++ _sensor_filter_fan, 1); ++ initialize_lmSensorsTable( "lmVoltSensorsTable", lmVoltSensorsTable_oid, ++ _sensor_filter_volt, 1000 ); /* MIB asks for mV */ ++ initialize_lmSensorsTable( "lmMiscSensorsTable", lmMiscSensorsTable_oid, ++ _sensor_filter_misc, 1 ); ++} ++ ++/* ++ * Common initialisation code, used for setting up all four tables ++ */ ++void ++initialize_lmSensorsTable(const char *tableName, oid *tableOID, ++ netsnmp_container_op *filter, int mult ) ++{ ++ netsnmp_handler_registration *reg; ++ netsnmp_table_registration_info *table_info; ++ netsnmp_cache *cache; ++ netsnmp_container *container; ++ ++ /* ++ * Ensure the HAL sensors module has been initialised, ++ * and retrieve the main sensors container. ++ * This table will then be registered using a filter on this container. ++ */ ++ sensorContainer = get_sensor_container(); ++ if ( !sensorContainer ) { ++ init_hw_sensors( ); ++ sensorContainer = get_sensor_container(); ++ } ++ container = netsnmp_container_find("sensorTable:table_container"); ++ container->insert_filter = filter; ++ netsnmp_container_add_index( sensorContainer, container ); ++ ++ ++ /* ++ * Create a basic registration structure for the table ++ */ ++ reg = netsnmp_create_handler_registration( ++ tableName, lmSensorsTables_handler, ++ tableOID, lmSensorsTables_oid_len, HANDLER_CAN_RONLY ++ ); ++ ++ /* ++ * Register the table using the filtered container ++ * Include an indicator of any scaling to be applied to the sensor value ++ */ ++ reg->my_reg_void = (void *)mult; ++ table_info = SNMP_MALLOC_TYPEDEF( netsnmp_table_registration_info ); ++ netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, 0); ++ table_info->min_column = COLUMN_LMSENSORS_INDEX; ++ table_info->max_column = COLUMN_LMSENSORS_VALUE; ++ netsnmp_container_table_register( reg, table_info, container, 0 ); ++ ++ /* ++ * If the HAL sensors module was configured as an on-demand caching ++ * module (rather than being automatically loaded regularly), ++ * then ensure this table makes use of that cache. ++ */ ++ cache = get_sensor_cache(); ++ if ( cache ) { ++ netsnmp_inject_handler_before( reg, netsnmp_cache_handler_get( cache ), ++ "table_container"); ++ } ++ ++} ++ ++ ++/* ++ * Container filters for the four tables ++ * ++ * Used to ensure that sensor entries appear in the appropriate table. ++ */ ++int _sensor_filter_temp( netsnmp_container *c, const void *v ) { ++ const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v; ++ /* Only matches temperature sensors */ ++ return (( sp->type == NETSNMP_SENSOR_TYPE_TEMPERATURE ) ? 0 : 1 ); ++} ++ ++int _sensor_filter_fan( netsnmp_container *c, const void *v ) { ++ const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v; ++ /* Only matches fan sensors */ ++ return (( sp->type == NETSNMP_SENSOR_TYPE_RPM ) ? 0 : 1 ); ++} ++ ++int _sensor_filter_volt( netsnmp_container *c, const void *v ) { ++ const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v; ++ /* Only matches voltage sensors (AC or DC) */ ++ return ((( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_DC ) || ++ ( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_AC )) ? 0 : 1 ); ++} ++ ++int _sensor_filter_misc( netsnmp_container *c, const void *v ) { ++ const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v; ++ /* Matches everything except temperature, fan or voltage sensors */ ++ return ((( sp->type == NETSNMP_SENSOR_TYPE_TEMPERATURE ) || ++ ( sp->type == NETSNMP_SENSOR_TYPE_RPM ) || ++ ( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_DC ) || ++ ( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_AC )) ? 1 : 0 ); ++} ++ ++ ++/* ++ * Handle requests for any of the four lmXxxxSensorsTables ++ * ++ * This is possible because all the table share the ++ * same structure and behaviour. ++ */ ++int ++lmSensorsTables_handler( ++ netsnmp_mib_handler *handler, ++ netsnmp_handler_registration *reginfo, ++ netsnmp_agent_request_info *reqinfo, ++ netsnmp_request_info *requests) { ++ ++ netsnmp_request_info *request; ++ netsnmp_table_request_info *table_info; ++ netsnmp_sensor_info *sensor_info; ++ int mult = (int)reginfo->my_reg_void; ++ ++ DEBUGMSGTL(( "ucd-snmp/lmsensorsMib","lmSensorsTables_handler - root: ")); ++ DEBUGMSGOID(("ucd-snmp/lmsensorsMib", reginfo->rootoid, reginfo->rootoid_len)); ++ DEBUGMSG(( "ucd-snmp/lmsensorsMib",", mode %d\n", reqinfo->mode )); ++ /* ++ * This is a read-only table, so we only need to handle GET requests. ++ * (The container helper converts GETNEXT->GET requests automatically). ++ */ ++ switch (reqinfo->mode) { ++ case MODE_GET: ++ for (request=requests; request; request=request->next) { ++ sensor_info = (netsnmp_sensor_info *) ++ netsnmp_container_table_extract_context(request); ++ if ( !sensor_info ) { ++ netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE); ++ continue; ++ } ++ ++ table_info = netsnmp_extract_table_info(request); ++ switch (table_info->colnum) { ++ case COLUMN_LMSENSORS_INDEX: ++ snmp_set_var_typed_integer( request->requestvb, ASN_INTEGER, ++ sensor_info->idx.oids[0]); ++ break; ++ case COLUMN_LMSENSORS_DEVICE: ++ if ( sensor_info->descr[0] != '\0' ) { ++ snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR, ++ sensor_info->descr, strlen(sensor_info->descr)); ++ } else { ++ snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR, ++ sensor_info->name, strlen(sensor_info->name)); ++ } ++ break; ++ case COLUMN_LMSENSORS_VALUE: ++ /* Multiply the value by the appropriate scaling factor for this table */ ++ snmp_set_var_typed_integer( request->requestvb, ASN_GAUGE, ++ (int)(mult*sensor_info->value)); ++ break; ++ default: ++ netsnmp_set_request_error(reqinfo, request, ++ SNMP_NOSUCHOBJECT); ++ break; ++ } ++ } ++ break; ++ ++ } ++ return SNMP_ERR_NOERROR; ++} +Index: agent/mibgroup/ucd-snmp/lmsensorsMib.h +=================================================================== +--- agent/mibgroup/ucd-snmp/lmsensorsMib.h (revision 0) ++++ agent/mibgroup/ucd-snmp/lmsensorsMib.h (revision 16739) +@@ -0,0 +1,23 @@ ++#ifndef LM_SENSORS_MIB_H ++#define LM_SENSORS_MIB_H ++ ++config_require(hardware/sensors) ++config_add_mib(LM-SENSORS-MIB) ++ ++/* function declarations */ ++void init_lmsensorsMib(void); ++ ++/* ++ * Handler and Column definitions for lmXxxxSensorsTable ++ * ++ * Note that the same handler (and hence the same ++ * column identifiers) are used for all four tables. ++ * This is possible because all the table share the ++ * same structure and behaviour. ++ */ ++Netsnmp_Node_Handler lmSensorsTables_handler; ++#define COLUMN_LMSENSORS_INDEX 1 ++#define COLUMN_LMSENSORS_DEVICE 2 ++#define COLUMN_LMSENSORS_VALUE 3 ++ ++#endif /* LM_SENSORS_MIB_H */ +Index: agent/mibgroup/hardware/sensors.h +=================================================================== +--- agent/mibgroup/hardware/sensors.h (revision 0) ++++ agent/mibgroup/hardware/sensors.h (revision 16739) +@@ -0,0 +1,13 @@ ++config_require(hardware/sensors/hw_sensors) ++ ++#if defined(solaris) ++# if defined(HAVE_PICL_H) ++config_require(hardware/sensors/picld_sensors) ++# else ++config_require(hardware/sensors/kstat_sensors) ++# endif ++#else ++config_require(hardware/sensors/lmsensors_v3) ++#endif ++ ++//config_require(hardware/sensors/dummy_sensors) +Index: agent/mibgroup/hardware/sensors/hw_sensors.h +=================================================================== +--- agent/mibgroup/hardware/sensors/hw_sensors.h (revision 0) ++++ agent/mibgroup/hardware/sensors/hw_sensors.h (revision 16739) +@@ -0,0 +1 @@ ++void init_hw_sensors( void ); +Index: agent/mibgroup/hardware/sensors/lmsensors_v2.h +=================================================================== +--- agent/mibgroup/hardware/sensors/lmsensors_v2.h (revision 0) ++++ agent/mibgroup/hardware/sensors/lmsensors_v2.h (revision 16739) +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +Index: agent/mibgroup/hardware/sensors/kstat_sensors.c +=================================================================== +--- agent/mibgroup/hardware/sensors/kstat_sensors.c (revision 0) ++++ agent/mibgroup/hardware/sensors/kstat_sensors.c (revision 16739) +@@ -0,0 +1,161 @@ ++#include ++#include ++#include ++#include ++ ++#include "util_funcs.h" ++#include ++ ++#include ++#include ++ ++void netsnmp_sensor_arch_init( void ) { ++ DEBUGMSGTL(("sensors:arch", "Initialise KStat Sensors module\n")); ++} ++ ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ netsnmp_sensor_info *sp; ++ ++ int i; ++ const char *fantypes[]={"CPU","PWR","AFB"}; ++ char name[ 256 ]; ++ ++ kstat_ctl_t *kc; ++ kstat_t *kp; ++ envctrl_fan_t *fan_info; ++ envctrl_ps_t *power_info; ++ envctrl_encl_t *enc_info; ++ ++ ++ DEBUGMSGTL(("sensors:arch", "Reload KStat Sensors module\n")); ++ ++ kc = kstat_open(); ++ if ( kc == 0) { ++ DEBUGMSGTL(("sensors:arch", "Couldn't open kstat\n")); ++ return 1; ++ } ++ ++ ++ /* ++ * Retrieve fan information ++ */ ++ kp = kstat_lookup( kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_FANSTAT); ++ if (( kp == 0 ) || (kstat_read( kc, kp, 0 ) == -1 )) { ++ DEBUGMSGTL(("sensors:arch", "No fan information\n")); ++ } else { ++ fan_info = (envctrl_fan_t *)kp->ks_data; ++ for (i=0; iks_ndata; i++) { ++ memset( name, 0, 256 ); ++ snprintf( name, 255, "%s%d", fantypes[fan_info->type], fan_info->instance ); ++ ++ sp = sensor_by_name( name, NETSNMP_SENSOR_TYPE_RPM ); ++ if ( sp ) { ++ sp->value = fan_info->fanspeed; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ snprintf( sp->descr, 255, "fan type %s number %d", ++ fantypes[fan_info->type], fan_info->instance ); ++ } ++ ++ fan_info++; ++ } ++ } ++ ++ ++ /* ++ * Retrieve Power Supply information ++ */ ++ kp = kstat_lookup( kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_PSNAME); ++ if (( kp == 0 ) || (kstat_read( kc, kp, 0 ) == -1 )) { ++ DEBUGMSGTL(("sensors:arch", "No PSU information\n")); ++ } else { ++ power_info = (envctrl_ps_t *)kp->ks_data; ++ for (i=0; iks_ndata; i++) { ++ memset( name, 0, 256 ); ++ snprintf( name, 255, "PSU%d", power_info->instance ); ++ ++ sp = sensor_by_name( name, NETSNMP_SENSOR_TYPE_TEMPERATURE); ++ if ( sp ) { ++ sp->value = power_info->ps_tempr; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ snprintf( sp->descr, 255, "power supply %d", power_info->instance ); ++ } ++ ++ power_info++; ++ } ++ } ++ ++ ++ /* ++ * Retrieve Enclosure information ++ */ ++ kp = kstat_lookup( kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_ENCL); ++ if (( kp == 0 ) || (kstat_read( kc, kp, 0 ) == -1 )) { ++ DEBUGMSGTL(("sensors:arch", "No enclosure information\n")); ++ } else { ++ enc_info = (envctrl_encl_t *)kp->ks_data; ++ for (i=0; iks_ndata; i++) { ++ /* ++ * The enclosure information covers several different types of sensor ++ */ ++ switch ( enc_info->type ) { ++ case ENVCTRL_ENCL_FSP: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure Front Panel\n")); ++ sp = sensor_by_name( "FSP", NETSNMP_SENSOR_TYPE_OTHER); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ break; ++ ++ case ENVCTRL_ENCL_AMBTEMPR: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure Ambient Temperature\n")); ++ sp = sensor_by_name( "Ambient", NETSNMP_SENSOR_TYPE_TEMPERATURE); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ break; ++ ++ case ENVCTRL_ENCL_CPUTEMPR: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure CPU Temperature\n")); ++ memset( name, 0, 256 ); ++ snprintf( name, 255, "CPU%d", enc_info->instance ); ++ sp = sensor_by_name( name, NETSNMP_SENSOR_TYPE_TEMPERATURE); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ snprintf( sp->descr, 255, "CPU%d temperature", enc_info->instance ); ++ } ++ break; ++ ++ case ENVCTRL_ENCL_BACKPLANE4: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure Backplane4\n")); ++ sp = sensor_by_name( "Backplane4", NETSNMP_SENSOR_TYPE_OTHER); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ break; ++ ++ case ENVCTRL_ENCL_BACKPLANE8: ++ DEBUGMSGTL(("sensors:arch:detail", "Enclosure Backplane4\n")); ++ sp = sensor_by_name( "Backplane4", NETSNMP_SENSOR_TYPE_OTHER); ++ if ( sp ) { ++ sp->value = enc_info->value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ break; ++ ++ default: ++ DEBUGMSGTL(("sensors:arch:detail", "Unrecognised Enclosure entry (%d)n", ++ enc_info->type)); ++ } ++ ++ enc_info++; ++ } ++ } ++ ++ return 0; ++} +Index: agent/mibgroup/hardware/sensors/lmsensors_v3.h +=================================================================== +--- agent/mibgroup/hardware/sensors/lmsensors_v3.h (revision 0) ++++ agent/mibgroup/hardware/sensors/lmsensors_v3.h (revision 16739) +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +Index: agent/mibgroup/hardware/sensors/dummy_sensors.c +=================================================================== +--- agent/mibgroup/hardware/sensors/dummy_sensors.c (revision 0) ++++ agent/mibgroup/hardware/sensors/dummy_sensors.c (revision 16739) +@@ -0,0 +1,60 @@ ++#include ++#include ++#include ++#include ++ ++ ++void netsnmp_sensor_arch_init( void ) { ++ /* Nothing to do */ ++ DEBUGMSGTL(("sensors:arch", "Initialise Dummy Sensors module\n")); ++} ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ time_t now; ++ struct tm *tm; ++ netsnmp_sensor_info *sp; ++ ++ time(&now); ++ tm = localtime(&now); ++ ++ DEBUGMSGTL(("sensors:arch", "Reload Dummy Sensors module\n")); ++ ++ /* First pseudo-sensor - slowly-rising temperature */ ++ sp = sensor_by_name( "minute", NETSNMP_SENSOR_TYPE_TEMPERATURE ); ++ sp->value = tm->tm_min; ++ snprintf( sp->descr, 256, "Minute-based pseudo-sensor - slowly-rising temperature" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Second pseudo-sensor - quickly-rising temperature */ ++ sp = sensor_by_name( "second", NETSNMP_SENSOR_TYPE_TEMPERATURE ); ++ sp->value = tm->tm_sec; ++ snprintf( sp->descr, 256, "Second-based pseudo-sensor - quickly-rising temperature" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Third pseudo-sensor - annual fan speed */ ++ sp = sensor_by_name( "year", NETSNMP_SENSOR_TYPE_RPM ); ++ sp->value = tm->tm_year + 1900; ++ snprintf( sp->descr, 256, "RPM pseudo-sensor - annual fan speed" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Fourth pseudo-sensor - daily voltage */ ++ sp = sensor_by_name( "day", NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); ++ sp->value = tm->tm_mday-20; ++ snprintf( sp->descr, 256, "Day-based pseudo-sensor - positive or negative voltage" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Fifth pseudo-sensor - monthly voltage */ ++ sp = sensor_by_name( "month", NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); ++ sp->value = tm->tm_mon; ++ snprintf( sp->descr, 256, "Month-based pseudo-sensor - positive voltage" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ /* Sixth pseudo-sensor - annual daily something */ ++ sp = sensor_by_name( "yday", NETSNMP_SENSOR_TYPE_OTHER ); ++ sp->value = tm->tm_yday; ++ snprintf( sp->descr, 256, "Day-based pseudo-sensor - annual something" ); ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ ++ return 0; ++} +Index: agent/mibgroup/hardware/sensors/kstat_sensors.h +=================================================================== +--- agent/mibgroup/hardware/sensors/kstat_sensors.h (revision 0) ++++ agent/mibgroup/hardware/sensors/kstat_sensors.h (revision 16739) +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +Index: agent/mibgroup/hardware/sensors/picld_sensors.c +=================================================================== +--- agent/mibgroup/hardware/sensors/picld_sensors.c (revision 0) ++++ agent/mibgroup/hardware/sensors/picld_sensors.c (revision 16739) +@@ -0,0 +1,341 @@ ++#include ++#include ++#include ++#include ++ ++#include "util_funcs.h" ++#include ++ ++#include ++#include ++ ++void netsnmp_sensor_arch_init( void ) { ++ DEBUGMSGTL(("sensors:arch", "Initialise PICLd Sensors module\n")); ++ picl_initialize(); ++} ++ ++ ++/* ++ * Handle a numeric-valued sensor ++ */ ++static int ++read_num_sensor( picl_nodehdl_t childh, char *propval, float *value ) ++{ ++ picl_nodehdl_t sensorh; ++ picl_propinfo_t sensor_info; ++ picl_errno_t error_code; ++ ++ union valu { ++ char buf[PICL_PROPSIZE_MAX]; ++ uint32_t us4; ++ uint16_t us2; ++ int32_t is4; ++ int16_t is2; ++ float f; ++ } val; ++ ++ /* ++ * Retrieve the specified sensor information and value ++ */ ++ error_code = picl_get_propinfo_by_name(childh, propval, &sensor_info, &sensorh); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "sensor info lookup failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ error_code = picl_get_propval(sensorh, &val.buf, sensor_info.size); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "sensor value lookup failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ /* ++ * Check the validity (type and size) of this value ++ */ ++ if ( sensor_info.type == PICL_PTYPE_FLOAT ) { ++ *value = val.f; ++ } else if ( sensor_info.type == PICL_PTYPE_UNSIGNED_INT ) { ++ /* 16-bit or 32-bit unsigned integers */ ++ if ( sensor_info.size == 2 ) { ++ *value = val.us2; ++ } else if ( sensor_info.size == 4 ) { ++ *value = val.us4; ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "unsigned integer (%d bit)\n", ++ sensor_info.size * 8)); ++ return PICL_FAILURE; ++ } ++ } else if ( sensor_info.type == PICL_PTYPE_INT ) { ++ /* 16-bit or 32-bit signed integers */ ++ if ( sensor_info.size == 2 ) { ++ *value = val.is2; ++ } else if ( sensor_info.size == 4 ) { ++ *value = val.is4; ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "signed integer (%d bit)\n", ++ sensor_info.size * 8)); ++ return PICL_FAILURE; ++ } ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "unrecognised type (%d)\n", ++ sensor_info.type)); ++ return PICL_FAILURE; ++ } ++ ++ return error_code; ++} ++ ++static int ++process_num_sensor( picl_nodehdl_t childh, char *propname, char *propval, int typ ) ++{ ++ netsnmp_sensor_info *sp; ++ float value; ++ picl_errno_t error_code; ++ ++ sp = sensor_by_name( propname, typ ); ++ if ( !sp ) { ++ return -1; ++ } ++ ++ error_code = read_num_sensor( childh, propval, &value ); ++ if ( error_code == PICL_SUCCESS ) { ++ sp->value = value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "Failed to read %s sensor value (%d)\n", ++ propname, error_code)); ++ return -1; ++ } ++ return 0; ++} ++ ++ ++ ++/* ++ * Handle an enumeration-valued sensor ++ */ ++char *switch_settings[] = { "OFF","ON","NORMAL","LOCKED", ++ "UNKNOWN","DIAG","SECURE", ++ NULL }; ++char *led_settings[] = { "OFF","ON","BLINK", ++ NULL }; ++char *i2c_settings[] = { "OK", ++ NULL }; ++ ++static int ++read_enum_sensor( picl_nodehdl_t childh, float *value, char **options ) ++{ ++ picl_nodehdl_t sensorh; ++ picl_propinfo_t sensor_info; ++ picl_errno_t error_code; ++ char state[PICL_PROPSIZE_MAX]; ++ int i; ++ ++ /* ++ * Retrieve the specified sensor information and value ++ */ ++ error_code = picl_get_propinfo_by_name(childh, "State", &sensor_info, &sensorh); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "sensor info lookup failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ error_code = picl_get_propval(sensorh, state, sensor_info.size); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "sensor value lookup failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ /* ++ * Try to find a matching entry in the list of options. ++ * Note that some platforms may use upper or lower case ++ * versions of these enumeration values ++ * (so the checks are case insensitive) ++ */ ++ *value = 99; /* Dummy value */ ++ for ( i=0; options[i] != NULL; i++ ) { ++ if (strncasecmp(state, options[i], strlen(options[i])) == 0) { ++ *value = i; ++ return 0; ++ } ++ } ++ ++ DEBUGMSGTL(("sensors:arch:detail", "Enumeration state %s not matched\n", ++ state)); ++ return 0; /* Or an error ? */ ++} ++ ++static int ++process_enum_sensor( picl_nodehdl_t childh, char *propname, int typ, char **options ) ++{ ++ netsnmp_sensor_info *sp; ++ float value; ++ picl_errno_t error_code; ++ ++ sp = sensor_by_name( propname, typ ); ++ if ( !sp ) { ++ return -1; ++ } ++ ++ error_code = read_enum_sensor( childh, &value, options ); ++ if ( error_code == PICL_SUCCESS ) { ++ sp->value = value; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } else { ++ DEBUGMSGTL(("sensors:arch:detail", "Failed to read %s sensor value (%d)\n", ++ propname, error_code)); ++ return -1; ++ } ++ return 0; ++} ++static int ++process_enum_sensor( picl_nodehdl_t childh, char *propname, int typ, char **options ) ++{ ++ return 0; ++} ++ ++ ++ ++/* ++ * Recursively walk through the tree of sensors ++ */ ++static int ++process_sensors( int level, picl_nodehdl_t nodeh ) { ++ picl_nodehdl_t childh, nexth; ++ char propname[ PICL_PROPNAMELEN_MAX ]; ++ char propclass[ PICL_CLASSNAMELEN_MAX ]; ++ picl_errno_t error_code; ++ ++ level++; ++ DEBUGMSGTL(("sensors:arch:detail", "process_sensors - level %d\n", level)); ++ ++ /* Look up the first child node at this level */ ++ error_code = pick_get_propval_by_name( nodeh, PICL_PROP_CHILD, ++ &childh, sizeof(childh)); ++ if ( error_code != PICL_SUCCESS ) { ++ DEBUGMSGTL(("sensors:arch:detail", "Failed to get first child node (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ /* Step through the child nodes, retrieving the name and class of each one */ ++ while ( error_code == PICL_SUCCESS ) { ++ error_code = pick_get_propval_by_name( childh, PICL_PROP_NAME, ++ propname, sizeof(propname)-1); ++ if ( error_code != PICL_SUCCESS ) { ++ /* The Node With No Name */ ++ DEBUGMSGTL(("sensors:arch:detail", "get property name failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ error_code = pick_get_propval_by_name( childh, PICL_PROP_CLASSNAME, ++ propclass, sizeof(propclass)-1); ++ if ( error_code != PICL_SUCCESS ) { ++ /* The Classless Society */ ++ DEBUGMSGTL(("sensors:arch:detail", "get property class failed (%d)\n", ++ error_code)); ++ return( error_code ); ++ } ++ ++ DEBUGMSGTL(("sensors:arch:detail", "Name: %s, Class %s\n", ++ propname, propclass )); ++ ++ ++ /* ++ * Three classes represent further groups of sensors, etc. ++ * Call 'process_sensors' recursively to handle this next level ++ */ ++ if (( strstr( propclass, "picl" )) || ++ ( strstr( propclass, "frutree" )) || ++ ( strstr( propclass, "obp" ))) { ++ process_sensors( level, childh ); ++ } ++ /* ++ * Otherwise retrieve the value appropriately based on the ++ * class of the sensor. ++ * ++ * We need to specify the name of the PICL property to retrieve ++ * for this class of sensor, and the Net-SNMP sensor type. ++ */ ++ else if ( strstr( propclass, "fan-tachometer" )) { ++ process_num_sensor( childh, propname, "AtoDSensorValue", ++ NETSNMP_SENSOR_TYPE_RPM ); ++ } else if ( strstr( propclass, "fan" )) { ++ process_num_sensor( childh, propname, "Speed", ++ NETSNMP_SENSOR_TYPE_RPM ); ++ } else if ( strstr( propclass, "temperature-sensor" )) { ++ process_num_sensor( childh, propname, "Temperature", ++ NETSNMP_SENSOR_TYPE_TEMPERATURE ); ++ } else if ( strstr( propclass, "voltage-sensor" )) { ++ process_num_sensor( childh, propname, "Voltage", ++ /* ?? */ NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); ++ } else if ( strstr( propclass, "digital-sensor" )) { ++ process_num_sensor( childh, propname, "AtoDSensorValue", ++ /* ?? */ NETSNMP_SENSOR_TYPE_VOLTAGE_DC ); ++ /* ++ * Enumeration-valued sensors use a fixed PICL property ("State"), ++ * but take a list of the values appropriate for that sensor, ++ * as well as the Net-SNMP sensor type. ++ */ ++ } else if ( strstr( propclass, "switch" )) { ++ process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_OTHER, ++ switch_settings ); ++ } else if ( strstr( propclass, "led" )) { ++ process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_OTHER, ++ led_settings ); ++ } else if ( strstr( propclass, "i2c" )) { ++ process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_BOOLEAN, /* ?? */ ++ i2c_settings ); ++ } else { ++ /* Skip other classes of sensor */ ++ DEBUGMSGTL(("sensors:arch:detail", "Skipping class %s\n", propclass )); ++ } ++ ++ /* ++ * Move on to the next child node at the current level (if any) ++ */ ++ error_code = pick_get_propval_by_name( childh, PICL_PROP_PEER, ++ &nexth, sizeof(nexth)); ++ if ( error_code != PICL_SUCCESS ) { ++ /* That's All Folks! */ ++ return (( error_code == PICL_PROPNOTFOUND ) ++ ? PICL_SUCCESS : error_code ); ++ } ++ childh = nexth; ++ } ++ ++ return error_code; ++} ++ ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ int error_code; ++ picl_nodehdl_t rooth; ++ ++ DEBUGMSGTL(("sensors:arch", "Reload PICLd Sensors module\n")); ++ ++ error_code = picl_get_root(&rooth); ++ if ( error_code != PICL_SUCCESS) { ++ DEBUGMSGTL(("sensors:arch", "Couldn't get root node (error %d)\n", error_code)); ++ return 1; ++ } ++ ++ error_code = process_sensors(0, rooth); ++ if ( error_code != 255 ) ++ if ( error_code != 7 ) /* ignore PICL_PROPNOTFOUND error */ ++ DEBUGMSGTL(("sensors:arch", "Internal PICLd problem (error %d)\n", error_code)); ++ ++ return 0; ++} ++ ++void netsnmp_sensor_arch_shutdown( void ) { ++ DEBUGMSGTL(("sensors:arch", "Shutdown PicLD Sensors module\n")); ++ picl_shutdown(); ++} ++ +Index: agent/mibgroup/hardware/sensors/hw_sensors.c +=================================================================== +--- agent/mibgroup/hardware/sensors/hw_sensors.c (revision 0) ++++ agent/mibgroup/hardware/sensors/hw_sensors.c (revision 16739) +@@ -0,0 +1,183 @@ ++#include ++#include ++#include ++#include ++ ++ ++extern NetsnmpCacheLoad netsnmp_sensor_arch_load; ++extern void netsnmp_sensor_arch_init( void ); ++static int _sensor_load( void ); ++static void _sensor_free( void ); ++ ++static int _sensorAutoUpdate = 0; /* 0 means on-demand caching */ ++static void _sensor_update_stats( unsigned int, void* ); ++ ++netsnmp_cache *_sensor_cache = NULL; ++netsnmp_container *_sensor_container = NULL; ++static int _sensor_idx = 0; ++ ++void init_hw_sensors( void ) { ++ ++ if ( _sensor_container ) ++ return; /* Already initialised */ ++ ++ DEBUGMSGTL(("sensors", "Initialise Hardware Sensors module\n")); ++ ++ /* ++ * Define a container to hold the basic list of sensors ++ * The four LM-SENSOR-MIB containers will be created in ++ * the relevant initialisation routine(s) ++ */ ++ _sensor_container = netsnmp_container_find("sensorTable:table_container"); ++ if ( NULL == _sensor_container ) { ++ snmp_log( LOG_ERR, "failed to create container for sensorTable"); ++ return; ++ } ++ netsnmp_sensor_arch_init( ); ++ ++ /* ++ * If we're sampling the sensor information automatically, ++ * then arrange for this to be triggered regularly. ++ * ++ * If we're not sampling these values regularly, ++ * create a suitable cache handler instead. ++ */ ++ if ( _sensorAutoUpdate ) { ++ DEBUGMSGTL(("sensors", "Reloading Hardware Sensors automatically (%d)\n", ++ _sensorAutoUpdate)); ++ snmp_alarm_register( _sensorAutoUpdate, SA_REPEAT, ++ _sensor_update_stats, NULL ); ++ } ++ else { ++ _sensor_cache = netsnmp_cache_create( 5, netsnmp_sensor_load, ++ netsnmp_sensor_free, NULL, 0 ); ++ DEBUGMSGTL(("sensors", "Reloading Hardware Sensors on-demand (%p)\n", ++ _sensor_cache)); ++ } ++} ++ ++void shutdown_hw_sensors( void ) { ++ _sensor_free(); ++} ++ ++/* ++ * Return the main sensor container ++ */ ++netsnmp_container *get_sensor_container( void ) { return _sensor_container; } ++ ++/* ++ * Return the main sensor cache control structure (if defined) ++ */ ++netsnmp_cache *get_sensor_cache( void ) { return _sensor_cache; } ++ ++ ++/* ++ * Wrapper routine for automatically updating sensor statistics ++ */ ++void ++_sensor_update_stats( unsigned int clientreg, void *data ) ++{ ++ _sensor_free(); ++ _sensor_load(); ++} ++ ++/* ++ * Wrapper routine for re-loading sensor statistics on demand ++ */ ++int ++netsnmp_sensor_load( netsnmp_cache *cache, void *data ) ++{ ++ return _sensor_load(); ++} ++ ++/* ++ * Wrapper routine for releasing expired sensor statistics ++ */ ++void ++netsnmp_sensor_free( netsnmp_cache *cache, void *data ) ++{ ++ _sensor_free(); ++} ++ ++ ++/* ++ * Architecture-independent processing of loading sensor statistics ++ */ ++static int ++_sensor_load( void ) ++{ ++ netsnmp_sensor_arch_load( NULL, NULL ); ++} ++ ++/* ++ * Architecture-independent release of sensor statistics ++ */ ++static void ++_sensor_free( void ) ++{ ++ netsnmp_sensor_info *sp; ++ ++ for (sp = CONTAINER_FIRST( _sensor_container ); ++ sp; ++ sp = CONTAINER_NEXT( _sensor_container, sp )) { ++ ++ sp->flags &= ~ NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++} ++ ++ ++/* ++ * Retrieve a sensor entry by name, ++ * or (optionally) insert a new one into the container ++ */ ++netsnmp_sensor_info * ++sensor_by_name( char *name, int create_type ) ++{ ++ netsnmp_sensor_info *sp; ++ ++ DEBUGMSGTL(("sensors:name", "Get sensor entry (%s)\n", name)); ++ ++ /* ++ * Look through the list for a matching entry ++ */ ++ /* .. or use a secondary index container ?? */ ++ for (sp = CONTAINER_FIRST( _sensor_container ); ++ sp; ++ sp = CONTAINER_NEXT( _sensor_container, sp )) { ++ ++ if ( !strcmp( name, sp->name )) ++ return sp; ++ } ++ ++ /* ++ * Not found... ++ */ ++ if ( create_type == NETSNMP_SENSOR_FIND_EXIST ) { ++ DEBUGMSGTL(("sensors:name", "No such sensor entry\n")); ++ return NULL; ++ } ++ ++ /* ++ * ... so let's create a new one, using the type supplied ++ */ ++ sp = SNMP_MALLOC_TYPEDEF( netsnmp_sensor_info ); ++ if ( sp ) { ++ strcpy( sp->name, name ); ++ sp->type = create_type; ++ /* ++ * Set up the index value. ++ * ++ * All this trouble, just for a simple integer. ++ * Surely there must be a better way? ++ */ ++ sp->idx.len = 1; ++ sp->idx.oids = SNMP_MALLOC_TYPEDEF( oid ); ++ sp->idx.oids[0] = ++_sensor_idx; ++ } ++ ++ DEBUGMSGTL(("sensors:name", "Create sensor entry (type = %d, index = %d\n", ++ create_type, _sensor_idx)); ++ CONTAINER_INSERT( _sensor_container, sp ); ++ return sp; ++} ++ +Index: agent/mibgroup/hardware/sensors/dummy_sensors.h +=================================================================== +--- agent/mibgroup/hardware/sensors/dummy_sensors.h (revision 0) ++++ agent/mibgroup/hardware/sensors/dummy_sensors.h (revision 16739) +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +Index: agent/mibgroup/hardware/sensors/lmsensors_v2.c +=================================================================== +--- agent/mibgroup/hardware/sensors/lmsensors_v2.c (revision 0) ++++ agent/mibgroup/hardware/sensors/lmsensors_v2.c (revision 16739) +@@ -0,0 +1,75 @@ ++#include ++#include ++#include ++#include ++ ++#include "util_funcs.h" ++#include ++#include ++ ++void netsnmp_sensor_arch_init( void ) { ++ FILE *fp = fopen("/etc/sensors.conf", "r"); ++ DEBUGMSGTL(("sensors:arch", "Initialise LM Sensors module\n")); ++ sensors_init( fp ); ++} ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ netsnmp_sensor_info *sp; ++ const sensors_chip_name *chip; ++ const sensors_feature_data *data; ++ int chip_nr = 0; ++ ++ DEBUGMSGTL(("sensors:arch", "Reload LM Sensors module\n")); ++ while ((chip = sensors_get_detected_chips(&chip_nr))) { ++ int a = 0; ++ int b = 0; ++ ++ while ((data = sensors_get_all_features(*chip, &a, &b))) { ++ DEBUGMSGTL(("sensors:arch:detail", "get_all_features (%d, %d)\n", a, b)); ++ char *label = NULL; ++ double val; ++ int type = NETSNMP_SENSOR_TYPE_OTHER; ++ ++ if ((data->mode & SENSORS_MODE_R) && ++ (data->mapping == SENSORS_NO_MAPPING) && ++ !sensors_get_label(*chip, data->number, &label) && ++ !sensors_get_feature(*chip, data->number, &val)) { ++ ++ DEBUGMSGTL(("sensors:arch:detail", "%s = %f\n", label, val)); ++ /* ++ * Determine the type of sensor from the description. ++ * ++ * If the text being looked for below is not in the label of a ++ * given sensor (e.g., the temp1 sensor has been labeled 'CPU' ++ * rather than 'CPU temp') it will be categorised as OTHER. ++ */ ++ if (strstr(label, "V")) { ++ type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC; ++ } ++ if (strstr(label, "fan") || strstr(label, "Fan")) { ++ type = NETSNMP_SENSOR_TYPE_RPM; ++ } ++ if (strstr(label, "temp") || strstr(label, "Temp")) { ++ type = NETSNMP_SENSOR_TYPE_TEMPERATURE; ++ } ++ ++ /* ++ * Use this type to create a new sensor entry ++ * (inserting it in the appropriate sub-containers) ++ */ ++ sp = sensor_by_name( label, type ); ++ if ( sp ) { ++ sp->value = val; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ } ++ if (label) { ++ free(label); ++ label = NULL; ++ } ++ } /* end while data */ ++ } /* end while chip */ ++ ++ return 0; ++} +Index: agent/mibgroup/hardware/sensors/picld_sensors.h +=================================================================== +--- agent/mibgroup/hardware/sensors/picld_sensors.h (revision 0) ++++ agent/mibgroup/hardware/sensors/picld_sensors.h (revision 16739) +@@ -0,0 +1 @@ ++config_require(hardware/sensors/hw_sensors) +Index: agent/mibgroup/hardware/sensors/lmsensors_v3.c +=================================================================== +--- agent/mibgroup/hardware/sensors/lmsensors_v3.c (revision 0) ++++ agent/mibgroup/hardware/sensors/lmsensors_v3.c (revision 16739) +@@ -0,0 +1,101 @@ ++#include ++#include ++#include ++#include ++ ++#include "util_funcs.h" ++#include ++#include ++ ++ ++void netsnmp_sensor_arch_init( void ) { ++ FILE *fp = fopen("/etc/sensors.conf", "r"); ++ DEBUGMSGTL(("sensors:arch", "Initialise v3 LM Sensors module\n")); ++ sensors_init( fp ); ++} ++ ++int ++netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) { ++ netsnmp_sensor_info *sp; ++ const sensors_chip_name *chip; ++ const sensors_feature *data; ++ const sensors_subfeature *data2; ++ int chip_nr = 0; ++ ++ DEBUGMSGTL(("sensors:arch", "Reload v3 LM Sensors module\n")); ++ while ((chip = sensors_get_detected_chips( NULL, &chip_nr))) { ++ int a = 0; ++ ++ while ((data = sensors_get_features( chip, &a))) { ++ DEBUGMSGTL(("sensors:arch:detail", "get_features (%s, %d)\n", data->name, data->number)); ++ int b = 0; ++ ++ ++ while ((data2 = sensors_get_all_subfeatures( chip, data, &b))) { ++ char *label = NULL; ++ double val; ++ int type = NETSNMP_SENSOR_TYPE_OTHER; ++ ++ DEBUGMSGTL(("sensors:arch:detail", " get_subfeatures (%s, %d)\n", data2->name, data2->number)); ++ /* ++ * Check the type of this subfeature, ++ * concentrating on the main "input" measurements. ++ */ ++ switch ( data2->type ) { ++ case SENSORS_SUBFEATURE_IN_INPUT: ++ type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC; ++ break; ++ case SENSORS_SUBFEATURE_FAN_INPUT: ++ type = NETSNMP_SENSOR_TYPE_RPM; ++ break; ++ case SENSORS_SUBFEATURE_TEMP_INPUT: ++ type = NETSNMP_SENSOR_TYPE_TEMPERATURE; ++ break; ++ case SENSORS_SUBFEATURE_VID: ++ type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC; ++ break; ++ default: ++ /* Skip everything other than these basic sensor features - ??? */ ++ DEBUGMSGTL(("sensors:arch:detail", " Skip type %x\n", data2->type)); ++ continue; ++ } ++ ++ /* ++ * Get the name and value of this subfeature ++ */ ++/* ++ if (!(label = sensors_get_label(chip, data))) { ++ DEBUGMSGTL(("sensors:arch:detail", " Can't get name (%s)\n", label)); ++ continue; ++ } ++ if (sensors_get_value(chip, data2->number, &val) < 0) { ++ DEBUGMSGTL(("sensors:arch:detail", " Can't get value (%f)\n", val)); ++ continue; ++ } ++*/ ++ if (!(label = sensors_get_label(chip, data)) || ++ (sensors_get_value(chip, data2->number, &val) < 0)) { ++ DEBUGMSGTL(("sensors:arch:detail", " Can't get name/value (%s, %f)\n", label, val)); ++ continue; ++ } ++ DEBUGMSGTL(("sensors:arch:detail", "%s = %f\n", label, val)); ++ ++ /* ++ * Use this type to create a new sensor entry ++ * (inserting it in the appropriate sub-containers) ++ */ ++ sp = sensor_by_name( label, type ); ++ if ( sp ) { ++ sp->value = val; ++ sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE; ++ } ++ if (label) { ++ free(label); ++ label = NULL; ++ } ++ } /* end while data2 */ ++ } /* end while data */ ++ } /* end while chip */ ++ ++ return 0; ++} diff --git a/net-snmp.spec b/net-snmp.spec index 58ca495..af686ad 100644 --- a/net-snmp.spec +++ b/net-snmp.spec @@ -7,7 +7,7 @@ Summary: A collection of SNMP protocol tools and libraries Name: net-snmp Version: %{major_ver} -Release: 5%{?dist} +Release: 6%{?dist} Epoch: 1 License: BSD and CMU @@ -37,6 +37,7 @@ Patch12: net-snmp-5.4.1-hostname.patch Patch13: net-snmp-5.4.1-shared-ip.patch Patch14: net-snmp-5.4-exec-crash.patch Patch15: net-snmp-5.1.2-snmpconf-selinux.patch +Patch16: net-snmp-5.4.1-sensors3.patch Requires(pre): /sbin/chkconfig Requires(post): /sbin/chkconfig @@ -163,6 +164,7 @@ and applications. %patch13 -p1 -b .shared-ip %patch14 -p1 -b .exec %patch15 -p1 -b .selinux +%patch16 -p0 -b .sensors # Do this patch with a perl hack... perl -pi -e "s|'\\\$install_libdir'|'%{_libdir}'|" ltmain.sh @@ -178,13 +180,13 @@ MIBS="host agentx smux \ ip-mib/ipv4InterfaceTable ip-mib/ipv6InterfaceTable \ ip-mib/ipAddressPrefixTable/ipAddressPrefixTable" %ifnarch s390 s390x -MIBS="$MIBS ucd-snmp/lmSensors" +MIBS="$MIBS ucd-snmp/lmsensorsMib" %endif %configure \ --enable-static --enable-shared \ --with-cflags="$RPM_OPT_FLAGS" \ - --with-ldflags="$LDFLAGS -lcrypto" \ + --with-ldflags="$LDFLAGS -lcrypto -lsensors" \ --with-sys-location="Unknown" \ --with-logfile="/var/log/snmpd.log" \ --with-persistent-directory="/var/net-snmp" \ @@ -375,6 +377,9 @@ rm -rf ${RPM_BUILD_ROOT} %{_libdir}/lib*.so.* %changelog +* Wed Nov 14 2007 Jan Safranek 5.4.1-6 +- add support of lm_sensors v3 + * Thu Oct 25 2007 Jan Safranek 5.4.1-5 - move mib2c-update from net-snmp-utils to net-snmp-perl, where mib2c is located