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