ipmi_sensor_id_t sensor_id;
char sensor_name[DATA_MAX_NAME_LEN];
char sensor_type[DATA_MAX_NAME_LEN];
+ char type_instance[DATA_MAX_NAME_LEN];
int sensor_not_present;
c_ipmi_sensor_list_t *next;
c_ipmi_instance_t *instance;
unsigned int use;
};
+struct c_ipmi_db_type_map_s {
+ enum ipmi_unit_type_e type;
+ const char *type_name;
+};
+typedef struct c_ipmi_db_type_map_s c_ipmi_db_type_map_t;
+
/*
* Module global variables
*/
-static os_handler_t *os_handler;
+static os_handler_t *os_handler = NULL;
static c_ipmi_instance_t *instances = NULL;
/*
#if COLLECT_DEBUG
case IPMI_LOG_DEBUG_START:
case IPMI_LOG_DEBUG:
- fprintf(stderr, "ipmi plugin: %s\n", msg);
+ DEBUG("ipmi plugin: %s", msg);
break;
case IPMI_LOG_DEBUG_CONT:
case IPMI_LOG_DEBUG_END:
- fprintf(stderr, "%s\n", msg);
+ DEBUG("%s", msg);
break;
#else
case IPMI_LOG_DEBUG_START:
}
} /* void c_ipmi_log */
+static notification_t c_ipmi_notification_init(c_ipmi_instance_t const *st,
+ int severity) {
+ notification_t n = {severity, cdtime(), "", "", "ipmi", "", "", "", NULL};
+
+ sstrncpy(n.host, (st->host != NULL) ? st->host : hostname_g, sizeof(n.host));
+ return n;
+} /* notification_t c_ipmi_notification_init */
+
/*
* Sensor handlers
*/
void *user_data) {
value_list_t vl = VALUE_LIST_INIT;
- c_ipmi_sensor_list_t *list_item = (c_ipmi_sensor_list_t *)user_data;
+ c_ipmi_sensor_list_t *list_item = user_data;
c_ipmi_instance_t *st = list_item->instance;
list_item->use--;
list_item->sensor_name, st->name);
if (st->notify_notpresent) {
- notification_t n = {
- NOTIF_WARNING, cdtime(), "", "", "ipmi", "", "", "", NULL};
+ notification_t n = c_ipmi_notification_init(st, NOTIF_WARNING);
- sstrncpy(n.host, (st->host != NULL) ? st->host : hostname_g,
- sizeof(n.host));
- sstrncpy(n.type_instance, list_item->sensor_name,
+ sstrncpy(n.type_instance, list_item->type_instance,
sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
snprintf(n.message, sizeof(n.message), "sensor %s not present",
list_item->sensor_name, st->name);
if (st->notify_notpresent) {
- notification_t n = {NOTIF_OKAY, cdtime(), "", "", "ipmi",
- "", "", "", NULL};
+ notification_t n = c_ipmi_notification_init(st, NOTIF_OKAY);
- sstrncpy(n.host, (st->host != NULL) ? st->host : hostname_g,
- sizeof(n.host));
- sstrncpy(n.type_instance, list_item->sensor_name,
+ sstrncpy(n.type_instance, list_item->type_instance,
sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
snprintf(n.message, sizeof(n.message), "sensor %s present",
sstrncpy(vl.host, st->host, sizeof(vl.host));
sstrncpy(vl.plugin, "ipmi", sizeof(vl.plugin));
sstrncpy(vl.type, list_item->sensor_type, sizeof(vl.type));
- sstrncpy(vl.type_instance, list_item->sensor_name, sizeof(vl.type_instance));
+ sstrncpy(vl.type_instance, list_item->type_instance,
+ sizeof(vl.type_instance));
plugin_dispatch_values(&vl);
} /* void sensor_read_handler */
sstrncpy(buffer, sensor_name, buf_len);
}
+static const char *sensor_unit_to_type(ipmi_sensor_t *sensor) {
+ static const c_ipmi_db_type_map_t ipmi_db_type_map[] = {
+ {IPMI_UNIT_TYPE_WATTS, "power"}, {IPMI_UNIT_TYPE_CFM, "flow"}};
+
+ /* check the modifier and rate of the sensor value */
+ if ((ipmi_sensor_get_modifier_unit_use(sensor) != IPMI_MODIFIER_UNIT_NONE) ||
+ (ipmi_sensor_get_rate_unit(sensor) != IPMI_RATE_UNIT_NONE))
+ return NULL;
+
+ /* find the db type by using sensor base unit type */
+ enum ipmi_unit_type_e ipmi_type = ipmi_sensor_get_base_unit(sensor);
+ for (int i = 0; i < STATIC_ARRAY_SIZE(ipmi_db_type_map); i++)
+ if (ipmi_db_type_map[i].type == ipmi_type)
+ return ipmi_db_type_map[i].type_name;
+
+ return NULL;
+} /* const char* sensor_unit_to_type */
+
static int sensor_list_add(c_ipmi_instance_t *st, ipmi_sensor_t *sensor) {
ipmi_sensor_id_t sensor_id;
c_ipmi_sensor_list_t *list_item;
*
* ipmi_sensor_id_get_reading() supports only 'Threshold' sensors.
* See lib/sensor.c:4842, stand_ipmi_sensor_get_reading() for details.
- */
+ */
if (!ipmi_sensor_get_is_readable(sensor)) {
INFO("ipmi plugin: sensor_list_add: Ignore sensor `%s` of `%s`, "
- "because it don't readable! Its type: (%#x, %s). ",
+ "because it isn't readable! Its type: (%#x, %s). ",
sensor_name_ptr, st->name, sensor_type,
ipmi_sensor_get_sensor_type_string(sensor));
return -1;
type = "fanspeed";
break;
+ case IPMI_SENSOR_TYPE_MEMORY:
+ type = "memory";
+ break;
+
default: {
+ /* try to get collectd DB type based on sensor base unit type */
+ if ((type = sensor_unit_to_type(sensor)) != NULL)
+ break;
+
INFO("ipmi plugin: sensor_list_add: Ignore sensor `%s` of `%s`, "
- "because I don't know how to handle its type (%#x, %s). "
- "If you need this sensor, please file a bug report.",
- sensor_name_ptr, st->name, sensor_type,
+ "because I don't know how to handle its units (%#x, %#x, %#x). "
+ "Sensor type: (%#x, %s). If you need this sensor, please file "
+ "a bug report at http://collectd.org/.",
+ sensor_name_ptr, st->name, ipmi_sensor_get_base_unit(sensor),
+ ipmi_sensor_get_modifier_unit(sensor),
+ ipmi_sensor_get_rate_unit(sensor), sensor_type,
ipmi_sensor_get_sensor_type_string(sensor));
return -1;
}
else
st->sensor_list = list_item;
+ /* if sensor provides the percentage value, use "percent" collectd type
+ and add the `percent` to the type instance of the reported value */
+ if (ipmi_sensor_get_percentage(sensor)) {
+ snprintf(list_item->type_instance, sizeof(list_item->type_instance),
+ "percent-%s", sensor_name_ptr);
+ type = "percent";
+ } else {
+ /* use type instance as a name of the sensor */
+ sstrncpy(list_item->type_instance, sensor_name_ptr,
+ sizeof(list_item->type_instance));
+ }
+
sstrncpy(list_item->sensor_name, sensor_name_ptr,
sizeof(list_item->sensor_name));
sstrncpy(list_item->sensor_type, type, sizeof(list_item->sensor_type));
pthread_mutex_unlock(&st->sensor_list_lock);
if (st->notify_add && (st->init_in_progress == 0)) {
- notification_t n = {NOTIF_OKAY, cdtime(), "", "", "ipmi", "", "", "", NULL};
+ notification_t n = c_ipmi_notification_init(st, NOTIF_OKAY);
- sstrncpy(n.host, (st->host != NULL) ? st->host : hostname_g,
- sizeof(n.host));
- sstrncpy(n.type_instance, list_item->sensor_name, sizeof(n.type_instance));
+ sstrncpy(n.type_instance, list_item->type_instance,
+ sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
snprintf(n.message, sizeof(n.message), "sensor %s added",
list_item->sensor_name);
pthread_mutex_unlock(&st->sensor_list_lock);
if (st->notify_remove && st->active) {
- notification_t n = {NOTIF_WARNING, cdtime(), "", "", "ipmi", "", "", "",
- NULL};
+ notification_t n = c_ipmi_notification_init(st, NOTIF_WARNING);
- sstrncpy(n.host, (st->host != NULL) ? st->host : hostname_g,
- sizeof(n.host));
- sstrncpy(n.type_instance, list_item->sensor_name, sizeof(n.type_instance));
+ sstrncpy(n.type_instance, list_item->type_instance,
+ sizeof(n.type_instance));
sstrncpy(n.type, list_item->sensor_type, sizeof(n.type));
snprintf(n.message, sizeof(n.message), "sensor %s removed",
list_item->sensor_name);
enum ipmi_value_present_e value_present, unsigned int raw_value,
double value, void *cb_data, ipmi_event_t *event) {
- c_ipmi_instance_t *st = (c_ipmi_instance_t *)cb_data;
+ c_ipmi_instance_t *st = cb_data;
/* From the IPMI specification Chapter 2: Events.
* If a callback handles the event, then all future callbacks called due to
if (event == NULL)
return IPMI_EVENT_NOT_HANDLED;
+ notification_t n = c_ipmi_notification_init(st, NOTIF_OKAY);
/* 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);
DEBUG("Threshold event received for sensor %s", n.type_instance);
- sstrncpy(n.host, (st->host != NULL) ? st->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));
int severity, int prev_severity,
void *cb_data, ipmi_event_t *event) {
- c_ipmi_instance_t *st = (c_ipmi_instance_t *)cb_data;
+ c_ipmi_instance_t *st = cb_data;
/* From the IPMI specification Chapter 2: Events.
* If a callback handles the event, then all future callbacks called due to
if (event == NULL)
return IPMI_EVENT_NOT_HANDLED;
- notification_t n = {NOTIF_OKAY, cdtime(), "", "", "ipmi", "", "", "", NULL};
+ notification_t n = c_ipmi_notification_init(st, NOTIF_OKAY);
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 =
DEBUG("Discrete event received for sensor %s", n.type_instance);
- sstrncpy(n.host, (st->host != NULL) ? st->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));
entity_sensor_update_handler(enum ipmi_update_e op,
ipmi_entity_t __attribute__((unused)) * entity,
ipmi_sensor_t *sensor, void *user_data) {
- c_ipmi_instance_t *st = (c_ipmi_instance_t *)user_data;
+ c_ipmi_instance_t *st = user_data;
if ((op == IPMI_ADDED) || (op == IPMI_CHANGED)) {
/* Will check for duplicate entries.. */
ipmi_domain_t __attribute__((unused)) * domain,
ipmi_entity_t *entity, void *user_data) {
int status;
- c_ipmi_instance_t *st = (c_ipmi_instance_t *)user_data;
+ c_ipmi_instance_t *st = user_data;
if (op == IPMI_ADDED) {
status = ipmi_entity_add_sensor_update_handler(
"user_data = %p);",
(void *)domain, err, conn_num, port_num, still_connected, user_data);
- c_ipmi_instance_t *st = (c_ipmi_instance_t *)user_data;
+ c_ipmi_instance_t *st = user_data;
if (err != 0)
c_ipmi_error(st, "domain_connection_change_handler", err);
if (!still_connected) {
if (st->notify_conn && st->connected && st->init_in_progress == 0) {
- notification_t n = {NOTIF_FAILURE, cdtime(), "", "", "ipmi", "", "", "",
- NULL};
+ notification_t n = c_ipmi_notification_init(st, NOTIF_FAILURE);
- sstrncpy(n.host, (st->host != NULL) ? st->host : hostname_g,
- sizeof(n.host));
sstrncpy(n.message, "IPMI connection lost", sizeof(n.plugin));
plugin_dispatch_notification(&n);
}
if (st->notify_conn && !st->connected && st->init_in_progress == 0) {
- notification_t n = {NOTIF_OKAY, cdtime(), "", "", "ipmi", "", "", "", NULL};
+ notification_t n = c_ipmi_notification_init(st, NOTIF_OKAY);
- sstrncpy(n.host, (st->host != NULL) ? st->host : hostname_g,
- sizeof(n.host));
sstrncpy(n.message, "IPMI connection restored", sizeof(n.plugin));
plugin_dispatch_notification(&n);
int status;
if (st->connaddr != NULL) {
- char *ip_addrs[1] = {NULL}, *ports[1] = {NULL};
-
- ip_addrs[0] = strdup(st->connaddr);
- ports[0] = strdup(IPMI_LAN_STD_PORT_STR);
-
- status = ipmi_ip_setup_con(ip_addrs, ports, 1, st->authtype,
- (unsigned int)IPMI_PRIVILEGE_USER, st->username,
- strlen(st->username), st->password,
- strlen(st->password), os_handler,
- /* user data = */ NULL, &st->connection);
+ status = ipmi_ip_setup_con(
+ &st->connaddr, &(char *){IPMI_LAN_STD_PORT_STR}, 1, st->authtype,
+ (unsigned int)IPMI_PRIVILEGE_USER, st->username, strlen(st->username),
+ st->password, strlen(st->password), os_handler,
+ /* user data = */ NULL, &st->connection);
if (status != 0) {
c_ipmi_error(st, "ipmi_ip_setup_con", status);
return -1;
}
}
- size_t open_option_num = 0;
- ipmi_open_option_t open_option[2];
-
- open_option[open_option_num].option = IPMI_OPEN_OPTION_ALL;
- open_option[open_option_num].ival = 1;
- open_option_num++;
-
+ ipmi_open_option_t opts[] = {
+ {.option = IPMI_OPEN_OPTION_ALL, {.ival = 1}},
#ifdef IPMI_OPEN_OPTION_USE_CACHE
- // This option appeared in OpenIPMI-2.0.17
- open_option[open_option_num].option = IPMI_OPEN_OPTION_USE_CACHE;
- open_option[open_option_num].ival = 0; /* Disable SDR cache in local file */
- open_option_num++;
+ /* OpenIPMI-2.0.17 and later: Disable SDR cache in local file */
+ {.option = IPMI_OPEN_OPTION_USE_CACHE, {.ival = 0}},
#endif
+ };
/*
* NOTE: Domain names must be unique. There is static `domains_list` common
status = ipmi_open_domain(
st->name, &st->connection, /* num_con = */ 1,
domain_connection_change_handler, /* user data = */ (void *)st,
- /* domain_fully_up_handler = */ NULL, /* user data = */ NULL, open_option,
- open_option_num, &domain_id);
+ /* domain_fully_up_handler = */ NULL, /* user data = */ NULL, opts,
+ STATIC_ARRAY_SIZE(opts), &domain_id);
if (status != 0) {
c_ipmi_error(st, "ipmi_open_domain", status);
return -1;
} /* int c_ipmi_thread_init */
static void *c_ipmi_thread_main(void *user_data) {
- c_ipmi_instance_t *st = (c_ipmi_instance_t *)user_data;
+ c_ipmi_instance_t *st = user_data;
int status = c_ipmi_thread_init(st);
if (status != 0) {
status = cf_util_get_boolean(child, &t);
if (status != 0)
break;
- if (t)
- ignorelist_set_invert(st->ignorelist, /* invert = */ 0);
- else
- ignorelist_set_invert(st->ignorelist, /* invert = */ 1);
+ ignorelist_set_invert(st->ignorelist, /* invert = */ !t);
} else if (strcasecmp("NotifyIPMIConnectionState", child->key) == 0) {
status = cf_util_get_boolean(child, &st->notify_conn);
} else if (strcasecmp("NotifySensorAdd", child->key) == 0) {
/* Non-instance option: Assume legacy configuration (without <Instance />
* blocks) and call c_ipmi_config_add_instance with the <Plugin /> block.
*/
+ WARNING("ipmi plugin: Legacy configuration found! Please update your "
+ "config file.");
return c_ipmi_config_add_instance(ci);
- } else
+ } else {
WARNING("ipmi plugin: The configuration option "
"\"%s\" is not allowed here. Did you "
"forget to add an <Instance /> block "
"around the configuration?",
child->key);
+ return -1;
+ }
} /* for (ci->children) */
return 0;
static int c_ipmi_read(user_data_t *user_data) {
c_ipmi_instance_t *st = user_data->data;
- if ((st->active == 0) || (st->thread_id == (pthread_t)0)) {
+ if (st->active == 0) {
INFO("ipmi plugin: c_ipmi_read: I'm not active, returning false.");
return -1;
}
} /* int c_ipmi_read */
static int c_ipmi_init(void) {
- int status;
c_ipmi_instance_t *st;
char callback_name[3 * DATA_MAX_NAME_LEN];
+ if (os_handler != NULL) {
+ return 0;
+ }
+
os_handler = ipmi_posix_thread_setup_os_handler(SIGIO);
if (os_handler == NULL) {
ERROR("ipmi plugin: ipmi_posix_thread_setup_os_handler failed.");
return -1;
};
- /* Don't send `ADD' notifications during startup (~ 1 minute) */
- time_t iv = CDTIME_T_TO_TIME_T(plugin_get_interval());
-
if (instances == NULL) {
/* No instances were configured, let's start a default instance. */
st = c_ipmi_init_instance();
c_ipmi_add_instance(st);
}
+ /* Don't send `ADD' notifications during startup (~ 1 minute) */
+ int cycles = 1 + (60 / CDTIME_T_TO_TIME_T(plugin_get_interval()));
+
st = instances;
while (NULL != st) {
/* The `st->name` is used as "domain name" for ipmi_open_domain().
.data = st,
};
- status = plugin_register_complex_read(
+ int status = plugin_register_complex_read(
/* group = */ "ipmi",
/* name = */ callback_name,
/* callback = */ c_ipmi_read,
/* user_data = */ &ud);
if (status != 0) {
- st->active = 0;
st = st->next;
continue;
}
- st->init_in_progress = 1 + (60 / iv);
+ st->init_in_progress = cycles;
st->active = 1;
status = plugin_thread_create(&st->thread_id, /* attr = */ NULL,
if (status != 0) {
st->active = 0;
- st->thread_id = (pthread_t)0;
+ st->thread_id = (pthread_t){0};
plugin_unregister_read(callback_name);
st->next = NULL;
st->active = 0;
- if (st->thread_id != (pthread_t)0) {
+ if (!pthread_equal(st->thread_id, (pthread_t){0})) {
pthread_join(st->thread_id, NULL);
- st->thread_id = (pthread_t)0;
+ st->thread_id = (pthread_t){0};
}
sensor_list_remove_all(st);
}
os_handler->free_os_handler(os_handler);
+ os_handler = NULL;
return 0;
} /* int c_ipmi_shutdown */