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