506 lines
12 KiB
C
506 lines
12 KiB
C
/* $NetBSD: envstat.c,v 1.23 2006/08/31 10:25:04 gson Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2000 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Bill Squier.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the NetBSD
|
|
* Foundation, Inc. and its contributors.
|
|
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#ifndef lint
|
|
__RCSID("$NetBSD: envstat.c,v 1.23 2006/08/31 10:25:04 gson Exp $");
|
|
#endif
|
|
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <err.h>
|
|
#include <paths.h>
|
|
|
|
#define ENVSYSUNITNAMES
|
|
#include <sys/envsys.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
int main(int, char **);
|
|
void listsensors(envsys_basic_info_t *, size_t);
|
|
size_t numsensors(int);
|
|
void fillsensors(int, envsys_tre_data_t *, envsys_basic_info_t *, size_t);
|
|
size_t longestname(envsys_basic_info_t *, size_t);
|
|
int marksensors(envsys_basic_info_t *, int *, char *, size_t);
|
|
int strtosnum(envsys_basic_info_t *, const char *, size_t);
|
|
void header(size_t, int, envsys_basic_info_t *, const int * const, size_t);
|
|
void values(size_t, int, envsys_tre_data_t *, const int * const, size_t);
|
|
void usage(void);
|
|
void printrow(int *, envsys_tre_data_t *, envsys_basic_info_t *, int, int,
|
|
size_t);
|
|
|
|
int rflag = 0;
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
int c, fd, ls, celsius;
|
|
size_t ns;
|
|
size_t interval, width, headrep, headcnt;
|
|
envsys_tre_data_t *etds;
|
|
envsys_basic_info_t *ebis;
|
|
int *cetds;
|
|
char *sensors;
|
|
const char *dev;
|
|
|
|
fd = -1;
|
|
ls = 0;
|
|
celsius = 1;
|
|
interval = 0;
|
|
width = 0;
|
|
sensors = NULL;
|
|
headrep = 22;
|
|
|
|
while ((c = getopt(argc, argv, "fi:ln:rs:w:")) != -1) {
|
|
switch(c) {
|
|
case 'r':
|
|
rflag = 1;
|
|
break;
|
|
case 'i': /* wait time between displays */
|
|
interval = atoi(optarg);
|
|
break;
|
|
case 'w': /* minimum column width */
|
|
width = atoi(optarg);
|
|
break;
|
|
case 'l': /* list sensor names */
|
|
ls = 1;
|
|
break;
|
|
case 'n': /* repeat header every headrep lines */
|
|
headrep = atoi(optarg);
|
|
break;
|
|
case 's': /* restrict display to named sensors */
|
|
sensors = (char *)malloc(strlen(optarg) + 1);
|
|
if (sensors == NULL)
|
|
exit(1);
|
|
strcpy(sensors, optarg);
|
|
break;
|
|
case 'f': /* display temp in degF */
|
|
celsius = 0;
|
|
break;
|
|
case '?':
|
|
default:
|
|
usage();
|
|
/* NOTREACHED */
|
|
}
|
|
}
|
|
|
|
if (optind < argc)
|
|
dev = argv[optind];
|
|
else
|
|
dev = _PATH_SYSMON;
|
|
|
|
if ((fd = open(dev, O_RDONLY)) == -1)
|
|
err(1, "unable to open %s", dev);
|
|
|
|
/*
|
|
* Determine number of sensors, allocate and fill arrays with
|
|
* initial information. Determine column width
|
|
*/
|
|
if ((ns = numsensors(fd)) == 0)
|
|
errx(1, "No sensors found");
|
|
|
|
cetds = (int *)malloc(ns * sizeof(int));
|
|
etds = (envsys_tre_data_t *)malloc(ns * sizeof(envsys_tre_data_t));
|
|
ebis = (envsys_basic_info_t *)malloc(ns * sizeof(envsys_basic_info_t));
|
|
|
|
if ((cetds == NULL) || (etds == NULL) || (ebis == NULL))
|
|
err(1, "Out of memory");
|
|
|
|
fillsensors(fd, etds, ebis, ns);
|
|
|
|
if (ls) {
|
|
listsensors(ebis, ns);
|
|
exit(0);
|
|
}
|
|
|
|
|
|
#define MAX(x, y) (((x) > (y)) ? (x) : (y))
|
|
if (!width) {
|
|
width = longestname(ebis, ns);
|
|
width = MAX(((79 - ns) / ns), width);
|
|
}
|
|
|
|
/* Mark which sensor numbers are to be displayed */
|
|
if (marksensors(ebis, cetds, sensors, ns) == -1)
|
|
exit(1);
|
|
|
|
if (rflag) {
|
|
if (interval == 0) {
|
|
printrow(cetds, etds, ebis, ns, celsius, width);
|
|
exit(0);
|
|
}
|
|
|
|
while (1) {
|
|
printrow(cetds, etds, ebis, ns, celsius, width);
|
|
sleep(interval);
|
|
fillsensors(fd, etds, ebis, ns);
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* If we didn't specify an interval value, print the sensors once */
|
|
if (!interval) {
|
|
if (headrep)
|
|
header(width, celsius, ebis, cetds, ns);
|
|
values(width, celsius, etds, cetds, ns);
|
|
|
|
exit (0);
|
|
}
|
|
|
|
headcnt = 0;
|
|
if (headrep)
|
|
header(width, celsius, ebis, cetds, ns);
|
|
|
|
for (;;) {
|
|
values(width, celsius, etds, cetds, ns);
|
|
if (headrep && (++headcnt == headrep)) {
|
|
headcnt = 0;
|
|
header(width, celsius, ebis, cetds, ns);
|
|
}
|
|
fflush(stdout);
|
|
|
|
sleep(interval);
|
|
|
|
fillsensors(fd, etds, ebis, ns);
|
|
}
|
|
|
|
/* NOTREACHED */
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* row wise processing
|
|
*/
|
|
void
|
|
printrow(int *cetds, envsys_tre_data_t *etds, envsys_basic_info_t *ebis,
|
|
int ns, int celsius, size_t width)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0 ; i < ns ; i++) {
|
|
if (cetds[i] == 0)
|
|
continue;
|
|
|
|
if ((etds[i].validflags & ENVSYS_FCURVALID) == 0)
|
|
continue;
|
|
|
|
if (ebis[i].units == ENVSYS_INDICATOR &&
|
|
etds[i].cur.data_s == 0)
|
|
continue;
|
|
|
|
printf("%*.*s", (int)width, (int)width, ebis[i].desc);
|
|
/* different units need some magic */
|
|
switch (ebis[i].units)
|
|
{
|
|
case ENVSYS_INDICATOR:
|
|
break;
|
|
case ENVSYS_INTEGER:
|
|
printf(": %10d", etds[i].cur.data_s);
|
|
break;
|
|
case ENVSYS_STEMP: {
|
|
double temp = (etds[i].cur.data_s / 1000000.0)
|
|
- 273.15;
|
|
if (celsius)
|
|
printf(": %10.3f degC", temp);
|
|
else {
|
|
temp = (9.0 / 5.0) * temp + 32.0;
|
|
printf(": %10.3f degF", temp);
|
|
}
|
|
break;
|
|
}
|
|
case ENVSYS_SFANRPM:
|
|
printf(": %10u RPM", etds[i].cur.data_us);
|
|
break;
|
|
default:
|
|
printf(": %10.3f %s",
|
|
etds[i].cur.data_s / 1000000.0,
|
|
envsysunitnames[ebis[i].units]);
|
|
break;
|
|
}
|
|
|
|
if (etds[i].validflags & ENVSYS_FFRACVALID) {
|
|
printf(" (%5.2f%%)",
|
|
(etds[i].cur.data_s * 100.0) /
|
|
etds[i].max.data_s);
|
|
}
|
|
|
|
printf("\n");
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* pre: cetds[i] != 0 iff sensor i should appear in the output
|
|
* post: a column header line is displayed on stdout
|
|
*/
|
|
void
|
|
header(size_t width, int celsius, envsys_basic_info_t *ebis,
|
|
const int * const cetds, size_t ns)
|
|
{
|
|
int i;
|
|
const char *s;
|
|
|
|
/* sensor names */
|
|
for (i = 0; i < ns; ++i)
|
|
if (cetds[i])
|
|
printf(" %*.*s", (int)width, (int)width, ebis[i].desc);
|
|
|
|
printf("\n");
|
|
|
|
/* units */
|
|
for (i = 0; i < ns; ++i)
|
|
if (cetds[i]) {
|
|
if ((ebis[i].units == ENVSYS_STEMP) &&
|
|
!celsius)
|
|
s = "degF";
|
|
else if (ebis[i].units >= ENVSYS_NSENSORS)
|
|
s = envsysunitnames[ENVSYS_NSENSORS];
|
|
else
|
|
s = envsysunitnames[ebis[i].units];
|
|
|
|
printf(" %*.*s", (int)width, (int)width, s);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
void
|
|
values(size_t width, int celsius, envsys_tre_data_t *etds,
|
|
const int * const cetds, size_t ns)
|
|
{
|
|
int i;
|
|
double temp;
|
|
|
|
for (i = 0; i < ns; ++i)
|
|
if (cetds[i]) {
|
|
|
|
/* * sensors without valid data */
|
|
if ((etds[i].validflags & ENVSYS_FCURVALID) == 0) {
|
|
printf(" %*.*s", (int)width, (int)width, "*");
|
|
continue;
|
|
}
|
|
|
|
switch(etds[i].units) {
|
|
case ENVSYS_INDICATOR:
|
|
printf(" %*.*s", (int)width, (int)width,
|
|
etds[i].cur.data_us ? "ON" : "OFF");
|
|
break;
|
|
case ENVSYS_STEMP:
|
|
temp = (etds[i].cur.data_us / 1000000.0) -
|
|
273.15;
|
|
if (!celsius)
|
|
temp = (9.0 / 5.0) * temp + 32.0;
|
|
printf(" %*.2f", (int)width, temp);
|
|
break;
|
|
case ENVSYS_SFANRPM:
|
|
printf(" %*u", (int)width, etds[i].cur.data_us);
|
|
break;
|
|
default:
|
|
printf(" %*.2f", (int)width, etds[i].cur.data_s /
|
|
1000000.0);
|
|
break;
|
|
}
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
|
|
/*
|
|
* post: displays usage on stderr
|
|
*/
|
|
void
|
|
usage(void)
|
|
{
|
|
|
|
(void)fprintf(stderr, "usage: %s [-fr] [-s s1,s2,...]", getprogname());
|
|
(void)fprintf(stderr, " [-i interval] [-n headrep] [-w width]");
|
|
(void)fprintf(stderr, " [device]\n");
|
|
(void)fprintf(stderr, " %s -l [device]\n", getprogname());
|
|
exit(1);
|
|
}
|
|
|
|
|
|
/*
|
|
* post: a list of sensor names supported by the device is displayed on stdout
|
|
*/
|
|
void
|
|
listsensors(envsys_basic_info_t *ebis, size_t ns)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ns; ++i)
|
|
if (ebis[i].validflags & ENVSYS_FVALID)
|
|
printf("%s\n", ebis[i].desc);
|
|
}
|
|
|
|
|
|
/*
|
|
* pre: fd contains a valid file descriptor of an envsys(4) supporting device
|
|
* post: returns the number of valid sensors provided by the device
|
|
* or -1 on error
|
|
*/
|
|
size_t
|
|
numsensors(int fd)
|
|
{
|
|
int count = 0, valid = 1;
|
|
envsys_tre_data_t etd;
|
|
etd.sensor = 0;
|
|
|
|
while (valid) {
|
|
if (ioctl(fd, ENVSYS_GTREDATA, &etd) == -1)
|
|
err(1, "Can't get sensor data");
|
|
|
|
valid = etd.validflags & ENVSYS_FVALID;
|
|
if (valid)
|
|
++count;
|
|
|
|
++etd.sensor;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
* pre: fd contains a valid file descriptor of an envsys(4) supporting device
|
|
* && ns is the number of sensors
|
|
* && etds and ebis are arrays of sufficient size
|
|
* post: returns 0 and etds and ebis arrays are filled with sensor info
|
|
* or returns -1 on failure
|
|
*/
|
|
void
|
|
fillsensors(int fd, envsys_tre_data_t *etds, envsys_basic_info_t *ebis,
|
|
size_t ns)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ns; ++i) {
|
|
ebis[i].sensor = i;
|
|
if (ioctl(fd, ENVSYS_GTREINFO, &ebis[i]) == -1)
|
|
err(1, "Can't get sensor info for sensor %d", i);
|
|
|
|
etds[i].sensor = i;
|
|
if (ioctl(fd, ENVSYS_GTREDATA, &etds[i]) == -1)
|
|
err(1, "Can't get sensor data for sensor %d", i);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* post: returns the strlen() of the longest sensor name
|
|
*/
|
|
size_t
|
|
longestname(envsys_basic_info_t *ebis, size_t ns)
|
|
{
|
|
size_t i, maxlen, cur;
|
|
|
|
maxlen = 0;
|
|
|
|
for (i = 0; i < ns; ++i) {
|
|
cur = strlen(ebis[i].desc);
|
|
if (cur > maxlen)
|
|
maxlen = cur;
|
|
}
|
|
|
|
return maxlen;
|
|
}
|
|
|
|
/*
|
|
* post: returns 0 and cetds[i] != 0 iff sensor i should appear in the output
|
|
* or returns -1
|
|
*/
|
|
int
|
|
marksensors(envsys_basic_info_t *ebis, int *cetds, char *sensors, size_t ns)
|
|
{
|
|
size_t i;
|
|
char *s;
|
|
|
|
if (sensors == NULL) {
|
|
/* No sensors specified, include them all */
|
|
for (i = 0; i < ns; ++i)
|
|
cetds[i] = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Assume no sensors in display */
|
|
memset(cetds, 0, ns * sizeof(int));
|
|
|
|
s = strtok(sensors, ",");
|
|
while (s != NULL) {
|
|
int snum;
|
|
if ((snum = strtosnum(ebis, s, ns)) != -1)
|
|
cetds[snum] = 1;
|
|
else {
|
|
warnx("Unknown sensor %s", s);
|
|
return (-1);
|
|
}
|
|
|
|
s = strtok(NULL, ",");
|
|
}
|
|
|
|
/* Check if we have at least one sensor selected for output */
|
|
for (i = 0; i < ns; ++i)
|
|
if (cetds[i] == 1)
|
|
return (0);
|
|
|
|
warnx("No sensors selected for display");
|
|
return (-1);
|
|
}
|
|
|
|
|
|
/*
|
|
* returns -1 if s is not a valid sensor name for the device
|
|
* or the sensor number of a sensor which has that name
|
|
*/
|
|
int
|
|
strtosnum(envsys_basic_info_t *ebis, const char *s, size_t ns)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = 0; i < ns; ++i) {
|
|
if((ebis[i].validflags & ENVSYS_FVALID) &&
|
|
!strcmp(s, ebis[i].desc))
|
|
return ebis[i].sensor;
|
|
}
|
|
|
|
return -1;
|
|
}
|