static void get_sensor_reading(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_reading *reading_data; int rv; reading_data = cb_data; if (ignore_sensor(sensor)) { reading_data->done = 1; reading_data->rvalue = SA_ERR_HPI_NOT_PRESENT; dbg("Sensor is not present, ignored"); return; } if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { rv = ipmi_reading_get(sensor, sensor_reading, reading_data); if (rv) { reading_data->done = 1; reading_data->rvalue = SA_ERR_HPI_INVALID_REQUEST; dbg("Unable to get sensor reading: %s\n", strerror( rv ) ); return; } } else { rv = ipmi_states_get(sensor, sensor_read_states, reading_data); if (rv) { reading_data->done = 1; reading_data->rvalue = SA_ERR_HPI_INVALID_REQUEST; dbg("Unable to get sensor reading states: %s\n", strerror( rv ) ); } } }
static void get_sensor_data(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_reading *reading_data; int rv; reading_data = cb_data; if (ignore_sensor(sensor)) { dbg("Sensor is not present, ignored"); return; } if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { rv = ipmi_reading_get(sensor, sensor_read, reading_data); if (rv) { dbg("Unable to get sensor reading: %s\n", strerror( rv ) ); return; } } else { #if 0 rv = ipmi_states_get(sensor, sensor_read_states, reading_data); if (rv) { dbg("Unable to get sensor reading states: %s\n", strerror( rv ) ); return; } #endif } }
static void sensor_change(enum ipmi_update_e op, ipmi_entity_t *ent, ipmi_sensor_t *sensor, void *cb_data) { const char *__function_name = "sensor_change"; zbx_ipmi_host_t *h = cb_data; zabbix_log(LOG_LEVEL_DEBUG, "In %s() phost:%p host:'[%s]:%d'", __function_name, h, h->ip, h->port); switch (ipmi_sensor_get_event_reading_type(sensor)) { case IPMI_EVENT_READING_TYPE_THRESHOLD: case IPMI_EVENT_READING_TYPE_DISCRETE_USAGE: case IPMI_EVENT_READING_TYPE_DISCRETE_STATE: case IPMI_EVENT_READING_TYPE_DISCRETE_PREDICTIVE_FAILURE: case IPMI_EVENT_READING_TYPE_DISCRETE_LIMIT_EXCEEDED: case IPMI_EVENT_READING_TYPE_DISCRETE_PERFORMANCE_MET: case IPMI_EVENT_READING_TYPE_DISCRETE_SEVERITY: case IPMI_EVENT_READING_TYPE_DISCRETE_DEVICE_PRESENCE: case IPMI_EVENT_READING_TYPE_DISCRETE_DEVICE_ENABLE: case IPMI_EVENT_READING_TYPE_DISCRETE_AVAILABILITY: case IPMI_EVENT_READING_TYPE_DISCRETE_REDUNDANCY: case IPMI_EVENT_READING_TYPE_DISCRETE_ACPI_POWER: if (op == IPMI_ADDED) { if (NULL == get_ipmi_sensor(h, sensor)) allocate_ipmi_sensor(h, sensor); } else if (op == IPMI_DELETED) delete_ipmi_sensor(h, sensor); break; case IPMI_EVENT_READING_TYPE_SENSOR_SPECIFIC: ; /* nothing */ } zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name); }
static void set_sensor_thresholds(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_thresholds *thres_data; SaErrorT rv; thres_data = cb_data; if (ignore_sensor(sensor)) { dbg("sensor is ignored"); thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = SA_ERR_HPI_NOT_PRESENT; return; } if (ipmi_sensor_get_event_reading_type(sensor) != IPMI_EVENT_READING_TYPE_THRESHOLD) { dbg("Not threshold sensor!"); thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = SA_ERR_HPI_INVALID_CMD; return; } if ((ipmi_sensor_get_threshold_access(sensor) != IPMI_THRESHOLD_ACCESS_SUPPORT_SETTABLE) || (ipmi_sensor_get_hysteresis_support(sensor) != IPMI_HYSTERESIS_SUPPORT_SETTABLE)) { dbg("sensor doesn't support threshold or histeresis set"); thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = SA_ERR_HPI_INVALID_CMD; return; } rv = set_thresholds(sensor, thres_data); if (rv != SA_OK) { dbg("Unable to set thresholds"); thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = rv; return; } rv = set_hysteresis(sensor, thres_data); if (rv != SA_OK) { thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = rv; dbg("Unable to set hysteresis"); return; } return; }
static void get_sensor_thresholds(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_thresholds *thres_data; int rv; thres_data = cb_data; if (ignore_sensor(sensor)) { dbg("ENTITY_NOT_PRESENT"); return; } if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { if (ipmi_sensor_get_threshold_access(sensor) == IPMI_EVENT_SUPPORT_NONE) dbg("sensor doesn't support threshold read"); else { rv = get_thresholds(sensor, thres_data); if (rv < 0) { dbg("Unable to get sensor thresholds"); return; } } rv = ipmi_sensor_get_hysteresis_support(sensor); if (rv == IPMI_HYSTERESIS_SUPPORT_NONE) { #if 0 /* I'm zeroing them so we return but invalid data FIXME? */ thres_data->sensor_thres->PosThdHysteresis.ValuesPresent = 0; thres_data->sensor_thres->NegThdHysteresis.ValuesPresent = 0; #else thres_data->sensor_thres->PosThdHysteresis.IsSupported = SAHPI_FALSE; thres_data->sensor_thres->NegThdHysteresis.IsSupported = SAHPI_FALSE; #endif thres_data->hyster_done = 1; /* read no more */ return; } else { if (rv == IPMI_HYSTERESIS_SUPPORT_READABLE || rv == IPMI_HYSTERESIS_SUPPORT_SETTABLE) { rv = get_hysteresis(sensor, thres_data); if (rv < 0) dbg("failed to get hysteresis"); } } } else { dbg("Not threshold sensor!"); } return; }
static void get_sensor_thresholds(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_thresholds *thres_data; int rv; thres_data = cb_data; if (ignore_sensor(sensor)) { thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = SA_ERR_HPI_NOT_PRESENT; dbg("ENTITY_NOT_PRESENT"); return; } if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { if (ipmi_sensor_get_threshold_access(sensor) == IPMI_THRESHOLD_ACCESS_SUPPORT_NONE) dbg("sensor doesn't support threshold read"); else { rv = get_thresholds(sensor, thres_data); if (rv < 0) { dbg("Unable to get sensor thresholds"); return; } } rv = ipmi_sensor_get_hysteresis_support(sensor); if (rv == IPMI_HYSTERESIS_SUPPORT_NONE) { thres_data->sensor_thres.PosThdHysteresis.IsSupported = SAHPI_FALSE; thres_data->sensor_thres.NegThdHysteresis.IsSupported = SAHPI_FALSE; thres_data->hyster_done = 1; /* read no more */ return; } else { if (rv == IPMI_HYSTERESIS_SUPPORT_READABLE || rv == IPMI_HYSTERESIS_SUPPORT_SETTABLE) { rv = get_hysteresis(sensor, thres_data); if (rv < 0) dbg("failed to get hysteresis"); } } } else { dbg("Not threshold sensor!"); } return; }
static SaHpiEventCategoryT ohoi_sensor_get_event_reading_type(ipmi_sensor_t *sensor) { SaHpiEventCategoryT hpi_category; unsigned int ipmi_category; ipmi_category = ipmi_sensor_get_event_reading_type(sensor); switch (ipmi_category) { case IPMI_EVENT_READING_TYPE_DISCRETE_ACPI_POWER: case IPMI_EVENT_READING_TYPE_SENSOR_SPECIFIC: hpi_category = SAHPI_EC_GENERIC; break; default: hpi_category = ipmi_category; break; } return hpi_category; }
void ohoi_sensor_event(enum ipmi_update_e op, ipmi_entity_t *ent, ipmi_sensor_t *sensor, void *cb_data) { char name[33]; int rv; struct oh_handler_state *handler = cb_data; ipmi_entity_id_t entity_id; SaHpiRptEntryT *rpt_entry; ipmi_sensor_get_id(sensor, name, 32); entity_id = ipmi_entity_convert_to_id(ent); rpt_entry = ohoi_get_resource_by_entityid( handler->rptcache, &entity_id); if (!rpt_entry) { dump_entity_id("Sensor without RPT Entry?!", entity_id); return; } if ( op == IPMI_ADDED ) { rpt_entry->ResourceCapabilities |= SAHPI_CAPABILITY_RDR | SAHPI_CAPABILITY_SENSOR; /* fill in the sensor data, add it to ipmi_event_list * and finally to the rpt-cache */ add_sensor_event(ent, sensor, handler, rpt_entry->ResourceEntity, rpt_entry->ResourceId); if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) rv = ipmi_sensor_threshold_set_event_handler( sensor, sensor_threshold_event, handler); else rv = ipmi_sensor_discrete_set_event_handler( sensor, sensor_discrete_event, handler); if (rv) dbg("Unable to reg sensor event handler: %#x\n", rv); } }
static zbx_ipmi_sensor_t *allocate_ipmi_sensor(zbx_ipmi_host_t *h, ipmi_sensor_t *sensor) { const char *__function_name = "allocate_ipmi_sensor"; char id_str[2 * IPMI_SENSOR_ID_SZ + 1]; zbx_ipmi_sensor_t *s; char id[IPMI_SENSOR_ID_SZ]; enum ipmi_str_type_e id_type; int id_sz, sz; char full_name[MAX_STRING_LEN]; id_sz = ipmi_sensor_get_id_length(sensor); memset(id, 0, sizeof(id)); ipmi_sensor_get_id(sensor, id, sizeof(id)); id_type = ipmi_sensor_get_id_type(sensor); zabbix_log(LOG_LEVEL_DEBUG, "In %s() sensor:'%s@[%s]:%d'", __function_name, sensor_id_to_str(id_str, sizeof(id_str), id, id_type, id_sz), h->ip, h->port); h->sensor_count++; sz = h->sensor_count * sizeof(zbx_ipmi_sensor_t); if (NULL == h->sensors) h->sensors = zbx_malloc(h->sensors, sz); else h->sensors = zbx_realloc(h->sensors, sz); s = &h->sensors[h->sensor_count - 1]; s->sensor = sensor; memcpy(s->id, id, sizeof(id)); s->id_type = id_type; s->id_sz = id_sz; memset(&s->value, 0, sizeof(s->value)); s->reading_type = ipmi_sensor_get_event_reading_type(sensor); s->type = ipmi_sensor_get_sensor_type(sensor); ipmi_sensor_get_name(s->sensor, full_name, sizeof(full_name)); zabbix_log(LOG_LEVEL_DEBUG, "Added sensor: host:'%s:%d' id_type:%d id_sz:%d id:'%s'" " reading_type:0x%x ('%s') type:0x%x ('%s') full_name:'%s'", h->ip, h->port, s->id_type, s->id_sz, sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz), s->reading_type, ipmi_sensor_get_event_reading_type_string(s->sensor), s->type, ipmi_sensor_get_sensor_type_string(s->sensor), full_name); zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%p", __function_name, s); return s; }
/* h->err = zbx_dsprintf(h->err, "Fatal error"); h->ret = NOTSUPPORTED; h->done = 1; return; } if (err) { h->err = zbx_dsprintf(h->err, "Error 0x%x while read discrete sensor %s@[%s]:%d", s->s_name, h->ip, h->port); h->ret = NOTSUPPORTED; h->done = 1; return; } ent = ipmi_sensor_get_entity(sensor); id = ipmi_entity_get_entity_id(ent); e_string = ipmi_get_entity_id_string(id); s_type_string = ipmi_sensor_get_sensor_type_string(sensor); s_reading_type_string = ipmi_sensor_get_event_reading_type_string(sensor); for (i = 0; i < 15; i++) { ret = ipmi_sensor_discrete_event_readable(sensor, i, &val); if (ret || !val) continue; zabbix_log(LOG_LEVEL_DEBUG, "State [%s | %s | %s | %s | state %d value is %d]", s->s_name, e_string, s_type_string, s_reading_type_string, i, ipmi_is_state_set(states, i)); s->value = ?; } } */ static void read_ipmi_sensor(zbx_ipmi_host_t *h, zbx_ipmi_sensor_t *s) { int type, ret; struct timeval tv; zabbix_log(LOG_LEVEL_DEBUG, "In read_ipmi_sensor() %s@[%s]:%d", s->s_name, h->ip, h->port); h->ret = SUCCEED; h->done = 0; type = ipmi_sensor_get_event_reading_type(s->sensor); switch (type) { case IPMI_EVENT_READING_TYPE_THRESHOLD: if (0 != (ret = ipmi_sensor_get_reading(s->sensor, got_thresh_reading, h))) { h->err = zbx_dsprintf(h->err, "Cannot read sensor %s." " ipmi_sensor_get_reading() return error: 0x%x", s->s_name, ret); h->ret = NOTSUPPORTED; return; } break; default: h->err = zbx_dsprintf(h->err, "Discrete sensor is not supported."); h->ret = NOTSUPPORTED; return; /* if (0 != (ret = ipmi_sensor_get_states(s->sensor, got_discrete_states, h))) { h->err = zbx_dsprintf(h->err, "Cannot read sensor %s." " ipmi_sensor_get_states() return error: 0x%x", s->s_name, ret); h->ret = NOTSUPPORTED; return; }*/ } tv.tv_sec = 10; tv.tv_usec = 0; while (0 == h->done) os_hnd->perform_one_op(os_hnd, &tv); }
static void read_ipmi_sensor(zbx_ipmi_host_t *h, zbx_ipmi_sensor_t *s) { const char *__function_name = "read_ipmi_sensor"; int type, ret; struct timeval tv; zabbix_log(LOG_LEVEL_DEBUG, "In %s() sensor:'%s@[%s]:%d'", __function_name, s->s_name, h->ip, h->port); h->ret = SUCCEED; h->done = 0; type = ipmi_sensor_get_event_reading_type(s->sensor); switch (type) { case IPMI_EVENT_READING_TYPE_THRESHOLD: if (0 != (ret = ipmi_sensor_get_reading(s->sensor, got_thresh_reading, h))) { h->err = zbx_dsprintf(h->err, "Cannot read sensor %s." " ipmi_sensor_get_reading() return error: 0x%x", s->s_name, ret); h->ret = NOTSUPPORTED; goto out; } break; default: h->err = zbx_strdup(h->err, "discrete sensor is not supported"); h->ret = NOTSUPPORTED; goto out; } tv.tv_sec = 10; tv.tv_usec = 0; while (0 == h->done) os_hnd->perform_one_op(os_hnd, &tv); out: zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(h->ret)); }
static void sensor_get(ipmi_sensor_t *sensor, void *cb_data) { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int rv; ipmi_cmdlang_cmd_info_get(cmd_info); if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { rv = ipmi_sensor_get_reading(sensor, read_sensor, cmd_info); } else { rv = ipmi_sensor_get_states(sensor, read_sensor_states, cmd_info); } if (rv) { ipmi_cmdlang_cmd_info_put(cmd_info); cmdlang->err = rv; cmdlang->errstr = "Error reading sensor"; ipmi_sensor_get_name(sensor, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_sensor.c(sensor_get)"; } }
static void set_sensor_thresholds(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_thresholds *thres_data; int rv; thres_data = cb_data; if (ignore_sensor(sensor)) { dbg("sensor is ignored"); return; } if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { if (ipmi_sensor_get_threshold_access(sensor) == IPMI_THRESHOLD_ACCESS_SUPPORT_SETTABLE) { rv = set_thresholds(sensor, thres_data); if (rv < 0) { dbg("Unable to set thresholds"); return; } } else dbg("sensor doesn't support threshold set"); rv = ipmi_sensor_get_hysteresis_support(sensor); if (rv == IPMI_HYSTERESIS_SUPPORT_SETTABLE) { rv = set_hysteresis(sensor, thres_data); if (rv < 0) { dbg("Unable to set hysteresis"); return; } } else dbg("sensor doesn't support hysteresis set"); } else dbg("Not threshold sensor!"); }
static void sensor_get_event_enables_done(ipmi_sensor_t *sensor, int err, ipmi_event_state_t *states, void *cb_data) { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); char sensor_name[IPMI_SENSOR_NAME_LEN]; int rv; int val; ipmi_cmdlang_lock(cmd_info); if (err) { cmdlang->errstr = "Error reading sensor event enables"; cmdlang->err = err; ipmi_sensor_get_name(sensor, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_sensor.c(sensor_get_event_enables_done)"; goto out; } ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name)); ipmi_cmdlang_out(cmd_info, "Sensor", NULL); ipmi_cmdlang_down(cmd_info); ipmi_cmdlang_out(cmd_info, "Name", sensor_name); ipmi_cmdlang_out_bool(cmd_info, "Event Messages Enabled", ipmi_event_state_get_events_enabled(states)); ipmi_cmdlang_out_bool(cmd_info, "Sensor Scanning Enabled", ipmi_event_state_get_scanning_enabled(states)); ipmi_cmdlang_out_bool(cmd_info, "Busy", ipmi_event_state_get_busy(states)); if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { enum ipmi_thresh_e thresh; enum ipmi_event_value_dir_e value_dir; enum ipmi_event_dir_e dir; for (thresh = IPMI_LOWER_NON_CRITICAL; thresh <= IPMI_UPPER_NON_RECOVERABLE; thresh++) { for (value_dir = IPMI_GOING_LOW; value_dir <= IPMI_GOING_HIGH; value_dir++) { for (dir = IPMI_ASSERTION; dir <= IPMI_DEASSERTION; dir++) { char th_name[50]; rv = ipmi_sensor_threshold_event_supported(sensor, thresh, value_dir, dir, &val); if (rv || !val) continue; ipmi_cmdlang_out(cmd_info, "Threshold", NULL); ipmi_cmdlang_down(cmd_info); snprintf(th_name, sizeof(th_name), "%s %s %s", ipmi_get_threshold_string(thresh), ipmi_get_value_dir_string(value_dir), ipmi_get_event_dir_string(dir)); ipmi_cmdlang_out(cmd_info, "Name", th_name); ipmi_cmdlang_out_bool(cmd_info, "Enabled", ipmi_is_threshold_event_set (states, thresh, value_dir, dir)); ipmi_cmdlang_up(cmd_info); } } } } else { int offset; const char *str; for (offset=0; offset<15; offset++) { rv = ipmi_sensor_discrete_event_readable(sensor, offset, &val); if (rv || !val) continue; ipmi_cmdlang_out(cmd_info, "Event", NULL); ipmi_cmdlang_down(cmd_info); ipmi_cmdlang_out_int(cmd_info, "Offset", offset); str = ipmi_sensor_reading_name_string(sensor, offset); if (strcmp(str, "unknown") != 0) ipmi_cmdlang_out(cmd_info, "Name", str); rv = ipmi_sensor_discrete_event_supported(sensor, offset, IPMI_ASSERTION, &val); if (!rv && val) { ipmi_cmdlang_out_bool(cmd_info, "Assertion Enabled", ipmi_is_discrete_event_set (states, offset, IPMI_ASSERTION)); } rv = ipmi_sensor_discrete_event_supported(sensor, offset, IPMI_DEASSERTION, &val); if (!rv && val) { ipmi_cmdlang_out_bool(cmd_info, "Deassertion Enabled", ipmi_is_discrete_event_set (states, offset, IPMI_DEASSERTION)); } ipmi_cmdlang_up(cmd_info); } } ipmi_cmdlang_up(cmd_info); out: ipmi_cmdlang_unlock(cmd_info); ipmi_cmdlang_cmd_info_put(cmd_info); }
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)"; }
static void sensor_rearm(ipmi_sensor_t *sensor, void *cb_data) { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int rv; int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info); int argc = ipmi_cmdlang_get_argc(cmd_info); char **argv = ipmi_cmdlang_get_argv(cmd_info); int global; ipmi_event_state_t *s = NULL; if ((argc - curr_arg) < 1) { cmdlang->errstr = "Not enough parameters"; cmdlang->err = EINVAL; goto out_err; } if (strcmp(argv[curr_arg], "global") == 0) { global = 1; } else { global = 0; s = ipmi_mem_alloc(ipmi_event_state_size()); if (!s) { cmdlang->errstr = "Out of memory"; cmdlang->err = ENOMEM; goto out_err; } ipmi_event_state_init(s); if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { enum ipmi_thresh_e thresh; enum ipmi_event_value_dir_e value_dir; enum ipmi_event_dir_e dir; while (curr_arg < argc) { ipmi_cmdlang_get_threshold_ev(argv[curr_arg], &thresh, &value_dir, &dir, cmd_info); if (cmdlang->err) { goto out_err; } ipmi_threshold_event_set(s, thresh, value_dir, dir); curr_arg++; } } else { int offset; enum ipmi_event_dir_e dir; while (curr_arg < argc) { ipmi_cmdlang_get_discrete_ev(argv[curr_arg], &offset, &dir, cmd_info); if (cmdlang->err) { goto out_err; } ipmi_discrete_event_set(s, offset, dir); curr_arg++; } } } ipmi_cmdlang_cmd_info_get(cmd_info); rv = ipmi_sensor_rearm(sensor, global, s, sensor_rearm_done, cmd_info); if (rv) { ipmi_cmdlang_cmd_info_put(cmd_info); cmdlang->err = rv; cmdlang->errstr = "Error rearming sensor"; goto out_err; } if (s) ipmi_mem_free(s); return; out_err: ipmi_sensor_get_name(sensor, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_sensor.c(sensor_rearm)"; if (s) ipmi_mem_free(s); }
/* Whenever the status of a sensor changes, the function is called We display the information of the sensor if we find a new sensor */ static void sensor_change(enum ipmi_update_e op, ipmi_entity_t *ent, ipmi_sensor_t *sensor, void *cb_data) { sdata_t *sdata; int rv; if (op == IPMI_ADDED) { sdata = alloc_sdata(sensor); if (!sdata) { printf("Unable to allocate sensor name memory\n"); return; } printf("Sensor added: %s\n", sdata->name); /* Get the current reading. */ if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { use_sdata(sdata); rv = ipmi_sensor_get_reading(sensor, got_thresh_reading, sdata); if (rv) { printf("ipmi_reading_get returned error 0x%x for sensor %s\n", rv, sdata->name); release_sdata(sdata); } } else { use_sdata(sdata); rv = ipmi_sensor_get_states(sensor, got_discrete_states, sdata); if (rv) { printf("ipmi_states_get returned error 0x%x for sensor %s\n", rv, sdata->name); release_sdata(sdata); } } /* Set up events. */ sdata->state_sup = ipmi_sensor_get_event_support(sensor); switch (sdata->state_sup) { case IPMI_EVENT_SUPPORT_NONE: case IPMI_EVENT_SUPPORT_GLOBAL_ENABLE: /* No events to set up. */ printf("Sensor %s has no event support\n", sdata->name); goto get_thresh; } use_sdata(sdata); rv = ipmi_sensor_get_event_enables(sensor, got_events, sdata); if (rv) { printf("ipmi_sensor_events_enable_get returned error 0x%x" " for sensor %s\n", rv, sdata->name); release_sdata(sdata); } get_thresh: /* Handle the threshold settings. */ if (ipmi_sensor_get_event_reading_type(sensor) != IPMI_EVENT_READING_TYPE_THRESHOLD) /* Thresholds only for threshold sensors (duh) */ goto out; sdata->thresh_sup = ipmi_sensor_get_threshold_access(sensor); switch (sdata->thresh_sup) { case IPMI_THRESHOLD_ACCESS_SUPPORT_NONE: printf("Sensor %s has no threshold support\n", sdata->name); goto out; case IPMI_THRESHOLD_ACCESS_SUPPORT_FIXED: printf("Sensor %s has fixed threshold support\n", sdata->name); goto out; } use_sdata(sdata); rv = ipmi_sensor_get_thresholds(sensor, got_thresholds, sdata); if (rv) { printf("ipmi_thresholds_get returned error 0x%x" " for sensor %s\n", rv, sdata->name); release_sdata(sdata); } } else if (op == IPMI_DELETED) { sdata = find_sdata(sensor); if (!sdata) { char name[120]; ipmi_sensor_get_name(sensor, name, sizeof(name)); printf("sensor %s was deleted but not found in the sensor db\n", name); goto out; } printf("sensor %s was deleted\n", sdata->name); release_sdata(sdata); } out: return; }
static void convert_to_ohoi_event_states(ipmi_sensor_t *sensor, ipmi_event_state_t *state, SaHpiEventStateT *assert, SaHpiEventStateT *deassert) { int i; *assert = 0; *deassert = 0; if(ipmi_sensor_get_event_reading_type(sensor) != IPMI_EVENT_READING_TYPE_THRESHOLD) { for (i = 0; i < 15; i++) { if (ipmi_is_discrete_event_set(state, i, IPMI_ASSERTION)) { *assert |= (1 << i); } if (ipmi_is_discrete_event_set(state, i, IPMI_DEASSERTION)) { *deassert |= (1 << i); } } return; } // threshold sensor if (ipmi_is_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL, IPMI_GOING_LOW, IPMI_ASSERTION)) { *assert |= SAHPI_ES_LOWER_MINOR; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL, IPMI_GOING_HIGH, IPMI_ASSERTION)) { *deassert |= SAHPI_ES_LOWER_MINOR; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL, IPMI_GOING_LOW, IPMI_DEASSERTION)) { *deassert |= SAHPI_ES_LOWER_MINOR; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL, IPMI_GOING_HIGH, IPMI_DEASSERTION)) { *assert |= SAHPI_ES_LOWER_MINOR; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_CRITICAL, IPMI_GOING_LOW, IPMI_ASSERTION)) { *assert |= SAHPI_ES_LOWER_MAJOR; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_CRITICAL, IPMI_GOING_HIGH, IPMI_ASSERTION)) { *deassert |= SAHPI_ES_LOWER_MAJOR; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_CRITICAL, IPMI_GOING_LOW, IPMI_DEASSERTION)) { *deassert |= SAHPI_ES_LOWER_MAJOR; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_CRITICAL, IPMI_GOING_HIGH, IPMI_DEASSERTION)) { *assert |= SAHPI_ES_LOWER_MAJOR; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_LOW, IPMI_ASSERTION)) { *assert |= SAHPI_ES_LOWER_CRIT; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_HIGH, IPMI_ASSERTION)) { *deassert |= SAHPI_ES_LOWER_CRIT; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_LOW, IPMI_DEASSERTION)) { *deassert |= SAHPI_ES_LOWER_CRIT; } if (ipmi_is_threshold_event_set(state, IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_HIGH, IPMI_DEASSERTION)) { *assert |= SAHPI_ES_LOWER_CRIT; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_NON_CRITICAL, IPMI_GOING_LOW, IPMI_ASSERTION)) { *deassert |= SAHPI_ES_UPPER_MINOR; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_NON_CRITICAL, IPMI_GOING_HIGH, IPMI_ASSERTION)) { *assert |= SAHPI_ES_UPPER_MINOR; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_NON_CRITICAL, IPMI_GOING_LOW, IPMI_DEASSERTION)) { *assert |= SAHPI_ES_UPPER_MINOR; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_NON_CRITICAL, IPMI_GOING_HIGH, IPMI_DEASSERTION)) { *deassert |= SAHPI_ES_UPPER_MINOR; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_CRITICAL, IPMI_GOING_LOW, IPMI_ASSERTION)) { *deassert |= SAHPI_ES_UPPER_MAJOR; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_CRITICAL, IPMI_GOING_HIGH, IPMI_ASSERTION)) { *assert |= SAHPI_ES_UPPER_MAJOR; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_CRITICAL, IPMI_GOING_LOW, IPMI_DEASSERTION)) { *assert |= SAHPI_ES_UPPER_MAJOR; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_CRITICAL, IPMI_GOING_HIGH, IPMI_DEASSERTION)) { *deassert |= SAHPI_ES_UPPER_MAJOR; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_LOW, IPMI_ASSERTION)) { *deassert |= SAHPI_ES_UPPER_CRIT; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_HIGH, IPMI_ASSERTION)) { *assert |= SAHPI_ES_UPPER_CRIT; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_LOW, IPMI_DEASSERTION)) { *assert |= SAHPI_ES_UPPER_CRIT; } if (ipmi_is_threshold_event_set(state, IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_HIGH, IPMI_DEASSERTION)) { *deassert |= SAHPI_ES_UPPER_CRIT; } }
static void get_sensor_thresholds(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_thresholds *thres_data; int rv; thres_data = cb_data; if (ignore_sensor(sensor)) { thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = SA_ERR_HPI_NOT_PRESENT; err("ENTITY_NOT_PRESENT"); return; } if (ipmi_sensor_get_event_reading_type(sensor) != IPMI_EVENT_READING_TYPE_THRESHOLD) { err("Not threshold sensor!"); thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = SA_ERR_HPI_INVALID_CMD; return; } if (ipmi_sensor_get_threshold_access(sensor) == IPMI_THRESHOLD_ACCESS_SUPPORT_NONE) { err("sensor doesn't support threshold read"); err("Unable to get sensor thresholds"); thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = SA_ERR_HPI_INVALID_CMD; return; } rv = get_thresholds(sensor, thres_data); if (rv != SA_OK) { err("Unable to get sensor thresholds"); thres_data->hyster_done = 1; thres_data->thres_done = 1; thres_data->rvalue = rv; return; } rv = ipmi_sensor_get_hysteresis_support(sensor); if (rv != IPMI_HYSTERESIS_SUPPORT_READABLE && rv != IPMI_HYSTERESIS_SUPPORT_SETTABLE) { // thres_data->thres_done = 1; thres_data->hyster_done = 1; thres_data->sensor_thres.PosThdHysteresis.IsSupported = SAHPI_FALSE; thres_data->sensor_thres.NegThdHysteresis.IsSupported = SAHPI_FALSE; return; } rv = get_hysteresis(sensor, thres_data); if (rv != SA_OK) { err("failed to get hysteresis"); thres_data->hyster_done = 1; // thres_data->thres_done = 1; thres_data->rvalue = SA_ERR_HPI_INTERNAL_ERROR; return; } return; }
static int insert_events_to_ipmi_event_state( ipmi_sensor_t *sensor, ipmi_event_state_t *state, SaHpiEventStateT a_mask, SaHpiEventStateT d_mask, unsigned int a_sup, unsigned int d_sup) { int i; if (ipmi_sensor_get_event_support(sensor) != IPMI_EVENT_SUPPORT_PER_STATE) { return 0; } if (ipmi_sensor_get_event_reading_type(sensor) != IPMI_EVENT_READING_TYPE_THRESHOLD) { // discrete sensor. map states 1:1 if ((a_mask &~a_sup) || (d_mask & ~d_sup)) { return 1; } for (i = 0; i < 15; i++) { if (a_mask & (1 << i)) { ipmi_discrete_event_set(state, i, IPMI_ASSERTION); } if (d_mask & (1 << i)) { ipmi_discrete_event_set(state, i, IPMI_DEASSERTION); } } return 0; } // threhold sensor; // set assertion mask if (a_mask & SAHPI_ES_LOWER_MINOR) { if (a_sup & OHOI_THS_LMINL) { ipmi_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL, IPMI_GOING_LOW, IPMI_ASSERTION); } else if (d_sup & OHOI_THS_LMINH) { ipmi_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL, IPMI_GOING_HIGH, IPMI_DEASSERTION); } else { return 1; } } if (a_mask & SAHPI_ES_LOWER_MAJOR) { if (a_sup & OHOI_THS_LMAJL) { ipmi_threshold_event_set(state, IPMI_LOWER_CRITICAL, IPMI_GOING_LOW, IPMI_ASSERTION); } else if (d_sup & OHOI_THS_LMAJH) { ipmi_threshold_event_set(state, IPMI_LOWER_CRITICAL, IPMI_GOING_HIGH, IPMI_DEASSERTION); } else { return 1; } } if (a_mask & SAHPI_ES_LOWER_CRIT) { if (a_sup & OHOI_THS_LCRTL) { ipmi_threshold_event_set(state, IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_LOW, IPMI_ASSERTION); } else if (d_sup & OHOI_THS_LCRTH) { ipmi_threshold_event_set(state, IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_HIGH, IPMI_DEASSERTION); } else { return 1; } } if (a_mask & SAHPI_ES_UPPER_MINOR) { if (a_sup & OHOI_THS_UMINH) { ipmi_threshold_event_set(state, IPMI_UPPER_NON_CRITICAL, IPMI_GOING_HIGH, IPMI_ASSERTION); } else if (d_sup & OHOI_THS_UMINL) { ipmi_threshold_event_set(state, IPMI_UPPER_NON_CRITICAL, IPMI_GOING_LOW, IPMI_DEASSERTION); } else { return 1; } } if (a_mask & SAHPI_ES_UPPER_MAJOR) { if (a_sup & OHOI_THS_UMAJH) { ipmi_threshold_event_set(state, IPMI_UPPER_CRITICAL, IPMI_GOING_HIGH, IPMI_ASSERTION); } else if (d_sup & OHOI_THS_UMAJL) { ipmi_threshold_event_set(state, IPMI_UPPER_CRITICAL, IPMI_GOING_LOW, IPMI_DEASSERTION); } else { return 1; } } if (a_mask & SAHPI_ES_UPPER_CRIT) { if (a_sup & OHOI_THS_UCRTH) { ipmi_threshold_event_set(state, IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_HIGH, IPMI_ASSERTION); } else if (d_sup & OHOI_THS_UCRTL) { ipmi_threshold_event_set(state, IPMI_GOING_LOW, IPMI_UPPER_NON_RECOVERABLE, IPMI_DEASSERTION); } else { return 1; } } // set deassertion mask if (d_mask & SAHPI_ES_LOWER_MINOR) { if (d_sup & OHOI_THS_LMINL) { ipmi_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL, IPMI_GOING_LOW, IPMI_DEASSERTION); } else if (a_sup & OHOI_THS_LMINH) { ipmi_threshold_event_set(state, IPMI_LOWER_NON_CRITICAL, IPMI_GOING_HIGH, IPMI_ASSERTION); } else { return 1; } } if (d_mask & SAHPI_ES_LOWER_MAJOR) { if (d_sup & OHOI_THS_LMAJL) { ipmi_threshold_event_set(state, IPMI_LOWER_CRITICAL, IPMI_GOING_LOW, IPMI_DEASSERTION); } else if (a_sup & OHOI_THS_LMAJH) { ipmi_threshold_event_set(state, IPMI_GOING_HIGH, IPMI_LOWER_CRITICAL, IPMI_ASSERTION); } else { return 1; } } if (d_mask & SAHPI_ES_LOWER_CRIT) { if (d_sup & OHOI_THS_LCRTL) { ipmi_threshold_event_set(state, IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_LOW, IPMI_DEASSERTION); } else if (a_sup & OHOI_THS_LCRTH) { ipmi_threshold_event_set(state, IPMI_LOWER_NON_RECOVERABLE, IPMI_GOING_HIGH, IPMI_ASSERTION); } else { return 1; } } if (d_mask & SAHPI_ES_UPPER_MINOR) { if (d_sup & OHOI_THS_UMINH) { ipmi_threshold_event_set(state, IPMI_UPPER_NON_CRITICAL, IPMI_GOING_HIGH, IPMI_DEASSERTION); } else if (a_sup & OHOI_THS_UMINL) { ipmi_threshold_event_set(state, IPMI_UPPER_NON_CRITICAL, IPMI_GOING_LOW, IPMI_ASSERTION); } else { return 1; } } if (d_mask & SAHPI_ES_UPPER_MAJOR) { if (d_sup & OHOI_THS_UMAJH) { ipmi_threshold_event_set(state, IPMI_UPPER_CRITICAL, IPMI_GOING_HIGH, IPMI_DEASSERTION); } else if (a_sup & OHOI_THS_UMAJL) { ipmi_threshold_event_set(state, IPMI_GOING_LOW, IPMI_UPPER_CRITICAL, IPMI_ASSERTION); } else { return 1; } } if (d_mask & SAHPI_ES_UPPER_CRIT) { if (d_sup & OHOI_THS_UCRTH) { ipmi_threshold_event_set(state, IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_HIGH, IPMI_DEASSERTION); } else if (a_sup & OHOI_THS_UCRTL) { ipmi_threshold_event_set(state, IPMI_UPPER_NON_RECOVERABLE, IPMI_GOING_LOW, IPMI_ASSERTION); } else { return 1; } } return 0; }
void ipmi_cmdlang_sensor_change(enum ipmi_update_e op, ipmi_entity_t *entity, ipmi_sensor_t *sensor, void *cb_data) { char *errstr; int rv; ipmi_cmd_info_t *evi; char sensor_name[IPMI_SENSOR_NAME_LEN]; ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name)); evi = ipmi_cmdlang_alloc_event_info(); if (!evi) { rv = ENOMEM; errstr = "Out of memory"; goto out_err; } ipmi_cmdlang_out(evi, "Object Type", "Sensor"); ipmi_cmdlang_out(evi, "Name", sensor_name); switch (op) { case IPMI_ADDED: ipmi_cmdlang_out(evi, "Operation", "Add"); if (ipmi_cmdlang_get_evinfo()) sensor_dump(sensor, evi); if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { rv = ipmi_sensor_add_threshold_event_handler (sensor, sensor_threshold_event_handler, NULL); } else { rv = ipmi_sensor_add_discrete_event_handler (sensor, sensor_discrete_event_handler, NULL); } if (rv) { ipmi_cmdlang_global_err(sensor_name, "cmd_sensor.c(ipmi_cmdlang_sensor_change)", "Unable to set event handler for sensor", rv); } break; case IPMI_DELETED: ipmi_cmdlang_out(evi, "Operation", "Delete"); break; case IPMI_CHANGED: ipmi_cmdlang_out(evi, "Operation", "Change"); if (ipmi_cmdlang_get_evinfo()) sensor_dump(sensor, evi); break; } ipmi_cmdlang_cmd_info_put(evi); return; out_err: ipmi_cmdlang_global_err(sensor_name, "cmd_sensor.c(ipmi_cmdlang_sensor_change)", errstr, rv); if (evi) ipmi_cmdlang_cmd_info_put(evi); }
static void got_events(ipmi_sensor_t *sensor, int err, ipmi_event_state_t *states, void *cb_data) { sdata_t *sdata = cb_data; int rv; if (err) { printf("Error 0x%x getting events for sensor %s\n", err, sdata->name); goto out_err; } /* Turn on the general events for a sensor, since this at least supports per-sensor enables. */ ipmi_event_state_set_events_enabled(sdata->es, 1); ipmi_event_state_set_scanning_enabled(sdata->es, 1); printf("Sensor %s event settings:\n", sdata->name); if (sdata->state_sup != IPMI_EVENT_SUPPORT_PER_STATE) { /* No per-state sensors, just do the global enable. */ } else if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { /* Check each event, print out the current state, and turn it on in the events to set if it is available. */ enum ipmi_event_value_dir_e value_dir; enum ipmi_event_dir_e dir; enum ipmi_thresh_e thresh; int val; for (value_dir=IPMI_GOING_LOW; value_dir<=IPMI_GOING_HIGH; value_dir++) { for (dir=IPMI_ASSERTION; dir<=IPMI_DEASSERTION; dir++) { for (thresh=IPMI_LOWER_NON_CRITICAL; thresh<=IPMI_UPPER_NON_RECOVERABLE; thresh++) { char *v; rv = ipmi_sensor_threshold_event_supported (sensor, thresh, value_dir, dir, &val); if (rv || !val) continue; if (ipmi_is_threshold_event_set(states, thresh, value_dir, dir)) v = ""; else v = " not"; printf(" %s %s %s was%s enabled\n", ipmi_get_threshold_string(thresh), ipmi_get_value_dir_string(value_dir), ipmi_get_event_dir_string(dir), v); ipmi_threshold_event_set(sdata->es, thresh, value_dir, dir); } } } } else { /* Check each event, print out the current state, and turn it on in the events to set if it is available. */ enum ipmi_event_dir_e dir; int i; for (dir=IPMI_ASSERTION; dir<=IPMI_DEASSERTION; dir++) { for (i=0; i<15; i++) { char *v; int val; rv = ipmi_sensor_discrete_event_supported (sensor, i, dir, &val); if (rv || !val) continue; if (ipmi_is_discrete_event_set(states, i, dir)) v = ""; else v = " not"; printf(" bit %d %s was%s enabled\n", i, ipmi_get_event_dir_string(dir), v); ipmi_discrete_event_set(sdata->es, i, dir); } } } rv = ipmi_sensor_set_event_enables(sensor, sdata->es, event_set_done, sdata); if (rv) { printf("Error 0x%x enabling events for sensor %s\n", err, sdata->name); goto out_err; } return; out_err: release_sdata(sdata); }
static void mod_event_enables(ipmi_sensor_t *sensor, void *cb_data, enum ev_en_kind kind) { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int rv; int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info); int argc = ipmi_cmdlang_get_argc(cmd_info); char **argv = ipmi_cmdlang_get_argv(cmd_info); ipmi_event_state_t *s = NULL; if ((argc - curr_arg) < 2) { /* Not enough parameters */ cmdlang->errstr = "Not enough parameters"; cmdlang->err = EINVAL; goto out_err; } s = ipmi_mem_alloc(ipmi_states_size()); if (!s) { cmdlang->errstr = "Out of memory"; cmdlang->err = ENOMEM; goto out_err; } ipmi_event_state_init(s); if (strcmp(argv[curr_arg], "msg") == 0) ipmi_event_state_set_events_enabled(s, 1); else if (strcmp(argv[curr_arg], "nomsg") == 0) ipmi_event_state_set_events_enabled(s, 0); else { cmdlang->errstr = "Invalid message enable setting"; cmdlang->err = EINVAL; goto out_err; } curr_arg++; if (strcmp(argv[curr_arg], "scan") == 0) ipmi_event_state_set_scanning_enabled(s, 1); else if (strcmp(argv[curr_arg], "noscan") == 0) ipmi_event_state_set_scanning_enabled(s, 0); else { cmdlang->errstr = "Invalid scanning enable setting"; cmdlang->err = EINVAL; goto out_err; } curr_arg++; if (ipmi_sensor_get_event_reading_type(sensor) == IPMI_EVENT_READING_TYPE_THRESHOLD) { while (curr_arg < argc) { enum ipmi_thresh_e thresh; enum ipmi_event_value_dir_e value_dir; enum ipmi_event_dir_e dir; ipmi_cmdlang_get_threshold_ev(argv[curr_arg], &thresh, &value_dir, &dir, cmd_info); if (cmdlang->err) { goto out_err; } ipmi_threshold_event_set(s, thresh, value_dir, dir); curr_arg++; } } else { while (curr_arg < argc) { int offset; enum ipmi_event_dir_e dir; ipmi_cmdlang_get_discrete_ev(argv[curr_arg], &offset, &dir, cmd_info); if (cmdlang->err) { goto out_err; } ipmi_discrete_event_set(s, offset, dir); curr_arg++; } } ipmi_cmdlang_cmd_info_get(cmd_info); switch (kind) { case ev_en_set: rv = ipmi_sensor_set_event_enables(sensor, s, sensor_set_event_enables_done, cmd_info); break; case ev_en_enable: rv = ipmi_sensor_enable_events(sensor, s, sensor_set_event_enables_done, cmd_info); break; case ev_en_disable: rv = ipmi_sensor_disable_events(sensor, s, sensor_set_event_enables_done, cmd_info); break; default: rv = EINVAL; } if (rv) { ipmi_cmdlang_cmd_info_put(cmd_info); cmdlang->err = rv; cmdlang->errstr = "Error setting event enables"; goto out_err; } ipmi_mem_free(s); return; out_err: ipmi_sensor_get_name(sensor, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_sensor.c(sensor_set_event_enables)"; if (s) ipmi_mem_free(s); }
static void set_sensor_event_enables(ipmi_sensor_t *sensor, void *cb_data) { struct ohoi_sensor_enables *enables_data; int rv; ipmi_event_state_t info; int i; enables_data = cb_data; if (is_ignored_sensor(sensor)) { dbg("sensor is ignored"); enables_data->done = 1; return; } if ((ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_PER_STATE)|| (ipmi_sensor_get_event_support(sensor) == IPMI_EVENT_SUPPORT_ENTIRE_SENSOR)) { ipmi_event_state_init(&info); if (enables_data->sensor_enables->SensorStatus & SAHPI_SENSTAT_EVENTS_ENABLED) ipmi_event_state_set_events_enabled(&info, 1); if (enables_data->sensor_enables->SensorStatus & SAHPI_SENSTAT_SCAN_ENABLED) ipmi_event_state_set_scanning_enabled(&info, 1); if (enables_data->sensor_enables->SensorStatus & SAHPI_SENSTAT_BUSY) ipmi_event_state_set_busy(&info, 1); #if 0 if ( enables_data->sensor_enables->AssertEvents == 0xffff ) { /* enable all assertion events */ info.__assertion_events = 0; for( i = 0; i < 12; i++ ) { int val = 0; if ( ipmi_sensor_get_event_reading_type( sensor ) == IPMI_EVENT_READING_TYPE_THRESHOLD ) ipmi_sensor_threshold_assertion_event_supported( sensor, 0, i, &val ); else ipmi_sensor_discrete_assertion_event_supported( sensor, i, &val ); if ( val ) info.__assertion_events |= (1 << i); } } else info.__assertion_events = enables_data->sensor_enables->AssertEvents; if ( enables_data->sensor_enables->DeassertEvents == 0xffff ) { /* enable all deassertion events */ info.__deassertion_events = 0; for( i = 0; i < 12; i++ ) { int val = 0; if ( ipmi_sensor_get_event_reading_type( sensor ) == IPMI_EVENT_READING_TYPE_THRESHOLD ) ipmi_sensor_threshold_deassertion_event_supported( sensor, 0, i, &val ); else ipmi_sensor_discrete_deassertion_event_supported( sensor, i, &val ); if ( val ) info.__deassertion_events |= (1 << i); } } else info.__deassertion_events = enables_data->sensor_enables->DeassertEvents; #endif for (i = 0; i < 32; i++) { if (enables_data->sensor_enables->AssertEvents & 1<<i ) ipmi_discrete_event_set(&info, i, IPMI_ASSERTION); else ipmi_discrete_event_clear(&info, i, IPMI_ASSERTION); if (enables_data->sensor_enables->DeassertEvents & 1<<i ) ipmi_discrete_event_set(&info, i, IPMI_DEASSERTION); else ipmi_discrete_event_clear(&info, i, IPMI_DEASSERTION); } rv = ipmi_sensor_events_enable_set(sensor, &info, set_data, &enables_data->done); if (rv) { dbg("Unable to sensor event enables: 0x%x\n", rv); enables_data->done = 1; } } else { dbg("%#x", ipmi_sensor_get_event_support(sensor)); enables_data->done = 1; } }