| 1 |
/** |
| 2 |
* collectd - src/onewire.c |
| 3 |
* Copyright (C) 2008 noris network AG |
| 4 |
* |
| 5 |
* This program is free software; you can redistribute it and/or modify it |
| 6 |
* under the terms of the GNU General Public License as published by the |
| 7 |
* Free Software Foundation; only version 2 of the License is applicable. |
| 8 |
* |
| 9 |
* This program is distributed in the hope that it will be useful, but |
| 10 |
* WITHOUT ANY WARRANTY; without even the implied warranty of |
| 11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 12 |
* General Public License for more details. |
| 13 |
* |
| 14 |
* You should have received a copy of the GNU General Public License along |
| 15 |
* with this program; if not, write to the Free Software Foundation, Inc., |
| 16 |
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 17 |
* |
| 18 |
* Authors: |
| 19 |
* Florian octo Forster <octo at noris.net> |
| 20 |
**/ |
| 21 |
|
| 22 |
#include "collectd.h" |
| 23 |
|
| 24 |
#include "plugin.h" |
| 25 |
#include "utils/common/common.h" |
| 26 |
#include "utils/ignorelist/ignorelist.h" |
| 27 |
|
| 28 |
#include <owcapi.h> |
| 29 |
#include <regex.h> |
| 30 |
#include <sys/time.h> |
| 31 |
#include <sys/types.h> |
| 32 |
|
| 33 |
#define OW_FAMILY_LENGTH 8 |
| 34 |
#define OW_FAMILY_MAX_FEATURES 2 |
| 35 |
struct ow_family_features_s { |
| 36 |
char family[OW_FAMILY_LENGTH]; |
| 37 |
struct { |
| 38 |
char filename[DATA_MAX_NAME_LEN]; |
| 39 |
char type[DATA_MAX_NAME_LEN]; |
| 40 |
char type_instance[DATA_MAX_NAME_LEN]; |
| 41 |
} features[OW_FAMILY_MAX_FEATURES]; |
| 42 |
size_t features_num; |
| 43 |
}; |
| 44 |
typedef struct ow_family_features_s ow_family_features_t; |
| 45 |
|
| 46 |
/* internal timing info collected in debug version only */ |
| 47 |
#if COLLECT_DEBUG |
| 48 |
static struct timeval tv_begin, tv_end, tv_diff; |
| 49 |
#endif /* COLLECT_DEBUG */ |
| 50 |
|
| 51 |
/* regexp to extract address (without family) and file from the owfs path */ |
| 52 |
static const char *regexp_to_match = |
| 53 |
"[A-Fa-f0-9]{2}\\.([A-Fa-f0-9]{12})/([[:alnum:]]+)$"; |
| 54 |
|
| 55 |
/* see http://owfs.sourceforge.net/ow_table.html for a list of families */ |
| 56 |
static ow_family_features_t ow_family_features[] = { |
| 57 |
{/* DS18S20 Precision Thermometer and DS1920 ibutton */ |
| 58 |
/* family = */ "10.", |
| 59 |
{{/* filename = */ "temperature", |
| 60 |
/* type = */ "temperature", |
| 61 |
/* type_instance = */ ""}}, |
| 62 |
/* features_num = */ 1}, |
| 63 |
{/* DS1822 Econo Thermometer */ |
| 64 |
/* family = */ "22.", |
| 65 |
{{/* filename = */ "temperature", |
| 66 |
/* type = */ "temperature", |
| 67 |
/* type_instance = */ ""}}, |
| 68 |
/* features_num = */ 1}, |
| 69 |
{/* DS18B20 Programmable Resolution Thermometer */ |
| 70 |
/* family = */ "28.", |
| 71 |
{{/* filename = */ "temperature", |
| 72 |
/* type = */ "temperature", |
| 73 |
/* type_instance = */ ""}}, |
| 74 |
/* features_num = */ 1}, |
| 75 |
{/* DS2436 Volts/Temp */ |
| 76 |
/* family = */ "1B.", |
| 77 |
{{/* filename = */ "temperature", |
| 78 |
/* type = */ "temperature", |
| 79 |
/* type_instance = */ ""}}, |
| 80 |
/* features_num = */ 1}, |
| 81 |
{/* DS2438 Volts/Temp */ |
| 82 |
/* family = */ "26.", |
| 83 |
{{/* filename = */ "temperature", |
| 84 |
/* type = */ "temperature", |
| 85 |
/* type_instance = */ ""}}, |
| 86 |
/* features_num = */ 1}}; |
| 87 |
static int ow_family_features_num = STATIC_ARRAY_SIZE(ow_family_features); |
| 88 |
|
| 89 |
static char *device_g; |
| 90 |
static cdtime_t ow_interval; |
| 91 |
static bool direct_access; |
| 92 |
|
| 93 |
static const char *config_keys[] = {"Device", "IgnoreSelected", "Sensor", |
| 94 |
"Interval"}; |
| 95 |
static int config_keys_num = STATIC_ARRAY_SIZE(config_keys); |
| 96 |
|
| 97 |
static ignorelist_t *sensor_list; |
| 98 |
|
| 99 |
static bool regex_direct_initialized; |
| 100 |
static regex_t regex_direct; |
| 101 |
|
| 102 |
/** |
| 103 |
* List of onewire owfs "files" to be directly read |
| 104 |
*/ |
| 105 |
typedef struct direct_access_element_s { |
| 106 |
char *path; /**< The whole owfs path */ |
| 107 |
char *address; /**< 1-wire address without family */ |
| 108 |
char *file; /**< owfs file - e.g. temperature */ |
| 109 |
struct direct_access_element_s *next; /**< Next in the list */ |
| 110 |
} direct_access_element_t; |
| 111 |
|
| 112 |
static direct_access_element_t *direct_list; |
| 113 |
|
| 114 |
/* =================================================================================== |
| 115 |
*/ |
| 116 |
|
| 117 |
#if COLLECT_DEBUG |
| 118 |
/* Return 1 if the difference is negative, otherwise 0. */ |
| 119 |
static int timeval_subtract(struct timeval *result, struct timeval *t2, |
| 120 |
struct timeval *t1) { |
| 121 |
long int diff = (t2->tv_usec + 1000000 * t2->tv_sec) - |
| 122 |
(t1->tv_usec + 1000000 * t1->tv_sec); |
| 123 |
result->tv_sec = diff / 1000000; |
| 124 |
result->tv_usec = diff % 1000000; |
| 125 |
|
| 126 |
return diff < 0; |
| 127 |
} |
| 128 |
#endif /* COLLECT_DEBUG */ |
| 129 |
|
| 130 |
/* =================================================================================== |
| 131 |
*/ |
| 132 |
|
| 133 |
static void direct_list_element_free(direct_access_element_t *el) { |
| 134 |
if (el != NULL) { |
| 135 |
DEBUG("onewire plugin: direct_list_element_free - deleting <%s>", el->path); |
| 136 |
sfree(el->path); |
| 137 |
sfree(el->address); |
| 138 |
sfree(el->file); |
| 139 |
free(el); |
| 140 |
} |
| 141 |
} |
| 142 |
|
| 143 |
static int direct_list_insert(const char *config) { |
| 144 |
regmatch_t pmatch[3]; |
| 145 |
size_t nmatch = 3; |
| 146 |
direct_access_element_t *element; |
| 147 |
|
| 148 |
DEBUG("onewire plugin: direct_list_insert <%s>", config); |
| 149 |
|
| 150 |
element = malloc(sizeof(*element)); |
| 151 |
if (element == NULL) { |
| 152 |
ERROR("onewire plugin: direct_list_insert - cannot allocate element"); |
| 153 |
return 1; |
| 154 |
} |
| 155 |
element->path = NULL; |
| 156 |
element->address = NULL; |
| 157 |
element->file = NULL; |
| 158 |
|
| 159 |
element->path = strdup(config); |
| 160 |
if (element->path == NULL) { |
| 161 |
ERROR("onewire plugin: direct_list_insert - cannot allocate path"); |
| 162 |
direct_list_element_free(element); |
| 163 |
return 1; |
| 164 |
} |
| 165 |
|
| 166 |
DEBUG("onewire plugin: direct_list_insert - about to match %s", config); |
| 167 |
|
| 168 |
if (!regex_direct_initialized) { |
| 169 |
if (regcomp(®ex_direct, regexp_to_match, REG_EXTENDED)) { |
| 170 |
ERROR("onewire plugin: Cannot compile regex"); |
| 171 |
direct_list_element_free(element); |
| 172 |
return 1; |
| 173 |
} |
| 174 |
regex_direct_initialized = true; |
| 175 |
DEBUG("onewire plugin: Compiled regex!!"); |
| 176 |
} |
| 177 |
|
| 178 |
if (regexec(®ex_direct, config, nmatch, pmatch, 0)) { |
| 179 |
ERROR("onewire plugin: direct_list_insert - no regex match"); |
| 180 |
direct_list_element_free(element); |
| 181 |
return 1; |
| 182 |
} |
| 183 |
|
| 184 |
if (pmatch[1].rm_so < 0) { |
| 185 |
ERROR("onewire plugin: direct_list_insert - no address regex match"); |
| 186 |
direct_list_element_free(element); |
| 187 |
return 1; |
| 188 |
} |
| 189 |
element->address = |
| 190 |
strndup(config + pmatch[1].rm_so, pmatch[1].rm_eo - pmatch[1].rm_so); |
| 191 |
if (element->address == NULL) { |
| 192 |
ERROR("onewire plugin: direct_list_insert - cannot allocate address"); |
| 193 |
direct_list_element_free(element); |
| 194 |
return 1; |
| 195 |
} |
| 196 |
DEBUG("onewire plugin: direct_list_insert - found address <%s>", |
| 197 |
element->address); |
| 198 |
|
| 199 |
if (pmatch[2].rm_so < 0) { |
| 200 |
ERROR("onewire plugin: direct_list_insert - no file regex match"); |
| 201 |
direct_list_element_free(element); |
| 202 |
return 1; |
| 203 |
} |
| 204 |
element->file = |
| 205 |
strndup(config + pmatch[2].rm_so, pmatch[2].rm_eo - pmatch[2].rm_so); |
| 206 |
if (element->file == NULL) { |
| 207 |
ERROR("onewire plugin: direct_list_insert - cannot allocate file"); |
| 208 |
direct_list_element_free(element); |
| 209 |
return 1; |
| 210 |
} |
| 211 |
DEBUG("onewire plugin: direct_list_insert - found file <%s>", element->file); |
| 212 |
|
| 213 |
element->next = direct_list; |
| 214 |
direct_list = element; |
| 215 |
|
| 216 |
return 0; |
| 217 |
} |
| 218 |
|
| 219 |
static void direct_list_free(void) { |
| 220 |
direct_access_element_t *traverse = direct_list; |
| 221 |
direct_access_element_t *tmp = NULL; |
| 222 |
; |
| 223 |
|
| 224 |
while (traverse != NULL) { |
| 225 |
tmp = traverse; |
| 226 |
traverse = traverse->next; |
| 227 |
direct_list_element_free(tmp); |
| 228 |
tmp = NULL; |
| 229 |
} |
| 230 |
} |
| 231 |
|
| 232 |
/* =================================================================================== |
| 233 |
*/ |
| 234 |
|
| 235 |
static int cow_load_config(const char *key, const char *value) { |
| 236 |
if (sensor_list == NULL) |
| 237 |
sensor_list = ignorelist_create(1); |
| 238 |
|
| 239 |
if (strcasecmp(key, "Sensor") == 0) { |
| 240 |
if (direct_list_insert(value)) { |
| 241 |
DEBUG("onewire plugin: Cannot add %s to direct_list_insert.", value); |
| 242 |
|
| 243 |
if (ignorelist_add(sensor_list, value)) { |
| 244 |
ERROR("onewire plugin: Cannot add value to ignorelist."); |
| 245 |
return 1; |
| 246 |
} |
| 247 |
} else { |
| 248 |
DEBUG("onewire plugin: %s is a direct access", value); |
| 249 |
direct_access = true; |
| 250 |
} |
| 251 |
} else if (strcasecmp(key, "IgnoreSelected") == 0) { |
| 252 |
ignorelist_set_invert(sensor_list, 1); |
| 253 |
if (IS_TRUE(value)) |
| 254 |
ignorelist_set_invert(sensor_list, 0); |
| 255 |
} else if (strcasecmp(key, "Device") == 0) { |
| 256 |
char *temp; |
| 257 |
temp = strdup(value); |
| 258 |
if (temp == NULL) { |
| 259 |
ERROR("onewire plugin: strdup failed."); |
| 260 |
return 1; |
| 261 |
} |
| 262 |
sfree(device_g); |
| 263 |
device_g = temp; |
| 264 |
} else if (strcasecmp("Interval", key) == 0) { |
| 265 |
double tmp; |
| 266 |
tmp = atof(value); |
| 267 |
if (tmp > 0.0) |
| 268 |
ow_interval = DOUBLE_TO_CDTIME_T(tmp); |
| 269 |
else |
| 270 |
ERROR("onewire plugin: Invalid `Interval' setting: %s", value); |
| 271 |
} else { |
| 272 |
return -1; |
| 273 |
} |
| 274 |
|
| 275 |
return 0; |
| 276 |
} |
| 277 |
|
| 278 |
static int cow_read_values(const char *path, const char *name, |
| 279 |
const ow_family_features_t *family_info) { |
| 280 |
value_list_t vl = VALUE_LIST_INIT; |
| 281 |
int success = 0; |
| 282 |
|
| 283 |
if (sensor_list != NULL) { |
| 284 |
DEBUG("onewire plugin: Checking ignorelist for `%s'", name); |
| 285 |
if (ignorelist_match(sensor_list, name) != 0) |
| 286 |
return 0; |
| 287 |
} |
| 288 |
|
| 289 |
sstrncpy(vl.plugin, "onewire", sizeof(vl.plugin)); |
| 290 |
sstrncpy(vl.plugin_instance, name, sizeof(vl.plugin_instance)); |
| 291 |
|
| 292 |
for (size_t i = 0; i < family_info->features_num; i++) { |
| 293 |
char *buffer; |
| 294 |
size_t buffer_size; |
| 295 |
int status; |
| 296 |
|
| 297 |
char file[4096]; |
| 298 |
char *endptr; |
| 299 |
|
| 300 |
ssnprintf(file, sizeof(file), "%s/%s", path, |
| 301 |
family_info->features[i].filename); |
| 302 |
file[sizeof(file) - 1] = '\0'; |
| 303 |
|
| 304 |
buffer = NULL; |
| 305 |
buffer_size = 0; |
| 306 |
DEBUG("Start reading onewire device %s", file); |
| 307 |
status = OW_get(file, &buffer, &buffer_size); |
| 308 |
if (status < 0) { |
| 309 |
ERROR("onewire plugin: OW_get (%s/%s) failed. error = %s;", path, |
| 310 |
family_info->features[i].filename, STRERRNO); |
| 311 |
return -1; |
| 312 |
} |
| 313 |
DEBUG("Read onewire device %s as %s", file, buffer); |
| 314 |
|
| 315 |
endptr = NULL; |
| 316 |
gauge_t g = strtod(buffer, &endptr); |
| 317 |
if (endptr == NULL) { |
| 318 |
ERROR("onewire plugin: Buffer is not a number: %s", buffer); |
| 319 |
continue; |
| 320 |
} |
| 321 |
|
| 322 |
sstrncpy(vl.type, family_info->features[i].type, sizeof(vl.type)); |
| 323 |
sstrncpy(vl.type_instance, family_info->features[i].type_instance, |
| 324 |
sizeof(vl.type_instance)); |
| 325 |
|
| 326 |
vl.values = &(value_t){.gauge = g}; |
| 327 |
vl.values_len = 1; |
| 328 |
|
| 329 |
plugin_dispatch_values(&vl); |
| 330 |
success++; |
| 331 |
|
| 332 |
free(buffer); |
| 333 |
} /* for (i = 0; i < features_num; i++) */ |
| 334 |
|
| 335 |
return (success > 0) ? 0 : -1; |
| 336 |
} /* int cow_read_values */ |
| 337 |
|
| 338 |
/* Forward declaration so the recursion below works */ |
| 339 |
static int cow_read_bus(const char *path); |
| 340 |
|
| 341 |
/* |
| 342 |
* cow_read_ds2409 |
| 343 |
* |
| 344 |
* Handles: |
| 345 |
* - DS2409 - MicroLAN Coupler |
| 346 |
*/ |
| 347 |
static int cow_read_ds2409(const char *path) { |
| 348 |
char subpath[4096]; |
| 349 |
int status; |
| 350 |
|
| 351 |
status = ssnprintf(subpath, sizeof(subpath), "%s/main", path); |
| 352 |
if ((status > 0) && (status < (int)sizeof(subpath))) |
| 353 |
cow_read_bus(subpath); |
| 354 |
|
| 355 |
status = ssnprintf(subpath, sizeof(subpath), "%s/aux", path); |
| 356 |
if ((status > 0) && (status < (int)sizeof(subpath))) |
| 357 |
cow_read_bus(subpath); |
| 358 |
|
| 359 |
return 0; |
| 360 |
} /* int cow_read_ds2409 */ |
| 361 |
|
| 362 |
static int cow_read_bus(const char *path) { |
| 363 |
char *buffer; |
| 364 |
size_t buffer_size; |
| 365 |
int status; |
| 366 |
|
| 367 |
char *buffer_ptr; |
| 368 |
char *dummy; |
| 369 |
char *saveptr; |
| 370 |
char subpath[4096]; |
| 371 |
|
| 372 |
status = OW_get(path, &buffer, &buffer_size); |
| 373 |
if (status < 0) { |
| 374 |
ERROR("onewire plugin: OW_get (%s) failed. error = %s;", path, STRERRNO); |
| 375 |
return -1; |
| 376 |
} |
| 377 |
DEBUG("onewire plugin: OW_get (%s) returned: %s", path, buffer); |
| 378 |
|
| 379 |
dummy = buffer; |
| 380 |
saveptr = NULL; |
| 381 |
while ((buffer_ptr = strtok_r(dummy, ",/", &saveptr)) != NULL) { |
| 382 |
int i; |
| 383 |
|
| 384 |
dummy = NULL; |
| 385 |
|
| 386 |
if (strcmp("/", path) == 0) |
| 387 |
status = ssnprintf(subpath, sizeof(subpath), "/%s", buffer_ptr); |
| 388 |
else |
| 389 |
status = ssnprintf(subpath, sizeof(subpath), "%s/%s", path, buffer_ptr); |
| 390 |
if ((status <= 0) || (status >= (int)sizeof(subpath))) |
| 391 |
continue; |
| 392 |
|
| 393 |
for (i = 0; i < ow_family_features_num; i++) { |
| 394 |
if (strncmp(ow_family_features[i].family, buffer_ptr, |
| 395 |
strlen(ow_family_features[i].family)) != 0) |
| 396 |
continue; |
| 397 |
|
| 398 |
cow_read_values(subpath, |
| 399 |
buffer_ptr + strlen(ow_family_features[i].family), |
| 400 |
ow_family_features + i); |
| 401 |
break; |
| 402 |
} |
| 403 |
if (i < ow_family_features_num) |
| 404 |
continue; |
| 405 |
|
| 406 |
/* DS2409 */ |
| 407 |
if (strncmp("1F.", buffer_ptr, strlen("1F.")) == 0) { |
| 408 |
cow_read_ds2409(subpath); |
| 409 |
continue; |
| 410 |
} |
| 411 |
} /* while (strtok_r) */ |
| 412 |
|
| 413 |
free(buffer); |
| 414 |
return 0; |
| 415 |
} /* int cow_read_bus */ |
| 416 |
|
| 417 |
/* =================================================================================== |
| 418 |
*/ |
| 419 |
|
| 420 |
static int cow_simple_read(void) { |
| 421 |
value_list_t vl = VALUE_LIST_INIT; |
| 422 |
char *buffer; |
| 423 |
size_t buffer_size; |
| 424 |
int status; |
| 425 |
char *endptr; |
| 426 |
direct_access_element_t *traverse; |
| 427 |
|
| 428 |
/* traverse list and check entries */ |
| 429 |
for (traverse = direct_list; traverse != NULL; traverse = traverse->next) { |
| 430 |
sstrncpy(vl.plugin, "onewire", sizeof(vl.plugin)); |
| 431 |
sstrncpy(vl.plugin_instance, traverse->address, sizeof(vl.plugin_instance)); |
| 432 |
|
| 433 |
status = OW_get(traverse->path, &buffer, &buffer_size); |
| 434 |
if (status < 0) { |
| 435 |
ERROR("onewire plugin: OW_get (%s) failed. status = %s;", traverse->path, |
| 436 |
STRERRNO); |
| 437 |
return -1; |
| 438 |
} |
| 439 |
DEBUG("onewire plugin: Read onewire device %s as %s", traverse->path, |
| 440 |
buffer); |
| 441 |
|
| 442 |
endptr = NULL; |
| 443 |
gauge_t g = strtod(buffer, &endptr); |
| 444 |
if (endptr == NULL) { |
| 445 |
ERROR("onewire plugin: Buffer is not a number: %s", buffer); |
| 446 |
continue; |
| 447 |
} |
| 448 |
|
| 449 |
sstrncpy(vl.type, traverse->file, sizeof(vl.type)); |
| 450 |
sstrncpy(vl.type_instance, "", sizeof("")); |
| 451 |
|
| 452 |
vl.values = &(value_t){.gauge = g}; |
| 453 |
vl.values_len = 1; |
| 454 |
|
| 455 |
plugin_dispatch_values(&vl); |
| 456 |
free(buffer); |
| 457 |
} /* for (traverse) */ |
| 458 |
|
| 459 |
return 0; |
| 460 |
} /* int cow_simple_read */ |
| 461 |
|
| 462 |
/* =================================================================================== |
| 463 |
*/ |
| 464 |
|
| 465 |
static int cow_read(user_data_t *ud __attribute__((unused))) { |
| 466 |
int result = 0; |
| 467 |
|
| 468 |
#if COLLECT_DEBUG |
| 469 |
gettimeofday(&tv_begin, NULL); |
| 470 |
#endif /* COLLECT_DEBUG */ |
| 471 |
|
| 472 |
if (direct_access) { |
| 473 |
DEBUG("onewire plugin: Direct access read"); |
| 474 |
result = cow_simple_read(); |
| 475 |
} else { |
| 476 |
DEBUG("onewire plugin: Standard access read"); |
| 477 |
result = cow_read_bus("/"); |
| 478 |
} |
| 479 |
|
| 480 |
#if COLLECT_DEBUG |
| 481 |
gettimeofday(&tv_end, NULL); |
| 482 |
timeval_subtract(&tv_diff, &tv_end, &tv_begin); |
| 483 |
DEBUG("onewire plugin: Onewire read took us %ld.%06ld s", tv_diff.tv_sec, |
| 484 |
tv_diff.tv_usec); |
| 485 |
#endif /* COLLECT_DEBUG */ |
| 486 |
|
| 487 |
return result; |
| 488 |
} /* int cow_read */ |
| 489 |
|
| 490 |
static int cow_shutdown(void) { |
| 491 |
OW_finish(); |
| 492 |
ignorelist_free(sensor_list); |
| 493 |
|
| 494 |
direct_list_free(); |
| 495 |
|
| 496 |
if (regex_direct_initialized) { |
| 497 |
regfree(®ex_direct); |
| 498 |
} |
| 499 |
|
| 500 |
return 0; |
| 501 |
} /* int cow_shutdown */ |
| 502 |
|
| 503 |
static int cow_init(void) { |
| 504 |
int status; |
| 505 |
|
| 506 |
if (device_g == NULL) { |
| 507 |
ERROR("onewire plugin: cow_init: No device configured."); |
| 508 |
return -1; |
| 509 |
} |
| 510 |
|
| 511 |
DEBUG("onewire plugin: about to init device <%s>.", device_g); |
| 512 |
status = (int)OW_init(device_g); |
| 513 |
if (status != 0) { |
| 514 |
ERROR("onewire plugin: OW_init(%s) failed: %s.", device_g, STRERRNO); |
| 515 |
return 1; |
| 516 |
} |
| 517 |
|
| 518 |
plugin_register_complex_read(/* group = */ NULL, "onewire", cow_read, |
| 519 |
ow_interval, /* user data = */ NULL); |
| 520 |
plugin_register_shutdown("onewire", cow_shutdown); |
| 521 |
|
| 522 |
return 0; |
| 523 |
} /* int cow_init */ |
| 524 |
|
| 525 |
void module_register(void) { |
| 526 |
plugin_register_init("onewire", cow_init); |
| 527 |
plugin_register_config("onewire", cow_load_config, config_keys, |
| 528 |
config_keys_num); |
| 529 |
} |