unsigned int get_sensor_data(unsigned int _id, struct sensor_data *_data)
{
int a, b, c, num;
const sensors_chip_name * chip;
const sensors_feature * features;
const sensors_subfeature * subfeatures;
a = num = 0;
_data->kind = -1;
while ((chip = sensors_get_detected_chips(NULL, &a)))
{
b = 0;
while ((features = sensors_get_features(chip, &b)))
{
c = 0;
while ((subfeatures = sensors_get_all_subfeatures(chip, features, &c)))
{
if (subfeatures->type == SENSORS_SUBFEATURE_FAN_INPUT)
{
if (_id == num)
{
_data->id = _id;
_data->chip = chip->addr;
_data->sensor = features->number;
char *label = sensors_get_label(chip, features);
memcpy(_data->label, label, strlen(label)+1);
free(label);
_data->kind = SENSOR_FAN;
sensors_get_value(chip, subfeatures->number, &_data->data);
return 1;
}
num++;
}
if (subfeatures->type == SENSORS_SUBFEATURE_TEMP_INPUT)
{
if (_id == num)
{
_data->id = _id;
_data->chip = chip->addr;
_data->sensor = features->number;
char *label = sensors_get_label(chip, features);
memcpy(_data->label, label, strlen(label)+1);
free(label);
_data->kind = SENSOR_TEMP;
sensors_get_value(chip, subfeatures->number, &_data->data);
return 1;
}
num++;
}
}
}
}
return 0;
}
void print_chip_raw(const sensors_chip_name *name)
{
int a, b, err;
const sensors_feature *feature;
const sensors_subfeature *sub;
char *label;
double val;
a = 0;
while ((feature = sensors_get_features(name, &a))) {
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature "
"%s!\n", feature->name);
continue;
}
printf("%s:\n", label);
free(label);
b = 0;
while ((sub = sensors_get_all_subfeatures(name, feature, &b))) {
if (sub->flags & SENSORS_MODE_R) {
if ((err = sensors_get_value(name, sub->number,
&val)))
fprintf(stderr, "ERROR: Can't get "
"value of subfeature %s: %s\n",
sub->name,
sensors_strerror(err));
else
printf(" %s: %.3f\n", sub->name, val);
} else
printf("(%s)\n", label);
}
}
}
static void print_chip_energy(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
double val;
const sensors_subfeature *sf;
char *label;
const char *unit;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_ENERGY_INPUT);
if (sf && get_input_value(name, sf, &val) == 0) {
scale_value(&val, &unit);
printf("%6.2f %sJ", val, unit);
} else
printf(" N/A");
printf("\n");
}
static void print_chip_curr(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
const sensors_subfeature *sf;
double val;
char *label;
struct sensor_subfeature_data sensors[NUM_CURR_SENSORS];
struct sensor_subfeature_data alarms[NUM_CURR_ALARMS];
int sensor_count, alarm_count;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_CURR_INPUT);
if (sf && get_input_value(name, sf, &val) == 0)
printf("%+6.2f A ", val);
else
printf(" N/A ");
sensor_count = alarm_count = 0;
get_sensor_limit_data(name, feature, current_sensors,
sensors, &sensor_count, alarms, &alarm_count);
print_limits(sensors, sensor_count, alarms, alarm_count, label_size,
"%s = %+6.2f A");
printf("\n");
}
static PyObject*
get_label(ChipName *self, PyObject *args, PyObject *kwargs)
{
char *kwlist[] = {"feature", NULL};
Feature *feature = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist,
&FeatureType, &feature))
{
return NULL;
}
char *label = sensors_get_label(&self->chip_name, &feature->feature);
if (label == NULL)
{
PyErr_SetString(SensorsException,
"sensors_get_label() returned NULL");
return NULL;
}
PyObject *py_label = PyString_FromString(label);
free(label);
return py_label;
}
static void print_chip_power(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
double val;
const sensors_subfeature *sf;
struct sensor_subfeature_data sensors[6];
struct sensor_subfeature_data alarms[3];
int sensor_count, alarm_count;
char *label;
const char *unit;
int i;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sensor_count = alarm_count = 0;
/* Power sensors come in 2 flavors: instantaneous and averaged.
To keep things simple, we assume that each sensor only implements
one flavor. */
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_POWER_INPUT);
get_sensor_limit_data(name, feature,
sf ? power_inst_sensors : power_avg_sensors,
sensors, ARRAY_SIZE(sensors), &sensor_count,
alarms, ARRAY_SIZE(alarms), &alarm_count);
/* Add sensors common to both flavors. */
get_sensor_limit_data(name, feature,
power_common_sensors,
sensors, ARRAY_SIZE(sensors), &sensor_count,
alarms, ARRAY_SIZE(alarms), &alarm_count);
if (!sf)
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_POWER_AVERAGE);
if (sf && get_input_value(name, sf, &val) == 0) {
scale_value(&val, &unit);
printf("%6.2f %sW ", val, unit);
} else
printf(" N/A ");
for (i = 0; i < sensor_count; i++)
scale_value(&sensors[i].value, &sensors[i].unit);
print_limits(sensors, sensor_count, alarms, alarm_count,
label_size, "%s = %6.2f %sW");
printf("\n");
}
static void print_chip_fan(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
const sensors_subfeature *sf, *sfmin, *sfdiv;
double val;
char *label;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_FAULT);
if (sf && get_value(name, sf))
printf(" FAULT");
else {
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_INPUT);
if (sf && get_input_value(name, sf, &val) == 0)
printf("%4.0f RPM", val);
else
printf(" N/A");
}
sfmin = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_MIN);
sfdiv = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_DIV);
if (sfmin && sfdiv)
printf(" (min = %4.0f RPM, div = %1.0f)",
get_value(name, sfmin),
get_value(name, sfdiv));
else if (sfmin)
printf(" (min = %4.0f RPM)",
get_value(name, sfmin));
else if (sfdiv)
printf(" (div = %1.0f)",
get_value(name, sfdiv));
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_FAN_ALARM);
if (sf && get_value(name, sf)) {
printf(" ALARM");
}
printf("\n");
}
static void
_j4status_sensors_add_feature_temp(J4statusPluginContext *context, const sensors_chip_name *chip, const sensors_feature *feature)
{
const char *name = _j4status_sensors_get_feature_name(chip, feature);
const sensors_subfeature *input;
input = sensors_get_subfeature(chip, feature, SENSORS_SUBFEATURE_TEMP_INPUT);
if ( input == NULL )
{
g_warning("No temperature input on chip '%s', skipping", name);
return;
}
J4statusSensorsFeature *sensor_feature;
sensor_feature = g_new0(J4statusSensorsFeature, 1);
sensor_feature->section = j4status_section_new(context->core);
sensor_feature->chip = chip;
sensor_feature->feature = feature;
sensor_feature->input = input;
sensor_feature->max = sensors_get_subfeature(chip, feature, SENSORS_SUBFEATURE_TEMP_MAX);
sensor_feature->crit = sensors_get_subfeature(chip, feature, SENSORS_SUBFEATURE_TEMP_CRIT);
char *label;
label = sensors_get_label(chip, feature);
gint64 max_width = strlen("+100.0*C");
if ( context->config.show_details )
{
if ( ( sensor_feature->crit != NULL ) && ( sensor_feature->max != NULL ) )
max_width += strlen(" (high = +100.0°C, crit = +100.0°C)");
else if ( sensor_feature->crit != NULL )
max_width += strlen(" (crit = +100.0°C)");
else if ( sensor_feature->max != NULL )
max_width += strlen(" (high = +100.0°C)");
}
j4status_section_set_name(sensor_feature->section, "sensors");
j4status_section_set_instance(sensor_feature->section, name);
j4status_section_set_label(sensor_feature->section, label);
j4status_section_set_max_width(sensor_feature->section, -max_width);
free(label);
if ( j4status_section_insert(sensor_feature->section) )
context->sections = g_list_prepend(context->sections, sensor_feature);
else
_j4status_sensors_feature_free(sensor_feature);
}
/* If a sensor is 'interesting' to us then return its label, otherwise NULL. */
static char *get_sensor_interesting_label (sensors_chip_name chip, int feature) {
char *label;
if (sensors_get_ignored(chip, feature) &&
(sensors_get_label(chip, feature, &label) == 0)) {
if (! (strcmp ("alarms", label) == 0 || strncmp ("sensor", label, 6) == 0)) {
return label;
} else {
free (label);
}
}
return NULL;
}
Feature::Feature(const sensors_chip_name* sensorsChipName, const sensors_feature* sensorsFeature)
: mSensorsChipName(sensorsChipName),
mSensorsFeature(sensorsFeature)
{
char *featureLabel = nullptr;
if ((featureLabel = sensors_get_label(mSensorsChipName, mSensorsFeature)))
{
mLabel = featureLabel;
free(featureLabel);
}
qDebug() << "Detected feature:" << QString::fromLatin1(sensorsFeature->name)
<< "(" << mLabel << ")";
}
Feature::Feature(const sensors_chip_name* sensorsChipName, const sensors_feature* sensorsFeature)
: mSensorsChipName(sensorsChipName),
mSensorsFeature(sensorsFeature)
{
char *featureLabel = NULL;
if ((featureLabel = sensors_get_label(mSensorsChipName, mSensorsFeature)))
{
mLabel = featureLabel;
free(featureLabel);
}
qDebug() << "Detected feature:" << QString::fromStdString(std::string(sensorsFeature->name))
<< "(" << QString::fromStdString(mLabel) << ")";
}
static void
build_sensor_list(void)
{
const sensors_chip_name *chip;
const sensors_chip_name *match = 0;
const sensors_feature *feature;
int chip_nr = 0;
char name[256];
while ((chip = sensors_get_detected_chips(match, &chip_nr))) {
sensors_snprintf_chip_name(name, sizeof(name), chip);
/* Get all features and filter accordingly. */
int fnr = 0;
while ((feature = sensors_get_features(chip, &fnr))) {
char *featurename = sensors_get_label(chip, feature);
if (!featurename)
continue;
/* Create a 'current' and 'critical' object pair.
* Ignore sensor if its not temperature based.
*/
switch(feature->type) {
case SENSORS_FEATURE_TEMP:
create_object(name, featurename, chip, feature,
SENSORS_TEMP_CURRENT);
create_object(name, featurename, chip, feature,
SENSORS_TEMP_CRITICAL);
break;
case SENSORS_FEATURE_IN:
create_object(name, featurename, chip, feature,
SENSORS_VOLTAGE_CURRENT);
break;
case SENSORS_FEATURE_CURR:
create_object(name, featurename, chip, feature,
SENSORS_CURRENT_CURRENT);
break;
case SENSORS_FEATURE_POWER:
create_object(name, featurename, chip, feature,
SENSORS_POWER_CURRENT);
break;
default:
break;
}
free(featurename);
}
}
}
static int get_label_size(const sensors_chip_name *name)
{
int i;
const sensors_feature *iter;
char *label;
unsigned int max_size = 11; /* 11 as minimum label width */
i = 0;
while ((iter = sensors_get_features(name, &i))) {
if ((label = sensors_get_label(name, iter)) &&
strlen(label) > max_size)
max_size = strlen(label);
free(label);
}
/* One more for the colon, and one more to guarantee at least one
space between that colon and the value */
return max_size + 2;
}
static void print_chip_humidity(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
char *label;
const sensors_subfeature *subfeature;
double humidity;
subfeature = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_HUMIDITY_INPUT);
if (!subfeature)
return;
if ((label = sensors_get_label(name, feature))
&& !sensors_get_value(name, subfeature->number, &humidity)) {
print_label(label, label_size);
printf("%6.1f %%RH\n", humidity);
}
free(label);
}
static void print_chip_intrusion(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
char *label;
const sensors_subfeature *subfeature;
double alarm;
subfeature = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_INTRUSION_ALARM);
if (!subfeature)
return;
if ((label = sensors_get_label(name, feature))
&& !sensors_get_value(name, subfeature->number, &alarm)) {
print_label(label, label_size);
printf("%s\n", alarm ? "ALARM" : "OK");
}
free(label);
}
static void print_chip_beep_enable(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
char *label;
const sensors_subfeature *subfeature;
double beep_enable;
subfeature = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_BEEP_ENABLE);
if (!subfeature)
return;
if ((label = sensors_get_label(name, feature))
&& !sensors_get_value(name, subfeature->number, &beep_enable)) {
print_label(label, label_size);
printf("%s\n", beep_enable ? "enabled" : "disabled");
}
free(label);
}
static void print_chip_vid(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
char *label;
const sensors_subfeature *subfeature;
double vid;
subfeature = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_VID);
if (!subfeature)
return;
if ((label = sensors_get_label(name, feature))
&& !sensors_get_value(name, subfeature->number, &vid)) {
print_label(label, label_size);
printf("%+6.3f V\n", vid);
}
free(label);
}
int init_sensor_data() {
const sensors_chip_name *chip_name;
const sensors_feature *feature;
const sensors_subfeature *subfeature;
char *label;
int fan_enabled=FALSE, temperature_enabled=FALSE;
int a,b,c;
a=0;
while ( (chip_name = sensors_get_detected_chips(NULL, &a)) ) {
b=0;
while ( (feature = sensors_get_features(chip_name, &b)) ) {
c=0;
while ( (subfeature = sensors_get_all_subfeatures(chip_name, feature, &c)) ) {
label = sensors_get_label(chip_name, feature);
if ( strcmp(CPU_TEMP, label)==0 ) {
printf ("Found sensor: %s (cpu temperature)\n", CPU_TEMP);
sd.chip_name_temp=chip_name;
sd.number_temp=subfeature->number;
temperature_enabled=TRUE;
break;
}
if (subfeature->type == SENSORS_SUBFEATURE_FAN_INPUT) {
printf ("Found FAN sensor\n");
sd.chip_name_fan=chip_name;
sd.number_fan=subfeature->number;
fan_enabled=TRUE;
break;
}
}
}
}
if (fan_enabled==TRUE && temperature_enabled==TRUE)
return TRUE;
return FALSE;
}
int
netsnmp_sensor_arch_load(netsnmp_cache *cache, void *vp) {
netsnmp_sensor_info *sp;
const sensors_chip_name *chip;
const sensors_feature *data;
const sensors_subfeature *data2;
int chip_nr = 0;
DEBUGMSGTL(("sensors:arch", "Reload v3 LM Sensors module\n"));
while ((chip = sensors_get_detected_chips( NULL, &chip_nr))) {
int a = 0;
while ((data = sensors_get_features( chip, &a))) {
DEBUGMSGTL(("sensors:arch:detail", "get_features (%s, %d)\n", data->name, data->number));
int b = 0;
while ((data2 = sensors_get_all_subfeatures( chip, data, &b))) {
char *label = NULL;
double val;
int type = NETSNMP_SENSOR_TYPE_OTHER;
DEBUGMSGTL(("sensors:arch:detail", " get_subfeatures (%s, %d)\n", data2->name, data2->number));
/*
* Check the type of this subfeature,
* concentrating on the main "input" measurements.
*/
switch ( data2->type ) {
case SENSORS_SUBFEATURE_IN_INPUT:
type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC;
break;
case SENSORS_SUBFEATURE_FAN_INPUT:
type = NETSNMP_SENSOR_TYPE_RPM;
break;
case SENSORS_SUBFEATURE_TEMP_INPUT:
type = NETSNMP_SENSOR_TYPE_TEMPERATURE;
break;
case SENSORS_SUBFEATURE_VID:
type = NETSNMP_SENSOR_TYPE_VOLTAGE_DC;
break;
default:
/* Skip everything other than these basic sensor features - ??? */
DEBUGMSGTL(("sensors:arch:detail", " Skip type %x\n", data2->type));
continue;
}
/*
* Get the name and value of this subfeature
*/
/*
if (!(label = sensors_get_label(chip, data))) {
DEBUGMSGTL(("sensors:arch:detail", " Can't get name (%s)\n", label));
continue;
}
if (sensors_get_value(chip, data2->number, &val) < 0) {
DEBUGMSGTL(("sensors:arch:detail", " Can't get value (%f)\n", val));
continue;
}
*/
if (!(label = sensors_get_label(chip, data)) ||
(sensors_get_value(chip, data2->number, &val) < 0)) {
DEBUGMSGTL(("sensors:arch:detail", " Can't get name/value (%s, %f)\n", label, val));
free(label);
label = NULL;
continue;
}
DEBUGMSGTL(("sensors:arch:detail", "%s = %f\n", label, val));
/*
* Use this type to create a new sensor entry
* (inserting it in the appropriate sub-containers)
*/
sp = sensor_by_name( label, type );
if ( sp ) {
sp->value = val;
sp->flags|= NETSNMP_SENSOR_FLAG_ACTIVE;
}
if (label) {
free(label);
label = NULL;
}
} /* end while data2 */
} /* end while data */
} /* end while chip */
return 0;
}
static int do_features(const sensors_chip_name *chip,
const FeatureDescriptor *feature, int action)
{
char *label;
const char *formatted;
int i, alrm, beep, ret;
double val[MAX_DATA];
/* If only scanning, take a quick exit if alarm is off */
alrm = get_flag(chip, feature->alarmNumber);
if (alrm == -1)
return -1;
if (action == DO_SCAN && !alrm)
return 0;
for (i = 0; feature->dataNumbers[i] >= 0; i++) {
ret = sensors_get_value(chip, feature->dataNumbers[i],
val + i);
if (ret) {
sensorLog(LOG_ERR,
"Error getting sensor data: %s/#%d: %s",
chip->prefix, feature->dataNumbers[i],
sensors_strerror(ret));
return -1;
}
}
/* For RRD, we don't need anything else */
if (action == DO_RRD) {
if (feature->rrd) {
const char *rrded = feature->rrd(val);
sprintf(rrdBuff + strlen(rrdBuff), ":%s",
rrded ? rrded : "U");
}
return 0;
}
/* For scanning and logging, we need extra information */
beep = get_flag(chip, feature->beepNumber);
if (beep == -1)
return -1;
formatted = feature->format(val, alrm, beep);
if (!formatted) {
sensorLog(LOG_ERR, "Error formatting sensor data");
return -1;
}
/* FIXME: It would be more efficient to store the label at
* initialization time.
*/
label = sensors_get_label(chip, feature->feature);
if (!label) {
sensorLog(LOG_ERR, "Error getting sensor label: %s/%s",
chip->prefix, feature->feature->name);
return -1;
}
if (action == DO_READ)
sensorLog(LOG_INFO, " %s: %s", label, formatted);
else
sensorLog(LOG_ALERT, "Sensor alarm: Chip %s: %s: %s",
chipName(chip), label, formatted);
free(label);
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 void print_chip_temp(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
struct sensor_subfeature_data sensors[NUM_TEMP_SENSORS];
struct sensor_subfeature_data alarms[NUM_TEMP_ALARMS];
int sensor_count, alarm_count;
const sensors_subfeature *sf;
double val;
char *label;
int i;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_FAULT);
if (sf && get_value(name, sf)) {
printf(" FAULT ");
} else {
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_INPUT);
if (sf && get_input_value(name, sf, &val) == 0) {
get_input_value(name, sf, &val);
if (fahrenheit)
val = deg_ctof(val);
printf("%+6.1f%s ", val, degstr);
} else
printf(" N/A ");
}
sensor_count = alarm_count = 0;
get_sensor_limit_data(name, feature, temp_sensors,
sensors, &sensor_count, alarms, &alarm_count);
for (i = 0; i < sensor_count; i++) {
if (fahrenheit)
sensors[i].value = deg_ctof(sensors[i].value);
sensors[i].unit = degstr;
}
print_limits(sensors, sensor_count, alarms, alarm_count, label_size,
"%-4s = %+5.1f%s");
/* print out temperature sensor info */
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_TEMP_TYPE);
if (sf) {
int sens = (int)get_value(name, sf);
/* older kernels / drivers sometimes report a beta value for
thermistors */
if (sens > 1000)
sens = 4;
printf(" sensor = %s", sens == 0 ? "disabled" :
sens == 1 ? "CPU diode" :
sens == 2 ? "transistor" :
sens == 3 ? "thermal diode" :
sens == 4 ? "thermistor" :
sens == 5 ? "AMD AMDSI" :
sens == 6 ? "Intel PECI" : "unknown");
}
printf("\n");
}
HwmonCounter::HwmonCounter(DriverCounter *next, char *const name, const sensors_chip_name *const chip, const sensors_feature *feature) : DriverCounter(next, name), mChip(chip), mFeature(feature), mDuplicate(false) {
mLabel = sensors_get_label(mChip, mFeature);
switch (mFeature->type) {
case SENSORS_FEATURE_IN:
mTitle = "Voltage";
mDisplay = "maximum";
mCounterClass = "absolute";
mUnit = "V";
mMultiplier = 0.001;
mMonotonic = false;
break;
case SENSORS_FEATURE_FAN:
mTitle = "Fan";
mDisplay = "average";
mCounterClass = "absolute";
mUnit = "RPM";
mMultiplier = 1.0;
mMonotonic = false;
break;
case SENSORS_FEATURE_TEMP:
mTitle = "Temperature";
mDisplay = "maximum";
mCounterClass = "absolute";
mUnit = "°C";
mMultiplier = 0.001;
mMonotonic = false;
break;
case SENSORS_FEATURE_POWER:
mTitle = "Power";
mDisplay = "maximum";
mCounterClass = "absolute";
mUnit = "W";
mMultiplier = 0.000001;
mMonotonic = false;
break;
case SENSORS_FEATURE_ENERGY:
mTitle = "Energy";
mDisplay = "accumulate";
mCounterClass = "delta";
mUnit = "J";
mMultiplier = 0.000001;
mMonotonic = true;
break;
case SENSORS_FEATURE_CURR:
mTitle = "Current";
mDisplay = "maximum";
mCounterClass = "absolute";
mUnit = "A";
mMultiplier = 0.001;
mMonotonic = false;
break;
case SENSORS_FEATURE_HUMIDITY:
mTitle = "Humidity";
mDisplay = "average";
mCounterClass = "absolute";
mUnit = "%";
mMultiplier = 0.001;
mMonotonic = false;
break;
default:
logg.logError("Unsupported hwmon feature %i", mFeature->type);
handleException();
}
for (HwmonCounter * counter = static_cast<HwmonCounter *>(next); counter != NULL; counter = static_cast<HwmonCounter *>(counter->getNext())) {
if (strcmp(mLabel, counter->getLabel()) == 0 && strcmp(mTitle, counter->getTitle()) == 0) {
mDuplicate = true;
counter->mDuplicate = true;
break;
}
}
}
Sensor(const sensors_chip_name * n, const sensors_feature * f) : name(n),
feature(f) {
char * l = sensors_get_label(n, f);
label = l;
free(l);
}
static int sensors_read (void)
{
if (sensors_load_conf () != 0)
return (-1);
#if SENSORS_API_VERSION < 0x400
for (featurelist_t *fl = first_feature; fl != NULL; fl = fl->next)
{
double value;
int status;
char plugin_instance[DATA_MAX_NAME_LEN];
char type_instance[DATA_MAX_NAME_LEN];
status = sensors_get_feature (*fl->chip,
fl->data->number, &value);
if (status < 0)
continue;
status = sensors_snprintf_chip_name (plugin_instance,
sizeof (plugin_instance), fl->chip);
if (status < 0)
continue;
sstrncpy (type_instance, fl->data->name,
sizeof (type_instance));
sensors_submit (plugin_instance,
sensor_type_name_map[fl->type],
type_instance,
value);
} /* for fl = first_feature .. NULL */
/* #endif SENSORS_API_VERSION < 0x400 */
#elif (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500)
for (featurelist_t *fl = first_feature; fl != NULL; fl = fl->next)
{
double value;
int status;
char plugin_instance[DATA_MAX_NAME_LEN];
char type_instance[DATA_MAX_NAME_LEN];
char *sensor_label;
const char *type;
status = sensors_get_value (fl->chip,
fl->subfeature->number, &value);
if (status < 0)
continue;
status = sensors_snprintf_chip_name (plugin_instance,
sizeof (plugin_instance), fl->chip);
if (status < 0)
continue;
if (use_labels)
{
sensor_label = sensors_get_label (fl->chip, fl->feature);
sstrncpy (type_instance, sensor_label, sizeof (type_instance));
free (sensor_label);
}
else
{
sstrncpy (type_instance, fl->feature->name,
sizeof (type_instance));
}
if (fl->feature->type == SENSORS_FEATURE_IN)
type = "voltage";
else if (fl->feature->type
== SENSORS_FEATURE_FAN)
type = "fanspeed";
else if (fl->feature->type
== SENSORS_FEATURE_TEMP)
type = "temperature";
else if (fl->feature->type
== SENSORS_FEATURE_POWER)
type = "power";
else
continue;
sensors_submit (plugin_instance, type, type_instance, value);
} /* for fl = first_feature .. NULL */
#endif /* (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) */
return (0);
} /* int sensors_read */
HwmonCounter::HwmonCounter(HwmonCounter *next, const sensors_chip_name *chip, const sensors_feature *feature) : next(next), key(getEventKey()), polled(false), readable(false), enabled(false), duplicate(false), chip(chip), feature(feature) {
int len = sensors_snprintf_chip_name(NULL, 0, chip) + 1;
char *chip_name = new char[len];
sensors_snprintf_chip_name(chip_name, len, chip);
len = snprintf(NULL, 0, "hwmon_%s_%d", chip_name, feature->number) + 1;
name = new char[len];
snprintf(name, len, "hwmon_%s_%d", chip_name, feature->number);
delete [] chip_name;
label = sensors_get_label(chip, feature);
switch (feature->type) {
case SENSORS_FEATURE_IN:
title = "Voltage";
input = SENSORS_SUBFEATURE_IN_INPUT;
display = "maximum";
counter_class = "absolute";
unit = "V";
modifier = 1000;
monotonic = false;
break;
case SENSORS_FEATURE_FAN:
title = "Fan";
input = SENSORS_SUBFEATURE_FAN_INPUT;
display = "average";
counter_class = "absolute";
unit = "RPM";
modifier = 1;
monotonic = false;
break;
case SENSORS_FEATURE_TEMP:
title = "Temperature";
input = SENSORS_SUBFEATURE_TEMP_INPUT;
display = "maximum";
counter_class = "absolute";
unit = "°C";
modifier = 1000;
monotonic = false;
break;
case SENSORS_FEATURE_POWER:
title = "Power";
input = SENSORS_SUBFEATURE_POWER_INPUT;
display = "maximum";
counter_class = "absolute";
unit = "W";
modifier = 1000000;
monotonic = false;
break;
case SENSORS_FEATURE_ENERGY:
title = "Energy";
input = SENSORS_SUBFEATURE_ENERGY_INPUT;
display = "accumulate";
counter_class = "delta";
unit = "J";
modifier = 1000000;
monotonic = true;
break;
case SENSORS_FEATURE_CURR:
title = "Current";
input = SENSORS_SUBFEATURE_CURR_INPUT;
display = "maximum";
counter_class = "absolute";
unit = "A";
modifier = 1000;
monotonic = false;
break;
case SENSORS_FEATURE_HUMIDITY:
title = "Humidity";
input = SENSORS_SUBFEATURE_HUMIDITY_INPUT;
display = "average";
counter_class = "absolute";
unit = "%";
modifier = 1000;
monotonic = false;
break;
default:
logg->logError(__FILE__, __LINE__, "Unsupported hwmon feature %i", feature->type);
handleException();
}
for (HwmonCounter * counter = next; counter != NULL; counter = counter->getNext()) {
if (strcmp(label, counter->getLabel()) == 0 && strcmp(title, counter->getTitle()) == 0) {
duplicate = true;
counter->duplicate = true;
break;
}
}
}
static void print_chip_power(const sensors_chip_name *name,
const sensors_feature *feature,
int label_size)
{
double val;
const sensors_subfeature *sf;
struct sensor_subfeature_data sensors[NUM_POWER_SENSORS];
struct sensor_subfeature_data alarms[NUM_POWER_ALARMS];
int sensor_count, alarm_count;
char *label;
const char *unit;
int i;
if (!(label = sensors_get_label(name, feature))) {
fprintf(stderr, "ERROR: Can't get label of feature %s!\n",
feature->name);
return;
}
print_label(label, label_size);
free(label);
sensor_count = alarm_count = 0;
/*
* Power sensors come in 2 flavors: instantaneous and averaged.
* Most devices only support one flavor, so we try to display the
* average power if the instantaneous power attribute does not exist.
* If both instantaneous power and average power are supported,
* average power is displayed as limit.
*/
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_POWER_INPUT);
get_sensor_limit_data(name, feature,
sf ? power_inst_sensors : power_avg_sensors,
sensors, &sensor_count, alarms, &alarm_count);
/* Add sensors common to both flavors. */
get_sensor_limit_data(name, feature, power_common_sensors,
sensors, &sensor_count, alarms, &alarm_count);
if (!sf)
sf = sensors_get_subfeature(name, feature,
SENSORS_SUBFEATURE_POWER_AVERAGE);
if (sf && get_input_value(name, sf, &val) == 0) {
scale_value(&val, &unit);
printf("%6.2f %sW%*s", val, unit, 2 - (int)strlen(unit), "");
} else
printf(" N/A ");
for (i = 0; i < sensor_count; i++) {
/*
* Unit is W and needs to be scaled for all attributes except
* interval, which does not need to be scaled and is reported in
* seconds.
*/
if (strcmp(sensors[i].name, "interval")) {
char *tmpstr;
tmpstr = alloca(4);
scale_value(&sensors[i].value, &unit);
snprintf(tmpstr, 4, "%sW", unit);
sensors[i].unit = tmpstr;
} else {
sensors[i].unit = "s";
}
}
print_limits(sensors, sensor_count, alarms, alarm_count,
label_size, "%s = %6.2f %s");
printf("\n");
}
HwmonCounter::HwmonCounter(DriverCounter *next, char *const name, const sensors_chip_name *chip, const sensors_feature *feature) : DriverCounter(next, name), chip(chip), feature(feature), duplicate(false) {
label = sensors_get_label(chip, feature);
switch (feature->type) {
case SENSORS_FEATURE_IN:
title = "Voltage";
display = "maximum";
counter_class = "absolute";
unit = "V";
modifier = 1000;
monotonic = false;
break;
case SENSORS_FEATURE_FAN:
title = "Fan";
display = "average";
counter_class = "absolute";
unit = "RPM";
modifier = 1;
monotonic = false;
break;
case SENSORS_FEATURE_TEMP:
title = "Temperature";
display = "maximum";
counter_class = "absolute";
unit = "°C";
modifier = 1000;
monotonic = false;
break;
case SENSORS_FEATURE_POWER:
title = "Power";
display = "maximum";
counter_class = "absolute";
unit = "W";
modifier = 1000000;
monotonic = false;
break;
case SENSORS_FEATURE_ENERGY:
title = "Energy";
display = "accumulate";
counter_class = "delta";
unit = "J";
modifier = 1000000;
monotonic = true;
break;
case SENSORS_FEATURE_CURR:
title = "Current";
display = "maximum";
counter_class = "absolute";
unit = "A";
modifier = 1000;
monotonic = false;
break;
case SENSORS_FEATURE_HUMIDITY:
title = "Humidity";
display = "average";
counter_class = "absolute";
unit = "%";
modifier = 1000;
monotonic = false;
break;
default:
logg->logError(__FILE__, __LINE__, "Unsupported hwmon feature %i", feature->type);
handleException();
}
for (HwmonCounter * counter = static_cast<HwmonCounter *>(next); counter != NULL; counter = static_cast<HwmonCounter *>(counter->getNext())) {
if (strcmp(label, counter->getLabel()) == 0 && strcmp(title, counter->getTitle()) == 0) {
duplicate = true;
counter->duplicate = true;
break;
}
}
}
/* ******** 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;
}