]> git.pld-linux.org Git - packages/net-snmp.git/blame - net-snmp-lm_sensors_3.patch
projects / packages / net-snmp.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- make "load" readonly if defined in main config, like sysDescription behaves
[packages/net-snmp.git] / net-snmp-lm_sensors_3.patch
CommitLineData
4f99ac2f 1351991: Port net-snmp to lm_sensors-3.x.x
2Source: upstream, svn diff -r 16736:16739
3Reviewed-By: Jan Safranek <jsafrane@redhat.com>
4
5Index: 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; }
18Index: 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;
71Index: 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
84Index: 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+}
294Index: 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 */
322Index: 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)
340Index: 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 );
346Index: 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)
352Index: 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+}
518Index: 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)
524Index: 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+}
589Index: 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)
595Index: 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+
941Index: 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+
1129Index: 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)
1135Index: 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+}
1215Index: 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)
1221Index: 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+}
A collection of SNMP protocol tools
This page took 1.223641 seconds and 4 git commands to generate.