From: Florian Forster Date: Fri, 6 Oct 2017 11:14:01 +0000 (+0200) Subject: Merge remote-tracking branch 'github/pr/2091' X-Git-Tag: collectd-5.8.0~56 X-Git-Url: https://git.octo.it/?p=collectd.git;a=commitdiff_plain;h=1581f3b307554cbf8b5784729754c5d73a1192a5;hp=5dbb7471b0a7ca7506f56f4c6dbaf58e790c6b7c Merge remote-tracking branch 'github/pr/2091' --- diff --git a/src/collectd.conf.in b/src/collectd.conf.in index 3287e0d1..6bddd8cb 100644 --- a/src/collectd.conf.in +++ b/src/collectd.conf.in @@ -682,6 +682,8 @@ # NotifySensorAdd false # NotifySensorRemove true # NotifySensorNotPresent false +# SELEnabled false +# SELClearEvent false # # diff --git a/src/collectd.conf.pod b/src/collectd.conf.pod index 3fa91596..14222c63 100644 --- a/src/collectd.conf.pod +++ b/src/collectd.conf.pod @@ -3381,6 +3381,19 @@ If a sensor disappears a notification is sent. If you have for example dual power supply and one of them is (un)plugged then a notification is sent. +=item B I|I + +If system event log (SEL) is enabled, plugin will listen for sensor threshold +and discrete events. When event is received the notification is sent. +Defaults to B. + +=item B I|I + +If SEL clear event is enabled, plugin will delete event from SEL list after +it is received and successfully handled. In this case other tools that are +subscribed for SEL events will receive an empty event. +Defaults to B. + =back =head2 Plugin C diff --git a/src/ipmi.c b/src/ipmi.c index c8c80429..87f8b441 100644 --- a/src/ipmi.c +++ b/src/ipmi.c @@ -59,16 +59,22 @@ static int c_ipmi_init_in_progress = 0; static int c_ipmi_active = 0; static pthread_t thread_id = (pthread_t)0; -static const char *config_keys[] = {"Sensor", "IgnoreSelected", - "NotifySensorAdd", "NotifySensorRemove", - "NotifySensorNotPresent"}; +static const char *config_keys[] = {"Sensor", + "IgnoreSelected", + "NotifySensorAdd", + "NotifySensorRemove", + "NotifySensorNotPresent", + "SELEnabled", + "SELClearEvent"}; static int config_keys_num = STATIC_ARRAY_SIZE(config_keys); static ignorelist_t *ignorelist = NULL; -static int c_ipmi_nofiy_add = 0; -static int c_ipmi_nofiy_remove = 0; -static int c_ipmi_nofiy_notpresent = 0; +static _Bool c_ipmi_notify_add = 0; +static _Bool c_ipmi_notify_remove = 0; +static _Bool c_ipmi_notify_notpresent = 0; +static _Bool c_ipmi_sel_enabled = 0; +static _Bool c_ipmi_sel_clear_event = 0; /* * Misc private functions @@ -115,7 +121,7 @@ static void sensor_read_handler(ipmi_sensor_t *sensor, int err, "not present.", list_item->sensor_name); - if (c_ipmi_nofiy_notpresent) { + if (c_ipmi_notify_notpresent) { notification_t n = { NOTIF_WARNING, cdtime(), "", "", "ipmi", "", "", "", NULL}; @@ -164,7 +170,7 @@ static void sensor_read_handler(ipmi_sensor_t *sensor, int err, INFO("ipmi plugin: sensor_read_handler: sensor %s present.", list_item->sensor_name); - if (c_ipmi_nofiy_notpresent) { + if (c_ipmi_notify_notpresent) { notification_t n = {NOTIF_OKAY, cdtime(), "", "", "ipmi", "", "", "", NULL}; @@ -200,56 +206,66 @@ static void sensor_read_handler(ipmi_sensor_t *sensor, int err, plugin_dispatch_values(&vl); } /* void sensor_read_handler */ +static void sensor_get_name(ipmi_sensor_t *sensor, char *buffer, int buf_len) { + char temp[DATA_MAX_NAME_LEN] = {0}; + ipmi_entity_t *ent = ipmi_sensor_get_entity(sensor); + const char *entity_id_string = ipmi_entity_get_entity_id_string(ent); + char sensor_name[DATA_MAX_NAME_LEN] = ""; + char *sensor_name_ptr; + + if ((buffer == NULL) || (buf_len == 0)) + return; + + ipmi_sensor_get_name(sensor, temp, sizeof(temp)); + temp[sizeof(temp) - 1] = 0; + + if (entity_id_string != NULL && strlen(temp)) + snprintf(sensor_name, sizeof(sensor_name), "%s %s", temp, entity_id_string); + else if (entity_id_string != NULL) + sstrncpy(sensor_name, entity_id_string, sizeof(sensor_name)); + else + sstrncpy(sensor_name, temp, sizeof(sensor_name)); + + if (strlen(temp)) { + sstrncpy(temp, sensor_name, sizeof(temp)); + sensor_name_ptr = strstr(temp, ")."); + if (sensor_name_ptr != NULL) { + /* If name is something like "foo (123).bar", + * change that to "bar (123)". + * Both, sensor_name_ptr and sensor_id_ptr point to memory within the + * `temp' array, which holds a copy of the current `sensor_name'. */ + char *sensor_id_ptr; + + /* `sensor_name_ptr' points to ").bar". */ + sensor_name_ptr[1] = 0; + /* `temp' holds "foo (123)\0bar\0". */ + sensor_name_ptr += 2; + /* `sensor_name_ptr' now points to "bar". */ + + sensor_id_ptr = strstr(temp, "("); + if (sensor_id_ptr != NULL) { + /* `sensor_id_ptr' now points to "(123)". */ + snprintf(sensor_name, sizeof(sensor_name), "%s %s", sensor_name_ptr, + sensor_id_ptr); + } + /* else: don't touch sensor_name. */ + } + } + sstrncpy(buffer, sensor_name, buf_len); +} + static int sensor_list_add(ipmi_sensor_t *sensor) { ipmi_sensor_id_t sensor_id; c_ipmi_sensor_list_t *list_item; c_ipmi_sensor_list_t *list_prev; char buffer[DATA_MAX_NAME_LEN] = {0}; - const char *entity_id_string; - char sensor_name[DATA_MAX_NAME_LEN]; - char *sensor_name_ptr; + char *sensor_name_ptr = buffer; int sensor_type; const char *type; - ipmi_entity_t *ent = ipmi_sensor_get_entity(sensor); sensor_id = ipmi_sensor_convert_to_id(sensor); - - ipmi_sensor_get_name(sensor, buffer, sizeof(buffer)); - buffer[sizeof(buffer) - 1] = 0; - - entity_id_string = ipmi_entity_get_entity_id_string(ent); - - if (entity_id_string == NULL) - sstrncpy(sensor_name, buffer, sizeof(sensor_name)); - else - snprintf(sensor_name, sizeof(sensor_name), "%s %s", buffer, - entity_id_string); - - sstrncpy(buffer, sensor_name, sizeof(buffer)); - sensor_name_ptr = strstr(buffer, ")."); - if (sensor_name_ptr != NULL) { - /* If name is something like "foo (123).bar", - * change that to "bar (123)". - * Both, sensor_name_ptr and sensor_id_ptr point to memory within the - * `buffer' array, which holds a copy of the current `sensor_name'. */ - char *sensor_id_ptr; - - /* `sensor_name_ptr' points to ").bar". */ - sensor_name_ptr[1] = 0; - /* `buffer' holds "foo (123)\0bar\0". */ - sensor_name_ptr += 2; - /* `sensor_name_ptr' now points to "bar". */ - - sensor_id_ptr = strstr(buffer, "("); - if (sensor_id_ptr != NULL) { - /* `sensor_id_ptr' now points to "(123)". */ - snprintf(sensor_name, sizeof(sensor_name), "%s %s", sensor_name_ptr, - sensor_id_ptr); - } - /* else: don't touch sensor_name. */ - } - sensor_name_ptr = sensor_name; + sensor_get_name(sensor, buffer, sizeof(buffer)); /* Both `ignorelist' and `plugin_instance' may be NULL. */ if (ignorelist_match(ignorelist, sensor_name_ptr) != 0) @@ -321,7 +337,7 @@ static int sensor_list_add(ipmi_sensor_t *sensor) { pthread_mutex_unlock(&sensor_list_lock); - if (c_ipmi_nofiy_add && (c_ipmi_init_in_progress == 0)) { + if (c_ipmi_notify_add && (c_ipmi_init_in_progress == 0)) { notification_t n = {NOTIF_OKAY, cdtime(), "", "", "ipmi", "", "", "", NULL}; sstrncpy(n.host, hostname_g, sizeof(n.host)); @@ -368,7 +384,7 @@ static int sensor_list_remove(ipmi_sensor_t *sensor) { pthread_mutex_unlock(&sensor_list_lock); - if (c_ipmi_nofiy_remove && c_ipmi_active) { + if (c_ipmi_notify_remove && c_ipmi_active) { notification_t n = {NOTIF_WARNING, cdtime(), "", "", "ipmi", "", "", "", NULL}; @@ -420,6 +436,160 @@ static int sensor_list_remove_all(void) { return 0; } /* int sensor_list_remove_all */ +static int sensor_convert_threshold_severity(enum ipmi_thresh_e severity) { + switch (severity) { + case IPMI_LOWER_NON_CRITICAL: + case IPMI_UPPER_NON_CRITICAL: + return NOTIF_OKAY; + case IPMI_LOWER_CRITICAL: + case IPMI_UPPER_CRITICAL: + return NOTIF_WARNING; + case IPMI_LOWER_NON_RECOVERABLE: + case IPMI_UPPER_NON_RECOVERABLE: + return NOTIF_FAILURE; + default: + return NOTIF_OKAY; + } /* switch (severity) */ +} /* int sensor_convert_threshold_severity */ + +static void add_event_common_data(notification_t *n, ipmi_sensor_t *sensor, + enum ipmi_event_dir_e dir, + ipmi_event_t *event) { + ipmi_entity_t *ent = ipmi_sensor_get_entity(sensor); + + plugin_notification_meta_add_string(n, "entity_name", + ipmi_entity_get_entity_id_string(ent)); + plugin_notification_meta_add_signed_int(n, "entity_id", + ipmi_entity_get_entity_id(ent)); + plugin_notification_meta_add_signed_int(n, "entity_instance", + ipmi_entity_get_entity_instance(ent)); + plugin_notification_meta_add_boolean(n, "assert", dir == IPMI_ASSERTION); + + if (event) + plugin_notification_meta_add_signed_int(n, "event_type", + ipmi_event_get_type(event)); +} /* void add_event_sensor_meta_data */ + +static int sensor_threshold_event_handler( + ipmi_sensor_t *sensor, enum ipmi_event_dir_e dir, + enum ipmi_thresh_e threshold, enum ipmi_event_value_dir_e high_low, + enum ipmi_value_present_e value_present, unsigned int raw_value, + double value, void *cb_data, ipmi_event_t *event) { + + /* From the IPMI specification Chapter 2: Events. + * If a callback handles the event, then all future callbacks called due to + * the event will receive a NULL for the event. So be ready to handle a NULL + * event in all your event handlers. A NULL may also be passed to an event + * handler if the callback was not due to an event. */ + if (event == NULL) + return IPMI_EVENT_NOT_HANDLED; + + /* offset is a table index and it's represented as enum of strings that are + organized in the way - high and low for each threshold severity level */ + notification_t n = {NOTIF_OKAY, cdtime(), "", "", "ipmi", "", "", "", NULL}; + unsigned int offset = (2 * threshold) + high_low; + unsigned int event_type = ipmi_sensor_get_event_reading_type(sensor); + unsigned int sensor_type = ipmi_sensor_get_sensor_type(sensor); + const char *event_state = + ipmi_get_reading_name(event_type, sensor_type, offset); + sensor_get_name(sensor, n.type_instance, sizeof(n.type_instance)); + if (value_present != IPMI_NO_VALUES_PRESENT) + snprintf(n.message, sizeof(n.message), + "sensor %s received event: %s, value is %f", n.type_instance, + event_state, value); + else + snprintf(n.message, sizeof(n.message), + "sensor %s received event: %s, value not provided", + n.type_instance, event_state); + + DEBUG("Threshold event received for sensor %s", n.type_instance); + + sstrncpy(n.host, hostname_g, sizeof(n.host)); + sstrncpy(n.type, ipmi_sensor_get_sensor_type_string(sensor), sizeof(n.type)); + n.severity = sensor_convert_threshold_severity(threshold); + n.time = NS_TO_CDTIME_T(ipmi_event_get_timestamp(event)); + + plugin_notification_meta_add_string(&n, "severity", + ipmi_get_threshold_string(threshold)); + plugin_notification_meta_add_string(&n, "direction", + ipmi_get_value_dir_string(high_low)); + + switch (value_present) { + case IPMI_BOTH_VALUES_PRESENT: + plugin_notification_meta_add_double(&n, "val", value); + /* both values present, so fall-through to add raw value too */ + case IPMI_RAW_VALUE_PRESENT: { + char buf[DATA_MAX_NAME_LEN] = {0}; + snprintf(buf, sizeof(buf), "0x%2.2x", raw_value); + plugin_notification_meta_add_string(&n, "raw", buf); + } break; + default: + break; + } /* switch (value_present) */ + + add_event_common_data(&n, sensor, dir, event); + + plugin_dispatch_notification(&n); + plugin_notification_meta_free(n.meta); + + /* Delete handled ipmi event from the list */ + if (c_ipmi_sel_clear_event) { + ipmi_event_delete(event, NULL, NULL); + return IPMI_EVENT_HANDLED; + } + + return IPMI_EVENT_NOT_HANDLED; +} /* int sensor_threshold_event_handler */ + +static int sensor_discrete_event_handler(ipmi_sensor_t *sensor, + enum ipmi_event_dir_e dir, int offset, + int severity, int prev_severity, + void *cb_data, ipmi_event_t *event) { + /* From the IPMI specification Chapter 2: Events. + * If a callback handles the event, then all future callbacks called due to + * the event will receive a NULL for the event. So be ready to handle a NULL + * event in all your event handlers. A NULL may also be passed to an event + * handler if the callback was not due to an event. */ + if (event == NULL) + return IPMI_EVENT_NOT_HANDLED; + + notification_t n = {NOTIF_OKAY, cdtime(), "", "", "ipmi", "", "", "", NULL}; + unsigned int event_type = ipmi_sensor_get_event_reading_type(sensor); + unsigned int sensor_type = ipmi_sensor_get_sensor_type(sensor); + const char *event_state = + ipmi_get_reading_name(event_type, sensor_type, offset); + sensor_get_name(sensor, n.type_instance, sizeof(n.type_instance)); + snprintf(n.message, sizeof(n.message), "sensor %s received event: %s", + n.type_instance, event_state); + + DEBUG("Discrete event received for sensor %s", n.type_instance); + + sstrncpy(n.host, hostname_g, sizeof(n.host)); + sstrncpy(n.type, ipmi_sensor_get_sensor_type_string(sensor), sizeof(n.type)); + n.time = NS_TO_CDTIME_T(ipmi_event_get_timestamp(event)); + + plugin_notification_meta_add_signed_int(&n, "offset", offset); + + if (severity != -1) + plugin_notification_meta_add_signed_int(&n, "severity", severity); + + if (prev_severity != -1) + plugin_notification_meta_add_signed_int(&n, "prevseverity", prev_severity); + + add_event_common_data(&n, sensor, dir, event); + + plugin_dispatch_notification(&n); + plugin_notification_meta_free(n.meta); + + /* Delete handled ipmi event from the list */ + if (c_ipmi_sel_clear_event) { + ipmi_event_delete(event, NULL, NULL); + return IPMI_EVENT_HANDLED; + } + + return IPMI_EVENT_NOT_HANDLED; +} /* int sensor_discrete_event_handler */ + /* * Entity handlers */ @@ -431,8 +601,39 @@ static void entity_sensor_update_handler( if ((op == IPMI_ADDED) || (op == IPMI_CHANGED)) { /* Will check for duplicate entries.. */ sensor_list_add(sensor); + + if (c_ipmi_sel_enabled) { + int status = 0; + /* register threshold event if threshold sensor support events */ + if ((ipmi_sensor_get_event_reading_type(sensor) == + IPMI_EVENT_READING_TYPE_THRESHOLD) && + (ipmi_sensor_get_threshold_access(sensor) != + IPMI_THRESHOLD_ACCESS_SUPPORT_NONE)) + status = ipmi_sensor_add_threshold_event_handler( + sensor, sensor_threshold_event_handler, NULL); + /* register discrete handler if discrete/specific sensor support events */ + else if (ipmi_sensor_get_event_support(sensor) != IPMI_EVENT_SUPPORT_NONE) + status = ipmi_sensor_add_discrete_event_handler( + sensor, sensor_discrete_event_handler, NULL); + + if (status) { + char buf[DATA_MAX_NAME_LEN] = {0}; + sensor_get_name(sensor, buf, sizeof(buf)); + ERROR("Unable to add sensor %s event handler, status: %d", buf, status); + } + } } else if (op == IPMI_DELETED) { sensor_list_remove(sensor); + + if (c_ipmi_sel_enabled) { + if (ipmi_sensor_get_event_reading_type(sensor) == + IPMI_EVENT_READING_TYPE_THRESHOLD) + ipmi_sensor_remove_threshold_event_handler( + sensor, sensor_threshold_event_handler, NULL); + else + ipmi_sensor_remove_discrete_event_handler( + sensor, sensor_discrete_event_handler, NULL); + } } } /* void entity_sensor_update_handler */ @@ -459,6 +660,23 @@ static void domain_entity_update_handler( } } /* void domain_entity_update_handler */ +static void smi_event_handler(ipmi_con_t __attribute__((unused)) * ipmi, + const ipmi_addr_t __attribute__((unused)) * addr, + unsigned int __attribute__((unused)) addr_len, + ipmi_event_t *event, void *cb_data) { + unsigned int type = ipmi_event_get_type(event); + ipmi_domain_t *domain = cb_data; + + DEBUG("%s: Event received: type %u", __FUNCTION__, type); + + if (type != 0x02) + /* It's not a standard IPMI event. */ + return; + + /* force domain to reread SELs */ + ipmi_domain_reread_sels(domain, NULL, NULL); +} + static void domain_connection_change_handler(ipmi_domain_t *domain, int err, unsigned int conn_num, unsigned int port_num, @@ -476,6 +694,13 @@ static void domain_connection_change_handler(ipmi_domain_t *domain, int err, if (status != 0) { c_ipmi_error("ipmi_domain_add_entity_update_handler", status); } + + ipmi_con_t *smi_connection = user_data; + status = smi_connection->add_event_handler(smi_connection, smi_event_handler, + (void *)domain); + + if (status != 0) + c_ipmi_error("Failed to register smi event handler", status); } /* void domain_connection_change_handler */ static int thread_init(os_handler_t **ret_os_handler) { @@ -504,7 +729,8 @@ static int thread_init(os_handler_t **ret_os_handler) { status = ipmi_open_domain( "mydomain", &smi_connection, /* num_con = */ 1, - domain_connection_change_handler, /* user data = */ NULL, + domain_connection_change_handler, + /* user data = */ (void *)smi_connection, /* domain_fully_up_handler = */ NULL, /* user data = */ NULL, open_option, sizeof(open_option) / sizeof(open_option[0]), &domain_id); if (status != 0) { @@ -545,19 +771,17 @@ static int c_ipmi_config(const char *key, const char *value) { if (strcasecmp("Sensor", key) == 0) { ignorelist_add(ignorelist, value); } else if (strcasecmp("IgnoreSelected", key) == 0) { - int invert = 1; - if (IS_TRUE(value)) - invert = 0; - ignorelist_set_invert(ignorelist, invert); + ignorelist_set_invert(ignorelist, !IS_TRUE(value)); } else if (strcasecmp("NotifySensorAdd", key) == 0) { - if (IS_TRUE(value)) - c_ipmi_nofiy_add = 1; + c_ipmi_notify_add = IS_TRUE(value); } else if (strcasecmp("NotifySensorRemove", key) == 0) { - if (IS_TRUE(value)) - c_ipmi_nofiy_remove = 1; + c_ipmi_notify_remove = IS_TRUE(value); } else if (strcasecmp("NotifySensorNotPresent", key) == 0) { - if (IS_TRUE(value)) - c_ipmi_nofiy_notpresent = 1; + c_ipmi_notify_notpresent = IS_TRUE(value); + } else if (strcasecmp("SELEnabled", key) == 0) { + c_ipmi_sel_enabled = IS_TRUE(value); + } else if (strcasecmp("SELClearEvent", key) == 0) { + c_ipmi_sel_clear_event = IS_TRUE(value); } else { return -1; }