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;
}
}
