X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fsensors.c;h=0968e311fb170c63ba8c01727ed8ea7e423bf733;hb=ebdc9011b75c4c1478fbe02eb1cb9c69795288f9;hp=9cf0858ffeeff3c65b754c42896b325cdb85eeaa;hpb=2443213945a132eca96a0684137fe56538e206b7;p=collectd.git diff --git a/src/sensors.c b/src/sensors.c index 9cf0858f..0968e311 100644 --- a/src/sensors.c +++ b/src/sensors.c @@ -1,11 +1,10 @@ /** * collectd - src/sensors.c - * Copyright (C) 2005,2006 Florian octo Forster + * Copyright (C) 2005-2008 Florian octo Forster * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the - * Free Software Foundation; either version 2 of the License, or (at your - * option) any later version. + * Free Software Foundation; only version 2 of the License is applicable. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of @@ -34,74 +33,43 @@ #include "plugin.h" #include "configfile.h" #include "utils_ignorelist.h" -#include "utils_debug.h" - -#define MODULE_NAME "sensors" -#define MODULE_NAME_VOLTAGE MODULE_NAME"_voltage" #if defined(HAVE_SENSORS_SENSORS_H) # include -#else -# undef HAVE_LIBSENSORS #endif -#if defined(HAVE_LIBSENSORS) -# define SENSORS_HAVE_READ 1 -#else -# define SENSORS_HAVE_READ 0 +#if !defined(SENSORS_API_VERSION) +# define SENSORS_API_VERSION 0x000 #endif -#define BUFSIZE 512 - -/* temperature and fan sensors */ -static char *ds_def[] = -{ - "DS:value:GAUGE:"COLLECTD_HEARTBEAT":U:U", - NULL -}; -static int ds_num = 1; - -/* voltage sensors */ -static char *sensor_voltage_ds_def[] = -{ - "DS:voltage:GAUGE:"COLLECTD_HEARTBEAT":U:U", - NULL -}; -static int sensor_voltage_ds_num = 1; - -/* old naming */ -static char *old_filename_format = "sensors-%s.rrd"; -/* end old naming */ - -/* new naming default is to create chip-feature - * 1 => use new naming scheme chip-bus-address/type-feature - */ -static int sensor_extended_naming = 0; - -#if SENSORS_HAVE_READ +#if SENSORS_API_VERSION < 0x400 typedef struct featurelist { const sensors_chip_name *chip; @@ -187,10 +144,82 @@ typedef struct featurelist struct featurelist *next; } featurelist_t; +# ifndef SENSORS_CONF_PATH +# define SENSORS_CONF_PATH "/etc/sensors.conf" +# endif +/* #endif SENSORS_API_VERSION < 0x400 */ + +#elif (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) +typedef struct featurelist +{ + const sensors_chip_name *chip; + const sensors_feature *feature; + const sensors_subfeature *subfeature; + struct featurelist *next; +} featurelist_t; + +# ifndef SENSORS_CONF_PATH +# define SENSORS_CONF_PATH "/etc/sensors3.conf" +# endif +/* #endif (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) */ + +#else /* if SENSORS_API_VERSION >= 0x500 */ +# error "This version of libsensors is not supported yet. Please report this " \ + "as bug." +#endif + +static const char *conffile = SENSORS_CONF_PATH; featurelist_t *first_feature = NULL; -#endif /* if SENSORS_HAVE_READ */ +static ignorelist_t *sensor_list; +static time_t sensors_config_mtime = 0; -static int sensors_config (char *key, char *value) +#if SENSORS_API_VERSION < 0x400 +/* full chip name logic borrowed from lm_sensors */ +static int sensors_snprintf_chip_name (char *buf, size_t buf_size, + const sensors_chip_name *chip) +{ + int status = -1; + + if (chip->bus == SENSORS_CHIP_NAME_BUS_ISA) + { + status = snprintf (buf, buf_size, + "%s-isa-%04x", + chip->prefix, + chip->addr); + } + else if (chip->bus == SENSORS_CHIP_NAME_BUS_DUMMY) + { + status = snprintf (buf, buf_size, "%s-%s-%04x", + chip->prefix, + chip->busname, + chip->addr); + } + else + { + status = snprintf (buf, buf_size, "%s-i2c-%d-%02x", + chip->prefix, + chip->bus, + chip->addr); + } + + return (status); +} /* int sensors_snprintf_chip_name */ + +static int sensors_feature_name_to_type (const char *name) +{ + int i; + + /* Yes, this is slow, but it's only ever done during initialization, so + * it's a one time cost.. */ + for (i = 0; i < known_features_num; i++) + if (strcasecmp (known_features[i].label, name) == 0) + return (known_features[i].type); + + return (SENSOR_TYPE_UNKNOWN); +} /* int sensors_feature_name_to_type */ +#endif + +static int sensors_config (const char *key, const char *value) { if (sensor_list == NULL) sensor_list = ignorelist_create (1); @@ -199,7 +228,8 @@ static int sensors_config (char *key, char *value) { if (ignorelist_add (sensor_list, value)) { - syslog (LOG_EMERG, "Cannot add value to ignorelist."); + ERROR ("sensors plugin: " + "Cannot add value to ignorelist."); return (1); } } @@ -211,15 +241,6 @@ static int sensors_config (char *key, char *value) || (strcasecmp (value, "On") == 0)) ignorelist_set_invert (sensor_list, 0); } - else if (strcasecmp (key, "ExtendedSensorNaming") == 0) - { - if ((strcasecmp (value, "True") == 0) - || (strcasecmp (value, "Yes") == 0) - || (strcasecmp (value, "On") == 0)) - sensor_extended_naming = 1; - else - sensor_extended_naming = 0; - } else { return (-1); @@ -228,272 +249,352 @@ static int sensors_config (char *key, char *value) return (0); } -static void collectd_sensors_init (void) +void sensors_free_features (void) +{ + featurelist_t *thisft; + featurelist_t *nextft; + + if (first_feature == NULL) + return; + + sensors_cleanup (); + + for (thisft = first_feature; thisft != NULL; thisft = nextft) + { + nextft = thisft->next; + sfree (thisft); + } + first_feature = NULL; +} + +static int sensors_load_conf (void) { -#if SENSORS_HAVE_READ FILE *fh; featurelist_t *last_feature = NULL; - featurelist_t *new_feature; const sensors_chip_name *chip; int chip_num; - const sensors_feature_data *data; - int data_num0, data_num1; + struct stat statbuf; + int status; - new_feature = first_feature; - while (new_feature != NULL) + status = stat (conffile, &statbuf); + if (status != 0) { - last_feature = new_feature->next; - free (new_feature); - new_feature = last_feature; + char errbuf[1024]; + ERROR ("sensors plugin: stat (%s) failed: %s", conffile, + sstrerror (errno, errbuf, sizeof (errbuf))); + sensors_config_mtime = 0; } -#ifdef assert - assert (new_feature == NULL); - assert (last_feature == NULL); -#endif + if ((sensors_config_mtime != 0) + && (sensors_config_mtime == statbuf.st_mtime)) + return (0); - if ((fh = fopen ("/etc/sensors.conf", "r")) == NULL) - return; + if (sensors_config_mtime != 0) + { + NOTICE ("sensors plugin: Reloading config from %s", + conffile); + sensors_free_features (); + sensors_config_mtime = 0; + } - if (sensors_init (fh)) + fh = fopen (conffile, "r"); + if (fh == NULL) { - fclose (fh); - syslog (LOG_ERR, "sensors: Cannot initialize sensors. " - "Data will not be collected."); - return; + char errbuf[1024]; + ERROR ("sensors plugin: fopen(%s) failed: %s", conffile, + sstrerror (errno, errbuf, sizeof (errbuf))); + return (-1); } + status = sensors_init (fh); fclose (fh); + if (status != 0) + { + ERROR ("sensors plugin: Cannot initialize sensors. " + "Data will not be collected."); + return (-1); + } + + sensors_config_mtime = statbuf.st_mtime; +#if SENSORS_API_VERSION < 0x400 chip_num = 0; while ((chip = sensors_get_detected_chips (&chip_num)) != NULL) { - data = NULL; - data_num0 = data_num1 = 0; + int feature_num0 = 0; + int feature_num1 = 0; - while ((data = sensors_get_all_features (*chip, &data_num0, &data_num1)) - != NULL) + while (42) { - int i; + const sensors_feature_data *feature; + int feature_type; + featurelist_t *fl; + + feature = sensors_get_all_features (*chip, + &feature_num0, &feature_num1); + + /* Check if all features have been read. */ + if (feature == NULL) + break; /* "master features" only */ - if (data->mapping != SENSORS_NO_MAPPING) + if (feature->mapping != SENSORS_NO_MAPPING) + { + DEBUG ("sensors plugin: sensors_load_conf: " + "Ignoring subfeature `%s', " + "because (feature->mapping " + "!= SENSORS_NO_MAPPING).", + feature->name); continue; + } - /* Only known features */ - for (i = 0; known_features[i].type >= 0; i++) + /* skip ignored in sensors.conf */ + if (sensors_get_ignored (*chip, feature->number) == 0) { - if (strcmp (data->name, known_features[i].label) != 0) - continue; + DEBUG ("sensors plugin: sensors_load_conf: " + "Ignoring subfeature `%s', " + "because " + "`sensors_get_ignored' told " + "me so.", + feature->name); + continue; + } + + feature_type = sensors_feature_name_to_type ( + feature->name); + if (feature_type == SENSOR_TYPE_UNKNOWN) + { + DEBUG ("sensors plugin: sensors_load_conf: " + "Ignoring subfeature `%s', " + "because its type is " + "unknown.", + feature->name); + continue; + } - /* skip ignored in sensors.conf */ - if (sensors_get_ignored (*chip, data->number) == 0) - break; + fl = (featurelist_t *) malloc (sizeof (featurelist_t)); + if (fl == NULL) + { + ERROR ("sensors plugin: malloc failed."); + continue; + } + memset (fl, '\0', sizeof (featurelist_t)); - DBG ("Adding feature: %s-%s-%s", - chip->prefix, - sensor_type_prefix[known_features[i].type], - data->name); + fl->chip = chip; + fl->data = feature; + fl->type = feature_type; - if ((new_feature = (featurelist_t *) malloc (sizeof (featurelist_t))) == NULL) + if (first_feature == NULL) + first_feature = fl; + else + last_feature->next = fl; + last_feature = fl; + } /* while sensors_get_all_features */ + } /* while sensors_get_detected_chips */ +/* #endif SENSORS_API_VERSION < 0x400 */ + +#elif (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) + chip_num = 0; + while ((chip = sensors_get_detected_chips (NULL, &chip_num)) != NULL) + { + const sensors_feature *feature; + int feature_num = 0; + + while ((feature = sensors_get_features (chip, &feature_num)) != NULL) + { + const sensors_subfeature *subfeature; + int subfeature_num = 0; + + /* Only handle voltage, fanspeeds and temperatures */ + if ((feature->type != SENSORS_FEATURE_IN) + && (feature->type != SENSORS_FEATURE_FAN) + && (feature->type != SENSORS_FEATURE_TEMP)) + { + DEBUG ("sensors plugin: sensors_load_conf: " + "Ignoring feature `%s', " + "because its type is not " + "supported.", feature->name); + continue; + } + + while ((subfeature = sensors_get_all_subfeatures (chip, + feature, &subfeature_num)) != NULL) + { + featurelist_t *fl; + + if ((subfeature->type != SENSORS_SUBFEATURE_IN_INPUT) + && (subfeature->type != SENSORS_SUBFEATURE_FAN_INPUT) + && (subfeature->type != SENSORS_SUBFEATURE_TEMP_INPUT)) + continue; + + fl = (featurelist_t *) malloc (sizeof (featurelist_t)); + if (fl == NULL) { - DBG ("sensors plugin: malloc: %s", - strerror (errno)); - syslog (LOG_ERR, "sensors plugin: malloc: %s", - strerror (errno)); - break; + ERROR ("sensors plugin: malloc failed."); + continue; } + memset (fl, '\0', sizeof (featurelist_t)); - new_feature->chip = chip; - new_feature->data = data; - new_feature->type = known_features[i].type; - new_feature->next = NULL; + fl->chip = chip; + fl->feature = feature; + fl->subfeature = subfeature; if (first_feature == NULL) - { - first_feature = new_feature; - last_feature = new_feature; - } + first_feature = fl; else - { - last_feature->next = new_feature; - last_feature = new_feature; - } - - /* stop searching known features at first found */ - break; - } /* for i */ - } /* while sensors_get_all_features */ - } /* while sensors_get_detected_chips */ + last_feature->next = fl; + last_feature = fl; + } /* while (subfeature) */ + } /* while (feature) */ + } /* while (chip) */ +#endif /* (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) */ if (first_feature == NULL) + { sensors_cleanup (); -#endif /* if SENSORS_HAVE_READ */ + INFO ("sensors plugin: lm_sensors reports no " + "features. Data will not be collected."); + return (-1); + } - return; -} + return (0); +} /* int sensors_load_conf */ -static void sensors_shutdown (void) +static int sensors_shutdown (void) { - featurelist_t *thisft = first_feature; - featurelist_t *nextft; - + sensors_free_features (); ignorelist_free (sensor_list); - while (thisft != NULL) - { - nextft = thisft->next; - sfree (thisft); - thisft = nextft; - } - - sensors_cleanup (); -} + return (0); +} /* int sensors_shutdown */ -static void sensors_voltage_write (char *host, char *inst, char *val) +static void sensors_submit (const char *plugin_instance, + const char *type, const char *type_instance, + double val) { - char file[BUFSIZE]; + char match_key[1024]; int status; - /* skip ignored in our config */ - if (ignorelist_match (sensor_list, inst)) - return; - - /* extended sensor naming */ - if(sensor_extended_naming) - status = snprintf (file, BUFSIZE, extended_filename_format, inst); - else - status = snprintf (file, BUFSIZE, old_filename_format, inst); + value_t values[1]; + value_list_t vl = VALUE_LIST_INIT; - if ((status < 1) || (status >= BUFSIZE)) + status = snprintf (match_key, sizeof (match_key), "%s/%s-%s", + plugin_instance, type, type_instance); + if (status < 1) return; + match_key[sizeof (match_key) - 1] = '\0'; - rrd_update_file (host, file, val, sensor_voltage_ds_def, sensor_voltage_ds_num); -} - -static void sensors_write (char *host, char *inst, char *val) -{ - char file[BUFSIZE]; - int status; + if (sensor_list != NULL) + { + DEBUG ("sensors plugin: Checking ignorelist for `%s'", match_key); + if (ignorelist_match (sensor_list, match_key)) + return; + } - /* skip ignored in our config */ - if (ignorelist_match (sensor_list, inst)) - return; + values[0].gauge = val; - /* extended sensor naming */ - if (sensor_extended_naming) - status = snprintf (file, BUFSIZE, extended_filename_format, inst); - else - status = snprintf (file, BUFSIZE, old_filename_format, inst); + vl.values = values; + vl.values_len = 1; + vl.time = time (NULL); - if ((status < 1) || (status >= BUFSIZE)) - return; + strncpy (vl.host, hostname_g, sizeof (vl.host)); + vl.host[sizeof (vl.host) - 1] = '\0'; + strncpy (vl.plugin, "sensors", sizeof (vl.plugin)); + vl.plugin[sizeof (vl.plugin) - 1] = '\0'; + strncpy (vl.plugin_instance, plugin_instance, + sizeof (vl.plugin_instance)); + vl.plugin_instance[sizeof (vl.plugin_instance) - 1] = '\0'; + strncpy (vl.type_instance, type_instance, sizeof (vl.type_instance)); + vl.type_instance[sizeof (vl.type_instance) - 1] = '\0'; - rrd_update_file (host, file, val, ds_def, ds_num); -} + plugin_dispatch_values (type, &vl); +} /* void sensors_submit */ -#if SENSORS_HAVE_READ -static void sensors_submit (const char *feat_name, - const char *chip_prefix, double value, int type) +static int sensors_read (void) { - char buf[BUFSIZE]; - char inst[BUFSIZE]; + featurelist_t *fl; - if (snprintf (inst, BUFSIZE, "%s-%s", chip_prefix, feat_name) - >= BUFSIZE) - return; + if (sensors_load_conf () != 0) + return (-1); - /* skip ignored in our config */ - if (ignorelist_match (sensor_list, inst)) - return; +#if SENSORS_API_VERSION < 0x400 + for (fl = first_feature; fl != NULL; fl = fl->next) + { + double value; + int status; + char plugin_instance[DATA_MAX_NAME_LEN]; + char type_instance[DATA_MAX_NAME_LEN]; + + status = sensors_get_feature (*fl->chip, + fl->data->number, &value); + if (status < 0) + continue; - if (snprintf (buf, BUFSIZE, "%u:%.3f", (unsigned int) curtime, - value) >= BUFSIZE) - return; + status = sensors_snprintf_chip_name (plugin_instance, + sizeof (plugin_instance), fl->chip); + if (status < 0) + continue; + plugin_instance[sizeof (plugin_instance) - 1] = '\0'; - if (type == SENSOR_TYPE_VOLTAGE) - { - DBG ("%s: %s/%s, %s", MODULE_NAME_VOLTAGE, - sensor_type_prefix[type], inst, buf); - plugin_submit (MODULE_NAME_VOLTAGE, inst, buf); - } - else - { - DBG ("%s: %s/%s, %s", MODULE_NAME, - sensor_type_prefix[type], inst, buf); - plugin_submit (MODULE_NAME, inst, buf); - } -} + strncpy (type_instance, fl->data->name, + sizeof (type_instance)); + type_instance[sizeof (type_instance) - 1] = '\0'; -static void sensors_read (void) -{ - featurelist_t *feature; - double value; - char chip_fullprefix[BUFSIZE]; + sensors_submit (plugin_instance, + sensor_type_name_map[fl->type], + type_instance, + value); + } /* for fl = first_feature .. NULL */ +/* #endif SENSORS_API_VERSION < 0x400 */ - for (feature = first_feature; feature != NULL; feature = feature->next) +#elif (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) + for (fl = first_feature; fl != NULL; fl = fl->next) { - if (sensors_get_feature (*feature->chip, feature->data->number, &value) < 0) + double value; + int status; + char plugin_instance[DATA_MAX_NAME_LEN]; + char type_instance[DATA_MAX_NAME_LEN]; + const char *type; + + status = sensors_get_value (fl->chip, + fl->subfeature->number, &value); + if (status < 0) continue; - if (sensor_extended_naming) - { - /* full chip name logic borrowed from lm_sensors */ - if (feature->chip->bus == SENSORS_CHIP_NAME_BUS_ISA) - { - if (snprintf (chip_fullprefix, BUFSIZE, "%s-isa-%04x/%s", - feature->chip->prefix, - feature->chip->addr, - sensor_type_prefix[feature->type]) - >= BUFSIZE) - continue; - } - else if (feature->chip->bus == SENSORS_CHIP_NAME_BUS_DUMMY) - { - if (snprintf (chip_fullprefix, BUFSIZE, "%s-%s-%04x/%s", - feature->chip->prefix, - feature->chip->busname, - feature->chip->addr, - sensor_type_prefix[feature->type]) - >= BUFSIZE) - continue; - } - else - { - if (snprintf (chip_fullprefix, BUFSIZE, "%s-i2c-%d-%02x/%s", - feature->chip->prefix, - feature->chip->bus, - feature->chip->addr, - sensor_type_prefix[feature->type]) - >= BUFSIZE) - continue; - } - - sensors_submit (feature->data->name, - chip_fullprefix, - value, feature->type); - } + status = sensors_snprintf_chip_name (plugin_instance, + sizeof (plugin_instance), fl->chip); + if (status < 0) + continue; + plugin_instance[sizeof (plugin_instance) - 1] = '\0'; + + strncpy (type_instance, fl->feature->name, + sizeof (type_instance)); + type_instance[sizeof (type_instance) - 1] = '\0'; + + if (fl->feature->type == SENSORS_FEATURE_IN) + type = "voltage"; + else if (fl->feature->type + == SENSORS_FEATURE_FAN) + type = "fanspeed"; + else if (fl->feature->type + == SENSORS_FEATURE_TEMP) + type = "temperature"; else - { - sensors_submit (feature->data->name, - feature->chip->prefix, - value, feature->type); - } - } -} -#else -# define sensors_read NULL -#endif /* SENSORS_HAVE_READ */ + continue; + + sensors_submit (plugin_instance, type, type_instance, value); + } /* for fl = first_feature .. NULL */ +#endif /* (SENSORS_API_VERSION >= 0x400) && (SENSORS_API_VERSION < 0x500) */ + + return (0); +} /* int sensors_read */ void module_register (void) { - plugin_register (MODULE_NAME, collectd_sensors_init, sensors_read, sensors_write); - plugin_register (MODULE_NAME_VOLTAGE, NULL, NULL, sensors_voltage_write); - plugin_register_shutdown (MODULE_NAME, sensors_shutdown); - cf_register (MODULE_NAME, sensors_config, config_keys, config_keys_num); -} - -#undef BUFSIZE -#undef MODULE_NAME + plugin_register_config ("sensors", sensors_config, + config_keys, config_keys_num); + plugin_register_read ("sensors", sensors_read); + plugin_register_shutdown ("sensors", sensors_shutdown); +} /* void module_register */