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);
}
}
/* 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)";
}
}
int
ipmi_sensor_main(struct ipmi_intf *intf, int argc, char **argv)
{
int rc = 0;
if (argc == 0) {
rc = ipmi_sensor_list(intf);
} else if (strncmp(argv[0], "help", 4) == 0) {
lprintf(LOG_NOTICE, "Sensor Commands: list thresh get reading");
} else if (strncmp(argv[0], "list", 4) == 0) {
rc = ipmi_sensor_list(intf);
} else if (strncmp(argv[0], "thresh", 5) == 0) {
rc = ipmi_sensor_set_threshold(intf, argc - 1, &argv[1]);
} else if (strncmp(argv[0], "get", 3) == 0) {
rc = ipmi_sensor_get(intf, argc - 1, &argv[1]);
} else if (strncmp(argv[0], "reading", 7) == 0) {
rc = ipmi_sensor_get_reading(intf, argc - 1, &argv[1]);
} else {
lprintf(LOG_ERR, "Invalid sensor command: %s", argv[0]);
rc = -1;
}
return rc;
}
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;
}
