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;
err("Sensor is not present, ignored");
return;
}
if (ipmi_sensor_get_event_reading_type(sensor) ==
IPMI_EVENT_READING_TYPE_THRESHOLD) {
rv = ipmi_sensor_get_reading(sensor, sensor_reading,
reading_data);
if (rv) {
reading_data->done = 1;
reading_data->rvalue = SA_ERR_HPI_INVALID_REQUEST;
err("Unable to get sensor reading: 0x%x", rv);
}
return;
}
rv = ipmi_sensor_get_states(sensor, sensor_read_states, reading_data);
if (rv) {
reading_data->done = 1;
reading_data->rvalue = SA_ERR_HPI_INVALID_REQUEST;
err("Unable to get sensor reading states: 0x%x", rv);
}
}
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 read_ipmi_sensor(zbx_ipmi_host_t *h, zbx_ipmi_sensor_t *s)
{
const char *__function_name = "read_ipmi_sensor";
char id_str[2 * IPMI_SENSOR_ID_SZ + 1];
int ret;
const char *s_reading_type_string;
struct timeval tv;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() sensor:'%s@[%s]:%d'", __function_name,
sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz), h->ip, h->port);
h->ret = SUCCEED;
h->done = 0;
switch (s->reading_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",
sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz),
ret);
h->ret = NOTSUPPORTED;
goto out;
}
break;
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:
case IPMI_EVENT_READING_TYPE_SENSOR_SPECIFIC:
case 0x70: /* reading types 70h-7Fh are for OEM discrete sensors */
case 0x71:
case 0x72:
case 0x73:
case 0x74:
case 0x75:
case 0x76:
case 0x77:
case 0x78:
case 0x79:
case 0x7a:
case 0x7b:
case 0x7c:
case 0x7d:
case 0x7e:
case 0x7f:
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",
sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz),
ret);
h->ret = NOTSUPPORTED;
goto out;
}
break;
default:
s_reading_type_string = ipmi_sensor_get_event_reading_type_string(s->sensor);
h->err = zbx_dsprintf(h->err, "Cannot read sensor \"%s\"."
" IPMI reading type \"%s\" is not supported",
sensor_id_to_str(id_str, sizeof(id_str), s->id, s->id_type, s->id_sz),
s_reading_type_string);
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));
}
/* 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;
}
