static void got_thresholds(ipmi_sensor_t *sensor, int err, ipmi_thresholds_t *th, void *cb_data) { sdata_t *sdata = cb_data; enum ipmi_thresh_e thresh; int rv; if (err) { printf("Error 0x%x getting events for sensor %s\n", err, sdata->name); goto out_err; } printf("Sensor %s threshold settings:\n", sdata->name); for (thresh=IPMI_LOWER_NON_CRITICAL; thresh<=IPMI_UPPER_NON_RECOVERABLE; thresh++) { int val; double dval; rv = ipmi_sensor_threshold_readable(sensor, thresh, &val); if (rv || !val) /* Threshold not available. */ continue; rv = ipmi_threshold_get(th, thresh, &dval); if (rv) { printf(" threshold %s could not be fetched due to error 0x%x\n", ipmi_get_threshold_string(thresh), rv); } else { printf(" threshold %s is %lf\n", ipmi_get_threshold_string(thresh), dval); } } rv = ipmi_get_default_sensor_thresholds(sensor, sdata->th); if (rv) { printf("Error 0x%x getting def thresholds for sensor %s\n", rv, sdata->name); goto out_err; } rv = ipmi_sensor_set_thresholds(sensor, sdata->th, thresholds_set, sdata); if (rv) { printf("Error 0x%x setting thresholds for sensor %s\n", rv, sdata->name); goto out_err; } return; out_err: release_sdata(sdata); }
static void thres_get(ipmi_sensor_t *sensor, ipmi_thresholds_t *th, unsigned int event, SaHpiSensorReadingT *thres) { int val; ipmi_sensor_threshold_readable(sensor, event, &val); if (val) { thres->ValuesPresent = SAHPI_SRF_INTERPRETED; thres->Interpreted.Type = SAHPI_SENSOR_INTERPRETED_TYPE_FLOAT32; thres->Interpreted.Value.SensorFloat32 = (SaHpiFloat32T) th->vals[event].val; } }
static void thres_get(ipmi_sensor_t *sensor, ipmi_thresholds_t *th, unsigned int event, SaHpiSensorReadingT *thres) { int val; ipmi_sensor_threshold_readable(sensor, event, &val); if (val) { thres->IsSupported = SAHPI_TRUE; thres->Type = SAHPI_SENSOR_READING_TYPE_FLOAT64; thres->Value.SensorFloat64 = th->vals[event].val; }else { thres->IsSupported = SAHPI_FALSE; } }
static void thres_get(ipmi_sensor_t *sensor, ipmi_thresholds_t *th, unsigned int event, SaHpiSensorReadingT *thres) { int val; ipmi_sensor_threshold_readable(sensor, event, &val); if (val) { #if 0 thres->ValuesPresent = SAHPI_SRF_INTERPRETED; thres->Interpreted.Type = SAHPI_SENSOR_INTERPRETED_TYPE_FLOAT32; thres->Interpreted.Value.SensorFloat32 = (SaHpiFloat32T) th->vals[event].val; #else thres->IsSupported = SAHPI_TRUE; thres->Type = SAHPI_SENSOR_READING_TYPE_FLOAT64; thres->Value.SensorFloat64 = th->vals[event].val; #endif } }
static void add_sensor_event_thresholds(ipmi_sensor_t *sensor, SaHpiSensorRecT *rec) { int val; SaHpiSensorThdMaskT temp; unsigned int access; if (rec->Category != SAHPI_EC_THRESHOLD) { rec->ThresholdDefn.IsThreshold = SAHPI_FALSE; return; } access = ipmi_sensor_get_threshold_access(sensor); if (access == IPMI_THRESHOLD_ACCESS_SUPPORT_NONE) { rec->ThresholdDefn.IsThreshold = SAHPI_FALSE; return; } if (access >= IPMI_THRESHOLD_ACCESS_SUPPORT_READABLE) { rec->ThresholdDefn.IsThreshold = SAHPI_TRUE; rec->ThresholdDefn.TholdCapabilities = SAHPI_SRF_RAW | SAHPI_SRF_INTERPRETED; temp = 0; ipmi_sensor_threshold_readable(sensor, IPMI_LOWER_NON_CRITICAL, &val); if (val) temp |= SAHPI_STM_LOW_MINOR; ipmi_sensor_threshold_readable(sensor, IPMI_LOWER_CRITICAL, &val); if (val) temp |= SAHPI_STM_LOW_MAJOR; ipmi_sensor_threshold_readable(sensor, IPMI_LOWER_NON_RECOVERABLE, &val); if (val) temp |= SAHPI_STM_LOW_CRIT; ipmi_sensor_threshold_readable(sensor, IPMI_UPPER_NON_CRITICAL, &val); if (val) temp |= SAHPI_STM_UP_MINOR; ipmi_sensor_threshold_readable(sensor, IPMI_UPPER_CRITICAL, &val); if (val) temp |= SAHPI_STM_UP_MAJOR; ipmi_sensor_threshold_readable(sensor, IPMI_UPPER_NON_RECOVERABLE, &val); if (val) temp |= SAHPI_STM_UP_CRIT; val = ipmi_sensor_get_hysteresis_support(sensor); if (val == IPMI_HYSTERESIS_SUPPORT_READABLE || val == IPMI_HYSTERESIS_SUPPORT_SETTABLE) temp |= SAHPI_STM_UP_HYSTERESIS | SAHPI_STM_LOW_HYSTERESIS; rec->ThresholdDefn.ReadThold = temp; } if (access == IPMI_THRESHOLD_ACCESS_SUPPORT_SETTABLE) { temp = 0; ipmi_sensor_threshold_settable(sensor, IPMI_LOWER_NON_CRITICAL, &val); if (val) temp |= SAHPI_STM_LOW_MINOR; ipmi_sensor_threshold_settable(sensor, IPMI_LOWER_CRITICAL, &val); if (val) temp |= SAHPI_STM_LOW_MAJOR; ipmi_sensor_threshold_settable(sensor, IPMI_LOWER_NON_RECOVERABLE, &val); if (val) temp |= SAHPI_STM_LOW_CRIT; ipmi_sensor_threshold_settable(sensor, IPMI_UPPER_NON_CRITICAL, &val); if (val) temp |= SAHPI_STM_UP_MINOR; ipmi_sensor_threshold_settable(sensor, IPMI_UPPER_CRITICAL, &val); if (val) temp |= SAHPI_STM_UP_MAJOR; ipmi_sensor_threshold_settable(sensor, IPMI_UPPER_NON_RECOVERABLE, &val); if (val) temp |= SAHPI_STM_UP_CRIT; val = ipmi_sensor_get_hysteresis_support(sensor); if (val == IPMI_HYSTERESIS_SUPPORT_SETTABLE) temp |= SAHPI_STM_UP_HYSTERESIS | SAHPI_STM_LOW_HYSTERESIS; rec->ThresholdDefn.WriteThold = temp; } temp = 0; val = ipmi_sensor_get_hysteresis_support(sensor); if (val == IPMI_HYSTERESIS_SUPPORT_FIXED) temp |= SAHPI_STM_UP_HYSTERESIS | SAHPI_STM_LOW_HYSTERESIS; rec->ThresholdDefn.FixedThold = temp; }
static void sensor_dump(ipmi_sensor_t *sensor, ipmi_cmd_info_t *cmd_info) { ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int num, lun; char *str; const char *cstr; int event_support; int event_reading_type; int len; int rv; int val; event_reading_type = ipmi_sensor_get_event_reading_type(sensor); ipmi_sensor_get_num(sensor, &lun, &num); ipmi_cmdlang_out_int(cmd_info, "LUN", lun); ipmi_cmdlang_out_int(cmd_info, "Number", num); ipmi_cmdlang_out_int(cmd_info, "Event Reading Type", ipmi_sensor_get_event_reading_type(sensor)); ipmi_cmdlang_out(cmd_info, "Event Reading Type Name", ipmi_sensor_get_event_reading_type_string(sensor)); ipmi_cmdlang_out_int(cmd_info, "Type", ipmi_sensor_get_sensor_type(sensor)); ipmi_cmdlang_out(cmd_info, "Type Name", ipmi_sensor_get_sensor_type_string(sensor)); val = ipmi_sensor_get_sensor_direction(sensor); if (val != IPMI_SENSOR_DIRECTION_UNSPECIFIED) ipmi_cmdlang_out(cmd_info, "Direction", ipmi_get_sensor_direction_string(val)); event_support = ipmi_sensor_get_event_support(sensor); switch (event_support) { case IPMI_EVENT_SUPPORT_PER_STATE: ipmi_cmdlang_out(cmd_info, "Event Support", "per state"); break; case IPMI_EVENT_SUPPORT_ENTIRE_SENSOR: ipmi_cmdlang_out(cmd_info, "Event Support", "entire sensor"); break; case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE: ipmi_cmdlang_out(cmd_info, "Event Support", "global"); break; default: break; } ipmi_cmdlang_out_bool(cmd_info, "Init Scanning", ipmi_sensor_get_sensor_init_scanning(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Events", ipmi_sensor_get_sensor_init_events(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Thresholds", ipmi_sensor_get_sensor_init_thresholds(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Hysteresis", ipmi_sensor_get_sensor_init_hysteresis(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Type", ipmi_sensor_get_sensor_init_type(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Events", ipmi_sensor_get_sensor_init_pu_events(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Init Power Up Scanning", ipmi_sensor_get_sensor_init_pu_scanning(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Ignore If No Entity", ipmi_sensor_get_ignore_if_no_entity(sensor)); ipmi_cmdlang_out_bool(cmd_info, "Auto Rearm", ipmi_sensor_get_supports_auto_rearm(sensor)); ipmi_cmdlang_out_int(cmd_info, "OEM1", ipmi_sensor_get_oem1(sensor)); len = ipmi_sensor_get_id_length(sensor); if (len) { str = ipmi_mem_alloc(len); if (!str) { cmdlang->err = ENOMEM; cmdlang->errstr = "Out of memory"; goto out_err; } len = ipmi_sensor_get_id(sensor, str, len); ipmi_cmdlang_out_type(cmd_info, "Id", ipmi_sensor_get_id_type(sensor), str, len); ipmi_mem_free(str); } if (event_reading_type == IPMI_EVENT_READING_TYPE_THRESHOLD) { int access = ipmi_sensor_get_threshold_access(sensor); enum ipmi_thresh_e thresh; enum ipmi_event_value_dir_e value_dir; enum ipmi_event_dir_e dir; int rv; char th_name[50]; double dval; ipmi_cmdlang_out(cmd_info, "Threshold Access", ipmi_get_threshold_access_support_string(access)); for (thresh = IPMI_LOWER_NON_CRITICAL; thresh <= IPMI_UPPER_NON_RECOVERABLE; thresh++) { rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &val); if ((rv) || !val) continue; ipmi_cmdlang_out(cmd_info, "Threshold", NULL); ipmi_cmdlang_down(cmd_info); ipmi_cmdlang_out(cmd_info, "Name", ipmi_get_threshold_string(thresh)); rv = ipmi_sensor_threshold_readable(sensor, thresh, &val); if (rv) val = 0; ipmi_cmdlang_out_bool(cmd_info, "Readable", val); rv = ipmi_sensor_threshold_settable(sensor, thresh, &val); if (rv) val = 0; ipmi_cmdlang_out_bool(cmd_info, "Settable", val); for (value_dir = IPMI_GOING_LOW; value_dir <= IPMI_GOING_HIGH; value_dir++) { for (dir = IPMI_ASSERTION; dir <= IPMI_DEASSERTION; dir++) { rv = ipmi_sensor_threshold_event_supported(sensor, thresh, value_dir, dir, &val); if (rv || !val) continue; snprintf(th_name, sizeof(th_name), "%s %s", ipmi_get_value_dir_string(value_dir), ipmi_get_event_dir_string(dir)); ipmi_cmdlang_out(cmd_info, "Supports", th_name); } } ipmi_cmdlang_up(cmd_info); } val = ipmi_sensor_get_hysteresis_support(sensor); ipmi_cmdlang_out(cmd_info, "Hysteresis Support", ipmi_get_hysteresis_support_string(val)); #if 0 /* FIXME - no accuracy handling */ int ipmi_sensor_get_accuracy(ipmi_sensor_t *sensor, int val, double *accuracy); #endif rv = ipmi_sensor_get_nominal_reading(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Nominal Reading", dval); rv = ipmi_sensor_get_normal_max(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Normal Max", dval); rv = ipmi_sensor_get_normal_min(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Normal Min", dval); rv = ipmi_sensor_get_sensor_max(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Sensor Max", dval); rv = ipmi_sensor_get_sensor_min(sensor, &dval); if (!rv) ipmi_cmdlang_out_double(cmd_info, "Sensor Min", dval); ipmi_cmdlang_out_int(cmd_info, "Base Unit", ipmi_sensor_get_base_unit(sensor)); ipmi_cmdlang_out(cmd_info, "Base Unit Name", ipmi_sensor_get_base_unit_string(sensor)); cstr = ipmi_sensor_get_rate_unit_string(sensor); if (strlen(cstr)) { ipmi_cmdlang_out_int(cmd_info, "Rate Unit", ipmi_sensor_get_rate_unit(sensor)); ipmi_cmdlang_out(cmd_info, "Rate Unit Name", cstr); } switch (ipmi_sensor_get_modifier_unit_use(sensor)) { case IPMI_MODIFIER_UNIT_BASE_DIV_MOD: ipmi_cmdlang_out(cmd_info, "Modifier Use", "/"); ipmi_cmdlang_out_int(cmd_info, "Modifier Unit", ipmi_sensor_get_modifier_unit(sensor)); ipmi_cmdlang_out(cmd_info, "Modifier Unit Name", ipmi_sensor_get_modifier_unit_string(sensor)); break; case IPMI_MODIFIER_UNIT_BASE_MULT_MOD: ipmi_cmdlang_out(cmd_info, "Modifier Use", "*"); ipmi_cmdlang_out_int(cmd_info, "Modifier Unit", ipmi_sensor_get_modifier_unit(sensor)); ipmi_cmdlang_out(cmd_info, "Modifier Unit Name", ipmi_sensor_get_modifier_unit_string(sensor)); break; default: break; } if (ipmi_sensor_get_percentage(sensor)) ipmi_cmdlang_out(cmd_info, "Percentage", "%"); } else { int event; enum ipmi_event_dir_e dir; for (event=0; event<15; event++) { rv = ipmi_sensor_discrete_event_readable(sensor, event, &val); if (rv || !val) continue; ipmi_cmdlang_out(cmd_info, "Event", NULL); ipmi_cmdlang_down(cmd_info); ipmi_cmdlang_out_int(cmd_info, "Offset", event); cstr = ipmi_sensor_reading_name_string(sensor, event); if (strcmp(cstr, "unknown") != 0) ipmi_cmdlang_out(cmd_info, "Name", cstr); for (dir = IPMI_ASSERTION; dir <= IPMI_DEASSERTION; dir++) { rv = ipmi_sensor_discrete_event_supported(sensor, event, dir, &val); if (rv || !val) continue; ipmi_cmdlang_out(cmd_info, "Supports", ipmi_get_event_dir_string(dir)); } ipmi_cmdlang_up(cmd_info); } } return; out_err: ipmi_sensor_get_name(sensor, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_sensor.c(sensor_dump)"; }