net-snmp-lm_sensors_3.patch

   1 351991: Port net-snmp to lm_sensors-3.x.x
   2 Source: upstream, svn diff -r 16736:16739
   3 Reviewed-By: Jan Safranek <jsafrane@redhat.com>
   4
   5 Index: configure
   6 ===================================================================
   7 --- configure   (revision 16736)
   8 +++ configure   (revision 16739)
   9 @@ -32628,7 +32628,7 @@
  10  fi
  11
  12  # LM-SENSORS-MIB support
  13 -echo " $module_list " | grep " ucd-snmp/lmSensors " > /dev/null
  14 +echo " $module_list " | $GREP -i "ucd-snmp/lmsensor" > /dev/null
  15  if test $? -eq 0 ; then
  16          { echo "$as_me:$LINENO: checking for sensors support" >&5
  17  echo $ECHO_N "checking for sensors support... $ECHO_C" >&6; }
  18 Index: include/net-snmp/agent/hardware/sensors.h
  19 ===================================================================
  20 --- include/net-snmp/agent/hardware/sensors.h   (revision 0)
  21 +++ include/net-snmp/agent/hardware/sensors.h   (revision 16739)
  22 @@ -0,0 +1,48 @@
  23 +/*
  24 + * Hardware Abstraction Layer - Sensors module
  25 + *
  26 + * Public interface
  27 + */
  28 +
  29 +#define NETSNMP_SENSOR_TYPE_OTHER       1
  30 +#define NETSNMP_SENSOR_TYPE_VOLTAGE_AC  3
  31 +#define NETSNMP_SENSOR_TYPE_VOLTAGE_DC  4
  32 +#define NETSNMP_SENSOR_TYPE_CURRENT     5
  33 +#define NETSNMP_SENSOR_TYPE_POWER       6
  34 +#define NETSNMP_SENSOR_TYPE_FREQUENCY   7
  35 +#define NETSNMP_SENSOR_TYPE_TEMPERATURE 8
  36 +#define NETSNMP_SENSOR_TYPE_HUMIDITY    9
  37 +#define NETSNMP_SENSOR_TYPE_RPM        10
  38 +#define NETSNMP_SENSOR_TYPE_VOLUME     11
  39 +#define NETSNMP_SENSOR_TYPE_BOOLEAN    12
  40 +
  41 +
  42 +#define NETSNMP_SENSOR_FLAG_ACTIVE     0x01
  43 +#define NETSNMP_SENSOR_FLAG_NAVAIL     0x02
  44 +#define NETSNMP_SENSOR_FLAG_BROKEN     0x04
  45 +#define NETSNMP_SENSOR_FLAG_DISABLE    0x08
  46 +
  47 +#define NETSNMP_SENSOR_MASK_STATUS     0x06  /* NAVAIL|BROKEN */
  48 +
  49 +
  50 +#define NETSNMP_SENSOR_FIND_CREATE     1   /* or use one of the sensor type values */
  51 +#define NETSNMP_SENSOR_FIND_EXIST      0
  52 +
  53 +typedef struct netsnmp_sensor_info_s netsnmp_sensor_info;
  54 +struct netsnmp_sensor_info_s {
  55 +
  56 +    netsnmp_index  idx;
  57 +    /* int  idx; */
  58 +    char  name[256];
  59 +
  60 +    int   type;
  61 +    float value;
  62 +    char  descr[256];
  63 +    long  flags;
  64 +};
  65 +
  66 +netsnmp_container   *get_sensor_container( void );
  67 +netsnmp_cache       *get_sensor_cache( void );
  68 +netsnmp_sensor_info *sensor_by_name( char *, int );
  69 +NetsnmpCacheLoad     netsnmp_sensor_load;
  70 +NetsnmpCacheFree     netsnmp_sensor_free;
  71 Index: configure.in
  72 ===================================================================
  73 --- configure.in        (revision 16736)
  74 +++ configure.in        (revision 16739)
  75 @@ -2885,7 +2885,7 @@
  76  fi
  77
  78  # LM-SENSORS-MIB support
  79 -echo " $module_list " | grep " ucd-snmp/lmSensors " > /dev/null
  80 +echo " $module_list " | $GREP -i "ucd-snmp/lmsensor" > /dev/null
  81  if test $? -eq 0 ; then
  82          AC_MSG_CHECKING([for sensors support])
  83          case $target_os in
  84 Index: agent/mibgroup/ucd-snmp/lmsensorsMib.c
  85 ===================================================================
  86 --- agent/mibgroup/ucd-snmp/lmsensorsMib.c      (revision 0)
  87 +++ agent/mibgroup/ucd-snmp/lmsensorsMib.c      (revision 16739)
  88 @@ -0,0 +1,205 @@
  89 +#include <net-snmp/net-snmp-config.h>
  90 +#include <net-snmp/net-snmp-includes.h>
  91 +#include <net-snmp/agent/net-snmp-agent-includes.h>
  92 +#include <net-snmp/agent/hardware/sensors.h>
  93 +#include "ucd-snmp/lmsensorsMib.h"
  94 +
  95 +netsnmp_container *sensorContainer = NULL;
  96 +
  97 +void initialize_lmSensorsTable(const char *tableName, oid *tableOID,
  98 +                               netsnmp_container_op *filter, int mult );
  99 +
 100 +int _sensor_filter_temp( netsnmp_container *c, const void *v );
 101 +int _sensor_filter_fan(  netsnmp_container *c, const void *v );
 102 +int _sensor_filter_volt( netsnmp_container *c, const void *v );
 103 +int _sensor_filter_misc( netsnmp_container *c, const void *v );
 104 +
 105 +static oid lmTempSensorsTable_oid[]   = {1,3,6,1,4,1,2021,13,16,2};
 106 +static oid lmFanSensorsTable_oid[]    = {1,3,6,1,4,1,2021,13,16,3};
 107 +static oid lmVoltSensorsTable_oid[]   = {1,3,6,1,4,1,2021,13,16,4};
 108 +static oid lmMiscSensorsTable_oid[]   = {1,3,6,1,4,1,2021,13,16,5};
 109 +            /* All the tables have the same length root OID */
 110 +size_t     lmSensorsTables_oid_len = OID_LENGTH(lmMiscSensorsTable_oid);
 111 +
 112 +
 113 +/* Initialise the LM Sensors MIB module */
 114 +void
 115 +init_lmsensorsMib(void)
 116 +{
 117 +    DEBUGMSGTL(("ucd-snmp/lmsensorsMib","Initializing LM-SENSORS-MIB tables\n"));
 118 +
 119 +    /*
 120 +     * Initialise the four LM-SENSORS-MIB tables
 121 +     *
 122 +     * They are almost identical, so we can use the same registration code.
 123 +     */
 124 +    initialize_lmSensorsTable( "lmTempSensorsTable", lmTempSensorsTable_oid,
 125 +                                _sensor_filter_temp, 1000 );  /* MIB asks for mC */
 126 +    initialize_lmSensorsTable( "lmFanSensorsTable",  lmFanSensorsTable_oid,
 127 +                                _sensor_filter_fan,  1);
 128 +    initialize_lmSensorsTable( "lmVoltSensorsTable", lmVoltSensorsTable_oid,
 129 +                                _sensor_filter_volt, 1000 );  /* MIB asks for mV */
 130 +    initialize_lmSensorsTable( "lmMiscSensorsTable", lmMiscSensorsTable_oid,
 131 +                                _sensor_filter_misc, 1 );
 132 +}
 133 +
 134 +/*
 135 + * Common initialisation code, used for setting up all four tables
 136 + */
 137 +void
 138 +initialize_lmSensorsTable(const char *tableName, oid *tableOID,
 139 +                          netsnmp_container_op *filter, int mult )
 140 +{
 141 +    netsnmp_handler_registration    *reg;
 142 +    netsnmp_table_registration_info *table_info;
 143 +    netsnmp_cache     *cache;
 144 +    netsnmp_container *container;
 145 +
 146 +    /*
 147 +     * Ensure the HAL sensors module has been initialised,
 148 +     *   and retrieve the main sensors container.
 149 +     * This table will then be registered using a filter on this container.
 150 +     */
 151 +    sensorContainer = get_sensor_container();
 152 +    if ( !sensorContainer ) {
 153 +        init_hw_sensors( );
 154 +        sensorContainer = get_sensor_container();
 155 +    }
 156 +    container = netsnmp_container_find("sensorTable:table_container");
 157 +    container->insert_filter = filter;
 158 +    netsnmp_container_add_index( sensorContainer, container );
 159 +
 160 +
 161 +    /*
 162 +     * Create a basic registration structure for the table
 163 +     */
 164 +    reg = netsnmp_create_handler_registration(
 165 +               tableName, lmSensorsTables_handler,
 166 +               tableOID,  lmSensorsTables_oid_len, HANDLER_CAN_RONLY
 167 +              );
 168 +
 169 +    /*
 170 +     * Register the table using the filtered container
 171 +     * Include an indicator of any scaling to be applied to the sensor value
 172 +     */
 173 +    reg->my_reg_void = (void *)mult;
 174 +    table_info = SNMP_MALLOC_TYPEDEF( netsnmp_table_registration_info );
 175 +    netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, 0);
 176 +    table_info->min_column = COLUMN_LMSENSORS_INDEX;
 177 +    table_info->max_column = COLUMN_LMSENSORS_VALUE;
 178 +    netsnmp_container_table_register( reg, table_info, container, 0 );
 179 +
 180 +    /*
 181 +     * If the HAL sensors module was configured as an on-demand caching
 182 +     *  module (rather than being automatically loaded regularly),
 183 +     *  then ensure this table makes use of that cache.
 184 +     */
 185 +    cache = get_sensor_cache();
 186 +    if ( cache ) {
 187 +        netsnmp_inject_handler_before( reg, netsnmp_cache_handler_get( cache ),
 188 +                                            "table_container");
 189 +    }
 190 +
 191 +}
 192 +
 193 +
 194 +/*
 195 + *  Container filters for the four tables
 196 + *
 197 + *  Used to ensure that sensor entries appear in the appropriate table.
 198 + */
 199 +int _sensor_filter_temp( netsnmp_container *c, const void *v ) {
 200 +    const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v;
 201 +    /* Only matches temperature sensors */
 202 +    return (( sp->type == NETSNMP_SENSOR_TYPE_TEMPERATURE ) ? 0 : 1 );
 203 +}
 204 +
 205 +int _sensor_filter_fan( netsnmp_container *c, const void *v ) {
 206 +    const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v;
 207 +    /* Only matches fan sensors */
 208 +    return (( sp->type == NETSNMP_SENSOR_TYPE_RPM ) ? 0 : 1 );
 209 +}
 210 +
 211 +int _sensor_filter_volt( netsnmp_container *c, const void *v ) {
 212 +    const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v;
 213 +    /* Only matches voltage sensors (AC or DC) */
 214 +    return ((( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_DC ) ||
 215 +             ( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_AC )) ? 0 : 1 );
 216 +}
 217 +
 218 +int _sensor_filter_misc( netsnmp_container *c, const void *v ) {
 219 +    const netsnmp_sensor_info *sp = (const netsnmp_sensor_info *)v;
 220 +    /* Matches everything except temperature, fan or voltage sensors */
 221 +    return ((( sp->type == NETSNMP_SENSOR_TYPE_TEMPERATURE ) ||
 222 +             ( sp->type == NETSNMP_SENSOR_TYPE_RPM         ) ||
 223 +             ( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_DC  ) ||
 224 +             ( sp->type == NETSNMP_SENSOR_TYPE_VOLTAGE_AC  )) ? 1 : 0 );
 225 +}
 226 +
 227 +
 228 +/*
 229 + * Handle requests for any of the four lmXxxxSensorsTables
 230 + *
 231 + * This is possible because all the table share the
 232 + *  same structure and behaviour.
 233 + */
 234 +int
 235 +lmSensorsTables_handler(
 236 +    netsnmp_mib_handler               *handler,
 237 +    netsnmp_handler_registration      *reginfo,
 238 +    netsnmp_agent_request_info        *reqinfo,
 239 +    netsnmp_request_info              *requests) {
 240 +
 241 +    netsnmp_request_info       *request;
 242 +    netsnmp_table_request_info *table_info;
 243 +    netsnmp_sensor_info        *sensor_info;
 244 +    int mult  = (int)reginfo->my_reg_void;
 245 +
 246 +    DEBUGMSGTL(( "ucd-snmp/lmsensorsMib","lmSensorsTables_handler - root: "));
 247 +    DEBUGMSGOID(("ucd-snmp/lmsensorsMib", reginfo->rootoid, reginfo->rootoid_len));
 248 +    DEBUGMSG((   "ucd-snmp/lmsensorsMib",", mode %d\n", reqinfo->mode ));
 249 +    /*
 250 +     * This is a read-only table, so we only need to handle GET requests.
 251 +     *    (The container helper converts GETNEXT->GET requests automatically).
 252 +     */
 253 +    switch (reqinfo->mode) {
 254 +    case MODE_GET:
 255 +        for (request=requests; request; request=request->next) {
 256 +            sensor_info = (netsnmp_sensor_info *)
 257 +                            netsnmp_container_table_extract_context(request);
 258 +            if ( !sensor_info ) {
 259 +                netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE);
 260 +                continue;
 261 +            }
 262 +
 263 +            table_info   =  netsnmp_extract_table_info(request);
 264 +            switch (table_info->colnum) {
 265 +            case COLUMN_LMSENSORS_INDEX:
 266 +                snmp_set_var_typed_integer( request->requestvb, ASN_INTEGER,
 267 +                                            sensor_info->idx.oids[0]);
 268 +                break;
 269 +            case COLUMN_LMSENSORS_DEVICE:
 270 +                if ( sensor_info->descr[0] != '\0' ) {
 271 +                    snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
 272 +                                              sensor_info->descr, strlen(sensor_info->descr));
 273 +                } else {
 274 +                    snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
 275 +                                              sensor_info->name,  strlen(sensor_info->name));
 276 +                }
 277 +                break;
 278 +            case COLUMN_LMSENSORS_VALUE:
 279 +                /* Multiply the value by the appropriate scaling factor for this table */
 280 +                snmp_set_var_typed_integer( request->requestvb, ASN_GAUGE,
 281 +                                            (int)(mult*sensor_info->value));
 282 +                break;
 283 +            default:
 284 +                netsnmp_set_request_error(reqinfo, request,
 285 +                                          SNMP_NOSUCHOBJECT);
 286 +                break;
 287 +            }
 288 +        }
 289 +        break;
 290 +
 291 +    }
 292 +    return SNMP_ERR_NOERROR;
 293 +}
 294 Index: agent/mibgroup/ucd-snmp/lmsensorsMib.h
 295 ===================================================================
 296 --- agent/mibgroup/ucd-snmp/lmsensorsMib.h      (revision 0)
 297 +++ agent/mibgroup/ucd-snmp/lmsensorsMib.h      (revision 16739)
 298 @@ -0,0 +1,23 @@
 299 +#ifndef LM_SENSORS_MIB_H
 300 +#define LM_SENSORS_MIB_H
 301 +
 302 +config_require(hardware/sensors)
 303 +config_add_mib(LM-SENSORS-MIB)
 304 +
 305 +/* function declarations */
 306 +void init_lmsensorsMib(void);
 307 +
 308 +/*
 309 + * Handler and Column definitions for lmXxxxSensorsTable
 310 + *
 311 + * Note that the same handler (and hence the same
 312 + *  column identifiers) are used for all four tables.
 313 + * This is possible because all the table share the
 314 + *  same structure and behaviour.
 315 + */
 316 +Netsnmp_Node_Handler lmSensorsTables_handler;
 317 +#define COLUMN_LMSENSORS_INDEX         1
 318 +#define COLUMN_LMSENSORS_DEVICE                2
 319 +#define COLUMN_LMSENSORS_VALUE         3
 320 +
 321 +#endif /* LM_SENSORS_MIB_H */
 322 Index: agent/mibgroup/hardware/sensors.h
 323 ===================================================================
 324 --- agent/mibgroup/hardware/sensors.h   (revision 0)
 325 +++ agent/mibgroup/hardware/sensors.h   (revision 16739)
 326 @@ -0,0 +1,13 @@
 327 +config_require(hardware/sensors/hw_sensors)
 328 +
 329 +#if defined(solaris)
 330 +# if defined(HAVE_PICL_H)
 331 +config_require(hardware/sensors/picld_sensors)
 332 +# else
 333 +config_require(hardware/sensors/kstat_sensors)
 334 +# endif
 335 +#else
 336 +config_require(hardware/sensors/lmsensors_v3)
 337 +#endif
 338 +
 339 +//config_require(hardware/sensors/dummy_sensors)
 340 Index: agent/mibgroup/hardware/sensors/hw_sensors.h
 341 ===================================================================
 342 --- agent/mibgroup/hardware/sensors/hw_sensors.h        (revision 0)
 343 +++ agent/mibgroup/hardware/sensors/hw_sensors.h        (revision 16739)
 344 @@ -0,0 +1 @@
 345 +void init_hw_sensors( void );
 346 Index: agent/mibgroup/hardware/sensors/lmsensors_v2.h
 347 ===================================================================
 348 --- agent/mibgroup/hardware/sensors/lmsensors_v2.h      (revision 0)
 349 +++ agent/mibgroup/hardware/sensors/lmsensors_v2.h      (revision 16739)
 350 @@ -0,0 +1 @@
 351 +config_require(hardware/sensors/hw_sensors)
 352 Index: agent/mibgroup/hardware/sensors/kstat_sensors.c
 353 ===================================================================
 354 --- agent/mibgroup/hardware/sensors/kstat_sensors.c     (revision 0)
 355 +++ agent/mibgroup/hardware/sensors/kstat_sensors.c     (revision 16739)
 356 @@ -0,0 +1,161 @@
 357 +#include <net-snmp/net-snmp-config.h>
 358 +#include <net-snmp/net-snmp-includes.h>
 359 +#include <net-snmp/agent/net-snmp-agent-includes.h>
 360 +#include <net-snmp/agent/hardware/sensors.h>
 361 +
 362 +#include "util_funcs.h"
 363 +#include <time.h>
 364 +
 365 +#include <kstat.h>
 366 +#include </usr/platform/sun4u/include/sys/envctrl.h>
 367 +
 368 +void netsnmp_sensor_arch_init( void ) {
 369 +    DEBUGMSGTL(("sensors:arch", "Initialise KStat Sensors module\n"));
 370 +}
 371 +
 372 +
 373 +int
 374 +netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) {
 375 +    netsnmp_sensor_info        *sp;
 376 +
 377 +    int         i;
 378 +    const char *fantypes[]={"CPU","PWR","AFB"};
 379 +    char        name[ 256 ];
 380 +
 381 +    kstat_ctl_t    *kc;
 382 +    kstat_t        *kp;
 383 +    envctrl_fan_t  *fan_info;
 384 +    envctrl_ps_t   *power_info;
 385 +    envctrl_encl_t *enc_info;
 386 +
 387 +
 388 +    DEBUGMSGTL(("sensors:arch", "Reload KStat Sensors module\n"));
 389 +
 390 +    kc = kstat_open();
 391 +    if ( kc == 0) {
 392 +        DEBUGMSGTL(("sensors:arch", "Couldn't open kstat\n"));
 393 +        return 1;
 394 +    }
 395 +
 396 +
 397 +    /*
 398 +     * Retrieve fan information
 399 +     */
 400 +    kp = kstat_lookup( kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_FANSTAT);
 401 +    if (( kp == 0 ) || (kstat_read( kc, kp, 0 ) == -1 )) {
 402 +        DEBUGMSGTL(("sensors:arch", "No fan information\n"));
 403 +    } else {
 404 +        fan_info = (envctrl_fan_t *)kp->ks_data;
 405 +        for (i=0; i<kp->ks_ndata; i++) {
 406 +            memset( name, 0, 256 );
 407 +            snprintf( name, 255, "%s%d", fantypes[fan_info->type], fan_info->instance );
 408 +
 409 +            sp = sensor_by_name( name, NETSNMP_SENSOR_TYPE_RPM );
 410 +            if ( sp ) {
 411 +                sp->value = fan_info->fanspeed;
 412 +                sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 413 +                snprintf( sp->descr, 255, "fan type %s number %d",
 414 +                          fantypes[fan_info->type], fan_info->instance );
 415 +            }
 416 +
 417 +            fan_info++;
 418 +        }
 419 +    }
 420 +
 421 +
 422 +    /*
 423 +     * Retrieve Power Supply information
 424 +     */
 425 +    kp = kstat_lookup( kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_PSNAME);
 426 +    if (( kp == 0 ) || (kstat_read( kc, kp, 0 ) == -1 )) {
 427 +        DEBUGMSGTL(("sensors:arch", "No PSU information\n"));
 428 +    } else {
 429 +        power_info = (envctrl_ps_t *)kp->ks_data;
 430 +        for (i=0; i<kp->ks_ndata; i++) {
 431 +            memset( name, 0, 256 );
 432 +            snprintf( name, 255, "PSU%d", power_info->instance );
 433 +
 434 +            sp = sensor_by_name( name, NETSNMP_SENSOR_TYPE_TEMPERATURE);
 435 +            if ( sp ) {
 436 +                sp->value = power_info->ps_tempr;
 437 +                sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 438 +                snprintf( sp->descr, 255, "power supply %d", power_info->instance );
 439 +            }
 440 +
 441 +            power_info++;
 442 +        }
 443 +    }
 444 +
 445 +
 446 +    /*
 447 +     * Retrieve Enclosure information
 448 +     */
 449 +    kp = kstat_lookup( kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_ENCL);
 450 +    if (( kp == 0 ) || (kstat_read( kc, kp, 0 ) == -1 )) {
 451 +        DEBUGMSGTL(("sensors:arch", "No enclosure information\n"));
 452 +    } else {
 453 +        enc_info = (envctrl_encl_t *)kp->ks_data;
 454 +        for (i=0; i<kp->ks_ndata; i++) {
 455 +            /*
 456 +             * The enclosure information covers several different types of sensor
 457 +             */
 458 +            switch ( enc_info->type ) {
 459 +            case ENVCTRL_ENCL_FSP:
 460 +                DEBUGMSGTL(("sensors:arch:detail", "Enclosure Front Panel\n"));
 461 +                sp = sensor_by_name( "FSP", NETSNMP_SENSOR_TYPE_OTHER);
 462 +                if ( sp ) {
 463 +                    sp->value = enc_info->value;
 464 +                    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 465 +                }
 466 +                break;
 467 +
 468 +            case ENVCTRL_ENCL_AMBTEMPR:
 469 +                DEBUGMSGTL(("sensors:arch:detail", "Enclosure Ambient Temperature\n"));
 470 +                sp = sensor_by_name( "Ambient", NETSNMP_SENSOR_TYPE_TEMPERATURE);
 471 +                if ( sp ) {
 472 +                    sp->value = enc_info->value;
 473 +                    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 474 +                }
 475 +                break;
 476 +
 477 +            case ENVCTRL_ENCL_CPUTEMPR:
 478 +                DEBUGMSGTL(("sensors:arch:detail", "Enclosure CPU Temperature\n"));
 479 +                memset( name, 0, 256 );
 480 +                snprintf( name, 255, "CPU%d", enc_info->instance );
 481 +                sp = sensor_by_name( name, NETSNMP_SENSOR_TYPE_TEMPERATURE);
 482 +                if ( sp ) {
 483 +                    sp->value = enc_info->value;
 484 +                    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 485 +                    snprintf( sp->descr, 255, "CPU%d temperature", enc_info->instance );
 486 +                }
 487 +                break;
 488 +
 489 +            case ENVCTRL_ENCL_BACKPLANE4:
 490 +                DEBUGMSGTL(("sensors:arch:detail", "Enclosure Backplane4\n"));
 491 +                sp = sensor_by_name( "Backplane4", NETSNMP_SENSOR_TYPE_OTHER);
 492 +                if ( sp ) {
 493 +                    sp->value = enc_info->value;
 494 +                    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 495 +                }
 496 +                break;
 497 +
 498 +            case ENVCTRL_ENCL_BACKPLANE8:
 499 +                DEBUGMSGTL(("sensors:arch:detail", "Enclosure Backplane4\n"));
 500 +                sp = sensor_by_name( "Backplane4", NETSNMP_SENSOR_TYPE_OTHER);
 501 +                if ( sp ) {
 502 +                    sp->value = enc_info->value;
 503 +                    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 504 +                }
 505 +                break;
 506 +
 507 +            default:
 508 +                DEBUGMSGTL(("sensors:arch:detail", "Unrecognised Enclosure entry (%d)n",
 509 +                                                    enc_info->type));
 510 +            }
 511 +
 512 +            enc_info++;
 513 +        }
 514 +    }
 515 +
 516 +    return 0;
 517 +}
 518 Index: agent/mibgroup/hardware/sensors/lmsensors_v3.h
 519 ===================================================================
 520 --- agent/mibgroup/hardware/sensors/lmsensors_v3.h      (revision 0)
 521 +++ agent/mibgroup/hardware/sensors/lmsensors_v3.h      (revision 16739)
 522 @@ -0,0 +1 @@
 523 +config_require(hardware/sensors/hw_sensors)
 524 Index: agent/mibgroup/hardware/sensors/dummy_sensors.c
 525 ===================================================================
 526 --- agent/mibgroup/hardware/sensors/dummy_sensors.c     (revision 0)
 527 +++ agent/mibgroup/hardware/sensors/dummy_sensors.c     (revision 16739)
 528 @@ -0,0 +1,60 @@
 529 +#include <net-snmp/net-snmp-config.h>
 530 +#include <net-snmp/net-snmp-includes.h>
 531 +#include <net-snmp/agent/net-snmp-agent-includes.h>
 532 +#include <net-snmp/agent/hardware/sensors.h>
 533 +
 534 +
 535 +void netsnmp_sensor_arch_init( void ) {
 536 +    /* Nothing to do */
 537 +    DEBUGMSGTL(("sensors:arch", "Initialise Dummy Sensors module\n"));
 538 +}
 539 +
 540 +int
 541 +netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) {
 542 +    time_t now;
 543 +    struct tm                  *tm;
 544 +    netsnmp_sensor_info        *sp;
 545 +
 546 +    time(&now);
 547 +    tm = localtime(&now);
 548 +
 549 +    DEBUGMSGTL(("sensors:arch", "Reload Dummy Sensors module\n"));
 550 +
 551 +    /* First pseudo-sensor - slowly-rising temperature */
 552 +    sp = sensor_by_name( "minute", NETSNMP_SENSOR_TYPE_TEMPERATURE );
 553 +    sp->value = tm->tm_min;
 554 +    snprintf( sp->descr, 256, "Minute-based pseudo-sensor - slowly-rising temperature" );
 555 +    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 556 +
 557 +    /* Second pseudo-sensor - quickly-rising temperature */
 558 +    sp = sensor_by_name( "second", NETSNMP_SENSOR_TYPE_TEMPERATURE );
 559 +    sp->value = tm->tm_sec;
 560 +    snprintf( sp->descr, 256, "Second-based pseudo-sensor - quickly-rising temperature" );
 561 +    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 562 +
 563 +    /* Third pseudo-sensor - annual fan speed */
 564 +    sp = sensor_by_name( "year", NETSNMP_SENSOR_TYPE_RPM );
 565 +    sp->value = tm->tm_year + 1900;
 566 +    snprintf( sp->descr, 256, "RPM pseudo-sensor - annual fan speed" );
 567 +    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 568 +
 569 +    /* Fourth pseudo-sensor - daily voltage */
 570 +    sp = sensor_by_name( "day", NETSNMP_SENSOR_TYPE_VOLTAGE_DC );
 571 +    sp->value = tm->tm_mday-20;
 572 +    snprintf( sp->descr, 256, "Day-based pseudo-sensor - positive or negative voltage" );
 573 +    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 574 +
 575 +    /* Fifth pseudo-sensor - monthly voltage */
 576 +    sp = sensor_by_name( "month", NETSNMP_SENSOR_TYPE_VOLTAGE_DC );
 577 +    sp->value = tm->tm_mon;
 578 +    snprintf( sp->descr, 256, "Month-based pseudo-sensor - positive voltage" );
 579 +    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 580 +
 581 +    /* Sixth pseudo-sensor - annual daily something */
 582 +    sp = sensor_by_name( "yday", NETSNMP_SENSOR_TYPE_OTHER );
 583 +    sp->value = tm->tm_yday;
 584 +    snprintf( sp->descr, 256, "Day-based pseudo-sensor - annual something" );
 585 +    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 586 +
 587 +    return 0;
 588 +}
 589 Index: agent/mibgroup/hardware/sensors/kstat_sensors.h
 590 ===================================================================
 591 --- agent/mibgroup/hardware/sensors/kstat_sensors.h     (revision 0)
 592 +++ agent/mibgroup/hardware/sensors/kstat_sensors.h     (revision 16739)
 593 @@ -0,0 +1 @@
 594 +config_require(hardware/sensors/hw_sensors)
 595 Index: agent/mibgroup/hardware/sensors/picld_sensors.c
 596 ===================================================================
 597 --- agent/mibgroup/hardware/sensors/picld_sensors.c     (revision 0)
 598 +++ agent/mibgroup/hardware/sensors/picld_sensors.c     (revision 16739)
 599 @@ -0,0 +1,341 @@
 600 +#include <net-snmp/net-snmp-config.h>
 601 +#include <net-snmp/net-snmp-includes.h>
 602 +#include <net-snmp/agent/net-snmp-agent-includes.h>
 603 +#include <net-snmp/agent/hardware/sensors.h>
 604 +
 605 +#include "util_funcs.h"
 606 +#include <time.h>
 607 +
 608 +#include <picl.h>
 609 +#include </usr/platform/sun4u/include/sys/envctrl.h>
 610 +
 611 +void netsnmp_sensor_arch_init( void ) {
 612 +    DEBUGMSGTL(("sensors:arch", "Initialise PICLd Sensors module\n"));
 613 +    picl_initialize();
 614 +}
 615 +
 616 +
 617 +/*
 618 + * Handle a numeric-valued sensor
 619 + */
 620 +static int
 621 +read_num_sensor( picl_nodehdl_t childh, char *propval, float *value )
 622 +{
 623 +    picl_nodehdl_t  sensorh;
 624 +    picl_propinfo_t sensor_info;
 625 +    picl_errno_t    error_code;
 626 +
 627 +    union valu {
 628 +        char buf[PICL_PROPSIZE_MAX];
 629 +        uint32_t us4;
 630 +        uint16_t us2;
 631 +        int32_t is4;
 632 +        int16_t is2;
 633 +        float f;
 634 +    } val;
 635 +
 636 +    /*
 637 +     *  Retrieve the specified sensor information and value
 638 +     */
 639 +    error_code = picl_get_propinfo_by_name(childh, propval, &sensor_info, &sensorh);
 640 +    if ( error_code != PICL_SUCCESS ) {
 641 +        DEBUGMSGTL(("sensors:arch:detail", "sensor info lookup failed (%d)\n",
 642 +                                            error_code));
 643 +        return( error_code );
 644 +    }
 645 +
 646 +    error_code = picl_get_propval(sensorh, &val.buf, sensor_info.size);
 647 +    if ( error_code != PICL_SUCCESS ) {
 648 +        DEBUGMSGTL(("sensors:arch:detail", "sensor value lookup failed (%d)\n",
 649 +                                            error_code));
 650 +        return( error_code );
 651 +    }
 652 +
 653 +    /*
 654 +     *  Check the validity (type and size) of this value
 655 +     */
 656 +    if ( sensor_info.type == PICL_PTYPE_FLOAT ) {
 657 +        *value = val.f;
 658 +    } else if ( sensor_info.type == PICL_PTYPE_UNSIGNED_INT ) {
 659 +        /* 16-bit or 32-bit unsigned integers */
 660 +        if ( sensor_info.size == 2 ) {
 661 +            *value = val.us2;
 662 +        } else if ( sensor_info.size == 4 ) {
 663 +            *value = val.us4;
 664 +        } else {
 665 +            DEBUGMSGTL(("sensors:arch:detail", "unsigned integer (%d bit)\n",
 666 +                                                sensor_info.size * 8));
 667 +            return PICL_FAILURE;
 668 +        }
 669 +    } else if ( sensor_info.type == PICL_PTYPE_INT ) {
 670 +        /* 16-bit or 32-bit signed integers */
 671 +        if ( sensor_info.size == 2 ) {
 672 +            *value = val.is2;
 673 +        } else if ( sensor_info.size == 4 ) {
 674 +            *value = val.is4;
 675 +        } else {
 676 +            DEBUGMSGTL(("sensors:arch:detail", "signed integer (%d bit)\n",
 677 +                                                sensor_info.size * 8));
 678 +            return PICL_FAILURE;
 679 +        }
 680 +    } else {
 681 +        DEBUGMSGTL(("sensors:arch:detail", "unrecognised type (%d)\n",
 682 +                                            sensor_info.type));
 683 +        return PICL_FAILURE;
 684 +    }
 685 +
 686 +    return error_code;
 687 +}
 688 +
 689 +static int
 690 +process_num_sensor( picl_nodehdl_t childh, char *propname, char *propval, int typ )
 691 +{
 692 +    netsnmp_sensor_info        *sp;
 693 +    float                       value;
 694 +    picl_errno_t    error_code;
 695 +
 696 +    sp = sensor_by_name( propname, typ );
 697 +    if ( !sp ) {
 698 +         return -1;
 699 +    }
 700 +
 701 +    error_code = read_num_sensor( childh, propval, &value );
 702 +    if ( error_code == PICL_SUCCESS ) {
 703 +        sp->value = value;
 704 +        sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 705 +    } else {
 706 +        DEBUGMSGTL(("sensors:arch:detail", "Failed to read %s sensor value (%d)\n",
 707 +                                            propname, error_code));
 708 +        return -1;
 709 +    }
 710 +    return 0;
 711 +}
 712 +
 713 +
 714 +
 715 +/*
 716 + *    Handle an enumeration-valued sensor
 717 + */
 718 +char *switch_settings[] = { "OFF","ON","NORMAL","LOCKED",
 719 +                            "UNKNOWN","DIAG","SECURE",
 720 +                            NULL };
 721 +char *led_settings[]    = { "OFF","ON","BLINK",
 722 +                            NULL };
 723 +char *i2c_settings[]    = { "OK",
 724 +                            NULL };
 725 +
 726 +static int
 727 +read_enum_sensor( picl_nodehdl_t childh, float *value, char **options )
 728 +{
 729 +    picl_nodehdl_t  sensorh;
 730 +    picl_propinfo_t sensor_info;
 731 +    picl_errno_t    error_code;
 732 +    char            state[PICL_PROPSIZE_MAX];
 733 +    int             i;
 734 +
 735 +    /*
 736 +     *  Retrieve the specified sensor information and value
 737 +     */
 738 +    error_code = picl_get_propinfo_by_name(childh, "State", &sensor_info, &sensorh);
 739 +    if ( error_code != PICL_SUCCESS ) {
 740 +        DEBUGMSGTL(("sensors:arch:detail", "sensor info lookup failed (%d)\n",
 741 +                                            error_code));
 742 +        return( error_code );
 743 +    }
 744 +
 745 +    error_code = picl_get_propval(sensorh, state, sensor_info.size);
 746 +    if ( error_code != PICL_SUCCESS ) {
 747 +        DEBUGMSGTL(("sensors:arch:detail", "sensor value lookup failed (%d)\n",
 748 +                                            error_code));
 749 +        return( error_code );
 750 +    }
 751 +
 752 +    /*
 753 +     * Try to find a matching entry in the list of options.
 754 +     * Note that some platforms may use upper or lower case
 755 +     *   versions of these enumeration values
 756 +     *  (so the checks are case insensitive)
 757 +     */
 758 +    *value = 99;    /* Dummy value */
 759 +    for ( i=0;  options[i] != NULL; i++ ) {
 760 +        if (strncasecmp(state, options[i], strlen(options[i])) == 0) {
 761 +            *value = i;
 762 +            return 0;
 763 +        }
 764 +    }
 765 +
 766 +    DEBUGMSGTL(("sensors:arch:detail", "Enumeration state %s not matched\n",
 767 +                                        state));
 768 +    return 0;  /* Or an error ? */
 769 +}
 770 +
 771 +static int
 772 +process_enum_sensor( picl_nodehdl_t childh, char *propname, int typ, char **options )
 773 +{
 774 +    netsnmp_sensor_info        *sp;
 775 +    float                       value;
 776 +    picl_errno_t    error_code;
 777 +
 778 +    sp = sensor_by_name( propname, typ );
 779 +    if ( !sp ) {
 780 +         return -1;
 781 +    }
 782 +
 783 +    error_code = read_enum_sensor( childh, &value, options );
 784 +    if ( error_code == PICL_SUCCESS ) {
 785 +        sp->value = value;
 786 +        sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
 787 +    } else {
 788 +        DEBUGMSGTL(("sensors:arch:detail", "Failed to read %s sensor value (%d)\n",
 789 +                                            propname, error_code));
 790 +        return -1;
 791 +    }
 792 +    return 0;
 793 +}
 794 +static int
 795 +process_enum_sensor( picl_nodehdl_t childh, char *propname, int typ, char **options )
 796 +{
 797 +    return 0;
 798 +}
 799 +
 800 +
 801 +
 802 +/*
 803 + *  Recursively walk through the tree of sensors
 804 + */
 805 +static int
 806 +process_sensors( int level, picl_nodehdl_t nodeh ) {
 807 +    picl_nodehdl_t childh, nexth;
 808 +    char           propname[  PICL_PROPNAMELEN_MAX  ];
 809 +    char           propclass[ PICL_CLASSNAMELEN_MAX ];
 810 +    picl_errno_t   error_code;
 811 +
 812 +    level++;
 813 +    DEBUGMSGTL(("sensors:arch:detail", "process_sensors - level %d\n", level));
 814 +
 815 +    /* Look up the first child node at this level */
 816 +    error_code = pick_get_propval_by_name( nodeh, PICL_PROP_CHILD,
 817 +                                           &childh, sizeof(childh));
 818 +    if ( error_code != PICL_SUCCESS ) {
 819 +        DEBUGMSGTL(("sensors:arch:detail", "Failed to get first child node (%d)\n",
 820 +                                            error_code));
 821 +        return( error_code );
 822 +    }
 823 +
 824 +    /* Step through the child nodes, retrieving the name and class of each one */
 825 +    while ( error_code == PICL_SUCCESS ) {
 826 +        error_code = pick_get_propval_by_name( childh, PICL_PROP_NAME,
 827 +                                               propname, sizeof(propname)-1);
 828 +        if ( error_code != PICL_SUCCESS ) {
 829 +            /* The Node With No Name */
 830 +            DEBUGMSGTL(("sensors:arch:detail", "get property name failed (%d)\n",
 831 +                                                error_code));
 832 +            return( error_code );
 833 +        }
 834 +
 835 +        error_code = pick_get_propval_by_name( childh, PICL_PROP_CLASSNAME,
 836 +                                               propclass, sizeof(propclass)-1);
 837 +        if ( error_code != PICL_SUCCESS ) {
 838 +            /* The Classless Society */
 839 +            DEBUGMSGTL(("sensors:arch:detail", "get property class failed (%d)\n",
 840 +                                                error_code));
 841 +            return( error_code );
 842 +        }
 843 +
 844 +        DEBUGMSGTL(("sensors:arch:detail", "Name: %s, Class %s\n",
 845 +                                            propname, propclass ));
 846 +
 847 +
 848 +        /*
 849 +         *  Three classes represent further groups of sensors, etc.
 850 +         *  Call 'process_sensors' recursively to handle this next level
 851 +         */
 852 +        if (( strstr( propclass, "picl"    )) ||
 853 +            ( strstr( propclass, "frutree" )) ||
 854 +            ( strstr( propclass, "obp"     ))) {
 855 +            process_sensors( level, childh );
 856 +        }
 857 +        /*
 858 +         *  Otherwise retrieve the value appropriately based on the
 859 +         *     class of the sensor.
 860 +         *
 861 +         *  We need to specify the name of the PICL property to retrieve
 862 +         *     for this class of sensor, and the Net-SNMP sensor type.
 863 +         */
 864 +        else if ( strstr( propclass, "fan-tachometer" )) {
 865 +            process_num_sensor( childh, propname, "AtoDSensorValue",
 866 +                                                   NETSNMP_SENSOR_TYPE_RPM );
 867 +        } else if ( strstr( propclass, "fan" )) {
 868 +            process_num_sensor( childh, propname, "Speed",
 869 +                                                   NETSNMP_SENSOR_TYPE_RPM );
 870 +        } else if ( strstr( propclass, "temperature-sensor" )) {
 871 +            process_num_sensor( childh, propname, "Temperature",
 872 +                                                   NETSNMP_SENSOR_TYPE_TEMPERATURE );
 873 +        } else if ( strstr( propclass, "voltage-sensor" )) {
 874 +            process_num_sensor( childh, propname, "Voltage",
 875 +                                          /* ?? */ NETSNMP_SENSOR_TYPE_VOLTAGE_DC );
 876 +        } else if ( strstr( propclass, "digital-sensor" )) {
 877 +            process_num_sensor( childh, propname, "AtoDSensorValue",
 878 +                                          /* ?? */ NETSNMP_SENSOR_TYPE_VOLTAGE_DC );
 879 +            /*
 880 +             * Enumeration-valued sensors use a fixed PICL property ("State"),
 881 +             *   but take a list of the values appropriate for that sensor,
 882 +             *   as well as the Net-SNMP sensor type.
 883 +             */
 884 +        } else if ( strstr( propclass, "switch" )) {
 885 +            process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_OTHER,
 886 +                                                   switch_settings );
 887 +        } else if ( strstr( propclass, "led" )) {
 888 +            process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_OTHER,
 889 +                                                   led_settings );
 890 +        } else if ( strstr( propclass, "i2c" )) {
 891 +            process_enum_sensor( childh, propname, NETSNMP_SENSOR_TYPE_BOOLEAN, /* ?? */
 892 +                                                   i2c_settings );
 893 +        } else {
 894 +            /* Skip other classes of sensor */
 895 +            DEBUGMSGTL(("sensors:arch:detail", "Skipping class %s\n", propclass ));
 896 +        }
 897 +
 898 +        /*
 899 +         *  Move on to the next child node at the current level (if any)
 900 +         */
 901 +        error_code = pick_get_propval_by_name( childh, PICL_PROP_PEER,
 902 +                                               &nexth, sizeof(nexth));
 903 +        if ( error_code != PICL_SUCCESS ) {
 904 +            /* That's All Folks! */
 905 +            return (( error_code == PICL_PROPNOTFOUND )
 906 +                          ? PICL_SUCCESS : error_code );
 907 +        }
 908 +        childh = nexth;
 909 +    }
 910 +
 911 +    return error_code;
 912 +}
 913 +
 914 +
 915 +int
 916 +netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) {
 917 +    int               error_code;
 918 +    picl_nodehdl_t    rooth;
 919 +
 920 +    DEBUGMSGTL(("sensors:arch", "Reload PICLd Sensors module\n"));
 921 +
 922 +    error_code = picl_get_root(&rooth);
 923 +    if ( error_code != PICL_SUCCESS) {
 924 +        DEBUGMSGTL(("sensors:arch", "Couldn't get root node (error %d)\n", error_code));
 925 +        return 1;
 926 +    }
 927 +
 928 +    error_code = process_sensors(0, rooth);
 929 +    if ( error_code != 255 )
 930 +        if ( error_code != 7 )  /* ignore PICL_PROPNOTFOUND error */
 931 +            DEBUGMSGTL(("sensors:arch", "Internal PICLd problem (error %d)\n", error_code));
 932 +
 933 +    return 0;
 934 +}
 935 +
 936 +void netsnmp_sensor_arch_shutdown( void ) {
 937 +    DEBUGMSGTL(("sensors:arch", "Shutdown PicLD Sensors module\n"));
 938 +    picl_shutdown();
 939 +}
 940 +
 941 Index: agent/mibgroup/hardware/sensors/hw_sensors.c
 942 ===================================================================
 943 --- agent/mibgroup/hardware/sensors/hw_sensors.c        (revision 0)
 944 +++ agent/mibgroup/hardware/sensors/hw_sensors.c        (revision 16739)
 945 @@ -0,0 +1,183 @@
 946 +#include <net-snmp/net-snmp-config.h>
 947 +#include <net-snmp/net-snmp-includes.h>
 948 +#include <net-snmp/agent/net-snmp-agent-includes.h>
 949 +#include <net-snmp/agent/hardware/sensors.h>
 950 +
 951 +
 952 +extern NetsnmpCacheLoad netsnmp_sensor_arch_load;
 953 +extern void             netsnmp_sensor_arch_init( void );
 954 +static int  _sensor_load( void );
 955 +static void _sensor_free( void );
 956 +
 957 +static int _sensorAutoUpdate = 0;   /* 0 means on-demand caching */
 958 +static void _sensor_update_stats( unsigned int, void* );
 959 +
 960 +netsnmp_cache     *_sensor_cache     = NULL;
 961 +netsnmp_container *_sensor_container = NULL;
 962 +static int         _sensor_idx       = 0;
 963 +
 964 +void init_hw_sensors( void ) {
 965 +
 966 +    if ( _sensor_container )
 967 +        return;   /* Already initialised */
 968 +
 969 +    DEBUGMSGTL(("sensors", "Initialise Hardware Sensors module\n"));
 970 +
 971 +    /*
 972 +     * Define a container to hold the basic list of sensors
 973 +     * The four LM-SENSOR-MIB containers will be created in
 974 +     *  the relevant initialisation routine(s)
 975 +     */
 976 +    _sensor_container = netsnmp_container_find("sensorTable:table_container");
 977 +    if ( NULL == _sensor_container ) {
 978 +        snmp_log( LOG_ERR, "failed to create container for sensorTable");
 979 +        return;
 980 +    }
 981 +    netsnmp_sensor_arch_init( );
 982 +
 983 +    /*
 984 +     * If we're sampling the sensor information automatically,
 985 +     *   then arrange for this to be triggered regularly.
 986 +     *
 987 +     * If we're not sampling these values regularly,
 988 +     *   create a suitable cache handler instead.
 989 +     */
 990 +    if ( _sensorAutoUpdate ) {
 991 +        DEBUGMSGTL(("sensors", "Reloading Hardware Sensors automatically (%d)\n",
 992 +                               _sensorAutoUpdate));
 993 +        snmp_alarm_register( _sensorAutoUpdate, SA_REPEAT,
 994 +                             _sensor_update_stats, NULL );
 995 +    }
 996 +    else {
 997 +        _sensor_cache = netsnmp_cache_create( 5, netsnmp_sensor_load,
 998 +                                                 netsnmp_sensor_free, NULL, 0 );
 999 +        DEBUGMSGTL(("sensors", "Reloading Hardware Sensors on-demand (%p)\n",
1000 +                               _sensor_cache));
1001 +    }
1002 +}
1003 +
1004 +void shutdown_hw_sensors( void ) {
1005 +    _sensor_free();
1006 +}
1007 +
1008 +/*
1009 + *  Return the main sensor container
1010 + */
1011 +netsnmp_container *get_sensor_container( void ) { return _sensor_container; }
1012 +
1013 +/*
1014 + *  Return the main sensor cache control structure (if defined)
1015 + */
1016 +netsnmp_cache *get_sensor_cache( void ) { return _sensor_cache; }
1017 +
1018 +
1019 +/*
1020 + * Wrapper routine for automatically updating sensor statistics
1021 + */
1022 +void
1023 +_sensor_update_stats( unsigned int clientreg, void *data )
1024 +{
1025 +    _sensor_free();
1026 +    _sensor_load();
1027 +}
1028 +
1029 +/*
1030 + * Wrapper routine for re-loading sensor statistics on demand
1031 + */
1032 +int
1033 +netsnmp_sensor_load( netsnmp_cache *cache, void *data )
1034 +{
1035 +    return _sensor_load();
1036 +}
1037 +
1038 +/*
1039 + * Wrapper routine for releasing expired sensor statistics
1040 + */
1041 +void
1042 +netsnmp_sensor_free( netsnmp_cache *cache, void *data )
1043 +{
1044 +    _sensor_free();
1045 +}
1046 +
1047 +
1048 +/*
1049 + * Architecture-independent processing of loading sensor statistics
1050 + */
1051 +static int
1052 +_sensor_load( void )
1053 +{
1054 +    netsnmp_sensor_arch_load( NULL, NULL );
1055 +}
1056 +
1057 +/*
1058 + * Architecture-independent release of sensor statistics
1059 + */
1060 +static void
1061 +_sensor_free( void )
1062 +{
1063 +    netsnmp_sensor_info *sp;
1064 +
1065 +    for (sp = CONTAINER_FIRST( _sensor_container );
1066 +         sp;
1067 +         sp = CONTAINER_NEXT(  _sensor_container, sp )) {
1068 +
1069 +         sp->flags &= ~ NETSNMP_SENSOR_FLAG_ACTIVE;
1070 +    }
1071 +}
1072 +
1073 +
1074 +/*
1075 + * Retrieve a sensor entry by name,
1076 + *  or (optionally) insert a new one into the container
1077 + */
1078 +netsnmp_sensor_info *
1079 +sensor_by_name( char *name, int create_type )
1080 +{
1081 +    netsnmp_sensor_info *sp;
1082 +
1083 +    DEBUGMSGTL(("sensors:name", "Get sensor entry (%s)\n", name));
1084 +
1085 +    /*
1086 +     *  Look through the list for a matching entry
1087 +     */
1088 +        /* .. or use a secondary index container ?? */
1089 +    for (sp = CONTAINER_FIRST( _sensor_container );
1090 +         sp;
1091 +         sp = CONTAINER_NEXT(  _sensor_container, sp )) {
1092 +
1093 +        if ( !strcmp( name, sp->name ))
1094 +            return sp;
1095 +    }
1096 +
1097 +    /*
1098 +     * Not found...
1099 +     */
1100 +    if ( create_type == NETSNMP_SENSOR_FIND_EXIST ) {
1101 +        DEBUGMSGTL(("sensors:name", "No such sensor entry\n"));
1102 +        return NULL;
1103 +    }
1104 +
1105 +    /*
1106 +     * ... so let's create a new one, using the type supplied
1107 +     */
1108 +    sp = SNMP_MALLOC_TYPEDEF( netsnmp_sensor_info );
1109 +    if ( sp ) {
1110 +        strcpy( sp->name, name );
1111 +        sp->type = create_type;
1112 +        /*
1113 +         * Set up the index value.
1114 +         *
1115 +         * All this trouble, just for a simple integer.
1116 +         * Surely there must be a better way?
1117 +         */
1118 +        sp->idx.len  = 1;
1119 +        sp->idx.oids = SNMP_MALLOC_TYPEDEF( oid );
1120 +        sp->idx.oids[0] = ++_sensor_idx;
1121 +    }
1122 +
1123 +    DEBUGMSGTL(("sensors:name", "Create sensor entry (type = %d, index = %d\n",
1124 +                                 create_type, _sensor_idx));
1125 +    CONTAINER_INSERT( _sensor_container, sp );
1126 +    return sp;
1127 +}
1128 +
1129 Index: agent/mibgroup/hardware/sensors/dummy_sensors.h
1130 ===================================================================
1131 --- agent/mibgroup/hardware/sensors/dummy_sensors.h     (revision 0)
1132 +++ agent/mibgroup/hardware/sensors/dummy_sensors.h     (revision 16739)
1133 @@ -0,0 +1 @@
1134 +config_require(hardware/sensors/hw_sensors)
1135 Index: agent/mibgroup/hardware/sensors/lmsensors_v2.c
1136 ===================================================================
1137 --- agent/mibgroup/hardware/sensors/lmsensors_v2.c      (revision 0)
1138 +++ agent/mibgroup/hardware/sensors/lmsensors_v2.c      (revision 16739)
1139 @@ -0,0 +1,75 @@
1140 +#include <net-snmp/net-snmp-config.h>
1141 +#include <net-snmp/net-snmp-includes.h>
1142 +#include <net-snmp/agent/net-snmp-agent-includes.h>
1143 +#include <net-snmp/agent/hardware/sensors.h>
1144 +
1145 +#include "util_funcs.h"
1146 +#include <time.h>
1147 +#include <sensors/sensors.h>
1148 +
1149 +void netsnmp_sensor_arch_init( void ) {
1150 +    FILE *fp = fopen("/etc/sensors.conf", "r");
1151 +    DEBUGMSGTL(("sensors:arch", "Initialise LM Sensors module\n"));
1152 +    sensors_init( fp );
1153 +}
1154 +
1155 +int
1156 +netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) {
1157 +    netsnmp_sensor_info        *sp;
1158 +    const sensors_chip_name    *chip;
1159 +    const sensors_feature_data *data;
1160 +    int             chip_nr = 0;
1161 +
1162 +    DEBUGMSGTL(("sensors:arch", "Reload LM Sensors module\n"));
1163 +    while ((chip = sensors_get_detected_chips(&chip_nr))) {
1164 +       int             a = 0;
1165 +       int             b = 0;
1166 +
1167 +        while ((data = sensors_get_all_features(*chip, &a, &b))) {
1168 +            DEBUGMSGTL(("sensors:arch:detail", "get_all_features (%d, %d)\n", a, b));
1169 +            char           *label = NULL;
1170 +            double          val;
1171 +            int             type = NETSNMP_SENSOR_TYPE_OTHER;
1172 +
1173 +            if ((data->mode & SENSORS_MODE_R) &&
1174 +                (data->mapping == SENSORS_NO_MAPPING) &&
1175 +                !sensors_get_label(*chip, data->number, &label) &&
1176 +                !sensors_get_feature(*chip, data->number, &val)) {
1177 +
1178 +                DEBUGMSGTL(("sensors:arch:detail", "%s = %f\n", label, val));
1179 +                /*
1180 +                 * Determine the type of sensor from the description.
1181 +                 *
1182 +                 * If the text being looked for below is not in the label of a
1183 +                 * given sensor (e.g., the temp1 sensor has been labeled 'CPU'
1184 +                 * rather than 'CPU temp') it will be categorised as OTHER.
1185 +                 */
1186 +                if (strstr(label, "V")) {
1187 +                    type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC;
1188 +                }
1189 +                if (strstr(label, "fan") || strstr(label, "Fan")) {
1190 +                    type = NETSNMP_SENSOR_TYPE_RPM;
1191 +                }
1192 +                if (strstr(label, "temp") || strstr(label, "Temp")) {
1193 +                    type = NETSNMP_SENSOR_TYPE_TEMPERATURE;
1194 +                }
1195 +
1196 +                /*
1197 +                 * Use this type to create a new sensor entry
1198 +                 *  (inserting it in the appropriate sub-containers)
1199 +                 */
1200 +                sp = sensor_by_name( label, type );
1201 +                if ( sp ) {
1202 +                    sp->value = val;
1203 +                    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
1204 +                }
1205 +            }
1206 +           if (label) {
1207 +               free(label);
1208 +               label = NULL;
1209 +           }
1210 +        } /* end while data */
1211 +    } /* end while chip */
1212 +
1213 +    return 0;
1214 +}
1215 Index: agent/mibgroup/hardware/sensors/picld_sensors.h
1216 ===================================================================
1217 --- agent/mibgroup/hardware/sensors/picld_sensors.h     (revision 0)
1218 +++ agent/mibgroup/hardware/sensors/picld_sensors.h     (revision 16739)
1219 @@ -0,0 +1 @@
1220 +config_require(hardware/sensors/hw_sensors)
1221 Index: agent/mibgroup/hardware/sensors/lmsensors_v3.c
1222 ===================================================================
1223 --- agent/mibgroup/hardware/sensors/lmsensors_v3.c      (revision 0)
1224 +++ agent/mibgroup/hardware/sensors/lmsensors_v3.c      (revision 16739)
1225 @@ -0,0 +1,101 @@
1226 +#include <net-snmp/net-snmp-config.h>
1227 +#include <net-snmp/net-snmp-includes.h>
1228 +#include <net-snmp/agent/net-snmp-agent-includes.h>
1229 +#include <net-snmp/agent/hardware/sensors.h>
1230 +
1231 +#include "util_funcs.h"
1232 +#include <time.h>
1233 +#include <sensors/sensors.h>
1234 +
1235 +
1236 +void netsnmp_sensor_arch_init( void ) {
1237 +    FILE *fp = fopen("/etc/sensors.conf", "r");
1238 +    DEBUGMSGTL(("sensors:arch", "Initialise v3 LM Sensors module\n"));
1239 +    sensors_init( fp );
1240 +}
1241 +
1242 +int
1243 +netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) {
1244 +    netsnmp_sensor_info        *sp;
1245 +    const sensors_chip_name    *chip;
1246 +    const sensors_feature      *data;
1247 +    const sensors_subfeature   *data2;
1248 +    int             chip_nr = 0;
1249 +
1250 +    DEBUGMSGTL(("sensors:arch", "Reload v3 LM Sensors module\n"));
1251 +    while ((chip = sensors_get_detected_chips( NULL, &chip_nr))) {
1252 +       int             a = 0;
1253 +
1254 +        while ((data = sensors_get_features( chip, &a))) {
1255 +            DEBUGMSGTL(("sensors:arch:detail", "get_features (%s, %d)\n", data->name, data->number));
1256 +           int             b = 0;
1257 +
1258 +
1259 +            while ((data2 = sensors_get_all_subfeatures( chip, data, &b))) {
1260 +                char           *label = NULL;
1261 +                double          val;
1262 +                int             type = NETSNMP_SENSOR_TYPE_OTHER;
1263 +
1264 +                DEBUGMSGTL(("sensors:arch:detail", "  get_subfeatures (%s, %d)\n", data2->name, data2->number));
1265 +                /*
1266 +                 * Check the type of this subfeature,
1267 +                 *   concentrating on the main "input" measurements.
1268 +                 */
1269 +                switch ( data2->type ) {
1270 +                case SENSORS_SUBFEATURE_IN_INPUT:
1271 +                    type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC;
1272 +                    break;
1273 +                case SENSORS_SUBFEATURE_FAN_INPUT:
1274 +                    type = NETSNMP_SENSOR_TYPE_RPM;
1275 +                    break;
1276 +                case SENSORS_SUBFEATURE_TEMP_INPUT:
1277 +                    type = NETSNMP_SENSOR_TYPE_TEMPERATURE;
1278 +                    break;
1279 +                case SENSORS_SUBFEATURE_VID:
1280 +                    type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC;
1281 +                    break;
1282 +                default:
1283 +                    /* Skip everything other than these basic sensor features - ??? */
1284 +                    DEBUGMSGTL(("sensors:arch:detail", "  Skip type %x\n", data2->type));
1285 +                    continue;
1286 +                }
1287 +
1288 +                /*
1289 +                 * Get the name and value of this subfeature
1290 +                 */
1291 +/*
1292 +                if (!(label = sensors_get_label(chip, data))) {
1293 +                    DEBUGMSGTL(("sensors:arch:detail", "  Can't get name (%s)\n", label));
1294 +                    continue;
1295 +                }
1296 +                if (sensors_get_value(chip, data2->number, &val) < 0) {
1297 +                    DEBUGMSGTL(("sensors:arch:detail", "  Can't get value (%f)\n", val));
1298 +                    continue;
1299 +                }
1300 +*/
1301 +                if (!(label = sensors_get_label(chip, data)) ||
1302 +                     (sensors_get_value(chip, data2->number, &val) < 0)) {
1303 +                    DEBUGMSGTL(("sensors:arch:detail", "  Can't get name/value (%s, %f)\n", label, val));
1304 +                    continue;
1305 +                }
1306 +                DEBUGMSGTL(("sensors:arch:detail", "%s = %f\n", label, val));
1307 +
1308 +                /*
1309 +                 * Use this type to create a new sensor entry
1310 +                 *  (inserting it in the appropriate sub-containers)
1311 +                 */
1312 +                sp = sensor_by_name( label, type );
1313 +                if ( sp ) {
1314 +                    sp->value = val;
1315 +                    sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
1316 +                }
1317 +               if (label) {
1318 +                   free(label);
1319 +                   label = NULL;
1320 +               }
1321 +            } /* end while data2 */
1322 +        } /* end while data */
1323 +    } /* end while chip */
1324 +
1325 +    return 0;
1326 +}