static const sensors_feature_data * get_sensor_min_max(const sensors_chip_name *chip,
int *n1, int *n2,
int number,
gdouble *low_value,
gdouble *high_value) {
const sensors_feature_data *data;
double value;
/* The sub features are returned directly after the main feature by
sensors_get_all_features(), so no need to iterate over all features */
while ((data = sensors_get_all_features (*chip, n1, n2)) != NULL &&
data->mapping == number) {
if ((data->mode & SENSORS_MODE_R) &&
(sensors_get_feature(*chip, data->number, &value) == 0) &&
data->name != NULL) {
if (g_str_has_suffix(data->name, "_min")) {
*low_value = value;
g_debug("overriding low value of sensor %s with value %f\n", data->name, value);
} else if (g_str_has_suffix(data->name, "_max")) {
*high_value = value;
g_debug("overriding high value of sensor %s with value %f\n", data->name, value);
}
}
}
return data;
}
int main (int argc, char **argv) {
int i1 = 0, i2 = 0, i3 = 0, iter, err;
const sensors_chip_name *sens;
const sensors_feature_data *sfd;
char *label;
double res;
FILE *foo;
if (!(foo = fopen(CONF_FILE, "r"))) {
printf ("Zoinks! Couldn't open conf file. Bailing out.\n");
exit(1);
}
if (sensors_init(foo)) {
printf ("Were in trouble! sensors_init returned nonzero\n");
exit(1);
}
while (sens = sensors_get_detected_chips(&i1)) {
printf("Chip: %s-%#x-%#x\n", sens->prefix, sens->bus, sens->addr);
printf("Features:\n");
i2 = i3 = 0;
while (sfd = sensors_get_all_features(*sens, &i2, &i3)) {
printf("*************************\n");
printf("\tName: %s\n", sfd->name);
printf("\tNumber: %d\n", sfd->number);
printf("\tMapping: %d\n", sfd->mapping);
printf("\tUnused: %d\n", sfd->unused);
printf("\tMode: %d\n", sfd->mode);
if ((sfd->mode & SENSORS_MODE_R) &&
!(err = sensors_get_feature(*sens, sfd->number, &res))) {
printf("\tValue: %f\n", res);
}
else if (err) {
printf("Error reading sensor: %d\n", err);
}
}
printf("*************************\n\n");
}
return 0;
}
/* ******** end of picld sensor procedures * */
#endif /* solaris2 */
static int
_sensor_load(time_t t)
{
#ifdef solaris2
int i,j;
#ifdef HAVE_PICL_H
int er_code;
picl_errno_t error_code;
int level=0;
picl_nodehdl_t rooth;
#else
int typ;
int temp=0; /* do not reset this later, more than one typ has temperatures*/
int other=0;
const char *fantypes[]={"CPU","PWR","AFB"};
kstat_ctl_t *kc;
kstat_t *kp;
envctrl_fan_t *fan_info;
envctrl_ps_t *power_info;
envctrl_encl_t *enc_info;
#endif
/* DEBUGMSG(("ucd-snmp/lmSensors", "Reading the sensors\n")); */
/* initialize the array */
for (i = 0; i < N_TYPES; i++){
sensor_array[i].n = 0;
for (j=0; j < MAX_SENSORS; j++){
sensor_array[i].sensor[j].name[0] = '\0';
sensor_array[i].sensor[j].value = 0;
}
} /*end for i*/
/* try picld (if supported), if that doesn't work, try kstat */
#ifdef HAVE_PICL_H
er_code = picl_initialize();
if (er_code == PICL_SUCCESS) {
error_code = picl_get_root(&rooth);
if (error_code != PICL_SUCCESS) {
DEBUGMSG(("ucd-snmp/lmSensors", "picld couldn't get root error code->%d\n",error_code));
}
else{
DEBUGMSGTL(("ucd-snmp/lmSensors", "found root\n"));
error_code = process_sensors(level,rooth);
if (error_code != 255)
if (error_code != 7)
DEBUGMSG(("ucd-snmp/lmSensors", "picld had an internal problem error code->%d\n",error_code));
} /* end else */
picl_shutdown();
} /* end if err_code for picl_initialize */
else {
DEBUGMSG(("ucd-snmp/lmSensors", "picld couldn't initialize picld because error code->%d\n",er_code));
} /*end else picl_initialize */
#else /* end of picld section */
/* initialize kstat */
kc = kstat_open();
if (kc == 0) {
DEBUGMSG(("ucd-snmp/lmSensors", "couldn't open kstat"));
} /* endif kc */
else{
temp = 0;
kp = kstat_lookup(kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_FANSTAT);
if (kp == 0) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't lookup fan kstat\n"));
} /* endif lookup fans */
else{
if (kstat_read(kc, kp, 0) == -1) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't read fan kstat"));
} /* endif kstatread fan */
else{
typ = 1;
fan_info = (envctrl_fan_t *) kp->ks_data;
sensor_array[typ].n = kp->ks_ndata;
for (i=0; i < kp->ks_ndata; i++){
DEBUGMSG(("ucd-snmp/lmSensors", "found instance %d fan type %d speed %d OK %d bustedfan %d\n",
fan_info->instance, fan_info->type,fan_info->fanspeed,fan_info->fans_ok,fan_info->fanflt_num));
sensor_array[typ].sensor[i].value = fan_info->fanspeed;
snprintf(sensor_array[typ].sensor[i].name,(MAX_NAME - 1),
"fan type %s number %d",fantypes[fan_info->type],fan_info->instance);
sensor_array[typ].sensor[i].name[MAX_NAME - 1] = '\0';
fan_info++;
} /* end for fan_info */
} /* end else kstatread fan */
} /* end else lookup fans*/
kp = kstat_lookup(kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_PSNAME);
if (kp == 0) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't lookup power supply kstat\n"));
} /* endif lookup power supply */
else{
if (kstat_read(kc, kp, 0) == -1) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't read power supply kstat\n"));
} /* endif kstatread fan */
else{
typ = 0; /* this is a power supply temperature, not a voltage*/
power_info = (envctrl_ps_t *) kp->ks_data;
sensor_array[typ].n = kp->ks_ndata;
for (i=0; i < kp->ks_ndata; i++){
DEBUGMSG(("ucd-snmp/lmSensors", "found instance %d psupply temp mC %d %dW OK %d share %d limit %d\n",
power_info->instance, power_info->ps_tempr*1000,power_info->ps_rating,
power_info->ps_ok,power_info->curr_share_ok,power_info->limit_ok));
sensor_array[typ].sensor[temp].value = power_info->ps_tempr*1000;
snprintf(sensor_array[typ].sensor[temp].name,(MAX_NAME-1),
"power supply %d",power_info->instance);
sensor_array[typ].sensor[temp].name[MAX_NAME - 1] = '\0';
power_info++; /* increment the data structure */
temp++; /* increment the temperature sensor array element */
} /* end for power_info */
} /* end else kstatread power supply */
} /* end else lookup power supplies*/
kp = kstat_lookup(kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_ENCL);
if (kp == 0) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't lookup enclosure kstat\n"));
} /* endif lookup enclosure */
else{
if (kstat_read(kc, kp, 0) == -1) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't read enclosure kstat\n"));
} /* endif kstatread enclosure */
else{
enc_info = (envctrl_encl_t *) kp->ks_data;
other = 0;
for (i=0; i < kp->ks_ndata; i++){
switch (enc_info->type){
case ENVCTRL_ENCL_FSP:
DEBUGMSG(("ucd-snmp/lmSensors", "front panel value %d\n",enc_info->value));
typ = 3; /* misc */
sensor_array[typ].sensor[other].value = enc_info->value;
strlcpy(sensor_array[typ].sensor[other].name, "FSP",
MAX_NAME);
other++;
break;
case ENVCTRL_ENCL_AMBTEMPR:
DEBUGMSG(("ucd-snmp/lmSensors", "ambient temp mC %d\n",enc_info->value*1000));
typ = 0; /* temperature sensor */
sensor_array[typ].sensor[temp].value = enc_info->value*1000;
strlcpy(sensor_array[typ].sensor[temp].name, "Ambient",
MAX_NAME);
temp++;
break;
case ENVCTRL_ENCL_BACKPLANE4:
DEBUGMSG(("ucd-snmp/lmSensors", "There is a backplane4\n"));
typ = 3; /* misc */
sensor_array[typ].sensor[other].value = enc_info->value;
strlcpy(sensor_array[typ].sensor[other].name, "Backplane4",
MAX_NAME);
other++;
break;
case ENVCTRL_ENCL_BACKPLANE8:
DEBUGMSG(("ucd-snmp/lmSensors", "There is a backplane8\n"));
typ = 3; /* misc */
sensor_array[typ].sensor[other].value = enc_info->value;
strlcpy(sensor_array[typ].sensor[other].name, "Backplane8",
MAX_NAME);
other++;
break;
case ENVCTRL_ENCL_CPUTEMPR:
DEBUGMSG(("ucd-snmp/lmSensors", "CPU%d temperature mC %d\n",enc_info->instance,enc_info->value*1000));
typ = 0; /* temperature sensor */
sensor_array[typ].sensor[temp].value = enc_info->value*1000;
snprintf(sensor_array[typ].sensor[temp].name,MAX_NAME,"CPU%d",enc_info->instance);
sensor_array[typ].sensor[temp].name[MAX_NAME-1]='\0'; /* null terminate */
temp++;
break;
default:
DEBUGMSG(("ucd-snmp/lmSensors", "unknown element instance %d type %d value %d\n",
enc_info->instance, enc_info->type, enc_info->value));
break;
} /* end switch */
enc_info++;
} /* end for enc_info */
sensor_array[3].n = other;
sensor_array[0].n = temp;
} /* end else kstatread enclosure */
} /* end else lookup enclosure*/
kstat_close(kc);
} /* end else kstat */
#endif
#else /* end solaris2 only ie. ifdef everything else */
const sensors_chip_name *chip;
const sensors_feature_data *data;
int chip_nr = 0;
unsigned int i = 0;
DEBUGMSG(("ucd-snmp/lmSensors", "=> sensor_load\n"));
for (i = 0; i < N_TYPES; i++)
{
sensor_array[i].n = 0;
sensor_array[i].current_len = 0;
/* Malloc the default number of sensors. */
sensor_array[i].sensor = (_sensor*)malloc(sizeof(_sensor) * DEFAULT_SENSORS);
if (sensor_array[i].sensor == NULL)
{
/* Continuing would be unsafe */
snmp_log(LOG_ERR, "Cannot malloc sensor array!");
return 1;
} /* end if */
sensor_array[i].current_len = DEFAULT_SENSORS;
} /* end for */
while ((chip = sensors_get_detected_chips(&chip_nr))) {
int a = 0;
int b = 0;
while ((data = sensors_get_all_features(*chip, &a, &b))) {
char *label = NULL;
double val;
if ((data->mode & SENSORS_MODE_R) &&
(data->mapping == SENSORS_NO_MAPPING) &&
!sensors_get_label(*chip, data->number, &label) &&
!sensors_get_feature(*chip, data->number, &val)) {
int type = -1;
float mul = 0;
_sensor_array *array;
/* The label, as determined for a given chip in sensors.conf,
* is used to place each sensor in the appropriate bucket.
* Volt, Fan, Temp, and Misc. If the text being looked for below
* is not in the label of a given sensor (e.g., the temp1 sensor
* has been labeled 'CPU' and not 'CPU temp') it will end up being
* lumped in the MISC bucket. */
if (strstr(label, "V")) {
type = VOLT_TYPE;
mul = 1000.0;
}
if (strstr(label, "fan") || strstr(label, "Fan")) {
type = FAN_TYPE;
mul = 1.0;
}
if (strstr(label, "temp") || strstr(label, "Temp")) {
type = TEMP_TYPE;
mul = 1000.0;
}
if (type == -1) {
type = MISC_TYPE;
mul = 1000.0;
}
array = &sensor_array[type];
if ( array->current_len <= array->n) {
_sensor* old_buffer = array->sensor;
size_t new_size = (sizeof(_sensor) * array->current_len) + (sizeof(_sensor) * DEFAULT_SENSORS);
array->sensor = (_sensor*)realloc(array->sensor, new_size);
if (array->sensor == NULL)
{
/* Continuing would be unsafe */
snmp_log(LOG_ERR, "too many sensors to fit, and failed to alloc more, failing on %s\n", label);
free(old_buffer);
old_buffer = NULL;
if (label) {
free(label);
label = NULL;
} /* end if label */
return 1;
} /* end if array->sensor */
array->current_len = new_size / sizeof(_sensor);
DEBUGMSG(("ucd-snmp/lmSensors", "type #%d increased to %d elements\n", type, (int)array->current_len));
} /* end if array->current */
strlcpy(array->sensor[array->n].name, label, MAX_NAME);
array->sensor[array->n].value = (int) (val * mul);
DEBUGMSGTL(("sensors","sensor %s, value %d\n",
array->sensor[array->n].name,
array->sensor[array->n].value));
array->n++;
} /* end if data-mode */
if (label) {
free(label);
label = NULL;
} /* end if label */
} /* end while data */
} /* end while chip */
DEBUGMSG(("ucd-snmp/lmSensors", "<= sensor_load\n"));
#endif /* end else ie. ifdef everything else */
/* Update the timestamp after a load. */
timestamp = t;
return 0;
}
static GList *libsensors_plugin_get_sensors(void) {
const sensors_chip_name *chip_name;
int i;
GList *sensors = NULL;
#if SENSORS_API_VERSION < 0x400
FILE *file;
g_debug("%s: using libsensors version < 4", __FUNCTION__);
/* try to open config file, otherwise try alternate config
* file - if neither succeed, exit */
if ((file = fopen (LIBSENSORS_CONFIG_FILE, "r")) == NULL) {
if ((file = fopen (LIBSENSORS_ALTERNATIVE_CONFIG_FILE, "r")) == NULL) {
g_debug("%s: error opening libsensors config file... ", __FUNCTION__);
return sensors;
}
}
/* at this point should have an open config file, if is not
* valid, close file and return */
if (sensors_init(file) != 0) {
fclose(file);
g_debug("%s: error initing libsensors from config file...", __FUNCTION__);
return sensors;
}
fclose(file);
/* libsensors exposes a number of chips - ... */
i = 0;
while ((chip_name = sensors_get_detected_chips (&i)) != NULL) {
char *chip_name_string;
const sensors_feature_data *data;
int n1 = 0, n2 = 0;
chip_name_string = get_chip_name_string(chip_name);
/* ... each of which has one or more 'features' ... */
while ((data = sensors_get_all_features (*chip_name, &n1, &n2)) != NULL) { // error
// fill in list for us
check_sensor_with_data(&sensors, chip_name_string,
chip_name, &n1, &n2, data);
}
g_free (chip_name_string);
}
#else
g_debug("%s: using libsensors version >= 4", __FUNCTION__);
int nr = 0;
if (sensors_init(NULL) != 0) {
g_debug("%s: error initing libsensors", __FUNCTION__);
return sensors;
}
i = 0;
while ((chip_name = sensors_get_detected_chips(NULL, &nr)))
{
char *chip_name_string, *label;
const sensors_subfeature *input_feature;
const sensors_subfeature *low_feature;
const sensors_subfeature *high_feature;
const sensors_feature *main_feature;
SensorType type;
gint nr1 = 0;
gdouble value, low, high;
gchar *path;
gboolean visible;
IconType icon;
chip_name_string = get_chip_name_string(chip_name);
if (chip_name_string == NULL) {
g_debug("%s: %d: error getting name string for sensor: %s\n",
__FILE__, __LINE__, chip_name->path);
continue;
}
while ((main_feature = sensors_get_features(chip_name, &nr1)))
{
switch (main_feature->type)
{
case SENSORS_FEATURE_IN:
type = VOLTAGE_SENSOR;
input_feature = sensors_get_subfeature(chip_name,
main_feature,
SENSORS_SUBFEATURE_IN_INPUT);
low_feature = sensors_get_subfeature(chip_name,
main_feature,
SENSORS_SUBFEATURE_IN_MIN);
high_feature = sensors_get_subfeature(chip_name,
main_feature,
SENSORS_SUBFEATURE_IN_MAX);
break;
case SENSORS_FEATURE_FAN:
type = FAN_SENSOR;
input_feature = sensors_get_subfeature(chip_name,
main_feature,
SENSORS_SUBFEATURE_FAN_INPUT);
low_feature = sensors_get_subfeature(chip_name,
main_feature,
SENSORS_SUBFEATURE_FAN_MIN);
// no fan max feature
high_feature = NULL;
break;
case SENSORS_FEATURE_TEMP:
type = TEMP_SENSOR;
input_feature = sensors_get_subfeature(chip_name,
main_feature,
SENSORS_SUBFEATURE_TEMP_INPUT);
low_feature = sensors_get_subfeature(chip_name,
main_feature,
SENSORS_SUBFEATURE_TEMP_MIN);
high_feature = sensors_get_subfeature(chip_name,
main_feature,
SENSORS_SUBFEATURE_TEMP_MAX);
if (!high_feature)
high_feature = sensors_get_subfeature(chip_name,
main_feature,
SENSORS_SUBFEATURE_TEMP_CRIT);
break;
default:
g_debug("%s: %d: error determining type for: %s\n",
__FILE__, __LINE__, chip_name_string);
continue;
}
if (!input_feature)
{
g_debug("%s: %d: could not get input subfeature for: %s\n",
__FILE__, __LINE__, chip_name_string);
continue;
}
// if still here we got input feature so get label
label = sensors_get_label(chip_name, main_feature);
if (!label)
{
g_debug("%s: %d: error: could not get label for: %s\n",
__FILE__, __LINE__, chip_name_string);
continue;
}
g_assert(chip_name_string && label);
icon = get_sensor_icon(type);
visible = (type == TEMP_SENSOR ? TRUE : FALSE);
sensors_applet_plugin_default_sensor_limits(type,
&low,
&high);
if (low_feature) {
sensors_get_value(chip_name, low_feature->number, &low);
}
if (high_feature) {
sensors_get_value(chip_name, high_feature->number, &high);
}
if (sensors_get_value(chip_name, input_feature->number, &value) < 0) {
g_debug("%s: %d: error: could not get value for input feature of sensor: %s\n",
__FILE__, __LINE__, chip_name_string);
free(label);
continue;
}
g_debug("for chip %s (type %s) got label %s and value %f", chip_name_string,
(type == TEMP_SENSOR ? "temp" :
(type == FAN_SENSOR ? "fan" :
(type == VOLTAGE_SENSOR ? "voltage" : "error"))), label, value);
path = g_strdup_printf ("sensor://%s/%d", chip_name_string, input_feature->number);
g_hash_table_insert(hash_table, g_strdup(path), (void *)chip_name);
sensors_applet_plugin_add_sensor_with_limits(&sensors,
path,
label,
label,
type,
visible,
low,
high,
icon,
DEFAULT_GRAPH_COLOR);
}
g_free(chip_name_string);
}
#endif
return sensors;
}
static void
_sensor_load(clock_t t)
{
#ifdef solaris2
int i,j;
int typ;
int temp;
int other;
int er_code;
char *fantypes[]={"CPU","PWR","AFB"};
kstat_ctl_t *kc;
kstat_t *kp;
envctrl_fan_t *fan_info;
envctrl_ps_t *power_info;
envctrl_encl_t *enc_info;
#ifdef HAVE_PICL_H
picl_errno_t error_code;
picl_nodehdl_t rooth,plath;
char sname[PICL_PROPNAMELEN_MAX] = "SYSTEM";
#endif
/* DEBUGMSG(("ucd-snmp/lmSensors", "Reading the sensors\n")); */
/* initialize the array */
for (i = 0; i < N_TYPES; i++){
sensor_array[i].n = 0;
for (j=0; j < MAX_SENSORS; j++){
sensor_array[i].sensor[j].name[0] = '\0';
sensor_array[i].sensor[j].value = 0;
}
} /*end for i*/
/* try picld (if supported), if that doesn't work, try kstat */
#ifdef HAVE_PICL_H
er_code = picl_initialize();
if (er_code == PICL_SUCCESS) {
error_code = picl_get_root(&rooth);
if (error_code != PICL_SUCCESS) {
DEBUGMSG(("ucd-snmp/lmSensors", "picld couldn't get root error code->%d\n",error_code));
}
else{
error_code = get_child(rooth,sname,&plath);
if (error_code == PICL_SUCCESS){
error_code = process_sensors(plath);
if (error_code != 255)
if (error_code != 7)
DEBUGMSG(("ucd-snmp/lmSensors", "picld had an internal problem error code->%d\n",error_code));
} /* endif error_code */
else{
DEBUGMSG(("ucd-snmp/lmSensors", "picld couldn't get system tree error code->%d\n",error_code));
} /* end else error_code */
} /* end else */
picl_shutdown();
} /* end if err_code for picl_initialize */
else{ /* try kstat instead */
DEBUGMSG(("ucd-snmp/lmSensors", "picld couldn't initialize picld because error code->%d\n",er_code));
#endif /* end of picld section */
/* initialize kstat */
kc = kstat_open();
if (kc == 0) {
DEBUGMSG(("ucd-snmp/lmSensors", "couldn't open kstat"));
} /* endif kc */
else{
kp = kstat_lookup(kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_FANSTAT);
if (kp == 0) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't lookup fan kstat"));
} /* endif lookup fans */
else{
if (kstat_read(kc, kp, 0) == -1) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't read fan kstat"));
} /* endif kstatread fan */
else{
typ = 1;
fan_info = (envctrl_fan_t *) kp->ks_data;
sensor_array[typ].n = kp->ks_ndata;
for (i=0; i < kp->ks_ndata; i++){
DEBUGMSG(("ucd-snmp/lmSensors", "found instance %d fan type %d speed %d OK %d bustedfan %d\n",
fan_info->instance, fan_info->type,fan_info->fanspeed,fan_info->fans_ok,fan_info->fanflt_num));
sensor_array[typ].sensor[i].value = fan_info->fanspeed;
snprintf(sensor_array[typ].sensor[i].name,(MAX_NAME - 1),
"fan type %s number %d",fantypes[fan_info->type],fan_info->instance);
sensor_array[typ].sensor[i].name[MAX_NAME - 1] = '\0';
fan_info++;
} /* end for fan_info */
} /* end else kstatread fan */
} /* end else lookup fans*/
kp = kstat_lookup(kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_PSNAME);
if (kp == 0) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't lookup power supply kstat"));
} /* endif lookup power supply */
else{
if (kstat_read(kc, kp, 0) == -1) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't read power supply kstat"));
} /* endif kstatread fan */
else{
typ = 2;
power_info = (envctrl_ps_t *) kp->ks_data;
sensor_array[typ].n = kp->ks_ndata;
for (i=0; i < kp->ks_ndata; i++){
DEBUGMSG(("ucd-snmp/lmSensors", "found instance %d psupply temp %d %dW OK %d share %d limit %d\n",
power_info->instance, power_info->ps_tempr,power_info->ps_rating,
power_info->ps_ok,power_info->curr_share_ok,power_info->limit_ok));
sensor_array[typ].sensor[i].value = power_info->ps_tempr;
snprintf(sensor_array[typ].sensor[i].name,(MAX_NAME-1),
"power supply %d",power_info->instance);
sensor_array[typ].sensor[i].name[MAX_NAME - 1] = '\0';
power_info++;
} /* end for power_info */
} /* end else kstatread power supply */
} /* end else lookup power supplies*/
kp = kstat_lookup(kc, ENVCTRL_MODULE_NAME, 0, ENVCTRL_KSTAT_ENCL);
if (kp == 0) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't lookup enclosure kstat"));
} /* endif lookup enclosure */
else{
if (kstat_read(kc, kp, 0) == -1) {
DEBUGMSGTL(("ucd-snmp/lmSensors", "couldn't read enclosure kstat"));
} /* endif kstatread enclosure */
else{
enc_info = (envctrl_encl_t *) kp->ks_data;
temp = 0;
other = 0;
for (i=0; i < kp->ks_ndata; i++){
switch (enc_info->type){
case ENVCTRL_ENCL_FSP:
DEBUGMSG(("ucd-snmp/lmSensors", "front panel value %d\n",enc_info->value));
typ = 3; /* misc */
sensor_array[typ].sensor[other].value = enc_info->value;
strncpy(sensor_array[typ].sensor[other].name,"FSP",MAX_NAME-1);
sensor_array[typ].sensor[other].name[MAX_NAME-1]='\0'; /* null terminate */
other++;
break;
case ENVCTRL_ENCL_AMBTEMPR:
DEBUGMSG(("ucd-snmp/lmSensors", "ambient temp %d\n",enc_info->value));
typ = 0; /* temperature sensor */
sensor_array[typ].sensor[temp].value = enc_info->value;
strncpy(sensor_array[typ].sensor[temp].name,"Ambient",MAX_NAME-1);
sensor_array[typ].sensor[temp].name[MAX_NAME-1]='\0'; /* null terminate */
temp++;
break;
case ENVCTRL_ENCL_BACKPLANE4:
DEBUGMSG(("ucd-snmp/lmSensors", "There is a backplane4\n"));
typ = 3; /* misc */
sensor_array[typ].sensor[other].value = enc_info->value;
strncpy(sensor_array[typ].sensor[other].name,"Backplane4",MAX_NAME-1);
sensor_array[typ].sensor[other].name[MAX_NAME-1]='\0'; /* null terminate */
other++;
break;
case ENVCTRL_ENCL_BACKPLANE8:
DEBUGMSG(("ucd-snmp/lmSensors", "There is a backplane8\n"));
typ = 3; /* misc */
sensor_array[typ].sensor[other].value = enc_info->value;
strncpy(sensor_array[typ].sensor[other].name,"Backplane8",MAX_NAME-1);
sensor_array[typ].sensor[other].name[MAX_NAME-1]='\0'; /* null terminate */
other++;
break;
case ENVCTRL_ENCL_CPUTEMPR:
DEBUGMSG(("ucd-snmp/lmSensors", "CPU%d temperature %d\n",enc_info->instance,enc_info->value));
typ = 0; /* temperature sensor */
sensor_array[typ].sensor[temp].value = enc_info->value;
snprintf(sensor_array[typ].sensor[temp].name,MAX_NAME,"CPU%d",enc_info->instance);
sensor_array[typ].sensor[other].name[MAX_NAME-1]='\0'; /* null terminate */
temp++;
break;
default:
DEBUGMSG(("ucd-snmp/lmSensors", "unknown element instance &d type &d value %d\n",
enc_info->instance, enc_info->type, enc_info->value));
break;
} /* end switch */
enc_info++;
} /* end for enc_info */
sensor_array[3].n = other;
sensor_array[0].n = temp;
} /* end else kstatread enclosure */
} /* end else lookup enclosure*/
kstat_close(kc);
#ifdef HAVE_PICL_H
} /* end else kc not needed if no picld*/
#endif
} /* end else kstat */
#else /* end solaris2 */
const sensors_chip_name *chip;
const sensors_feature_data *data;
int chip_nr = 0;
int i;
for (i = 0; i < N_TYPES; i++)
sensor_array[i].n = 0;
while (chip = sensors_get_detected_chips(&chip_nr)) {
int a = 0;
int b = 0;
while (data = sensors_get_all_features(*chip, &a, &b)) {
char *label = NULL;
double val;
if ((data->mode & SENSORS_MODE_R) &&
(data->mapping == SENSORS_NO_MAPPING) &&
!sensors_get_label(*chip, data->number, &label) &&
!sensors_get_feature(*chip, data->number, &val)) {
int type = -1;
float mul;
_sensor_array *array;
if (strstr(label, "V")) {
type = 2;
mul = 1000.0;
}
if (strstr(label, "fan") || strstr(label, "Fan")) {
type = 1;
mul = 1.0;
}
if (strstr(label, "temp") || strstr(label, "Temp")) {
type = 0;
mul = 1000.0;
}
if (type == -1) {
type = 3;
mul = 1000.0;
}
array = &sensor_array[type];
if (MAX_SENSORS <= array->n) {
snmp_log(LOG_ERR, "too many sensors. ignoring %s\n", label);
break;
}
strncpy(array->sensor[array->n].name, label, MAX_NAME);
array->sensor[array->n].value = (int) (val * mul);
DEBUGMSGTL(("sensors","sensor %d, value %d\n",
array->sensor[array->n].name,
array->sensor[array->n].value));
array->n++;
}
if (label) {
free(label);
label = NULL;
}
}
}
#endif /*else solaris2 */
timestamp = t;
}
static int sensors_load_conf (void)
{
static int call_once = 0;
FILE *fh = NULL;
featurelist_t *last_feature = NULL;
const sensors_chip_name *chip;
int chip_num;
int status;
if (call_once)
return 0;
call_once = 1;
if (conffile != NULL)
{
fh = fopen (conffile, "r");
if (fh == NULL)
{
char errbuf[1024];
ERROR ("sensors plugin: fopen(%s) failed: %s", conffile,
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
}
status = sensors_init (fh);
if (fh)
fclose (fh);
if (status != 0)
{
ERROR ("sensors plugin: Cannot initialize sensors. "
"Data will not be collected.");
return (-1);
}
#if SENSORS_API_VERSION < 0x400
chip_num = 0;
while ((chip = sensors_get_detected_chips (&chip_num)) != NULL)
{
int feature_num0 = 0;
int feature_num1 = 0;
while (42)
{
const sensors_feature_data *feature;
int feature_type;
featurelist_t *fl;
feature = sensors_get_all_features (*chip,
&feature_num0, &feature_num1);
/* Check if all features have been read. */
if (feature == NULL)
break;
/* "master features" only */
if (feature->mapping != SENSORS_NO_MAPPING)
{
DEBUG ("sensors plugin: sensors_load_conf: "
"Ignoring subfeature `%s', "
"because (feature->mapping "
"!= SENSORS_NO_MAPPING).",
feature->name);
continue;
}
/* skip ignored in sensors.conf */
if (sensors_get_ignored (*chip, feature->number) == 0)
{
DEBUG ("sensors plugin: sensors_load_conf: "
"Ignoring subfeature `%s', "
"because "
"`sensors_get_ignored' told "
"me so.",
feature->name);
continue;
}
feature_type = sensors_feature_name_to_type (
feature->name);
if (feature_type == SENSOR_TYPE_UNKNOWN)
{
DEBUG ("sensors plugin: sensors_load_conf: "
"Ignoring subfeature `%s', "
"because its type is "
"unknown.",
feature->name);
continue;
}
fl = calloc (1, sizeof (*fl));
if (fl == NULL)
{
ERROR ("sensors plugin: calloc failed.");
continue;
}
fl->chip = chip;
fl->data = feature;
fl->type = feature_type;
if (first_feature == NULL)
first_feature = fl;
else
last_feature->next = fl;
last_feature = fl;
} /* while sensors_get_all_features */
} /* while sensors_get_detected_chips */
/* #endif SENSORS_API_VERSION < 0x400 */
#elif (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500)
chip_num = 0;
while ((chip = sensors_get_detected_chips (NULL, &chip_num)) != NULL)
{
const sensors_feature *feature;
int feature_num = 0;
while ((feature = sensors_get_features (chip, &feature_num)) != NULL)
{
const sensors_subfeature *subfeature;
int subfeature_num = 0;
/* Only handle voltage, fanspeeds and temperatures */
if ((feature->type != SENSORS_FEATURE_IN)
&& (feature->type != SENSORS_FEATURE_FAN)
&& (feature->type != SENSORS_FEATURE_TEMP)
&& (feature->type != SENSORS_FEATURE_POWER))
{
DEBUG ("sensors plugin: sensors_load_conf: "
"Ignoring feature `%s', "
"because its type is not "
"supported.", feature->name);
continue;
}
while ((subfeature = sensors_get_all_subfeatures (chip,
feature, &subfeature_num)) != NULL)
{
featurelist_t *fl;
if ((subfeature->type != SENSORS_SUBFEATURE_IN_INPUT)
&& (subfeature->type != SENSORS_SUBFEATURE_FAN_INPUT)
&& (subfeature->type != SENSORS_SUBFEATURE_TEMP_INPUT)
&& (subfeature->type != SENSORS_SUBFEATURE_POWER_INPUT))
continue;
fl = calloc (1, sizeof (*fl));
if (fl == NULL)
{
ERROR ("sensors plugin: calloc failed.");
continue;
}
fl->chip = chip;
fl->feature = feature;
fl->subfeature = subfeature;
if (first_feature == NULL)
first_feature = fl;
else
last_feature->next = fl;
last_feature = fl;
} /* while (subfeature) */
} /* while (feature) */
} /* while (chip) */
#endif /* (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) */
if (first_feature == NULL)
{
sensors_cleanup ();
INFO ("sensors plugin: lm_sensors reports no "
"features. Data will not be collected.");
return (-1);
}
return (0);
} /* int sensors_load_conf */