static void sensor_read_states(ipmi_sensor_t *sensor,
int err,
ipmi_states_t *states,
void *cb_data)
{
struct ohoi_sensor_reading *p = cb_data;
p->sensor_reading->ValuesPresent = SAHPI_SRF_EVENT_STATE;
if (ipmi_is_event_messages_enabled(states))
p->sensor_reading->EventStatus.SensorStatus |=
SAHPI_SENSTAT_EVENTS_ENABLED;
if (ipmi_is_sensor_scanning_enabled(states))
p->sensor_reading->EventStatus.SensorStatus |=
SAHPI_SENSTAT_EVENTS_ENABLED;
if (ipmi_is_initial_update_in_progress(states))
p->sensor_reading->EventStatus.SensorStatus |=
SAHPI_SENSTAT_BUSY;
p->sensor_reading->EventStatus.EventStatus = states->__states;
p->done = 1;
}
static void
read_sensor_states(ipmi_sensor_t *sensor,
int err,
ipmi_states_t *states,
void *cb_data)
{
ipmi_cmd_info_t *cmd_info = cb_data;
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
int i;
char sensor_name[IPMI_SENSOR_NAME_LEN];
int rv;
ipmi_cmdlang_lock(cmd_info);
if (err) {
cmdlang->errstr = "Error reading sensor";
cmdlang->err = err;
ipmi_sensor_get_name(sensor, cmdlang->objstr,
cmdlang->objstr_len);
cmdlang->location = "cmd_sensor.c(read_sensor_states)";
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_is_event_messages_enabled(states));
ipmi_cmdlang_out_bool(cmd_info, "Sensor Scanning Enabled",
ipmi_is_sensor_scanning_enabled(states));
ipmi_cmdlang_out_bool(cmd_info, "Initial Update In Progress",
ipmi_is_initial_update_in_progress(states));
for (i=0; i<15; i++) {
int ival;
const char *str;
rv = ipmi_sensor_discrete_event_readable(sensor, i, &ival);
if ((rv) || !ival)
continue;
ipmi_cmdlang_out(cmd_info, "Event", NULL);
ipmi_cmdlang_down(cmd_info);
ipmi_cmdlang_out_int(cmd_info, "Offset", i);
str = ipmi_sensor_reading_name_string(sensor, i);
if (strcmp(str, "unknown") != 0)
ipmi_cmdlang_out(cmd_info, "Name", str);
ipmi_cmdlang_out_bool(cmd_info, "Set", ipmi_is_state_set(states, i));
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
got_discrete_states(ipmi_sensor_t *sensor,
int err,
ipmi_states_t *states,
void *cb_data)
{
sdata_t *sdata = cb_data;
int i;
if (err) {
printf("Error 0x%x getting discrete states for sensor %s\n",
err, sdata->name);
goto out;
}
if (err) {
printf("Error 0x%x getting discrete states for sensor %s\n",
err, sdata->name);
goto out;
}
printf("Got state reading for sensor %s\n", sdata->name);
if (ipmi_is_event_messages_enabled(states))
printf(" event messages enabled\n");
if (ipmi_is_sensor_scanning_enabled(states))
printf(" sensor scanning enabled\n");
if (ipmi_is_initial_update_in_progress(states))
printf(" initial update in progress\n");
for (i=0; i<15; i++) {
int val, rv;
rv = ipmi_sensor_discrete_event_readable(sensor, i, &val);
if (rv || !val)
continue;
printf(" state %d value is %d\n", i, ipmi_is_state_set(states, i));
}
out:
release_sdata(sdata);
}
/* callback function invoked from OpenIPMI */
static void got_discrete_states(ipmi_sensor_t *sensor, int err, ipmi_states_t *states, void *cb_data)
{
const char *__function_name = "got_discrete_states";
char id_str[2 * IPMI_SENSOR_ID_SZ + 1];
int id, i, val, ret, is_state_set;
ipmi_entity_t *ent;
zbx_ipmi_host_t *h = cb_data;
zbx_ipmi_sensor_t *s;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (0 == ipmi_is_sensor_scanning_enabled(states) || 0 != ipmi_is_initial_update_in_progress(states))
{
h->err = zbx_strdup(h->err, "sensor data is not available");
h->ret = NOTSUPPORTED;
goto out;
}
s = get_ipmi_sensor(h, sensor);
if (NULL == s)
{
THIS_SHOULD_NEVER_HAPPEN;
h->err = zbx_strdup(h->err, "fatal error");
h->ret = NOTSUPPORTED;
goto out;
}
if (0 != err)
{
h->err = zbx_dsprintf(h->err, "error 0x%x while reading a discrete sensor %s@[%s]:%d", err,
sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz), h->ip, h->port);
h->ret = NOTSUPPORTED;
goto out;
}
ent = ipmi_sensor_get_entity(sensor);
id = ipmi_entity_get_entity_id(ent);
/* Discrete values are 16-bit. We're storing them into a 64-bit uint. */
#define MAX_DISCRETE_STATES 15
s->value.discrete = 0;
for (i = 0; i < MAX_DISCRETE_STATES; i++)
{
ret = ipmi_sensor_discrete_event_readable(sensor, i, &val);
if (0 != ret || 0 == val)
continue;
is_state_set = ipmi_is_state_set(states, i);
zabbix_log(LOG_LEVEL_DEBUG, "State [%s | %s | %s | %s | state %d value is %d]",
sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz),
ipmi_get_entity_id_string(id), ipmi_sensor_get_sensor_type_string(sensor),
ipmi_sensor_get_event_reading_type_string(sensor), i, is_state_set);
if (0 != is_state_set)
s->value.discrete |= 1 << i;
}
#undef MAX_DISCRETE_STATES
out:
h->done = 1;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(h->ret));
}
/* callback function invoked from OpenIPMI */
static void got_thresh_reading(ipmi_sensor_t *sensor, int err, enum ipmi_value_present_e value_present,
unsigned int raw_value, double val, ipmi_states_t *states, void *cb_data)
{
const char *__function_name = "got_thresh_reading";
char id_str[2 * IPMI_SENSOR_ID_SZ + 1];
const char *e_string, *s_type_string, *s_reading_type_string;
ipmi_entity_t *ent;
const char *percent = "", *base, *mod_use = "", *modifier = "", *rate;
zbx_ipmi_host_t *h = cb_data;
zbx_ipmi_sensor_t *s;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (0 != err)
{
zabbix_log(LOG_LEVEL_DEBUG, "%s() fail: %s", __function_name, zbx_strerror(err));
h->err = zbx_dsprintf(h->err, "error 0x%x while reading threshold sensor", err);
h->ret = NETWORK_ERROR;
goto out;
}
if (0 == ipmi_is_sensor_scanning_enabled(states) || 0 != ipmi_is_initial_update_in_progress(states))
{
h->err = zbx_strdup(h->err, "sensor data is not available");
h->ret = NOTSUPPORTED;
goto out;
}
s = get_ipmi_sensor(h, sensor);
if (NULL == s)
{
THIS_SHOULD_NEVER_HAPPEN;
h->err = zbx_strdup(h->err, "fatal error");
h->ret = NOTSUPPORTED;
goto out;
}
switch (value_present)
{
case IPMI_NO_VALUES_PRESENT:
case IPMI_RAW_VALUE_PRESENT:
h->err = zbx_strdup(h->err, "no value present for threshold sensor");
h->ret = NOTSUPPORTED;
break;
case IPMI_BOTH_VALUES_PRESENT:
s->value.threshold = val;
/* next lines only for debug logging */
ent = ipmi_sensor_get_entity(sensor);
e_string = ipmi_entity_get_entity_id_string(ent);
s_type_string = ipmi_sensor_get_sensor_type_string(sensor);
s_reading_type_string = ipmi_sensor_get_event_reading_type_string(sensor);
base = ipmi_sensor_get_base_unit_string(sensor);
if (ipmi_sensor_get_percentage(sensor))
percent = "%";
switch (ipmi_sensor_get_modifier_unit_use(sensor))
{
case IPMI_MODIFIER_UNIT_NONE:
break;
case IPMI_MODIFIER_UNIT_BASE_DIV_MOD:
mod_use = "/";
modifier = ipmi_sensor_get_modifier_unit_string(sensor);
break;
case IPMI_MODIFIER_UNIT_BASE_MULT_MOD:
mod_use = "*";
modifier = ipmi_sensor_get_modifier_unit_string(sensor);
break;
}
rate = ipmi_sensor_get_rate_unit_string(sensor);
zabbix_log(LOG_LEVEL_DEBUG, "Value [%s | %s | %s | %s | " ZBX_FS_DBL "%s %s%s%s%s]",
sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz),
e_string, s_type_string, s_reading_type_string, val, percent, base,
mod_use, modifier, rate);
break;
}
out:
h->done = 1;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(h->ret));
}
static void
read_sensor(ipmi_sensor_t *sensor,
int err,
enum ipmi_value_present_e value_present,
unsigned int raw_val,
double val,
ipmi_states_t *states,
void *cb_data)
{
ipmi_cmd_info_t *cmd_info = cb_data;
ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
enum ipmi_thresh_e thresh;
char sensor_name[IPMI_SENSOR_NAME_LEN];
int rv;
ipmi_cmdlang_lock(cmd_info);
if (err) {
cmdlang->errstr = "Error reading sensor";
cmdlang->err = err;
ipmi_sensor_get_name(sensor, cmdlang->objstr,
cmdlang->objstr_len);
cmdlang->location = "cmd_sensor.c(read_sensor)";
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_is_event_messages_enabled(states));
ipmi_cmdlang_out_bool(cmd_info, "Sensor Scanning Enabled",
ipmi_is_sensor_scanning_enabled(states));
ipmi_cmdlang_out_bool(cmd_info, "Initial Update In Progress",
ipmi_is_initial_update_in_progress(states));
switch (value_present) {
case IPMI_BOTH_VALUES_PRESENT:
ipmi_cmdlang_out_double(cmd_info, "Value", val);
/* FALLTHRU */
case IPMI_RAW_VALUE_PRESENT:
ipmi_cmdlang_out_hex(cmd_info, "Raw Value", raw_val);
default:
break;
}
for (thresh = IPMI_LOWER_NON_CRITICAL;
thresh <= IPMI_UPPER_NON_RECOVERABLE;
thresh++)
{
int ival;
rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &ival);
if ((rv) || !ival)
continue;
ipmi_cmdlang_out(cmd_info, "Threshold", NULL);
ipmi_cmdlang_down(cmd_info);
ipmi_cmdlang_out(cmd_info, "Name",
ipmi_get_threshold_string(thresh));
ipmi_cmdlang_out_bool(cmd_info, "Out Of Range",
ipmi_is_threshold_out_of_range(states, thresh));
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
got_thresh_reading(ipmi_sensor_t *sensor,
int err,
enum ipmi_value_present_e value_present,
unsigned int raw_value,
double val,
ipmi_states_t *states,
void *cb_data)
{
sdata_t *sdata = cb_data;
enum ipmi_thresh_e thresh;
if (err) {
printf("Error 0x%x getting discrete states for sensor %s\n",
err, sdata->name);
goto out;
}
printf("Got threshold reading for sensor %s\n", sdata->name);
if (ipmi_is_event_messages_enabled(states))
printf(" event messages enabled\n");
if (ipmi_is_sensor_scanning_enabled(states))
printf(" sensor scanning enabled\n");
if (ipmi_is_initial_update_in_progress(states))
printf(" initial update in progress\n");
switch (value_present)
{
case IPMI_NO_VALUES_PRESENT:
printf(" no value present\n");
break;
case IPMI_BOTH_VALUES_PRESENT:
{
const char *percent = "";
const char *base;
const char *mod_use = "";
const char *modifier = "";
const char *rate;
base = ipmi_sensor_get_base_unit_string(sensor);
if (ipmi_sensor_get_percentage(sensor))
percent = "%";
switch (ipmi_sensor_get_modifier_unit_use(sensor)) {
case IPMI_MODIFIER_UNIT_NONE:
break;
case IPMI_MODIFIER_UNIT_BASE_DIV_MOD:
mod_use = "/";
modifier = ipmi_sensor_get_modifier_unit_string(sensor);
break;
case IPMI_MODIFIER_UNIT_BASE_MULT_MOD:
mod_use = "*";
modifier = ipmi_sensor_get_modifier_unit_string(sensor);
break;
}
rate = ipmi_sensor_get_rate_unit_string(sensor);
printf(" value: %lf%s %s%s%s%s\n", val, percent,
base, mod_use, modifier, rate);
}
/* FALLTHROUGH */
case IPMI_RAW_VALUE_PRESENT:
printf(" raw value: 0x%2.2x\n", raw_value);
}
if (sdata->thresh_sup == IPMI_THRESHOLD_ACCESS_SUPPORT_NONE)
goto out;
for (thresh=IPMI_LOWER_NON_CRITICAL;
thresh<=IPMI_UPPER_NON_RECOVERABLE;
thresh++)
{
int val, rv;
rv = ipmi_sensor_threshold_reading_supported(sensor, thresh, &val);
if (rv || !val)
continue;
if (ipmi_is_threshold_out_of_range(states, thresh))
printf(" Threshold %s is out of range\n",
ipmi_get_threshold_string(thresh));
else
printf(" Threshold %s is in range\n",
ipmi_get_threshold_string(thresh));
}
out:
release_sdata(sdata);
}
