int initKnownChips(void) { int nr, count = 1; const sensors_chip_name *name; /* How many chips do we have? */ nr = 0; while ((name = sensors_get_detected_chips(NULL, &nr))) count++; /* Allocate the memory we need */ knownChips = calloc(count, sizeof(ChipDescriptor)); if (!knownChips) return 1; /* Fill in the data structures */ count = 0; nr = 0; while ((name = sensors_get_detected_chips(NULL, &nr))) { knownChips[count].name = name; if ((knownChips[count].features = generateChipFeatures(name))) count++; } return 0; }
static void _j4status_sensors_add_sensors(J4statusPluginContext *context, const sensors_chip_name *match) { const sensors_chip_name *chip; const sensors_feature *feature; int chip_nr = 0; while ( ( chip = sensors_get_detected_chips(match, &chip_nr) ) != NULL ) { int feature_nr = 0; while ( ( feature = sensors_get_features(chip, &feature_nr) ) != NULL ) { switch (feature->type) { case SENSORS_FEATURE_TEMP: _j4status_sensors_add_feature_temp(context, chip, feature); break; case SENSORS_FEATURE_FAN: _j4status_sensors_add_feature_fan(context, chip, feature); break; default: continue; } } } }
void HwmonDriver::readEvents(mxml_node_t *const) { int err = sensors_init(NULL); if (err) { logg->logMessage("Failed to initialize libsensors! (%d)", err); return; } sensors_sysfs_no_scaling = 1; int chip_nr = 0; const sensors_chip_name *chip; while ((chip = sensors_get_detected_chips(NULL, &chip_nr))) { int feature_nr = 0; const sensors_feature *feature; while ((feature = sensors_get_features(chip, &feature_nr))) { // Keep in sync with HwmonCounter::read // Can this counter be read? double value; const sensors_subfeature *const subfeature = sensors_get_subfeature(chip, feature, getInput(feature->type)); if ((subfeature == NULL) || (sensors_get_value(chip, subfeature->number, &value) != 0)) { continue; } // Get the name of the counter 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_%d", chip_name, chip_nr, feature->number) + 1; char *const name = new char[len]; snprintf(name, len, "hwmon_%s_%d_%d", chip_name, chip_nr, feature->number); delete [] chip_name; setCounters(new HwmonCounter(getCounters(), name, chip, feature)); } } }
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; }
/* Execute all set statements for this particular chip. The chip may contain wildcards! This function will return 0 on success, and <0 on failure. */ int sensors_do_chip_sets(const sensors_chip_name *name) { int nr, this_res; const sensors_chip_name *found_name; int res = 0; for (nr = 0; (found_name = sensors_get_detected_chips(name, &nr));) { this_res = sensors_do_this_chip_sets(found_name); if (this_res) res = this_res; } return res; }
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 applyToFeatures (FeatureFN fn, void *data) { const sensors_chip_name *chip; int i = 0, j, ret = 0, num = 0; while ((ret == 0) && ((chip = sensors_get_detected_chips (&i)) != NULL)) { for (j = 0; (ret == 0) && (j < numChipNames); ++ j) { if (sensors_match_chip (*chip, chipNames[j])) { int index0, subindex, chipindex = -1; for (index0 = 0; knownChips[index0]; ++ index0) for (subindex = 0; knownChips[index0]->names[subindex]; ++ subindex) if (!strcmp (chip->prefix, knownChips[index0]->names[subindex])) chipindex = index0; if (chipindex >= 0) { const ChipDescriptor *descriptor = knownChips[chipindex]; const FeatureDescriptor *features = descriptor->features; for (index0 = 0; (ret == 0) && (num < MAX_RRD_SENSORS) && features[index0].format; ++ index0) { const FeatureDescriptor *feature = features + index0; int labelNumber = feature->dataNumbers[0]; const char *rawLabel = NULL; char *label = NULL; int valid = 0; if (getValid (*chip, labelNumber, &valid)) { sensorLog (LOG_ERR, "Error getting sensor validity: %s/#%d", chip->prefix, labelNumber); ret = -1; } else if (getRawLabel (*chip, labelNumber, &rawLabel)) { sensorLog (LOG_ERR, "Error getting raw sensor label: %s/#%d", chip->prefix, labelNumber); ret = -1; } else if (getLabel (*chip, labelNumber, &label)) { sensorLog (LOG_ERR, "Error getting sensor label: %s/#%d", chip->prefix, labelNumber); ret = -1; } else if (valid) { rrdCheckLabel (rawLabel, num); ret = fn (data, rrdLabels[num], label, feature); ++ num; } if (label) free (label); } } } } } return ret; }
static int doChips(int action) { const sensors_chip_name *chip, *chip_arg; int i, j, ret = 0; for (j = 0; j < sensord_args.numChipNames; j++) { chip_arg = &sensord_args.chipNames[j]; i = 0; while ((chip = sensors_get_detected_chips(chip_arg, &i))) { ret = doChip(chip, action); if (ret) return ret; } } return ret; }
LMSensorList::LMSensorList() { sensors_init(NULL); int sensor_i = 0; const sensors_chip_name *sc; while ((sc = sensors_get_detected_chips(NULL, &sensor_i))) { int feature_i = 0; const sensors_feature *sf; while ((sf = sensors_get_features(sc, &feature_i))) { LMSensor *lms = new LMSensor(sc, sf); m_sensors.push_back(lms); } } }
static struct temperature* temperature_init(void) { int chip_nr = 0; struct temperature* temp = 0; if (sensors_init(0)) { fprintf(stderr, u8"Could not initialize libsensors.\n"); return 0; } temp = calloc(1, sizeof(struct temperature)); if (!temp) { fprintf(stderr, u8"Could not allocate memory for temperature struct.\n"); return 0; } while ((temp->chip = sensors_get_detected_chips(0, &chip_nr))) { if (!strcmp(chip_name, temp->chip->prefix)) { int feature_nr = 0; sensors_feature const* feat = 0; while ((feat = sensors_get_features(temp->chip, &feature_nr))) { if (feat->type == SENSORS_FEATURE_TEMP) { sensors_subfeature const* sub = sensors_get_subfeature(temp->chip, feat, SENSORS_SUBFEATURE_TEMP_INPUT); if (!sub) { fprintf(stderr, u8"Could not get chip subfeature.\n"); return 0; } ++temp->count; temp->numbers = realloc(temp->numbers, temp->count * sizeof(int)); temp->numbers[temp->count - 1] = sub->number; } } return temp; } } return 0; }
/* returns number of chips found */ static int do_the_real_work(const sensors_chip_name *match, int *err) { const sensors_chip_name *chip; int chip_nr; int cnt = 0; chip_nr = 0; while ((chip = sensors_get_detected_chips(match, &chip_nr))) { if (do_sets) { if (do_a_set(chip)) *err = 1; } else do_a_print(chip); cnt++; } return cnt; }
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; }
static int l_readAll(lua_State *L) { sensors_init(NULL); const sensors_chip_name *scn; const sensors_feature *sf; const sensors_subfeature *ss; int n, n1, n2, err; double r; char scns[80]; lua_newtable(L); //Push new table on to stack. Index -1 for(n = 0; (scn = sensors_get_detected_chips(NULL, &n)) != NULL; ) { // Iterate over detected chips for(n1 = 0; (sf = sensors_get_features(scn, &n1)) != NULL; ) // Iterate over features of chip for(n2 = 0; (ss = sensors_get_all_subfeatures(scn, sf, &n2)) != NULL; ) { // Iterate over subfeatures of features from chip sprintf(scns, "%s-%x-%x__%s", scn->prefix, scn->bus.nr, scn->addr, ss->name); // Set scns to (chip.prefix - chip.bus.nr - chip.addr __ subfeature.name ) err = sensors_get_value(scn, ss->number, &r); // Get value from chip using subfeature.number, store result in r. If err != 0 then an error occured. if (err == 0) { // Sensor data. Addres in char* scns, name in ss->name, result in r lua_pushnumber(L, r); //Push table value on stack. Table is now at -2 lua_setfield(L, -2, scns); //Set 3rd argument as key in table at stack index -2 to stack index -1 } else { return(luaL_error(L, "Can't read sensors!")); } } } sensors_cleanup(); return(1); }
/* List the buses in a format suitable for sensors.conf. We only list bus types for which bus statements are actually useful and supported. Known bug: i2c buses with number >= 32 or 64 could be listed several times. Very unlikely to ever happen, though. */ static void print_bus_list(void) { const sensors_chip_name *chip; int chip_nr; unsigned long seen_i2c = 0; chip_nr = 0; while ((chip = sensors_get_detected_chips(NULL, &chip_nr))) { switch (chip->bus.type) { case SENSORS_BUS_TYPE_I2C: if (chip->bus.nr < (int)sizeof(unsigned long) * 8) { if (seen_i2c & (1 << chip->bus.nr)) break; seen_i2c |= 1 << chip->bus.nr; } printf("bus \"i2c-%d\" \"%s\"\n", chip->bus.nr, sensors_get_adapter_name(&chip->bus)); break; } } }
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; }
void Hwmon::setup() { // hwmon does not currently work with perf if (gSessionData->perf.isSetup()) { return; } int err = sensors_init(NULL); if (err) { logg->logMessage("Failed to initialize libsensors! (%d)", err); return; } sensors_sysfs_no_scaling = 1; int chip_nr = 0; const sensors_chip_name *chip; while ((chip = sensors_get_detected_chips(NULL, &chip_nr))) { int feature_nr = 0; const sensors_feature *feature; while ((feature = sensors_get_features(chip, &feature_nr))) { counters = new HwmonCounter(counters, chip, feature); } } }
unsigned int get_sensor_num(void) { int a, b, c, num; const sensors_chip_name * chip; const sensors_feature * features; const sensors_subfeature * subfeatures; a = num = 0; sensors_init(NULL); 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) { // chip = chip->addr // sensor = features->number num++; break; } if (subfeatures->type != SENSORS_SUBFEATURE_TEMP_INPUT) { num++; break; } } } } return num; }
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 */
/* ******** 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; }
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; }
int main(int argc, char* argv[]) { unsigned char r, g, b; struct timespec tms; const sensors_chip_name *chip; const sensors_feature *feature; int nr, subfeat_nr; double temp, used_temp, cpu_percent, ram_free_percent; FILE *cpufile; // Open the sensors if(sensors_init(NULL) != 0) { printf("Error initializing the sensors\n"); return 1; } atexit(sensors_cleanup); // Ready to open lights // Open the device using the VID, PID handle = hid_open(0x1770, 0xff00, NULL); if (!handle) { printf("Unable to open MSI Led device.\n"); return 1; } signal(SIGINT, signal_callback_handler); while(1) { nr = 0; used_temp = 0; while((chip = sensors_get_detected_chips(NULL, &nr)) != NULL) { subfeat_nr = 0; while((feature = sensors_get_features(chip, &subfeat_nr)) != NULL) { // Uncomment the next printfs to get your device and subdevice ID //printf("%s [%d,%d] ", sensors_get_label(chip, feature), nr-1, subfeat_nr-1); if(sensors_get_value(chip, subfeat_nr-1, &temp) == 0) { //printf(" = %.2fºC\n", temp); } else { //printf(" = NO DATA\n"); } if(nr-1 == DEVICE_ID && subfeat_nr-1 == SUBDEV_ID) used_temp = temp; } } if(used_temp <= 0) r = 0; // No data. Make it full green (zero red) else r = CLAMP(0, 0xFF*(used_temp - TEMP_LOW)/(TEMP_HIGH - TEMP_LOW), 0xFF); g = 0xFF - r; // Fade from red to green b = 0; commit(handle, MODE_NORMAL); // You have to commit first in GE60 (?) sendActivateArea(handle, AREA_LEFT, r, g, b); // Get CPU info cpu_percent = 0.0; cpufile = fopen("/proc/loadavg", "r"); if(cpufile) { fscanf(cpufile, "%lf", &cpu_percent); fclose(cpufile); } cpu_percent /= NUMBER_CPUS; r = 0; g = 0xFF; b = CLAMP(0, 0xFF * cpu_percent, 0xFF); //printf("CPU: %.2f\n", cpu_percent * 100.0); sendActivateArea(handle, AREA_MIDDLE, r, g, b); // Get RAM info ram_free_percent = get_ram_free(); //printf("RAM: %.2lf\n", ram_used_percent); b = CLAMP(0, 0xFF * ram_free_percent, 0xFF); r = 0xFF - b; g = 0; sendActivateArea(handle, AREA_RIGHT, r, g, b); tms.tv_sec = REFRESH_INTERVAL; tms.tv_nsec = 0; nanosleep(&tms, NULL); } // This should never be executed tho... hid_close(handle); handle = NULL; hid_exit(); return 0; }
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; }