1 /* $OpenBSD: sensorsd.c,v 1.46 2008/06/14 00:16:10 cnst Exp $ */ 2 3 /* 4 * Copyright (c) 2003 Henning Brauer <henning@openbsd.org> 5 * Copyright (c) 2005 Matthew Gream <matthew.gream@pobox.com> 6 * Copyright (c) 2006 Constantine A. Murenin <cnst+openbsd@bugmail.mojo.ru> 7 * 8 * Permission to use, copy, modify, and distribute this software for any 9 * purpose with or without fee is hereby granted, provided that the above 10 * copyright notice and this permission notice appear in all copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 19 */ 20 21 #include <sys/param.h> 22 #include <sys/sysctl.h> 23 #include <sys/sensors.h> 24 25 #include <err.h> 26 #include <errno.h> 27 #include <inttypes.h> 28 #include <signal.h> 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <string.h> 32 #include <syslog.h> 33 #include <time.h> 34 #include <unistd.h> 35 36 #define RFBUFSIZ 28 /* buffer size for print_sensor */ 37 #define RFBUFCNT 4 /* ring buffers */ 38 #define CHECK_PERIOD 20 /* check every n seconds */ 39 40 enum sensorsd_s_status { 41 SENSORSD_S_UNSPEC, /* status is unspecified */ 42 SENSORSD_S_INVALID, /* status is invalid, per SENSOR_FINVALID */ 43 SENSORSD_S_WITHIN, /* status is within limits */ 44 SENSORSD_S_ABOVE, /* status is above the higher limit */ 45 SENSORSD_S_BELOW /* status is below the lower limit */ 46 }; 47 48 struct limits_t { 49 TAILQ_ENTRY(limits_t) entries; 50 enum sensor_type type; /* sensor type */ 51 int numt; /* sensor number */ 52 int64_t last_val; 53 int64_t lower; /* lower limit */ 54 int64_t upper; /* upper limit */ 55 char *command; /* failure command */ 56 time_t astatus_changed; 57 time_t ustatus_changed; 58 enum sensor_status astatus; /* last automatic status */ 59 enum sensor_status astatus2; 60 enum sensorsd_s_status ustatus; /* last user-limit status */ 61 enum sensorsd_s_status ustatus2; 62 int acount; /* stat change counter */ 63 int ucount; /* stat change counter */ 64 u_int8_t flags; /* sensorsd limit flags */ 65 #define SENSORSD_L_USERLIMIT 0x0001 /* user specified limit */ 66 #define SENSORSD_L_ISTATUS 0x0002 /* ignore automatic status */ 67 }; 68 69 struct sdlim_t { 70 TAILQ_ENTRY(sdlim_t) entries; 71 char dxname[16]; /* device unix name */ 72 int dev; /* device number */ 73 int sensor_cnt; 74 TAILQ_HEAD(, limits_t) limits; 75 }; 76 77 void usage(void); 78 void create(void); 79 struct sdlim_t *create_sdlim(struct sensordev *); 80 void destroy_sdlim(struct sdlim_t *); 81 void check(time_t); 82 void check_sdlim(struct sdlim_t *, time_t); 83 void execute(char *); 84 void report(time_t); 85 void report_sdlim(struct sdlim_t *, time_t); 86 static char *print_sensor(enum sensor_type, int64_t); 87 void parse_config(char *); 88 void parse_config_sdlim(struct sdlim_t *, char *); 89 int64_t get_val(char *, int, enum sensor_type); 90 void reparse_cfg(int); 91 92 TAILQ_HEAD(sdlimhead_t, sdlim_t); 93 struct sdlimhead_t sdlims = TAILQ_HEAD_INITIALIZER(sdlims); 94 95 char *configfile; 96 volatile sig_atomic_t reload = 0; 97 int debug = 0; 98 99 void 100 usage(void) 101 { 102 fprintf(stderr, "usage: %s [-d] [-c check]\n", getprogname()); 103 exit(1); 104 } 105 106 int 107 main(int argc, char *argv[]) 108 { 109 time_t last_report = 0, this_check; 110 int ch, check_period = CHECK_PERIOD; 111 const char *errstr; 112 113 while ((ch = getopt(argc, argv, "c:d")) != -1) { 114 switch (ch) { 115 case 'c': 116 check_period = strtonum(optarg, 1, 600, &errstr); 117 if (errstr) 118 errx(1, "check %s", errstr); 119 break; 120 case 'd': 121 debug = 1; 122 break; 123 default: 124 usage(); 125 } 126 } 127 128 argc -= optind; 129 argv += optind; 130 if (argc > 0) 131 usage(); 132 133 openlog("sensorsd", LOG_PID | LOG_NDELAY, LOG_DAEMON); 134 135 create(); 136 137 if (configfile == NULL) 138 if (asprintf(&configfile, "/etc/sensorsd.conf") == -1) 139 err(1, "out of memory"); 140 parse_config(configfile); 141 142 if (debug == 0 && daemon(0, 0) == -1) 143 err(1, "unable to fork"); 144 145 signal(SIGHUP, reparse_cfg); 146 signal(SIGCHLD, SIG_IGN); 147 148 for (;;) { 149 if (reload) { 150 parse_config(configfile); 151 syslog(LOG_INFO, "configuration reloaded"); 152 reload = 0; 153 } 154 this_check = time(NULL); 155 if (!(last_report < this_check)) 156 this_check = last_report + 1; 157 check(this_check); 158 report(last_report); 159 last_report = this_check; 160 sleep(check_period); 161 } 162 } 163 164 void 165 create(void) 166 { 167 struct sensordev sensordev; 168 struct sdlim_t *sdlim; 169 size_t sdlen = sizeof(sensordev); 170 int mib[3], dev, sensor_cnt = 0; 171 172 mib[0] = CTL_HW; 173 mib[1] = HW_SENSORS; 174 175 for (dev = 0; dev < MAXSENSORDEVICES; dev++) { 176 mib[2] = dev; 177 if (sysctl(mib, 3, &sensordev, &sdlen, NULL, 0) == -1) { 178 if (errno != ENOENT) 179 warn("sysctl"); 180 continue; 181 } 182 sdlim = create_sdlim(&sensordev); 183 TAILQ_INSERT_TAIL(&sdlims, sdlim, entries); 184 sensor_cnt += sdlim->sensor_cnt; 185 } 186 187 syslog(LOG_INFO, "startup, system has %d sensors", sensor_cnt); 188 } 189 190 struct sdlim_t * 191 create_sdlim(struct sensordev *snsrdev) 192 { 193 struct sensor sensor; 194 struct sdlim_t *sdlim; 195 struct limits_t *limit; 196 size_t slen = sizeof(sensor); 197 int mib[5], numt; 198 enum sensor_type type; 199 200 if ((sdlim = calloc(1, sizeof(struct sdlim_t))) == NULL) 201 err(1, "calloc"); 202 203 strlcpy(sdlim->dxname, snsrdev->xname, sizeof(sdlim->dxname)); 204 205 mib[0] = CTL_HW; 206 mib[1] = HW_SENSORS; 207 mib[2] = sdlim->dev = snsrdev->num; 208 209 TAILQ_INIT(&sdlim->limits); 210 211 for (type = 0; type < SENSOR_MAX_TYPES; type++) { 212 mib[3] = type; 213 for (numt = 0; numt < snsrdev->maxnumt[type]; numt++) { 214 mib[4] = numt; 215 if (sysctl(mib, 5, &sensor, &slen, NULL, 0) == -1) { 216 if (errno != ENOENT) 217 warn("sysctl"); 218 continue; 219 } 220 if ((limit = calloc(1, sizeof(struct limits_t))) == 221 NULL) 222 err(1, "calloc"); 223 limit->type = type; 224 limit->numt = numt; 225 TAILQ_INSERT_TAIL(&sdlim->limits, limit, entries); 226 sdlim->sensor_cnt++; 227 } 228 } 229 230 return (sdlim); 231 } 232 233 void 234 destroy_sdlim(struct sdlim_t *sdlim) 235 { 236 struct limits_t *limit; 237 238 while((limit = TAILQ_FIRST(&sdlim->limits)) != NULL) { 239 TAILQ_REMOVE(&sdlim->limits, limit, entries); 240 if (limit->command != NULL) 241 free(limit->command); 242 free(limit); 243 } 244 free(sdlim); 245 } 246 247 void 248 check(time_t this_check) 249 { 250 struct sensordev sensordev; 251 struct sdlim_t *sdlim, *next; 252 int mib[3]; 253 int h, t, i; 254 size_t sdlen = sizeof(sensordev); 255 256 if (TAILQ_EMPTY(&sdlims)) { 257 h = 0; 258 t = -1; 259 } else { 260 h = TAILQ_FIRST(&sdlims)->dev; 261 t = TAILQ_LAST(&sdlims, sdlimhead_t)->dev; 262 } 263 sdlim = TAILQ_FIRST(&sdlims); 264 265 mib[0] = CTL_HW; 266 mib[1] = HW_SENSORS; 267 /* look ahead for 4 more sensordevs */ 268 for (i = h; i <= t + 4; i++) { 269 if (sdlim != NULL && i > sdlim->dev) 270 sdlim = TAILQ_NEXT(sdlim, entries); 271 if (sdlim == NULL && i <= t) 272 syslog(LOG_ALERT, "inconsistent sdlim logic"); 273 mib[2] = i; 274 if (sysctl(mib, 3, &sensordev, &sdlen, NULL, 0) == -1) { 275 if (errno != ENOENT) 276 warn("sysctl"); 277 if (sdlim != NULL && i == sdlim->dev) { 278 next = TAILQ_NEXT(sdlim, entries); 279 TAILQ_REMOVE(&sdlims, sdlim, entries); 280 syslog(LOG_INFO, "%s has disappeared", 281 sdlim->dxname); 282 destroy_sdlim(sdlim); 283 sdlim = next; 284 } 285 continue; 286 } 287 if (sdlim != NULL && i == sdlim->dev) { 288 if (strcmp(sdlim->dxname, sensordev.xname) == 0) { 289 check_sdlim(sdlim, this_check); 290 continue; 291 } else { 292 next = TAILQ_NEXT(sdlim, entries); 293 TAILQ_REMOVE(&sdlims, sdlim, entries); 294 syslog(LOG_INFO, "%s has been replaced", 295 sdlim->dxname); 296 destroy_sdlim(sdlim); 297 sdlim = next; 298 } 299 } 300 next = create_sdlim(&sensordev); 301 /* inserting next before sdlim */ 302 if (sdlim != NULL) 303 TAILQ_INSERT_BEFORE(sdlim, next, entries); 304 else 305 TAILQ_INSERT_TAIL(&sdlims, next, entries); 306 syslog(LOG_INFO, "%s has appeared", next->dxname); 307 sdlim = next; 308 parse_config_sdlim(sdlim, configfile); 309 check_sdlim(sdlim, this_check); 310 } 311 312 if (TAILQ_EMPTY(&sdlims)) 313 return; 314 /* Ensure that our queue is consistent. */ 315 for (sdlim = TAILQ_FIRST(&sdlims); 316 (next = TAILQ_NEXT(sdlim, entries)) != NULL; 317 sdlim = next) 318 if (sdlim->dev > next->dev) 319 syslog(LOG_ALERT, "inconsistent sdlims queue"); 320 } 321 322 void 323 check_sdlim(struct sdlim_t *sdlim, time_t this_check) 324 { 325 struct sensor sensor; 326 struct limits_t *limit; 327 size_t len; 328 int mib[5]; 329 330 mib[0] = CTL_HW; 331 mib[1] = HW_SENSORS; 332 mib[2] = sdlim->dev; 333 len = sizeof(sensor); 334 335 TAILQ_FOREACH(limit, &sdlim->limits, entries) { 336 if ((limit->flags & SENSORSD_L_ISTATUS) && 337 !(limit->flags & SENSORSD_L_USERLIMIT)) 338 continue; 339 340 mib[3] = limit->type; 341 mib[4] = limit->numt; 342 if (sysctl(mib, 5, &sensor, &len, NULL, 0) == -1) 343 err(1, "sysctl"); 344 345 if (!(limit->flags & SENSORSD_L_ISTATUS)) { 346 enum sensor_status newastatus = sensor.status; 347 348 if (limit->astatus != newastatus) { 349 if (limit->astatus2 != newastatus) { 350 limit->astatus2 = newastatus; 351 limit->acount = 0; 352 } else if (++limit->acount >= 3) { 353 limit->last_val = sensor.value; 354 limit->astatus2 = 355 limit->astatus = newastatus; 356 limit->astatus_changed = this_check; 357 } 358 } 359 } 360 361 if (limit->flags & SENSORSD_L_USERLIMIT) { 362 enum sensorsd_s_status newustatus; 363 364 if (sensor.flags & SENSOR_FINVALID) 365 newustatus = SENSORSD_S_INVALID; 366 else if (sensor.value > limit->upper) 367 newustatus = SENSORSD_S_ABOVE; 368 else if (sensor.value < limit->lower) 369 newustatus = SENSORSD_S_BELOW; 370 else 371 newustatus = SENSORSD_S_WITHIN; 372 373 if (limit->ustatus != newustatus) { 374 if (limit->ustatus2 != newustatus) { 375 limit->ustatus2 = newustatus; 376 limit->ucount = 0; 377 } else if (++limit->ucount >= 3) { 378 limit->last_val = sensor.value; 379 limit->ustatus2 = 380 limit->ustatus = newustatus; 381 limit->ustatus_changed = this_check; 382 } 383 } 384 } 385 } 386 } 387 388 void 389 execute(char *command) 390 { 391 const char *argp[] = {"sh", "-c", command, NULL}; 392 393 switch (fork()) { 394 case -1: 395 syslog(LOG_CRIT, "execute: fork() failed"); 396 break; 397 case 0: 398 execv("/bin/sh", __DECONST(char **, argp)); 399 _exit(1); 400 /* NOTREACHED */ 401 default: 402 break; 403 } 404 } 405 406 void 407 report(time_t last_report) 408 { 409 struct sdlim_t *sdlim; 410 411 TAILQ_FOREACH(sdlim, &sdlims, entries) 412 report_sdlim(sdlim, last_report); 413 } 414 415 void 416 report_sdlim(struct sdlim_t *sdlim, time_t last_report) 417 { 418 struct limits_t *limit; 419 420 TAILQ_FOREACH(limit, &sdlim->limits, entries) { 421 if ((limit->astatus_changed <= last_report) && 422 (limit->ustatus_changed <= last_report)) 423 continue; 424 425 if (limit->astatus_changed > last_report) { 426 const char *as = NULL; 427 428 switch (limit->astatus) { 429 case SENSOR_S_UNSPEC: 430 as = ""; 431 break; 432 case SENSOR_S_OK: 433 as = ", OK"; 434 break; 435 case SENSOR_S_WARN: 436 as = ", WARN"; 437 break; 438 case SENSOR_S_CRIT: 439 as = ", CRITICAL"; 440 break; 441 case SENSOR_S_UNKNOWN: 442 as = ", UNKNOWN"; 443 break; 444 } 445 syslog(limit->astatus == SENSOR_S_OK ? LOG_INFO : 446 LOG_ALERT, "%s.%s%d: %s%s", 447 sdlim->dxname, sensor_type_s[limit->type], 448 limit->numt, 449 print_sensor(limit->type, limit->last_val), as); 450 } 451 452 if (limit->ustatus_changed > last_report) { 453 char us[BUFSIZ]; 454 455 switch (limit->ustatus) { 456 case SENSORSD_S_UNSPEC: 457 snprintf(us, sizeof(us), 458 "ustatus uninitialised"); 459 break; 460 case SENSORSD_S_INVALID: 461 snprintf(us, sizeof(us), "marked invalid"); 462 break; 463 case SENSORSD_S_WITHIN: 464 snprintf(us, sizeof(us), "within limits: %s", 465 print_sensor(limit->type, limit->last_val)); 466 break; 467 case SENSORSD_S_ABOVE: 468 snprintf(us, sizeof(us), "exceeds limits: %s is above %s", 469 print_sensor(limit->type, limit->last_val), 470 print_sensor(limit->type, limit->upper)); 471 break; 472 case SENSORSD_S_BELOW: 473 snprintf(us, sizeof(us), "exceeds limits: %s is below %s", 474 print_sensor(limit->type, limit->last_val), 475 print_sensor(limit->type, limit->lower)); 476 break; 477 } 478 syslog(limit->ustatus == SENSORSD_S_WITHIN ? LOG_INFO : 479 LOG_ALERT, "%s.%s%d: %s", 480 sdlim->dxname, sensor_type_s[limit->type], 481 limit->numt, us); 482 } 483 484 if (limit->command) { 485 int i = 0, n = 0, r; 486 char *cmd = limit->command; 487 char buf[BUFSIZ]; 488 int len = sizeof(buf); 489 490 buf[0] = '\0'; 491 for (i = n = 0; n < len; ++i) { 492 if (cmd[i] == '\0') { 493 buf[n++] = '\0'; 494 break; 495 } 496 if (cmd[i] != '%') { 497 buf[n++] = limit->command[i]; 498 continue; 499 } 500 i++; 501 if (cmd[i] == '\0') { 502 buf[n++] = '\0'; 503 break; 504 } 505 506 switch (cmd[i]) { 507 case 'x': 508 r = snprintf(&buf[n], len - n, "%s", 509 sdlim->dxname); 510 break; 511 case 't': 512 r = snprintf(&buf[n], len - n, "%s", 513 sensor_type_s[limit->type]); 514 break; 515 case 'n': 516 r = snprintf(&buf[n], len - n, "%d", 517 limit->numt); 518 break; 519 case 'l': 520 { 521 const char *s = ""; 522 switch(limit->ustatus){ 523 case SENSORSD_S_UNSPEC: 524 s = "uninitialised"; 525 break; 526 case SENSORSD_S_INVALID: 527 s = "invalid"; 528 break; 529 case SENSORSD_S_WITHIN: 530 s = "within"; 531 break; 532 case SENSORSD_S_ABOVE: 533 s = "above"; 534 break; 535 case SENSORSD_S_BELOW: 536 s = "below"; 537 break; 538 } 539 r = snprintf(&buf[n], len - n, "%s", 540 s); 541 break; 542 } 543 case 's': 544 { 545 const char *s; 546 switch(limit->astatus){ 547 case SENSOR_S_UNSPEC: 548 s = "UNSPEC"; 549 break; 550 case SENSOR_S_OK: 551 s = "OK"; 552 break; 553 case SENSOR_S_WARN: 554 s = "WARNING"; 555 break; 556 case SENSOR_S_CRIT: 557 s = "CRITICAL"; 558 break; 559 default: 560 s = "UNKNOWN"; 561 } 562 r = snprintf(&buf[n], len - n, "%s", 563 s); 564 break; 565 } 566 case '2': 567 r = snprintf(&buf[n], len - n, "%s", 568 print_sensor(limit->type, 569 limit->last_val)); 570 break; 571 case '3': 572 r = snprintf(&buf[n], len - n, "%s", 573 print_sensor(limit->type, 574 limit->lower)); 575 break; 576 case '4': 577 r = snprintf(&buf[n], len - n, "%s", 578 print_sensor(limit->type, 579 limit->upper)); 580 break; 581 default: 582 r = snprintf(&buf[n], len - n, "%%%c", 583 cmd[i]); 584 break; 585 } 586 if (r < 0 || (r >= len - n)) { 587 syslog(LOG_CRIT, "could not parse " 588 "command"); 589 return; 590 } 591 if (r > 0) 592 n += r; 593 } 594 if (buf[0]) 595 execute(buf); 596 } 597 } 598 } 599 600 const char *drvstat[] = { 601 NULL, "empty", "ready", "powerup", "online", "idle", "active", 602 "rebuild", "powerdown", "fail", "pfail" 603 }; 604 605 static char * 606 print_sensor(enum sensor_type type, int64_t value) 607 { 608 static char rfbuf[RFBUFCNT][RFBUFSIZ]; /* ring buffer */ 609 static int idx; 610 char *fbuf; 611 612 fbuf = rfbuf[idx++]; 613 if (idx == RFBUFCNT) 614 idx = 0; 615 616 switch (type) { 617 case SENSOR_TEMP: 618 snprintf(fbuf, RFBUFSIZ, "%.2f degC", 619 (value - 273150000) / 1000000.0); 620 break; 621 case SENSOR_FANRPM: 622 snprintf(fbuf, RFBUFSIZ, "%"PRId64" RPM", value); 623 break; 624 case SENSOR_VOLTS_DC: 625 snprintf(fbuf, RFBUFSIZ, "%.2f V DC", value / 1000000.0); 626 break; 627 case SENSOR_AMPS: 628 snprintf(fbuf, RFBUFSIZ, "%.2f A", value / 1000000.0); 629 break; 630 case SENSOR_WATTHOUR: 631 snprintf(fbuf, RFBUFSIZ, "%.2f Wh", value / 1000000.0); 632 break; 633 case SENSOR_AMPHOUR: 634 snprintf(fbuf, RFBUFSIZ, "%.2f Ah", value / 1000000.0); 635 break; 636 case SENSOR_INDICATOR: 637 snprintf(fbuf, RFBUFSIZ, "%s", value? "On" : "Off"); 638 break; 639 case SENSOR_INTEGER: 640 snprintf(fbuf, RFBUFSIZ, "%"PRId64, value); 641 break; 642 case SENSOR_PERCENT: 643 snprintf(fbuf, RFBUFSIZ, "%.2f%%", value / 1000.0); 644 break; 645 case SENSOR_LUX: 646 snprintf(fbuf, RFBUFSIZ, "%.2f lx", value / 1000000.0); 647 break; 648 case SENSOR_DRIVE: 649 if (0 < value && value < (int64_t)NELEM(drvstat)) 650 snprintf(fbuf, RFBUFSIZ, "%s", drvstat[value]); 651 else 652 snprintf(fbuf, RFBUFSIZ, "%"PRId64" ???", value); 653 break; 654 case SENSOR_TIMEDELTA: 655 snprintf(fbuf, RFBUFSIZ, "%.6f secs", value / 1000000000.0); 656 break; 657 default: 658 snprintf(fbuf, RFBUFSIZ, "%"PRId64" ???", value); 659 } 660 661 return (fbuf); 662 } 663 664 void 665 parse_config(char *cf) 666 { 667 struct sdlim_t *sdlim; 668 669 TAILQ_FOREACH(sdlim, &sdlims, entries) 670 parse_config_sdlim(sdlim, cf); 671 } 672 673 void 674 parse_config_sdlim(struct sdlim_t *sdlim, char *cf) 675 { 676 struct limits_t *p; 677 char *buf = NULL, *ebuf = NULL; 678 char node[48]; 679 char *cfa[2]; 680 681 cfa[0] = cf; 682 cfa[1] = NULL; 683 684 TAILQ_FOREACH(p, &sdlim->limits, entries) { 685 snprintf(node, sizeof(node), "hw.sensors.%s.%s%d", 686 sdlim->dxname, sensor_type_s[p->type], p->numt); 687 p->flags = 0; 688 if (cgetent(&buf, cfa, node) != 0) 689 if (cgetent(&buf, cfa, sensor_type_s[p->type]) != 0) 690 continue; 691 if (cgetcap(buf, "istatus", ':')) 692 p->flags |= SENSORSD_L_ISTATUS; 693 if (cgetstr(buf, "low", &ebuf) < 0) 694 ebuf = NULL; 695 p->lower = get_val(ebuf, 0, p->type); 696 if (cgetstr(buf, "high", &ebuf) < 0) 697 ebuf = NULL; 698 p->upper = get_val(ebuf, 1, p->type); 699 if (cgetstr(buf, "command", &ebuf) < 0) 700 ebuf = NULL; 701 if (ebuf) 702 asprintf(&(p->command), "%s", ebuf); 703 free(buf); 704 buf = NULL; 705 if (p->lower != LLONG_MIN || p->upper != LLONG_MAX) 706 p->flags |= SENSORSD_L_USERLIMIT; 707 } 708 } 709 710 int64_t 711 get_val(char *buf, int upper, enum sensor_type type) 712 { 713 double val; 714 int64_t rval = 0; 715 char *p; 716 717 if (buf == NULL) { 718 if (upper) 719 return (LLONG_MAX); 720 else 721 return (LLONG_MIN); 722 } 723 724 val = strtod(buf, &p); 725 if (buf == p) 726 err(1, "incorrect value: %s", buf); 727 728 switch(type) { 729 case SENSOR_TEMP: 730 switch(*p) { 731 case 'C': 732 printf("C"); 733 rval = val * 1000 * 1000 + 273150000; 734 break; 735 case 'F': 736 printf("F"); 737 rval = (val * 1000 * 1000 + 459670000) / 9 * 5; 738 break; 739 default: 740 errx(1, "unknown unit %s for temp sensor", p); 741 } 742 break; 743 case SENSOR_FANRPM: 744 rval = val; 745 break; 746 case SENSOR_VOLTS_DC: 747 if (*p != 'V') 748 errx(1, "unknown unit %s for voltage sensor", p); 749 rval = val * 1000 * 1000; 750 break; 751 case SENSOR_PERCENT: 752 rval = val * 1000.0; 753 break; 754 case SENSOR_INDICATOR: 755 case SENSOR_INTEGER: 756 case SENSOR_DRIVE: 757 rval = val; 758 break; 759 case SENSOR_AMPS: 760 case SENSOR_WATTHOUR: 761 case SENSOR_AMPHOUR: 762 case SENSOR_LUX: 763 rval = val * 1000 * 1000; 764 break; 765 case SENSOR_TIMEDELTA: 766 rval = val * 1000 * 1000 * 1000; 767 break; 768 default: 769 errx(1, "unsupported sensor type"); 770 /* not reached */ 771 } 772 free(buf); 773 return (rval); 774 } 775 776 /* ARGSUSED */ 777 void 778 reparse_cfg(__unused int signo) 779 { 780 reload = 1; 781 } 782