/* $OpenBSD: sensorsd.c,v 1.36 2007/12/05 17:28:06 cnst Exp $ */ /* * Copyright (c) 2003 Henning Brauer * Copyright (c) 2005 Matthew Gream * Copyright (c) 2006 Constantine A. Murenin * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include #include #include #include #include #include #include #include #include #include #include #include #define RFBUFSIZ 28 /* buffer size for print_sensor */ #define RFBUFCNT 4 /* ring buffers */ #define REPORT_PERIOD 60 /* report every n seconds */ #define CHECK_PERIOD 20 /* check every n seconds */ enum sensorsd_s_status { SENSORSD_S_UNSPEC, /* status is unspecified */ SENSORSD_S_INVALID, /* status is invalid, per SENSOR_FINVALID */ SENSORSD_S_WITHIN, /* status is within limits */ SENSORSD_S_OUTSIDE /* status is outside limits */ }; struct limits_t { TAILQ_ENTRY(limits_t) entries; enum sensor_type type; /* sensor type */ int numt; /* sensor number */ int64_t last_val; int64_t lower; /* lower limit */ int64_t upper; /* upper limit */ char *command; /* failure command */ time_t astatus_changed; time_t ustatus_changed; enum sensor_status astatus; /* last automatic status */ enum sensor_status astatus2; enum sensorsd_s_status ustatus; /* last user-limit status */ enum sensorsd_s_status ustatus2; int acount; /* stat change counter */ int ucount; /* stat change counter */ u_int8_t flags; /* sensorsd limit flags */ #define SENSORSD_L_USERLIMIT 0x0001 /* user specified limit */ #define SENSORSD_L_ISTATUS 0x0002 /* ignore automatic status */ }; struct sdlim_t { TAILQ_ENTRY(sdlim_t) entries; char dxname[16]; /* device unix name */ int dev; /* device number */ int sensor_cnt; TAILQ_HEAD(, limits_t) limits; }; void usage(void); struct sdlim_t *create_sdlim(struct sensordev *); void check(void); void check_sdlim(struct sdlim_t *); void execute(char *); void report(time_t); void report_sdlim(struct sdlim_t *, time_t); static char *print_sensor(enum sensor_type, int64_t); void parse_config(char *); void parse_config_sdlim(struct sdlim_t *, char **); int64_t get_val(char *, int, enum sensor_type); void reparse_cfg(int); TAILQ_HEAD(, sdlim_t) sdlims = TAILQ_HEAD_INITIALIZER(sdlims); char *configfile; volatile sig_atomic_t reload = 0; int debug = 0; void usage(void) { extern char *__progname; fprintf(stderr, "usage: %s [-d] [-c check] [-r report]\n", __progname); exit(1); } int main(int argc, char *argv[]) { struct sensordev sensordev; struct sdlim_t *sdlim; size_t sdlen = sizeof(sensordev); time_t next_report, last_report = 0, next_check; int mib[3], dev; int sleeptime, sensor_cnt = 0, ch; int check_period = CHECK_PERIOD; int report_period = REPORT_PERIOD; const char *errstr; while ((ch = getopt(argc, argv, "c:dr:")) != -1) { switch (ch) { case 'c': check_period = strtonum(optarg, 1, 600, &errstr); if (errstr) errx(1, "check %s", errstr); break; case 'd': debug = 1; break; case 'r': report_period = strtonum(optarg, 1, 600, &errstr); if (errstr) errx(1, "report %s", errstr); break; default: usage(); } } mib[0] = CTL_HW; mib[1] = HW_SENSORS; for (dev = 0; dev < MAXSENSORDEVICES; dev++) { mib[2] = dev; if (sysctl(mib, 3, &sensordev, &sdlen, NULL, 0) == -1) { if (errno != ENOENT) warn("sysctl"); continue; } sdlim = create_sdlim(&sensordev); TAILQ_INSERT_TAIL(&sdlims, sdlim, entries); sensor_cnt += sdlim->sensor_cnt; } if (sensor_cnt == 0) errx(1, "no sensors found"); openlog("sensorsd", LOG_PID | LOG_NDELAY, LOG_DAEMON); if (configfile == NULL) if (asprintf(&configfile, "/etc/sensorsd.conf") == -1) err(1, "out of memory"); parse_config(configfile); if (debug == 0 && daemon(0, 0) == -1) err(1, "unable to fork"); signal(SIGHUP, reparse_cfg); signal(SIGCHLD, SIG_IGN); syslog(LOG_INFO, "startup, system has %d sensors", sensor_cnt); next_check = next_report = time(NULL); for (;;) { if (reload) { parse_config(configfile); syslog(LOG_INFO, "configuration reloaded"); reload = 0; } if (next_check <= time(NULL)) { check(); next_check = time(NULL) + check_period; } if (next_report <= time(NULL)) { report(last_report); last_report = next_report; next_report = time(NULL) + report_period; } if (next_report < next_check) sleeptime = next_report - time(NULL); else sleeptime = next_check - time(NULL); if (sleeptime > 0) sleep(sleeptime); } } struct sdlim_t * create_sdlim(struct sensordev *snsrdev) { struct sensor sensor; struct sdlim_t *sdlim; struct limits_t *limit; size_t slen = sizeof(sensor); int mib[5], numt; enum sensor_type type; if ((sdlim = calloc(1, sizeof(struct sdlim_t))) == NULL) err(1, "calloc"); strlcpy(sdlim->dxname, snsrdev->xname, sizeof(sdlim->dxname)); mib[0] = CTL_HW; mib[1] = HW_SENSORS; mib[2] = sdlim->dev = snsrdev->num; TAILQ_INIT(&sdlim->limits); for (type = 0; type < SENSOR_MAX_TYPES; type++) { mib[3] = type; for (numt = 0; numt < snsrdev->maxnumt[type]; numt++) { mib[4] = numt; if (sysctl(mib, 5, &sensor, &slen, NULL, 0) == -1) { if (errno != ENOENT) warn("sysctl"); continue; } if ((limit = calloc(1, sizeof(struct limits_t))) == NULL) err(1, "calloc"); limit->type = type; limit->numt = numt; TAILQ_INSERT_TAIL(&sdlim->limits, limit, entries); sdlim->sensor_cnt++; } } return (sdlim); } void check(void) { struct sdlim_t *sdlim; TAILQ_FOREACH(sdlim, &sdlims, entries) check_sdlim(sdlim); } void check_sdlim(struct sdlim_t *sdlim) { struct sensor sensor; struct limits_t *limit; size_t len; int mib[5]; mib[0] = CTL_HW; mib[1] = HW_SENSORS; mib[2] = sdlim->dev; len = sizeof(sensor); TAILQ_FOREACH(limit, &sdlim->limits, entries) { if ((limit->flags & SENSORSD_L_ISTATUS) && !(limit->flags & SENSORSD_L_USERLIMIT)) continue; mib[3] = limit->type; mib[4] = limit->numt; if (sysctl(mib, 5, &sensor, &len, NULL, 0) == -1) err(1, "sysctl"); if (!(limit->flags & SENSORSD_L_ISTATUS)) { enum sensor_status newastatus = sensor.status; if (limit->astatus != newastatus) { if (limit->astatus2 != newastatus) { limit->astatus2 = newastatus; limit->acount = 0; } else if (++limit->acount >= 3) { limit->last_val = sensor.value; limit->astatus2 = limit->astatus = newastatus; limit->astatus_changed = time(NULL); } } } if (limit->flags & SENSORSD_L_USERLIMIT) { enum sensorsd_s_status newustatus; if (sensor.flags & SENSOR_FINVALID) newustatus = SENSORSD_S_INVALID; else if (sensor.value > limit->upper || sensor.value < limit->lower) newustatus = SENSORSD_S_OUTSIDE; else newustatus = SENSORSD_S_WITHIN; if (limit->ustatus != newustatus) { if (limit->ustatus2 != newustatus) { limit->ustatus2 = newustatus; limit->ucount = 0; } else if (++limit->ucount >= 3) { limit->last_val = sensor.value; limit->ustatus2 = limit->ustatus = newustatus; limit->ustatus_changed = time(NULL); } } } } } void execute(char *command) { char *argp[] = {"sh", "-c", command, NULL}; switch (fork()) { case -1: syslog(LOG_CRIT, "execute: fork() failed"); break; case 0: execv("/bin/sh", argp); _exit(1); /* NOTREACHED */ default: break; } } void report(time_t last_report) { struct sdlim_t *sdlim; TAILQ_FOREACH(sdlim, &sdlims, entries) report_sdlim(sdlim, last_report); } void report_sdlim(struct sdlim_t *sdlim, time_t last_report) { struct limits_t *limit; TAILQ_FOREACH(limit, &sdlim->limits, entries) { if ((limit->astatus_changed <= last_report) && (limit->ustatus_changed <= last_report)) continue; if (limit->astatus_changed > last_report) { const char *as = NULL; switch (limit->astatus) { case SENSOR_S_UNSPEC: as = ""; break; case SENSOR_S_OK: as = ", OK"; break; case SENSOR_S_WARN: as = ", WARN"; break; case SENSOR_S_CRIT: as = ", CRITICAL"; break; case SENSOR_S_UNKNOWN: as = ", UNKNOWN"; break; } syslog(limit->astatus == SENSOR_S_OK ? LOG_INFO : LOG_ALERT, "%s.%s%d: %s%s", sdlim->dxname, sensor_type_s[limit->type], limit->numt, print_sensor(limit->type, limit->last_val), as); } if (limit->ustatus_changed > last_report) { char us[BUFSIZ]; switch (limit->ustatus) { case SENSORSD_S_UNSPEC: snprintf(us, sizeof(us), "ustatus uninitialised"); break; case SENSORSD_S_INVALID: snprintf(us, sizeof(us), "marked invalid"); break; case SENSORSD_S_WITHIN: snprintf(us, sizeof(us), "within limits: %s", print_sensor(limit->type, limit->last_val)); break; case SENSORSD_S_OUTSIDE: snprintf(us, sizeof(us), "exceeds limits: %s", print_sensor(limit->type, limit->last_val)); break; } syslog(limit->ustatus == SENSORSD_S_WITHIN ? LOG_INFO : LOG_ALERT, "%s.%s%d: %s", sdlim->dxname, sensor_type_s[limit->type], limit->numt, us); } if (limit->command) { int i = 0, n = 0, r; char *cmd = limit->command; char buf[BUFSIZ]; int len = sizeof(buf); buf[0] = '\0'; for (i = n = 0; n < len; ++i) { if (cmd[i] == '\0') { buf[n++] = '\0'; break; } if (cmd[i] != '%') { buf[n++] = limit->command[i]; continue; } i++; if (cmd[i] == '\0') { buf[n++] = '\0'; break; } switch (cmd[i]) { case 'x': r = snprintf(&buf[n], len - n, "%s", sdlim->dxname); break; case 't': r = snprintf(&buf[n], len - n, "%s", sensor_type_s[limit->type]); break; case 'n': r = snprintf(&buf[n], len - n, "%d", limit->numt); break; case '2': r = snprintf(&buf[n], len - n, "%s", print_sensor(limit->type, limit->last_val)); break; case '3': r = snprintf(&buf[n], len - n, "%s", print_sensor(limit->type, limit->lower)); break; case '4': r = snprintf(&buf[n], len - n, "%s", print_sensor(limit->type, limit->upper)); break; default: r = snprintf(&buf[n], len - n, "%%%c", cmd[i]); break; } if (r < 0 || (r >= len - n)) { syslog(LOG_CRIT, "could not parse " "command"); return; } if (r > 0) n += r; } if (buf[0]) execute(buf); } } } const char *drvstat[] = { NULL, "empty", "ready", "powerup", "online", "idle", "active", "rebuild", "powerdown", "fail", "pfail" }; static char * print_sensor(enum sensor_type type, int64_t value) { static char rfbuf[RFBUFCNT][RFBUFSIZ]; /* ring buffer */ static int idx; char *fbuf; fbuf = rfbuf[idx++]; if (idx == RFBUFCNT) idx = 0; switch (type) { case SENSOR_TEMP: snprintf(fbuf, RFBUFSIZ, "%.2f degC", (value - 273150000) / 1000000.0); break; case SENSOR_FANRPM: snprintf(fbuf, RFBUFSIZ, "%lld RPM", value); break; case SENSOR_VOLTS_DC: snprintf(fbuf, RFBUFSIZ, "%.2f V DC", value / 1000000.0); break; case SENSOR_AMPS: snprintf(fbuf, RFBUFSIZ, "%.2f A", value / 1000000.0); break; case SENSOR_WATTHOUR: snprintf(fbuf, RFBUFSIZ, "%.2f Wh", value / 1000000.0); break; case SENSOR_AMPHOUR: snprintf(fbuf, RFBUFSIZ, "%.2f Ah", value / 1000000.0); break; case SENSOR_INDICATOR: snprintf(fbuf, RFBUFSIZ, "%s", value? "On" : "Off"); break; case SENSOR_INTEGER: snprintf(fbuf, RFBUFSIZ, "%lld", value); break; case SENSOR_PERCENT: snprintf(fbuf, RFBUFSIZ, "%.2f%%", value / 1000.0); break; case SENSOR_LUX: snprintf(fbuf, RFBUFSIZ, "%.2f lx", value / 1000000.0); break; case SENSOR_DRIVE: if (0 < value && value < sizeof(drvstat)/sizeof(drvstat[0])) snprintf(fbuf, RFBUFSIZ, "%s", drvstat[value]); else snprintf(fbuf, RFBUFSIZ, "%lld ???", value); break; case SENSOR_TIMEDELTA: snprintf(fbuf, RFBUFSIZ, "%.6f secs", value / 1000000000.0); break; default: snprintf(fbuf, RFBUFSIZ, "%lld ???", value); } return (fbuf); } void parse_config(char *cf) { struct sdlim_t *sdlim; char **cfa; if ((cfa = calloc(2, sizeof(char *))) == NULL) err(1, "calloc"); cfa[0] = cf; cfa[1] = NULL; TAILQ_FOREACH(sdlim, &sdlims, entries) parse_config_sdlim(sdlim, cfa); free(cfa); } void parse_config_sdlim(struct sdlim_t *sdlim, char **cfa) { struct limits_t *p; char *buf = NULL, *ebuf = NULL; char node[48]; TAILQ_FOREACH(p, &sdlim->limits, entries) { snprintf(node, sizeof(node), "hw.sensors.%s.%s%d", sdlim->dxname, sensor_type_s[p->type], p->numt); p->flags = 0; if (cgetent(&buf, cfa, node) != 0) if (cgetent(&buf, cfa, sensor_type_s[p->type]) != 0) continue; if (cgetcap(buf, "istatus", ':')) p->flags |= SENSORSD_L_ISTATUS; if (cgetstr(buf, "low", &ebuf) < 0) ebuf = NULL; p->lower = get_val(ebuf, 0, p->type); if (cgetstr(buf, "high", &ebuf) < 0) ebuf = NULL; p->upper = get_val(ebuf, 1, p->type); if (cgetstr(buf, "command", &ebuf) < 0) ebuf = NULL; if (ebuf) asprintf(&(p->command), "%s", ebuf); free(buf); buf = NULL; if (p->lower != LLONG_MIN || p->upper != LLONG_MAX) p->flags |= SENSORSD_L_USERLIMIT; } } int64_t get_val(char *buf, int upper, enum sensor_type type) { double val; int64_t rval = 0; char *p; if (buf == NULL) { if (upper) return (LLONG_MAX); else return (LLONG_MIN); } val = strtod(buf, &p); if (buf == p) err(1, "incorrect value: %s", buf); switch(type) { case SENSOR_TEMP: switch(*p) { case 'C': printf("C"); rval = (val + 273.16) * 1000 * 1000; break; case 'F': printf("F"); rval = ((val - 32.0) / 9 * 5 + 273.16) * 1000 * 1000; break; default: errx(1, "unknown unit %s for temp sensor", p); } break; case SENSOR_FANRPM: rval = val; break; case SENSOR_VOLTS_DC: if (*p != 'V') errx(1, "unknown unit %s for voltage sensor", p); rval = val * 1000 * 1000; break; case SENSOR_PERCENT: rval = val * 1000.0; break; case SENSOR_INDICATOR: case SENSOR_INTEGER: case SENSOR_DRIVE: rval = val; break; case SENSOR_AMPS: case SENSOR_WATTHOUR: case SENSOR_AMPHOUR: case SENSOR_LUX: rval = val * 1000 * 1000; break; case SENSOR_TIMEDELTA: rval = val * 1000 * 1000 * 1000; break; default: errx(1, "unsupported sensor type"); /* not reached */ } free(buf); return (rval); } /* ARGSUSED */ void reparse_cfg(int signo) { reload = 1; }