wt/lm-sensors
1
0 Fork 0
mirror of https://github.com/lm-sensors/lm-sensors.git synced 2026-10-20 11:29:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Made a few changes to nonstandard sensord:

Browse Source 
. added support for via686a and other new chips
. added support for alarms and beeps
. updated to log through syslog instead of a custom logfile
. updated so when run as "sensors" (ln -s sensord sensors) it
  mimics the existing sensors command except for formatting
. modularized a bit
Yet to do:
. complete support for alarm checking without sensor logging
. signal alarms through syslog level ALERT
. add final support for multivalued alarms
. check up on some questions about existing sensors command
. update manual page inc. notes on syslog usage
. test more fully
-- merlin


git-svn-id: http://lm-sensors.org/svn/lm-sensors/trunk@828 7894878c-1315-0410-8ee3-d5d059ff63e0
This commit is contained in:
Merlin Hughes committed 2000-07-02 22:49:34 +00:00
1 parent 93f3a9f7ac
commit ae68e2238c
8 files changed
+1202 -509
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

prog/sensord/Module.mk
+1 -1
View File
@@ -27,7 +27,7 @@ PROGSENSORDMAN1FILES := $(MODULE_DIR)/sensord.8
# Regrettably, even 'simply expanded variables' will not put their currently
# defined value verbatim into the command-list of rules...
PROGSENSORDTARGETS := $(MODULE_DIR)/sensord
PROGSENSORDSOURCES := $(MODULE_DIR)/sensord.c $(MODULE_DIR)/chips.c
PROGSENSORDSOURCES := $(MODULE_DIR)/args.c $(MODULE_DIR)/chips.c $(MODULE_DIR)/lib.c $(MODULE_DIR)/sense.c $(MODULE_DIR)/sensord.c
# Include all dependency files. We use '.rd' to indicate this will create
# executables.
prog/sensord/args.c
+211
View File
@@ -0,0 +1,211 @@
/*
* sensord
*
* A daemon that periodically logs sensor information to syslog.
*
* Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <syslog.h>
#include "sensord.h"
#include "lib/error.h"
#define MAX_CHIP_NAMES 32
int isDaemon = 0;
const char *sensorsCfgFile = "sensors.conf";
int sleepTime = 5 * 60;
int logTime = 30 * 60;
int syslogFacility = LOG_LOCAL4;
int doSet = 0;
sensors_chip_name chipNames[MAX_CHIP_NAMES];
int numChipNames = 0;
static int
parseTime
(char *arg) {
char *end;
int value = strtoul (arg, &end, 10);
if ((end > arg) && (*end == 's')) {
++ end;
} else if ((end > arg) && (*end == 'm')) {
value *= 60;
++ end;
} else if ((end > arg) && (*end == 'h')) {
value *= 60 * 60;
++ end;
}
if ((end == arg) || *end) {
fprintf (stderr, "Error parsing time value `%s'.\n", arg);
return -1;
}
return value;
}
static struct {
const char *name;
int id;
} facilities[] = {
{ "local0", LOG_LOCAL0 }, { "local1", LOG_LOCAL1 },
{ "local2", LOG_LOCAL2 }, { "local3", LOG_LOCAL3 },
{ "local4", LOG_LOCAL4 }, { "local5", LOG_LOCAL5 },
{ "local6", LOG_LOCAL6 }, { "local7", LOG_LOCAL7 },
{ "daemon", LOG_DAEMON }, { "user", LOG_USER },
{ NULL }
};
static int
parseFacility
(char *arg) {
int i = 0;
while (facilities[i].name && strcasecmp (arg, facilities[i].name))
++ i;
if (!facilities[i].name) {
fprintf (stderr, "Error parsing facility value `%s'.\n", arg);
return -1;
}
return facilities[i].id;
}
/* TODO: -s, --set */
static const char *daemonSyntax =
" -i, --interval <time> -- interval between checking sensors (default 5m)\n"
" -l, --log-interval <time> -- interval between logging sensors (default 30m)\n"
" -f, --syslog-facility <f> -- syslog facility to use (default local4)\n";
static const char *appSyntax =
" -s, --set -- execute set statements too (root only)\n";
static const char *commonSyntax =
" -c, --config-file <file> -- configuration file (default sensors.conf)\n"
" -v, --version -- display version and exit\n"
" -h, --help -- display help and exit\n"
"\n"
"If no path is specified, a list of directories is examined for the config file;\n"
"specify the filename `-' to read the config file from stdin.\n"
"\n"
"If no chips are specified, all chip info will be printed.\n";
static const char *daemonShortOptions = "i:l:f:c:vh";
static const struct option daemonLongOptions[] = {
{ "interval", required_argument, NULL, 'i' },
{ "log-interval", required_argument, NULL, 'l' },
{ "syslog-facility", required_argument, NULL, 'f' },
{ "config-file", required_argument, NULL, 'c' },
{ "version", no_argument, NULL, 'v' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
static const char *appShortOptions = "sc:vh";
static const struct option appLongOptions[] = {
{ "set", no_argument, NULL, 's' },
{ "config-file", required_argument, NULL, 'c' },
{ "version", no_argument, NULL, 'v' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
int
parseArgs
(int argc, char **argv) {
int c;
const char *shortOptions;
const struct option *longOptions;
isDaemon = (argv[0][strlen (argv[0]) - 1] == 'd');
shortOptions = isDaemon ? daemonShortOptions : appShortOptions;
longOptions = isDaemon ? daemonLongOptions : appLongOptions;
while ((c = getopt_long (argc, argv, shortOptions, longOptions, NULL)) != EOF) {
switch(c) {
case 'i':
if ((sleepTime = parseTime (optarg)) < 0)
return -1;
break;
case 'l':
if ((logTime = parseTime (optarg)) < 0)
return -1;
break;
case 'f':
if ((syslogFacility = parseFacility (optarg)) < 0)
return -1;
break;
case 's':
doSet = 1;
break;
case 'c':
if ((sensorsCfgFile = strdup (optarg)) == NULL)
return -1;
break;
case 'v':
printf ("sensord version %s\n", version);
exit (EXIT_SUCCESS);
break;
case 'h':
printf ("Syntax: %s {options} {chips}\n%s%s", argv[0], isDaemon ? daemonSyntax : appSyntax, commonSyntax);
exit (EXIT_SUCCESS);
break;
case ':':
case '?':
printf ("Try `%s --help' for more information.\n", argv[0]);
return -1;
break;
default:
fprintf (stderr, "Internal error while parsing options.\n");
return -1;
break;
}
}
if (logTime < sleepTime)
logTime = sleepTime;
return 0;
}
int
parseChips
(int argc, char **argv) {
if (optind == argc) {
chipNames[0].prefix = SENSORS_CHIP_NAME_PREFIX_ANY;
chipNames[0].bus = SENSORS_CHIP_NAME_BUS_ANY;
chipNames[0].addr = SENSORS_CHIP_NAME_ADDR_ANY;
numChipNames = 1;
} else {
int i, n = argc - optind, err;
if (n > MAX_CHIP_NAMES) {
fprintf (stderr, "Too many chip names.\n");
return -1;
}
for (i = 0; i < n; ++ i) {
char *arg = argv[optind + i];
if ((err = sensors_parse_chip_name (arg, chipNames + i))) {
fprintf (stderr, "Invalid chip name `%s': %s\n", arg, sensors_strerror (err));
return -1;
}
}
numChipNames = n;
}
return 0;
}
prog/sensord/chips.c
+512 -204
View File
@@ -1,10 +1,9 @@
/*
* sensord
*
* A daemon that logs all sensor information to /var/log/sensors
* every 5 minutes.
* A daemon that periodically logs sensor information to syslog.
*
* Copyright (c) 1999 Merlin Hughes <merlin@merlin.org>
* Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
*
* 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
@@ -21,70 +20,118 @@
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "lib/sensors.h"
#include "lib/chips.h"
#include <stdio.h>
#include <stdlib.h>
#include "sensord.h"
#include "lib/chips.h"
#include "kernel/include/sensors.h"
/* missing: "gl520sm", "thmc50", "adm1022" */
/* I don't support gl518sm-r00 - but neither does sensors */
/* Should the maxilife funky fan stuff be in sensors.conf? */
/* I don't support alarms. */
/* N.B: missing from sensors (and this) but in lib/chips.h: "gl520sm", "thmc50", "adm1022" */
/** formatters **/
static char buff[4096];
static char *
fmtValu_0
(double values[]) {
sprintf (buff, "%.0f", values[0]);
fmtExtra
(int alarm, int beep) {
if (alarm)
sprintf (buff + strlen (buff), " [ALARM]");
if (beep)
sprintf (buff + strlen (buff), " [BEEP]");
return buff;
}
static char *
fmtValu_0
(double values[], int alarm, int beep) {
sprintf (buff, "%.0f", values[0]);
return fmtExtra (alarm, beep);
}
static char *
fmtTemps_0
(double values[]) {
(double values[], int alarm, int beep) {
sprintf (buff, "%.0f C (limit = %.0f C, hysteresis = %.0f C)", values[0], values[1], values[2]);
return buff;
return fmtExtra (alarm, beep);
}
static char *
fmtTemps_1
(double values[]) {
(double values[], int alarm, int beep) {
sprintf (buff, "%.1f C (limit = %.1f C, hysteresis = %.1f C)", values[0], values[1], values[2]);
return buff;
return fmtExtra (alarm, beep);
}
static char *
fmtVolt_2
(double values[]) {
(double values[], int alarm, int beep) {
sprintf (buff, "%+.2f V", values[0]);
return buff;
return fmtExtra (alarm, beep);
}
static char *
fmtVolts_2
(double values[]) {
(double values[], int alarm, int beep) {
sprintf (buff, "%+.2f V (min = %+.2f V, max = %+.2f V)", values[0], values[1], values[2]);
return buff;
return fmtExtra (alarm, beep);
}
static char *
fmtFans_0
(double values[]) {
(double values[], int alarm, int beep) {
sprintf (buff, "%.0f RPM (min = %.0f RPM, div = %.0f)", values[0], values[1], values[2]);
return buff;
return fmtExtra (alarm, beep);
}
static char *
fmtMHz_2
(double values[]) {
(double values[], int alarm, int beep) {
sprintf (buff, "%.2f MHz (min = %.2f MHz, max = %.2f MHz)", values[0], values[1], values[2]);
return buff;
return fmtExtra (alarm, beep);
}
static char *
fmtChassisIntrusionDetection
(double values[], int alarm, int beep) {
sprintf (buff, "Chassis intrusion detection");
return fmtExtra (alarm, beep);
}
static char *
fmtBoardTemperatureInput
(double values[], int alarm, int beep) {
sprintf (buff, "Board temperature input"); /* N.B: "(usually LM75 chips)" */
return fmtExtra (alarm, beep);
}
static char *
fmtSoundAlarm
(double values[], int alarm, int beep) {
sprintf (buff, "Sound alarm %s", (values[0] < 0.5) ? "disabled" : "enabled");
return fmtExtra (alarm, beep);
}
static char *
fmtInt
(double values[], int alarm, int beep) {
sprintf (buff, "%d", (int) values[0]);
return fmtExtra (alarm, beep);
}
static char *
fmtIntCrossInt
(double values[], int alarm, int beep) {
sprintf (buff, "%dx%d", (int) values[0], (int) values[1]);
return fmtExtra (alarm, beep);
}
static char *
fmtIntDashInt
(double values[], int alarm, int beep) {
sprintf (buff, "%d-%d", (int) values[0], (int) values[1]);
return fmtExtra (alarm, beep);
}
/** LM75 **/
@@ -93,373 +140,634 @@ static const char *lm75_names[] = {
SENSORS_LM75_PREFIX, NULL
};
static FeatureDescriptor lm75_features[] = {
{ fmtTemps_1, SENSORS_LM75_TEMP,
static const FeatureDescriptor lm75_features[] = {
{ fmtTemps_1, 0, 0,
{ SENSORS_LM75_TEMP, SENSORS_LM75_TEMP_HYST, SENSORS_LM75_TEMP_OVER, -1 } },
{ NULL }
};
static const ChipDescriptor lm75_chip = {
lm75_names, lm75_features, 0, 0
};
/** ADM1021 **/
static const char *adm1021_names[] = {
SENSORS_ADM1021_PREFIX, NULL
};
static FeatureDescriptor adm1021_features[] = {
{ fmtTemps_0, SENSORS_ADM1021_TEMP,
static const FeatureDescriptor adm1021_features[] = {
{ fmtTemps_0, ADM1021_ALARM_TEMP_HIGH | ADM1021_ALARM_TEMP_LOW, 0, /* TODO!! */
{ SENSORS_ADM1021_TEMP, SENSORS_ADM1021_TEMP_OVER, SENSORS_ADM1021_TEMP_HYST, -1 } },
{ fmtTemps_0, SENSORS_ADM1021_REMOTE_TEMP,
{ fmtTemps_0, ADM1021_ALARM_RTEMP_HIGH | ADM1021_ALARM_RTEMP_LOW | ADM1021_ALARM_RTEMP_NA, 0, /* TODO!! */
{ SENSORS_ADM1021_REMOTE_TEMP, SENSORS_ADM1021_REMOTE_TEMP_OVER, SENSORS_ADM1021_REMOTE_TEMP_HYST, -1 } },
{ fmtValu_0, SENSORS_ADM1021_DIE_CODE,
{ fmtValu_0, 0, 0,
{ SENSORS_ADM1021_DIE_CODE, -1 } },
{ NULL }
};
static const ChipDescriptor adm1021_chip = {
adm1021_names, adm1021_features, SENSORS_ADM1021_ALARMS, 0
};
/** MAX1617 **/
static const char *max1617_names[] = {
SENSORS_MAX1617_PREFIX, SENSORS_MAX1617A_PREFIX, SENSORS_THMC10_PREFIX, SENSORS_LM84_PREFIX, SENSORS_GL523_PREFIX, NULL
};
static FeatureDescriptor max1617_features[] = {
{ fmtTemps_0, SENSORS_ADM1021_TEMP,
{ SENSORS_ADM1021_TEMP, SENSORS_ADM1021_TEMP_OVER, SENSORS_ADM1021_TEMP_HYST, -1 } },
{ fmtTemps_0, SENSORS_ADM1021_REMOTE_TEMP,
{ SENSORS_ADM1021_REMOTE_TEMP, SENSORS_ADM1021_REMOTE_TEMP_OVER, SENSORS_ADM1021_REMOTE_TEMP_HYST, -1 } },
static const FeatureDescriptor max1617_features[] = {
{ fmtTemps_0, ADM1021_ALARM_TEMP_HIGH | ADM1021_ALARM_TEMP_LOW, 0, /* TODO!! */
{ SENSORS_MAX1617_TEMP, SENSORS_MAX1617_TEMP_OVER, SENSORS_MAX1617_TEMP_HYST, -1 } },
{ fmtTemps_0, ADM1021_ALARM_RTEMP_HIGH | ADM1021_ALARM_RTEMP_LOW | ADM1021_ALARM_RTEMP_NA, 0, /* TODO!! */
{ SENSORS_MAX1617_REMOTE_TEMP, SENSORS_MAX1617_REMOTE_TEMP_OVER, SENSORS_MAX1617_REMOTE_TEMP_HYST, -1 } },
{ NULL }
};
static const ChipDescriptor max1617_chip = {
max1617_names, max1617_features, SENSORS_MAX1617_ALARMS, 0
};
/** ADM9240 **/
static const char *adm9240_names[] = {
SENSORS_ADM9240_PREFIX, SENSORS_DS1780_PREFIX, SENSORS_LM81_PREFIX, NULL
};
static FeatureDescriptor adm9240_features[] = {
{ fmtVolts_2, SENSORS_ADM9240_IN0,
static const FeatureDescriptor adm9240_features[] = {
{ fmtVolts_2, ADM9240_ALARM_IN0, 0,
{ SENSORS_ADM9240_IN0, SENSORS_ADM9240_IN0_MIN, SENSORS_ADM9240_IN0_MAX, -1 } },
{ fmtVolts_2, SENSORS_ADM9240_IN1,
{ fmtVolts_2, ADM9240_ALARM_IN1, 0,
{ SENSORS_ADM9240_IN1, SENSORS_ADM9240_IN1_MIN, SENSORS_ADM9240_IN1_MAX, -1 } },
{ fmtVolts_2, SENSORS_ADM9240_IN2,
{ fmtVolts_2, ADM9240_ALARM_IN2, 0,
{ SENSORS_ADM9240_IN2, SENSORS_ADM9240_IN2_MIN, SENSORS_ADM9240_IN2_MAX, -1 } },
{ fmtVolts_2, SENSORS_ADM9240_IN3,
{ fmtVolts_2, ADM9240_ALARM_IN3, 0,
{ SENSORS_ADM9240_IN3, SENSORS_ADM9240_IN3_MIN, SENSORS_ADM9240_IN3_MAX, -1 } },
{ fmtVolts_2, SENSORS_ADM9240_IN4,
{ fmtVolts_2, ADM9240_ALARM_IN4, 0,
{ SENSORS_ADM9240_IN4, SENSORS_ADM9240_IN4_MIN, SENSORS_ADM9240_IN4_MAX, -1 } },
{ fmtVolts_2, SENSORS_ADM9240_IN5,
{ fmtVolts_2, ADM9240_ALARM_IN5, 0,
{ SENSORS_ADM9240_IN5, SENSORS_ADM9240_IN5_MIN, SENSORS_ADM9240_IN5_MAX, -1 } },
{ fmtFans_0, SENSORS_ADM9240_FAN1,
{ fmtFans_0, ADM9240_ALARM_FAN1, 0,
{ SENSORS_ADM9240_FAN1, SENSORS_ADM9240_FAN1_MIN, SENSORS_ADM9240_FAN1_DIV, -1 } },
{ fmtFans_0, SENSORS_ADM9240_FAN2,
{ fmtFans_0, ADM9240_ALARM_FAN2, 0,
{ SENSORS_ADM9240_FAN2, SENSORS_ADM9240_FAN2_MIN, SENSORS_ADM9240_FAN2_DIV, -1 } },
{ fmtTemps_0, SENSORS_ADM9240_TEMP,
{ fmtTemps_0, ADM9240_ALARM_TEMP, 0,
{ SENSORS_ADM9240_TEMP, SENSORS_ADM9240_TEMP_OVER, SENSORS_ADM9240_TEMP_HYST, -1 } },
{ fmtVolt_2, SENSORS_ADM9240_VID,
{ fmtVolt_2, 0, 0,
{ SENSORS_ADM9240_VID, -1 } },
{ fmtChassisIntrusionDetection, ADM9240_ALARM_CHAS, 0,
{ SENSORS_ADM9240_ALARMS, -1 } },
{ NULL }
};
static const ChipDescriptor adm9240_chip = {
adm9240_names, adm9240_features, SENSORS_ADM9240_ALARMS, 0
};
/** LM78 **/
static const char *lm78_names[] = {
SENSORS_LM78_PREFIX, SENSORS_LM78J_PREFIX, SENSORS_LM79_PREFIX, NULL
};
static const FeatureDescriptor lm78_features[] = {
{ fmtVolts_2, LM78_ALARM_IN0, 0,
{ SENSORS_LM78_IN0, SENSORS_LM78_IN0_MIN, SENSORS_LM78_IN0_MAX, -1 } },
{ fmtVolts_2, LM78_ALARM_IN1, 0,
{ SENSORS_LM78_IN1, SENSORS_LM78_IN1_MIN, SENSORS_LM78_IN1_MAX, -1 } },
{ fmtVolts_2, LM78_ALARM_IN2, 0,
{ SENSORS_LM78_IN2, SENSORS_LM78_IN2_MIN, SENSORS_LM78_IN2_MAX, -1 } },
{ fmtVolts_2, LM78_ALARM_IN3, 0,
{ SENSORS_LM78_IN3, SENSORS_LM78_IN3_MIN, SENSORS_LM78_IN3_MAX, -1 } },
{ fmtVolts_2, LM78_ALARM_IN4, 0,
{ SENSORS_LM78_IN4, SENSORS_LM78_IN4_MIN, SENSORS_LM78_IN4_MAX, -1 } },
{ fmtVolts_2, LM78_ALARM_IN5, 0,
{ SENSORS_LM78_IN5, SENSORS_LM78_IN5_MIN, SENSORS_LM78_IN5_MAX, -1 } },
{ fmtVolts_2, LM78_ALARM_IN6, 0,
{ SENSORS_LM78_IN6, SENSORS_LM78_IN6_MIN, SENSORS_LM78_IN6_MAX, -1 } },
{ fmtFans_0, LM78_ALARM_FAN1, 0,
{ SENSORS_LM78_FAN1, SENSORS_LM78_FAN1_MIN, SENSORS_LM78_FAN1_DIV, -1 } },
{ fmtFans_0, LM78_ALARM_FAN2, 0,
{ SENSORS_LM78_FAN2, SENSORS_LM78_FAN2_MIN, SENSORS_LM78_FAN2_DIV, -1 } },
{ fmtFans_0, LM78_ALARM_FAN3, 0,
{ SENSORS_LM78_FAN3, SENSORS_LM78_FAN3_MIN, SENSORS_LM78_FAN3_DIV, -1 } },
{ fmtTemps_0, LM78_ALARM_TEMP, 0,
{ SENSORS_LM78_TEMP, SENSORS_LM78_TEMP_OVER, SENSORS_LM78_TEMP_HYST, -1 } },
{ fmtBoardTemperatureInput, LM78_ALARM_BTI, 0,
{ SENSORS_LM78_ALARMS, -1 } },
{ fmtChassisIntrusionDetection, LM78_ALARM_CHAS, 0,
{ SENSORS_LM78_ALARMS, -1 } },
{ fmtVolt_2, 0, 0,
{ SENSORS_LM78_VID, -1 } },
{ NULL }
};
static const ChipDescriptor lm78_chip = {
lm78_names, lm78_features, SENSORS_LM78_ALARMS, 0
};
/** SIS5595 **/
static const char *sis5595_names[] = {
SENSORS_SIS5595_PREFIX, NULL
};
static FeatureDescriptor sis5595_features[] = {
{ fmtVolts_2, SENSORS_SIS5595_IN0,
static const FeatureDescriptor sis5595_features[] = {
{ fmtVolts_2, SIS5595_ALARM_IN0, 0,
{ SENSORS_SIS5595_IN0, SENSORS_SIS5595_IN0_MIN, SENSORS_SIS5595_IN0_MAX, -1 } },
{ fmtVolts_2, SENSORS_SIS5595_IN1,
{ fmtVolts_2, SIS5595_ALARM_IN1, 0,
{ SENSORS_SIS5595_IN1, SENSORS_SIS5595_IN1_MIN, SENSORS_SIS5595_IN1_MAX, -1 } },
{ fmtVolts_2, SENSORS_SIS5595_IN2,
{ fmtVolts_2, SIS5595_ALARM_IN2, 0,
{ SENSORS_SIS5595_IN2, SENSORS_SIS5595_IN2_MIN, SENSORS_SIS5595_IN2_MAX, -1 } },
{ fmtVolts_2, SENSORS_SIS5595_IN3,
{ fmtVolts_2, SIS5595_ALARM_IN3, 0,
{ SENSORS_SIS5595_IN3, SENSORS_SIS5595_IN3_MIN, SENSORS_SIS5595_IN3_MAX, -1 } },
{ fmtFans_0, SENSORS_SIS5595_FAN1,
{ fmtFans_0, SIS5595_ALARM_FAN1, 0,
{ SENSORS_SIS5595_FAN1, SENSORS_SIS5595_FAN1_MIN, SENSORS_SIS5595_FAN1_DIV, -1 } },
{ fmtFans_0, SENSORS_SIS5595_FAN2,
{ fmtFans_0, SIS5595_ALARM_FAN2, 0,
{ SENSORS_SIS5595_FAN2, SENSORS_SIS5595_FAN2_MIN, SENSORS_SIS5595_FAN2_DIV, -1 } },
{ fmtTemps_0, SENSORS_SIS5595_TEMP,
{ fmtTemps_0, SIS5595_ALARM_TEMP, 0,
{ SENSORS_SIS5595_TEMP, SENSORS_SIS5595_TEMP_OVER, SENSORS_SIS5595_TEMP_HYST, -1 } },
{ fmtBoardTemperatureInput, SIS5595_ALARM_BTI, 0,
{ SENSORS_SIS5595_ALARMS, -1 } },
{ NULL }
};
/** LM78 **/
static const char *lm78_names[] = {
SENSORS_LM78_PREFIX, SENSORS_LM78J_PREFIX, SENSORS_LM79_PREFIX, /*"sis5595",*/ NULL
static const ChipDescriptor sis5595_chip = {
sis5595_names, sis5595_features, SENSORS_SIS5595_ALARMS, 0
};
static FeatureDescriptor lm78_features[] = {
{ fmtVolts_2, SENSORS_LM78_IN0,
{ SENSORS_LM78_IN0, SENSORS_LM78_IN0_MIN, SENSORS_LM78_IN0_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM78_IN1,
{ SENSORS_LM78_IN1, SENSORS_LM78_IN1_MIN, SENSORS_LM78_IN1_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM78_IN2,
{ SENSORS_LM78_IN2, SENSORS_LM78_IN2_MIN, SENSORS_LM78_IN2_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM78_IN3,
{ SENSORS_LM78_IN3, SENSORS_LM78_IN3_MIN, SENSORS_LM78_IN3_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM78_IN4,
{ SENSORS_LM78_IN4, SENSORS_LM78_IN4_MIN, SENSORS_LM78_IN4_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM78_IN5,
{ SENSORS_LM78_IN5, SENSORS_LM78_IN5_MIN, SENSORS_LM78_IN5_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM78_IN6,
{ SENSORS_LM78_IN6, SENSORS_LM78_IN6_MIN, SENSORS_LM78_IN6_MAX, -1 } },
{ fmtFans_0, SENSORS_LM78_FAN1,
{ SENSORS_LM78_FAN1, SENSORS_LM78_FAN1_MIN, SENSORS_LM78_FAN1_DIV, -1 } },
{ fmtFans_0, SENSORS_LM78_FAN2,
{ SENSORS_LM78_FAN2, SENSORS_LM78_FAN2_MIN, SENSORS_LM78_FAN2_DIV, -1 } },
{ fmtFans_0, SENSORS_LM78_FAN3,
{ SENSORS_LM78_FAN3, SENSORS_LM78_FAN3_MIN, SENSORS_LM78_FAN3_DIV, -1 } },
{ fmtTemps_0, SENSORS_LM78_TEMP,
{ SENSORS_LM78_TEMP, SENSORS_LM78_TEMP_OVER, SENSORS_LM78_TEMP_HYST, -1 } },
{ fmtVolt_2, SENSORS_LM78_VID,
{ SENSORS_LM78_VID, -1 } },
/** VIA686A **/
static const char *via686a_names[] = {
SENSORS_VIA686A_PREFIX, NULL
};
static const FeatureDescriptor via686a_features[] = {
{ fmtVolts_2, VIA686A_ALARM_IN0, 0,
{ SENSORS_VIA686A_IN0, SENSORS_VIA686A_IN0_MIN, SENSORS_VIA686A_IN0_MAX, -1 } },
{ fmtVolts_2, VIA686A_ALARM_IN1, 0,
{ SENSORS_VIA686A_IN1, SENSORS_VIA686A_IN1_MIN, SENSORS_VIA686A_IN1_MAX, -1 } },
{ fmtVolts_2, VIA686A_ALARM_IN2, 0,
{ SENSORS_VIA686A_IN2, SENSORS_VIA686A_IN2_MIN, SENSORS_VIA686A_IN2_MAX, -1 } },
{ fmtVolts_2, VIA686A_ALARM_IN3, 0,
{ SENSORS_VIA686A_IN3, SENSORS_VIA686A_IN3_MIN, SENSORS_VIA686A_IN3_MAX, -1 } },
{ fmtVolts_2, VIA686A_ALARM_IN4, 0,
{ SENSORS_VIA686A_IN4, SENSORS_VIA686A_IN4_MIN, SENSORS_VIA686A_IN4_MAX, -1 } },
{ fmtFans_0, VIA686A_ALARM_FAN1, 0,
{ SENSORS_VIA686A_FAN1, SENSORS_VIA686A_FAN1_MIN, SENSORS_VIA686A_FAN1_DIV, -1 } },
{ fmtFans_0, VIA686A_ALARM_FAN2, 0,
{ SENSORS_VIA686A_FAN2, SENSORS_VIA686A_FAN2_MIN, SENSORS_VIA686A_FAN2_DIV, -1 } },
{ fmtTemps_1, VIA686A_ALARM_TEMP, 0,
{ SENSORS_VIA686A_TEMP, SENSORS_VIA686A_TEMP_OVER, SENSORS_VIA686A_TEMP_HYST, -1 } },
{ fmtTemps_1, VIA686A_ALARM_TEMP2, 0,
{ SENSORS_VIA686A_TEMP2, SENSORS_VIA686A_TEMP2_OVER, SENSORS_VIA686A_TEMP2_HYST, -1 } },
{ fmtTemps_1, VIA686A_ALARM_TEMP3, 0,
{ SENSORS_VIA686A_TEMP3, SENSORS_VIA686A_TEMP3_OVER, SENSORS_VIA686A_TEMP3_HYST, -1 } },
{ NULL }
};
/** GL518 **/
static const char *gl518_names[] = {
SENSORS_GL518_PREFIX, NULL
};
static FeatureDescriptor gl518_features[] = {
{ fmtVolts_2, SENSORS_GL518_VDD,
{ SENSORS_GL518_VDD, SENSORS_GL518_VDD_MIN, SENSORS_GL518_VDD_MAX, -1 } },
{ fmtVolts_2, SENSORS_GL518_VIN1,
{ SENSORS_GL518_VIN1, SENSORS_GL518_VIN1_MIN, SENSORS_GL518_VIN1_MAX, -1 } },
{ fmtVolts_2, SENSORS_GL518_VIN2,
{ SENSORS_GL518_VIN2, SENSORS_GL518_VIN2_MIN, SENSORS_GL518_VIN2_MAX, -1 } },
{ fmtVolts_2, SENSORS_GL518_VIN3,
{ SENSORS_GL518_VIN3, SENSORS_GL518_VIN3_MIN, SENSORS_GL518_VIN3_MAX, -1 } },
{ fmtFans_0, SENSORS_GL518_FAN1,
{ SENSORS_GL518_FAN1, SENSORS_GL518_FAN1_MIN, SENSORS_GL518_FAN1_DIV, -1 } },
{ fmtFans_0, SENSORS_GL518_FAN2,
{ SENSORS_GL518_FAN2, SENSORS_GL518_FAN2_MIN, SENSORS_GL518_FAN2_DIV, -1 } },
{ fmtTemps_0, SENSORS_GL518_TEMP,
{ SENSORS_GL518_TEMP, SENSORS_GL518_TEMP_OVER, SENSORS_GL518_TEMP_HYST, -1 } },
{ NULL }
static const ChipDescriptor via686a_chip = {
via686a_names, via686a_features, SENSORS_VIA686A_ALARMS, 0
};
/** LM80 **/
static char *
static char * /* N.B: in sensors the first temp is %.2f!! */
fmtTemps_LM80
(double values[]) {
(double values[], int alarm, int beep) {
sprintf (buff, "%.0f C (hot limit = %.0f C, hot hysteresis = %.0f C, os limit = %.0f C, os hysteresis = %.0f C)", values[0], values[1], values[2], values[3], values[4]);
return buff;
return fmtExtra (alarm, beep);
}
static const char *lm80_names[] = {
SENSORS_LM80_PREFIX, NULL
};
static FeatureDescriptor lm80_features[] = {
{ fmtVolts_2, SENSORS_LM80_IN0,
static const FeatureDescriptor lm80_features[] = {
{ fmtVolts_2, LM80_ALARM_IN0, 0,
{ SENSORS_LM80_IN0, SENSORS_LM80_IN0_MIN, SENSORS_LM80_IN0_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM80_IN1,
{ fmtVolts_2, LM80_ALARM_IN1, 0,
{ SENSORS_LM80_IN1, SENSORS_LM80_IN1_MIN, SENSORS_LM80_IN1_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM80_IN2,
{ fmtVolts_2, LM80_ALARM_IN2, 0,
{ SENSORS_LM80_IN2, SENSORS_LM80_IN2_MIN, SENSORS_LM80_IN2_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM80_IN3,
{ fmtVolts_2, LM80_ALARM_IN3, 0,
{ SENSORS_LM80_IN3, SENSORS_LM80_IN3_MIN, SENSORS_LM80_IN3_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM80_IN4,
{ fmtVolts_2, LM80_ALARM_IN4, 0,
{ SENSORS_LM80_IN4, SENSORS_LM80_IN4_MIN, SENSORS_LM80_IN4_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM80_IN5,
{ fmtVolts_2, LM80_ALARM_IN5, 0,
{ SENSORS_LM80_IN5, SENSORS_LM80_IN5_MIN, SENSORS_LM80_IN5_MAX, -1 } },
{ fmtVolts_2, SENSORS_LM80_IN6,
{ fmtVolts_2, LM80_ALARM_IN6, 0,
{ SENSORS_LM80_IN6, SENSORS_LM80_IN6_MIN, SENSORS_LM80_IN6_MAX, -1 } },
{ fmtFans_0, SENSORS_LM80_FAN1,
{ fmtFans_0, LM80_ALARM_FAN1, 0,
{ SENSORS_LM80_FAN1, SENSORS_LM80_FAN1_MIN, SENSORS_LM80_FAN1_DIV, -1 } },
{ fmtFans_0, SENSORS_LM80_FAN2,
{ fmtFans_0, LM80_ALARM_FAN2, 0,
{ SENSORS_LM80_FAN2, SENSORS_LM80_FAN2_MIN, SENSORS_LM80_FAN2_DIV, -1 } },
{ fmtTemps_LM80, SENSORS_LM80_TEMP,
{ fmtTemps_LM80, LM80_ALARM_TEMP_HOT, 0,
{ SENSORS_LM80_TEMP, SENSORS_LM80_TEMP_HOT_MAX, SENSORS_LM80_TEMP_HOT_HYST, SENSORS_LM80_TEMP_OS_MAX, SENSORS_LM80_TEMP_OS_HYST, -1 } },
{ fmtBoardTemperatureInput, LM80_ALARM_BTI, 0,
{ SENSORS_LM80_ALARMS, -1 } },
{ fmtChassisIntrusionDetection, LM80_ALARM_CHAS, 0,
{ SENSORS_LM80_ALARMS, -1 } },
{ NULL }
};
static const ChipDescriptor lm80_chip = {
lm80_names, lm80_features, SENSORS_LM80_ALARMS, 0
};
/** GL518 **/
/* N.B: sensors supports a "gl518sm-r00" but it is not picked up in main.c...
static char *
fmtVolts_GL518_R00
(double values[], int alarm, int beep) {
if (values[0] == 0.0)
sprintf (buff, "n/a (min = %+.2f V, max = %+.2f V)", values[1], values[2]);
else
sprintf (buff, "%+.2f V (min = %+.2f V, max = %+.2f V)", values[0], values[1], values[2]);
return fmtExtra (alarm, beep);
}
*/
static const char *gl518_names[] = {
SENSORS_GL518_PREFIX, NULL
};
static const FeatureDescriptor gl518_features[] = {
{ fmtVolts_2, GL518_ALARM_VDD, GL518_ALARM_VDD,
{ SENSORS_GL518_VDD, SENSORS_GL518_VDD_MIN, SENSORS_GL518_VDD_MAX, -1 } },
{ fmtVolts_2, GL518_ALARM_VIN1, GL518_ALARM_VIN1,
{ SENSORS_GL518_VIN1, SENSORS_GL518_VIN1_MIN, SENSORS_GL518_VIN1_MAX, -1 } },
{ fmtVolts_2, GL518_ALARM_VIN2, GL518_ALARM_VIN2,
{ SENSORS_GL518_VIN2, SENSORS_GL518_VIN2_MIN, SENSORS_GL518_VIN2_MAX, -1 } },
{ fmtVolts_2, GL518_ALARM_VIN3, GL518_ALARM_VIN3,
{ SENSORS_GL518_VIN3, SENSORS_GL518_VIN3_MIN, SENSORS_GL518_VIN3_MAX, -1 } },
{ fmtFans_0, GL518_ALARM_FAN1, GL518_ALARM_FAN1,
{ SENSORS_GL518_FAN1, SENSORS_GL518_FAN1_MIN, SENSORS_GL518_FAN1_DIV, -1 } },
{ fmtFans_0, GL518_ALARM_FAN2, GL518_ALARM_FAN2,
{ SENSORS_GL518_FAN2, SENSORS_GL518_FAN2_MIN, SENSORS_GL518_FAN2_DIV, -1 } },
{ fmtTemps_0, GL518_ALARM_TEMP, GL518_ALARM_TEMP,
{ SENSORS_GL518_TEMP, SENSORS_GL518_TEMP_OVER, SENSORS_GL518_TEMP_HYST, -1 } },
{ fmtSoundAlarm, 0, 0,
{ SENSORS_GL518_BEEP_ENABLE, -1 } },
{ NULL }
};
static const ChipDescriptor gl518_chip = {
gl518_names, gl518_features, SENSORS_GL518_ALARMS, SENSORS_GL518_BEEPS
};
/** ADM1025 **/
static const char *adm1025_names[] = {
SENSORS_ADM1025_PREFIX, NULL
};
static const FeatureDescriptor adm1025_features[] = {
{ fmtVolts_2, ADM1025_ALARM_IN0, 0,
{ SENSORS_ADM1025_IN0, SENSORS_ADM1025_IN0_MIN, SENSORS_ADM1025_IN0_MAX, -1 } },
{ fmtVolts_2, ADM1025_ALARM_IN1, 0,
{ SENSORS_ADM1025_IN1, SENSORS_ADM1025_IN1_MIN, SENSORS_ADM1025_IN1_MAX, -1 } },
{ fmtVolts_2, ADM1025_ALARM_IN2, 0,
{ SENSORS_ADM1025_IN2, SENSORS_ADM1025_IN2_MIN, SENSORS_ADM1025_IN2_MAX, -1 } },
{ fmtVolts_2, ADM1025_ALARM_IN3, 0,
{ SENSORS_ADM1025_IN3, SENSORS_ADM1025_IN3_MIN, SENSORS_ADM1025_IN3_MAX, -1 } },
{ fmtVolts_2, ADM1025_ALARM_IN4, 0,
{ SENSORS_ADM1025_IN4, SENSORS_ADM1025_IN4_MIN, SENSORS_ADM1025_IN4_MAX, -1 } },
{ fmtVolts_2, ADM1025_ALARM_IN5, 0,
{ SENSORS_ADM1025_IN5, SENSORS_ADM1025_IN5_MIN, SENSORS_ADM1025_IN5_MAX, -1 } },
{ fmtTemps_1, ADM1025_ALARM_TEMP, 0,
{ SENSORS_ADM1025_TEMP1, SENSORS_ADM1025_TEMP1_OVER, SENSORS_ADM1025_TEMP1_HYST, -1 } },
{ NULL }
};
static const ChipDescriptor adm1025_chip = {
adm1025_names, adm1025_features, SENSORS_ADM1025_ALARMS, 0
};
/** W83781D **/
static const char *w83781d_names[] = {
SENSORS_W83781D_PREFIX, NULL
SENSORS_W83781D_PREFIX, SENSORS_AS99127F_PREFIX, NULL
};
static FeatureDescriptor w83781d_features[] = {
{ fmtVolts_2, SENSORS_W83781D_IN0,
/* TODO: flags inverted for as99127f */
static const FeatureDescriptor w83781d_features[] = {
{ fmtVolts_2, W83781D_ALARM_IN0, W83781D_ALARM_IN0,
{ SENSORS_W83781D_IN0, SENSORS_W83781D_IN0_MIN, SENSORS_W83781D_IN0_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83781D_IN1,
{ fmtVolts_2, W83781D_ALARM_IN1, W83781D_ALARM_IN1,
{ SENSORS_W83781D_IN1, SENSORS_W83781D_IN1_MIN, SENSORS_W83781D_IN1_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83781D_IN2,
{ fmtVolts_2, W83781D_ALARM_IN2, W83781D_ALARM_IN2,
{ SENSORS_W83781D_IN2, SENSORS_W83781D_IN2_MIN, SENSORS_W83781D_IN2_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83781D_IN3,
{ fmtVolts_2, W83781D_ALARM_IN3, W83781D_ALARM_IN3,
{ SENSORS_W83781D_IN3, SENSORS_W83781D_IN3_MIN, SENSORS_W83781D_IN3_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83781D_IN4,
{ fmtVolts_2, W83781D_ALARM_IN4, W83781D_ALARM_IN4,
{ SENSORS_W83781D_IN4, SENSORS_W83781D_IN4_MIN, SENSORS_W83781D_IN4_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83781D_IN5,
{ fmtVolts_2, W83781D_ALARM_IN5, W83781D_ALARM_IN5,
{ SENSORS_W83781D_IN5, SENSORS_W83781D_IN5_MIN, SENSORS_W83781D_IN5_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83781D_IN6,
{ fmtVolts_2, W83781D_ALARM_IN6, W83781D_ALARM_IN6,
{ SENSORS_W83781D_IN6, SENSORS_W83781D_IN6_MIN, SENSORS_W83781D_IN6_MAX, -1 } },
{ fmtFans_0, SENSORS_W83781D_FAN1,
{ fmtFans_0, W83781D_ALARM_FAN1, W83781D_ALARM_FAN1,
{ SENSORS_W83781D_FAN1, SENSORS_W83781D_FAN1_MIN, SENSORS_W83781D_FAN1_DIV, -1 } },
{ fmtFans_0, SENSORS_W83781D_FAN2,
{ fmtFans_0, W83781D_ALARM_FAN2, W83781D_ALARM_FAN2,
{ SENSORS_W83781D_FAN2, SENSORS_W83781D_FAN2_MIN, SENSORS_W83781D_FAN2_DIV, -1 } },
{ fmtFans_0, SENSORS_W83781D_FAN3,
{ fmtFans_0, W83781D_ALARM_FAN3, W83781D_ALARM_FAN3,
{ SENSORS_W83781D_FAN3, SENSORS_W83781D_FAN3_MIN, SENSORS_W83781D_FAN3_DIV, -1 } },
{ fmtTemps_1, SENSORS_W83781D_TEMP1,
{ fmtTemps_1, W83781D_ALARM_TEMP1, W83781D_ALARM_TEMP1,
{ SENSORS_W83781D_TEMP1, SENSORS_W83781D_TEMP1_OVER, SENSORS_W83781D_TEMP1_HYST, -1 } },
{ fmtTemps_1, SENSORS_W83781D_TEMP2,
{ fmtTemps_1, W83781D_ALARM_TEMP2, W83781D_ALARM_TEMP2,
{ SENSORS_W83781D_TEMP2, SENSORS_W83781D_TEMP2_OVER, SENSORS_W83781D_TEMP2_HYST, -1 } },
{ fmtTemps_1, SENSORS_W83781D_TEMP3,
{ fmtTemps_1, W83781D_ALARM_TEMP3, W83781D_ALARM_TEMP3,
{ SENSORS_W83781D_TEMP3, SENSORS_W83781D_TEMP3_OVER, SENSORS_W83781D_TEMP3_HYST, -1 } },
{ fmtVolt_2, SENSORS_W83781D_VID,
{ fmtVolt_2, 0, 0,
{ SENSORS_W83781D_VID, -1 } },
{ fmtChassisIntrusionDetection, W83781D_ALARM_CHAS, W83781D_ALARM_CHAS,
{ SENSORS_W83781D_ALARMS, -1 } },
{ fmtSoundAlarm, 0, 0, /* N.B: Is this beep correct for as99127f? */
{ SENSORS_W83781D_BEEP_ENABLE, -1 } },
{ NULL }
};
static const ChipDescriptor w83781d_chip = {
w83781d_names, w83781d_features, SENSORS_W83781D_ALARMS, SENSORS_W83781D_BEEPS
};
/** W83782D **/
static char *
fmtTemps_W8378x
(double values[]) {
(double values[], int alarm, int beep) {
int sensorID = (int) values[3];
char *sensor = (sensorID == 1) ? "PII/Celeron diode" : (sensorID == 2) ? "3904 transistor" : "thermistor"; /* Is this still right? */
sprintf (buff, "%.1f C (limit = %.1f C, hysteresis = %.1f C, sensor = %s)", values[0], values[1], values[2], sensor);
return buff;
}
const char *sensor = (sensorID == 1) ? "PII/Celeron diode" :
(sensorID == 2) ? "3904 transistor" : "thermistor";
/* Is this still right? */
sprintf (buff, "%.1f C (limit = %.1f C, hysteresis = %.1f C, sensor = %s)",
values[0], values[1], values[2], sensor);
return fmtExtra (alarm, beep);
} /* N.B: TEMP1 in sensors is just %.0f.. */
static const char *w83782d_names[] = {
SENSORS_W83782D_PREFIX, SENSORS_W83627HF_PREFIX, SENSORS_AS99127F_PREFIX, NULL
SENSORS_W83782D_PREFIX, SENSORS_W83627HF_PREFIX, NULL
};
static FeatureDescriptor w83782d_features[] = {
{ fmtVolts_2, SENSORS_W83782D_IN0,
static const FeatureDescriptor w83782d_features[] = {
{ fmtVolts_2, W83781D_ALARM_IN0, W83781D_ALARM_IN0,
{ SENSORS_W83782D_IN0, SENSORS_W83782D_IN0_MIN, SENSORS_W83782D_IN0_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83782D_IN1,
{ fmtVolts_2, W83781D_ALARM_IN1, W83781D_ALARM_IN1,
{ SENSORS_W83782D_IN1, SENSORS_W83782D_IN1_MIN, SENSORS_W83782D_IN1_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83782D_IN2,
{ fmtVolts_2, W83781D_ALARM_IN2, W83781D_ALARM_IN2,
{ SENSORS_W83782D_IN2, SENSORS_W83782D_IN2_MIN, SENSORS_W83782D_IN2_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83782D_IN3,
{ fmtVolts_2, W83781D_ALARM_IN3, W83781D_ALARM_IN3,
{ SENSORS_W83782D_IN3, SENSORS_W83782D_IN3_MIN, SENSORS_W83782D_IN3_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83782D_IN4,
{ fmtVolts_2, W83781D_ALARM_IN4, W83781D_ALARM_IN4,
{ SENSORS_W83782D_IN4, SENSORS_W83782D_IN4_MIN, SENSORS_W83782D_IN4_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83782D_IN5,
{ fmtVolts_2, W83781D_ALARM_IN5, W83781D_ALARM_IN5,
{ SENSORS_W83782D_IN5, SENSORS_W83782D_IN5_MIN, SENSORS_W83782D_IN5_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83782D_IN7,
{ fmtVolts_2, W83782D_ALARM_IN7, W83782D_ALARM_IN7,
{ SENSORS_W83782D_IN7, SENSORS_W83782D_IN7_MIN, SENSORS_W83782D_IN7_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83782D_IN8,
{ fmtVolts_2, W83782D_ALARM_IN8, W83782D_ALARM_IN8,
{ SENSORS_W83782D_IN8, SENSORS_W83782D_IN8_MIN, SENSORS_W83782D_IN8_MAX, -1 } },
{ fmtFans_0, SENSORS_W83782D_FAN1,
{ fmtFans_0, W83781D_ALARM_FAN1, W83781D_ALARM_FAN1,
{ SENSORS_W83782D_FAN1, SENSORS_W83782D_FAN1_MIN, SENSORS_W83782D_FAN1_DIV, -1 } },
{ fmtFans_0, SENSORS_W83782D_FAN2,
{ fmtFans_0, W83781D_ALARM_FAN2, W83781D_ALARM_FAN2,
{ SENSORS_W83782D_FAN2, SENSORS_W83782D_FAN2_MIN, SENSORS_W83782D_FAN2_DIV, -1 } },
{ fmtFans_0, SENSORS_W83782D_FAN3,
{ fmtFans_0, W83781D_ALARM_FAN3, W83781D_ALARM_FAN3,
{ SENSORS_W83782D_FAN3, SENSORS_W83782D_FAN3_MIN, SENSORS_W83782D_FAN3_DIV, -1 } },
{ fmtTemps_W8378x, SENSORS_W83782D_TEMP1,
{ fmtTemps_W8378x, W83781D_ALARM_TEMP1, W83781D_ALARM_TEMP1,
{ SENSORS_W83782D_TEMP1, SENSORS_W83782D_TEMP1_OVER, SENSORS_W83782D_TEMP1_HYST, SENSORS_W83782D_SENS1, -1 } },
{ fmtTemps_W8378x, SENSORS_W83782D_TEMP2,
{ fmtTemps_W8378x, W83781D_ALARM_TEMP2, W83781D_ALARM_TEMP2,
{ SENSORS_W83782D_TEMP2, SENSORS_W83782D_TEMP2_OVER, SENSORS_W83782D_TEMP2_HYST, SENSORS_W83782D_SENS2, -1 } },
{ fmtTemps_W8378x, SENSORS_W83782D_TEMP3,
{ fmtTemps_W8378x, W83781D_ALARM_TEMP3, W83781D_ALARM_TEMP3,
{ SENSORS_W83782D_TEMP3, SENSORS_W83782D_TEMP3_OVER, SENSORS_W83782D_TEMP3_HYST, SENSORS_W83782D_SENS3, -1 } },
{ fmtVolt_2, SENSORS_W83782D_VID,
{ fmtVolt_2, 0, 0,
{ SENSORS_W83782D_VID, -1 } },
{ fmtChassisIntrusionDetection, W83781D_ALARM_CHAS, W83781D_ALARM_CHAS,
{ SENSORS_W83781D_ALARMS, -1 } },
{ fmtSoundAlarm, 0, 0,
{ SENSORS_W83781D_BEEP_ENABLE, -1 } },
{ NULL }
};
static const ChipDescriptor w83782d_chip = {
w83782d_names, w83782d_features, SENSORS_W83782D_ALARMS, SENSORS_W83782D_BEEPS
};
/** W83783S **/
static const char *w83783s_names[] = {
SENSORS_W83783S_PREFIX, NULL
};
static FeatureDescriptor w83783s_features[] = {
{ fmtVolts_2, SENSORS_W83783S_IN0,
static const FeatureDescriptor w83783s_features[] = {
{ fmtVolts_2, W83781D_ALARM_IN0, W83781D_ALARM_IN0,
{ SENSORS_W83783S_IN0, SENSORS_W83783S_IN0_MIN, SENSORS_W83783S_IN0_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83783S_IN1,
{ SENSORS_W83783S_IN1, SENSORS_W83783S_IN1_MIN, SENSORS_W83783S_IN1_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83783S_IN2,
{ fmtVolts_2, W83781D_ALARM_IN2, W83781D_ALARM_IN2,
{ SENSORS_W83783S_IN2, SENSORS_W83783S_IN2_MIN, SENSORS_W83783S_IN2_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83783S_IN3,
{ fmtVolts_2, W83781D_ALARM_IN3, W83781D_ALARM_IN3,
{ SENSORS_W83783S_IN3, SENSORS_W83783S_IN3_MIN, SENSORS_W83783S_IN3_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83783S_IN4,
{ fmtVolts_2, W83781D_ALARM_IN4, W83781D_ALARM_IN4,
{ SENSORS_W83783S_IN4, SENSORS_W83783S_IN4_MIN, SENSORS_W83783S_IN4_MAX, -1 } },
{ fmtVolts_2, SENSORS_W83783S_IN5,
{ fmtVolts_2, W83781D_ALARM_IN5, W83781D_ALARM_IN5,
{ SENSORS_W83783S_IN5, SENSORS_W83783S_IN5_MIN, SENSORS_W83783S_IN5_MAX, -1 } },
{ fmtFans_0, SENSORS_W83783S_FAN1,
{ fmtFans_0, W83781D_ALARM_FAN1, W83781D_ALARM_FAN1,
{ SENSORS_W83783S_FAN1, SENSORS_W83783S_FAN1_MIN, SENSORS_W83783S_FAN1_DIV, -1 } },
{ fmtFans_0, SENSORS_W83783S_FAN2,
{ fmtFans_0, W83781D_ALARM_FAN2, W83781D_ALARM_FAN2,
{ SENSORS_W83783S_FAN2, SENSORS_W83783S_FAN2_MIN, SENSORS_W83783S_FAN2_DIV, -1 } },
{ fmtFans_0, SENSORS_W83783S_FAN3,
{ fmtFans_0, W83781D_ALARM_FAN3, W83781D_ALARM_FAN3,
{ SENSORS_W83783S_FAN3, SENSORS_W83783S_FAN3_MIN, SENSORS_W83783S_FAN3_DIV, -1 } },
{ fmtTemps_W8378x, SENSORS_W83783S_TEMP1,
{ fmtTemps_W8378x, W83781D_ALARM_TEMP1, W83781D_ALARM_TEMP1,
{ SENSORS_W83783S_TEMP1, SENSORS_W83783S_TEMP1_OVER, SENSORS_W83783S_TEMP1_HYST, SENSORS_W83783S_SENS1, -1 } },
{ fmtTemps_W8378x, SENSORS_W83783S_TEMP2,
{ fmtTemps_W8378x, W83781D_ALARM_TEMP2, W83781D_ALARM_TEMP2,
{ SENSORS_W83783S_TEMP2, SENSORS_W83783S_TEMP2_OVER, SENSORS_W83783S_TEMP2_HYST, SENSORS_W83783S_SENS2, -1 } },
{ fmtVolt_2, SENSORS_W83783S_VID,
{ fmtVolt_2, 0, 0,
{ SENSORS_W83783S_VID, -1 } },
{ fmtChassisIntrusionDetection, W83781D_ALARM_CHAS, W83781D_ALARM_CHAS,
{ SENSORS_W83781D_ALARMS, -1 } },
{ fmtSoundAlarm, 0, 0,
{ SENSORS_W83781D_BEEP_ENABLE, -1 } },
{ NULL }
};
static const ChipDescriptor w83783s_chip = {
w83783s_names, w83783s_features, SENSORS_W83783S_ALARMS, SENSORS_W83783S_BEEPS
};
/** MAXILIFE **/
static char *
fmtTemps_Maxilife
(double values[], int alarm, int beep) {
if (!values[0] && !values[1] && !values[2])
return NULL;
return fmtTemps_1 (values, alarm, beep);
}
static char *
fmtFans_Maxilife
(double values[]) {
(double values[], int alarm, int beep) {
if (!values[0] && !values[1] && !values[2])
return NULL;
if (values[0] < 0) {
sprintf (buff, "Off (min = %.0f RPM, div = %.0f)", values[1], values[2]);
} else {
sprintf (buff, "%.0f RPM (min = %.0f RPM, div = %.0f)", values[0] / values[2], values[1] / values[2], values[2]);
}
return buff;
return fmtExtra (alarm, beep);
}
static char *
fmtMHz_Maxilife
(double values[], int alarm, int beep) {
if (!values[0] && !values[1] && !values[2])
return NULL;
return fmtMHz_2 (values, alarm, beep);
}
static char *
fmtVolts_Maxilife
(double values[], int alarm, int beep) {
if (!values[0] && !values[1] && !values[2])
return NULL;
return fmtVolts_2 (values, alarm, beep);
}
static const char *maxilife_names[] = {
SENSORS_MAXI_CG_PREFIX, SENSORS_MAXI_CO_PREFIX, SENSORS_MAXI_AS_PREFIX, NULL
};
static FeatureDescriptor maxilife_features[] = {
{ fmtTemps_1, SENSORS_MAXI_CG_TEMP1,
static const FeatureDescriptor maxilife_features[] = {
{ fmtTemps_Maxilife, 0, 0,
{ SENSORS_MAXI_CG_TEMP1, SENSORS_MAXI_CG_TEMP1_MAX, SENSORS_MAXI_CG_TEMP1_HYST, -1 } },
{ fmtTemps_1, SENSORS_MAXI_CG_TEMP2,
{ fmtTemps_Maxilife, MAXI_ALARM_TEMP2, 0,
{ SENSORS_MAXI_CG_TEMP2, SENSORS_MAXI_CG_TEMP2_MAX, SENSORS_MAXI_CG_TEMP2_HYST, -1 } },
{ fmtTemps_1, SENSORS_MAXI_CG_TEMP3,
{ fmtTemps_Maxilife, 0, 0,
{ SENSORS_MAXI_CG_TEMP3, SENSORS_MAXI_CG_TEMP3_MAX, SENSORS_MAXI_CG_TEMP3_HYST, -1 } },
{ fmtTemps_1, SENSORS_MAXI_CG_TEMP4,
{ fmtTemps_Maxilife, MAXI_ALARM_TEMP4, 0,
{ SENSORS_MAXI_CG_TEMP4, SENSORS_MAXI_CG_TEMP4_MAX, SENSORS_MAXI_CG_TEMP4_HYST, -1 } },
{ fmtTemps_1, SENSORS_MAXI_CG_TEMP4,
{ fmtTemps_Maxilife, MAXI_ALARM_TEMP5, 0,
{ SENSORS_MAXI_CG_TEMP5, SENSORS_MAXI_CG_TEMP5_MAX, SENSORS_MAXI_CG_TEMP4_HYST, -1 } },
{ fmtFans_Maxilife, SENSORS_MAXI_CG_FAN1,
{ fmtFans_Maxilife, MAXI_ALARM_FAN1, 0,
{ SENSORS_MAXI_CG_FAN1, SENSORS_MAXI_CG_FAN1_MIN, SENSORS_MAXI_CG_FAN1_DIV, -1 } },
{ fmtFans_Maxilife, SENSORS_MAXI_CG_FAN2,
{ fmtFans_Maxilife, MAXI_ALARM_FAN2, 0,
{ SENSORS_MAXI_CG_FAN2, SENSORS_MAXI_CG_FAN2_MIN, SENSORS_MAXI_CG_FAN2_DIV, -1 } },
{ fmtFans_Maxilife, SENSORS_MAXI_CG_FAN3,
{ fmtFans_Maxilife, MAXI_ALARM_FAN3, 0,
{ SENSORS_MAXI_CG_FAN3, SENSORS_MAXI_CG_FAN3_MIN, SENSORS_MAXI_CG_FAN3_DIV, -1 } },
{ fmtMHz_2, SENSORS_MAXI_CG_PLL,
{ fmtMHz_Maxilife, MAXI_ALARM_PLL, 0,
{ SENSORS_MAXI_CG_PLL, SENSORS_MAXI_CG_PLL_MIN, SENSORS_MAXI_CG_PLL_MAX, -1 } },
{ fmtVolts_2, SENSORS_MAXI_CG_VID1,
{ fmtVolts_Maxilife, MAXI_ALARM_VID1, 0,
{ SENSORS_MAXI_CG_VID1, SENSORS_MAXI_CG_VID1_MIN, SENSORS_MAXI_CG_VID1_MAX, -1 } },
{ fmtVolts_2, SENSORS_MAXI_CG_VID2,
{ fmtVolts_Maxilife, MAXI_ALARM_VID2, 0,
{ SENSORS_MAXI_CG_VID2, SENSORS_MAXI_CG_VID2_MIN, SENSORS_MAXI_CG_VID2_MAX, -1 } },
{ fmtVolts_2, SENSORS_MAXI_CG_VID3,
{ fmtVolts_Maxilife, MAXI_ALARM_VID3, 0,
{ SENSORS_MAXI_CG_VID3, SENSORS_MAXI_CG_VID3_MIN, SENSORS_MAXI_CG_VID3_MAX, -1 } },
{ fmtVolts_2, SENSORS_MAXI_CG_VID4,
{ fmtVolts_Maxilife, MAXI_ALARM_VID4, 0,
{ SENSORS_MAXI_CG_VID4, SENSORS_MAXI_CG_VID4_MIN, SENSORS_MAXI_CG_VID4_MAX, -1 } },
{ NULL }
};
/** ALL **/
static const ChipDescriptor maxilife_chip = {
maxilife_names, maxilife_features, SENSORS_MAXI_CG_ALARMS, 0
};
ChipDescriptor knownChips[] = {
{ lm75_names, lm75_features },
{ adm1021_names, adm1021_features },
{ max1617_names, max1617_features },
{ adm9240_names, adm9240_features },
{ lm78_names, lm78_features },
{ sis5595_names, sis5595_features },
{ lm80_names, lm80_features },
{ gl518_names, gl518_features },
{ w83781d_names, w83781d_features },
{ w83782d_names, w83782d_features },
{ w83783s_names, w83783s_features },
{ maxilife_names, maxilife_features },
/** EEPROM **/
static char *
fmtType_EEPROM
(double values[], int alarm, int beep) {
if ((int) values[0] == 4)
sprintf (buff, "SDRAM DIMM SPD");
else
sprintf (buff, "Invalid"); /* N.B: sensors just returns, aborting further tests; I don't.. */
return fmtExtra (alarm, beep);
}
static char *
fmtRowCol_EEPROM
(double values[], int alarm, int beep) {
int row = (int) values[0];
int col = (int) values[1];
int num = (int) values[2];
int foo = (row & 0xf) + (col & 0xf) + num - 16;
if ((foo > 0) && (foo <= 10))
sprintf (buff, "%d", 1 << foo);
else
sprintf (buff, "Invalid");
return fmtExtra (alarm, beep);
}
static const char *eeprom_names[] = {
SENSORS_EEPROM_PREFIX, NULL
};
static const FeatureDescriptor eeprom_features[] = {
{ fmtType_EEPROM, 0, 0,
{ SENSORS_EEPROM_TYPE, -1 } },
{ fmtRowCol_EEPROM, 0, 0,
{ SENSORS_EEPROM_ROWADDR, SENSORS_EEPROM_COLADDR, SENSORS_EEPROM_NUMROWS, -1 } },
{ NULL }
};
static const ChipDescriptor eeprom_chip = {
eeprom_names, eeprom_features, 0, 0
};
/** DDCMON **/
static char *
fmtID_DDCMON
(double values[], int alarm, int beep) {
int value = (int) values[0];
buff[0] = ((value >> 10) & 0x1f) + '@';
buff[1] = ((value >> 5) & 0x1f) + '@';
buff[2] = (value & 0x1f) + '@';
buff[3] = ((value >> 20) & 0xf) + '0';
buff[4] = ((value >> 16) & 0xf) + '0';
buff[5] = ((value >> 28) & 0xf) + '0';
buff[6] = ((value >> 24) & 0xf) + '0';
buff[7] = '\0';
return fmtExtra (alarm, beep);
}
static const char *ddcmon_names[] = {
SENSORS_DDCMON_PREFIX, NULL
};
static const FeatureDescriptor ddcmon_features[] = {
{ fmtID_DDCMON, 0, 0,
{ SENSORS_DDCMON_ID, -1 } },
{ fmtInt, 0, 0,
{ SENSORS_DDCMON_SERIAL, -1 } },
{ fmtIntCrossInt, 0, 0,
{ SENSORS_DDCMON_VERSIZE, SENSORS_DDCMON_HORSIZE, -1 } },
{ fmtIntDashInt, 0, 0,
{ SENSORS_DDCMON_VERSYNCMIN, SENSORS_DDCMON_VERSYNCMAX, -1 } },
{ fmtIntDashInt, 0, 0,
{ SENSORS_DDCMON_HORSYNCMIN, SENSORS_DDCMON_HORSYNCMAX, -1 } },
{ NULL }
};
static const ChipDescriptor ddcmon_chip = {
ddcmon_names, ddcmon_features, 0, 0
};
/** ALL **/
const ChipDescriptor * const knownChips[] = {
&adm1021_chip,
&adm1025_chip,
&adm9240_chip,
&ddcmon_chip,
&eeprom_chip,
&gl518_chip,
&lm75_chip,
&lm78_chip,
&lm80_chip,
&max1617_chip,
&maxilife_chip,
&sis5595_chip,
&via686a_chip,
&w83781d_chip,
&w83782d_chip,
&w83783s_chip,
NULL
};
prog/sensord/lib.c
+131
View File
@@ -0,0 +1,131 @@
/*
* sensord
*
* A daemon that periodically logs sensor information to syslog.
*
* Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <time.h>
#include <unistd.h>
#include <sys/stat.h>
#include "sensord.h"
#include "lib/error.h"
static const char *sensorsCfgPaths[] = {
"/etc", "/usr/lib/sensors", "/usr/local/lib/sensors", "/usr/lib", "/usr/local/lib", NULL
};
#define CFG_PATH_LEN 4096
static char cfgPath[CFG_PATH_LEN + 1];
static time_t cfgLastModified;
int
initLib
(void) {
cfgPath[CFG_PATH_LEN] = '\0';
if (!strcmp (sensorsCfgFile, "-")) {
strncpy (cfgPath, sensorsCfgFile, CFG_PATH_LEN);
} else if (sensorsCfgFile[0] == '/') {
strncpy (cfgPath, sensorsCfgFile, CFG_PATH_LEN);
} else if (strchr (sensorsCfgFile, '/')) {
char *cwd = getcwd (NULL, 0);
snprintf (cfgPath, CFG_PATH_LEN, "%s/%s", cwd, sensorsCfgFile);
free (cwd);
} else {
int index0;
struct stat stats;
for (index0 = 0; sensorsCfgPaths[index0]; ++ index0) {
snprintf (cfgPath, CFG_PATH_LEN, "%s/%s", sensorsCfgPaths[index0], sensorsCfgFile);
if (stat (cfgPath, &stats) == 0)
break;
}
if (!sensorsCfgPaths[index0]) {
sensorLog (LOG_ERR, "Error locating sensors configuration file: %s", sensorsCfgFile);
return 9;
}
}
return 0;
}
static int
loadConfig
(int reload) {
struct stat stats;
FILE *cfg = NULL;
int ret = 0;
if (!strcmp (cfgPath, "-")) {
if (!reload) {
if ((ret = sensors_init (stdin))) {
if (ret == SENSORS_ERR_PROC)
sensorLog (LOG_ERR, "Error reading /proc; modules probably not loaded");
else
sensorLog (LOG_ERR, "Error %d loading sensors configuration file: <stdin>", ret);
ret = 12;
}
}
} else if (stat (cfgPath, &stats) < 0) {
sensorLog (LOG_ERR, "Error stating sensors configuration file: %s", cfgPath);
ret = 10;
} else if (!reload || (difftime (stats.st_mtime, cfgLastModified) > 0.0)) {
if (reload)
sensorLog (LOG_INFO, "configuration reloading");
if (!(cfg = fopen (cfgPath, "r"))) {
sensorLog (LOG_ERR, "Error opening sensors configuration file: %s", cfgPath);
ret = 11;
} else if ((ret = sensors_init (cfg))) {
if (ret == SENSORS_ERR_PROC)
sensorLog (LOG_ERR, "Error reading /proc; modules probably not loaded");
else
sensorLog (LOG_ERR, "Error %d loading sensors configuration file: %s", ret, cfgPath);
ret = 11;
} else {
cfgLastModified = stats.st_mtime;
}
if (cfg)
fclose (cfg);
}
return ret;
}
int
loadLib
(void) {
return loadConfig (0);
}
int
reloadLib
(void) {
return loadConfig (1);
}
int
unloadLib
(void) {
sensors_cleanup ();
return 0;
}
prog/sensord/sense.c
+210
View File
@@ -0,0 +1,210 @@
/*
* sensord
*
* A daemon that periodically logs sensor information to syslog.
*
* Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include "sensord.h"
#include "lib/error.h"
static int
getLabelAndValid
(sensors_chip_name name, int feature, char **label, int *valid) {
int err;
err = sensors_get_label (name, feature, label);
if (!err)
err = sensors_get_ignored (name, feature);
if (err >= 0) {
*valid = err;
err = 0;
}
return err;
}
static int
readUnknownChip
(const sensors_chip_name *chip) {
const sensors_feature_data *sensor;
int index0 = 0, index1 = 0;
int ret = 0;
while ((ret == 0) && ((sensor = sensors_get_all_features (*chip, &index0, &index1)) != NULL)) {
char *label = NULL;
int valid = 0;
double value;
if (getLabelAndValid (*chip, sensor->number, &label, &valid)) {
sensorLog (LOG_ERR, "Error getting sensor label: %s/%s", chip->prefix, sensor->name);
ret = 20;
} else if (!valid) {
/* skip invalid */
} else if (!(sensor->mode & SENSORS_MODE_R)) {
sensorLog (LOG_INFO, "%s: %s", sensor->name, label);
} else if ((ret = sensors_get_feature (*chip, sensor->number, &value))) {
sensorLog (LOG_ERR, "Error getting sensor data: %s/%s: %s", chip->prefix, sensor->name, sensors_strerror (ret));
ret = 21;
} else {
sensorLog (LOG_INFO, "%s%s: %.2f", (sensor->mapping == SENSORS_NO_MAPPING) ? "" : "-"/*, sensor->name*/, label, value);
}
if (label)
free (label);
}
return ret;
}
static int
readKnownChip
(const sensors_chip_name *chip, const ChipDescriptor *descriptor) {
const FeatureDescriptor *features = descriptor->features;
int alarms = 0, beeps = 0;
int index0, subindex;
int ret = 0;
double tmp;
if (!ret && descriptor->alarmNumber) {
if ((ret = sensors_get_feature (*chip, descriptor->alarmNumber, &tmp))) {
sensorLog (LOG_ERR, "Error getting sensor data: %s/#%d: %s", chip->prefix, descriptor->alarmNumber, sensors_strerror (ret));
ret = 20;
} else {
alarms = (int) (tmp + 0.5);
}
}
if (!ret && descriptor->beepNumber) {
if ((ret = sensors_get_feature (*chip, descriptor->beepNumber, &tmp))) {
sensorLog (LOG_ERR, "Error getting sensor data: %s/#%d: %s", chip->prefix, descriptor->beepNumber, sensors_strerror (ret));
ret = 21;
} else {
beeps = (int) (tmp + 0.5);
}
}
for (index0 = 0; (ret == 0) && features[index0].format; ++ index0) {
const FeatureDescriptor *feature = features + index0;
int labelNumber = feature->dataNumbers[0];
char *label = NULL;
int valid = 0;
if (getLabelAndValid (*chip, labelNumber, &label, &valid)) {
sensorLog (LOG_ERR, "Error getting sensor label: %s/#%d", chip->prefix, labelNumber);
ret = 22;
} else if (valid) {
double values[MAX_DATA];
int alarm = alarms & feature->alarmMask;
int beep = beeps & feature->beepMask;
for (subindex = 0; !ret && (feature->dataNumbers[subindex] >= 0); ++ subindex) {
if ((ret = sensors_get_feature (*chip, feature->dataNumbers[subindex], values + subindex))) {
sensorLog (LOG_ERR, "Error getting sensor data: %s/#%d: %s", chip->prefix, feature->dataNumbers[subindex], sensors_strerror (ret));
ret = 23;
}
}
if (ret == 0) {
char *formatted = feature->format (values, alarm, beep);
if (formatted) {
sensorLog (LOG_INFO, " %s: %s"/*, sensor->name*/, label, formatted);
}
}
}
if (label)
free (label);
}
return ret;
}
static void
idChip
(const sensors_chip_name *chip) {
const char *adapter, *algorithm;
if (chip->bus == SENSORS_CHIP_NAME_BUS_ISA)
sensorLog (LOG_INFO, "Chip: %s-isa-%04x", chip->prefix, chip->addr);
else
sensorLog (LOG_INFO, "Chip: %s-i2c-%d-%02x", chip->prefix, chip->bus, chip->addr);
adapter = sensors_get_adapter_name (chip->bus);
if (adapter)
sensorLog (LOG_INFO, "Adapter: %s", adapter);
algorithm = sensors_get_algorithm_name (chip->bus);
if (algorithm)
sensorLog (LOG_INFO, "Algorithm: %s", algorithm);
/* assert adapter || algorithm */
}
static int
setChip
(const sensors_chip_name *chip) {
int ret;
if ((ret = sensors_do_chip_sets (*chip))) {
sensorLog (LOG_ERR, "Error performing chip sets: %s: %s", chip->prefix, sensors_strerror (ret));
ret = 20;
}
return ret;
}
static int
readChip
(const sensors_chip_name *chip) {
int index0, subindex, chipindex = -1;
int ret = 0;
for (index0 = 0; knownChips[index0]; ++ index0)
for (subindex = 0; knownChips[index0]->names[subindex]; ++ subindex)
if (!strcmp (chip->prefix, knownChips[index0]->names[subindex]))
chipindex = index0;
if (chipindex >= 0)
ret = readKnownChip (chip, knownChips[chipindex]);
else
ret = readUnknownChip (chip);
return ret;
}
int
readChips
(void) {
const sensors_chip_name *chip;
int i = 0, j, ret = 0;
sensorLog (LOG_DEBUG, "sensor scan started");
while ((ret == 0) && ((chip = sensors_get_detected_chips (&i)) != NULL)) {
for (j = 0; j < numChipNames; ++ j) {
if (sensors_match_chip (*chip, chipNames[j])) {
idChip (chip);
if (doSet)
ret = setChip (chip);
else
ret = readChip (chip);
break;
}
}
}
sensorLog (LOG_DEBUG, "sensor scan finished");
return ret;
}
prog/sensord/sensord.8
+20 -2
View File
@@ -32,7 +32,7 @@ sensord \- Sensor information logging daemon.
.SH DESCRIPTION
.B Sensord
is a daemon that records in a log file the readings of all sensor chips at
an interval of five minutes, or as configured on the command line.
an interval of thirty minutes, or as configured on the command line.
.B Sensord
knows about certain chips, and outputs nicely formatted readings for them; but
@@ -52,7 +52,7 @@ is not present, the following paths are examined:
.BR /usr/local/lib .
.IP "-i interval"
Specifies the interval, in seconds, between sensor readings. The default
is 300 seconds (5 minutes).
is 1800 seconds (30 minutes).
.IP "-l log-file"
Specify the log file to which to append. If no file is specified, the
default log file `/var/log/sensors' is created. Note that this file is
@@ -82,6 +82,24 @@ being started. Typically, this is achieved with an entry in
`/etc/rc.d/...' containing
.BR modprobe (1)
commands to load the required modules before starting the daemon.
.SH WARNING
On a typical system with one sensor chip, expect about 1KB per sensor
entry in the log file. This works out at about 1.5MB per month. You
must rotate the sensor log files, using something like
.BR logrotate (8)
or equivalent. You might, for example, create `/etc/logrotate.d/sensord'
containing:
.IP
.nf
# Sample logrotate.d entry
/var/log/sensors {
missingok
postrotate
/usr/sbin/killall -HUP sensord
endscript
}
.fi
.PP
.SH BUGS
.B Sensord
does not currently support reading alarm events from sensor devices.
prog/sensord/sensord.c
+73 -293
View File
@@ -1,10 +1,9 @@
/*
* sensord
*
* A daemon that logs all sensor information to /var/log/sensors
* every 5 minutes.
* A daemon that periodically logs sensor information to syslog.
*
* Copyright (c) 1999 Merlin Hughes <merlin@merlin.org>
* Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
*
* 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
@@ -23,339 +22,95 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <dirent.h>
#include <unistd.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include "lib/sensors.h"
#include <unistd.h>
#include "sensord.h"
static const char *version = "0.2.0";
static const char *sensorsCfgPaths[] = {
"/etc", "/usr/lib/sensors", "/usr/local/lib/sensors", "/usr/lib", "/usr/local/lib", NULL
};
static const char *sensorsCfgFile = "sensors.conf";
static const char *sensorsLogFile = "/var/log/sensors";
static int sleepTime = 5 * 60;
static int cfgLoaded = 0;
time_t cfgLastModified;
static FILE *sensorsLog = NULL;
static int logOpened = 0;
static volatile sig_atomic_t done = 0;
static volatile sig_atomic_t rotate = 0;
#define LOG_BUFFER 4096
#include <stdarg.h>
void
sensorLog
(int priority, const char *fmt, ...) {
static char buffer[1 + LOG_BUFFER];
va_list ap;
va_start (ap, fmt);
vsnprintf (buffer, LOG_BUFFER, fmt, ap);
buffer[LOG_BUFFER] = '\0';
va_end (ap);
if (logOpened) {
syslog (priority, "%s", buffer);
} else if (priority != LOG_DEBUG) {
fprintf (stderr, "%s\n", buffer);
fflush (stderr);
}
}
static void
signalHandler
(int sig) {
signal (sig, signalHandler);
switch (sig) {
case SIGHUP:
rotate = 1;
break;
case SIGTERM:
done = 1;
break;
}
}
static void
initSignals
(void) {
/* I should use sigaction but... */
signal (SIGHUP, signalHandler);
signal (SIGTERM, signalHandler);
}
static char *
nowf
(void) {
time_t now;
char *str;
int len;
static char buff[1024];
time (&now);
str = ctime (&now);
len = strlen (str);
memcpy (buff, str, len - 1);
buff[len - 1] = '\0';
return buff;
}
static int
readUnknownChip
(const sensors_chip_name *chip) {
const sensors_feature_data *sensor;
int index0 = 0, index1 = 0;
int ret = 0;
while (!done && (ret == 0) && ((sensor = sensors_get_all_features (*chip, &index0, &index1)) != NULL)) {
char *label = NULL;
double value;
if (sensors_get_label (*chip, sensor->number, &label)) {
syslog (LOG_ERR, "Error getting sensor label: %s/%s", chip->prefix, sensor->name);
ret = 20;
} else if (!(sensor->mode & SENSORS_MODE_R)) {
fprintf (sensorsLog, "\t%s: %s\n", sensor->name, label);
} else if (sensors_get_feature (*chip, sensor->number, &value)) {
syslog (LOG_ERR, "Error getting sensor data: %s/%s", chip->prefix, sensor->name);
ret = 21;
} else {
fprintf (sensorsLog, "\t%s%s: %s: %.2f\n", (sensor->mapping == SENSORS_NO_MAPPING) ? "" : "-", sensor->name, label, value);
}
if (label)
free (label);
}
return ret;
}
static int
readKnownChip
(const sensors_chip_name *chip, ChipDescriptor *descriptor) {
FeatureDescriptor *features = descriptor->features;
int index0, subindex;
int ret = 0;
for (index0 = 0; !done && (ret == 0) && features[index0].format; ++ index0) {
FeatureDescriptor *feature = features + index0;
char *label = NULL;
double values[MAX_DATA];
if (sensors_get_label (*chip, feature->labelNumber, &label)) {
syslog (LOG_ERR, "Error getting sensor label: %s/#%d", chip->prefix, feature->labelNumber);
ret = 20;
}
for (subindex = 0; !done && (ret == 0) && (feature->dataNumbers[subindex] >= 0); ++ subindex) {
if (sensors_get_feature (*chip, feature->dataNumbers[subindex], values + subindex)) {
syslog (LOG_ERR, "Error getting sensor data: %s/#%d", chip->prefix, feature->dataNumbers[subindex]);
ret = 21;
}
}
if (!done && (ret == 0))
fprintf (sensorsLog, "\t%s: %s\n"/*, sensor->name*/, label, feature->format (values));
if (label)
free (label);
}
return ret;
}
static int
readChip
(const sensors_chip_name *chip) {
const char *adapter, *algorithm;
int index0, subindex, chipindex = -1;
int ret = 0;
if (chip->bus == SENSORS_CHIP_NAME_BUS_ISA)
fprintf (sensorsLog, "%s: Chip: %s-isa-%04x\n", nowf(), chip->prefix, chip->addr);
else
fprintf (sensorsLog, "%s: Chip: %s-i2c-%d-%02x\n", nowf(), chip->prefix, chip->bus, chip->addr);
adapter = sensors_get_adapter_name (chip->bus);
if (adapter)
fprintf (sensorsLog, "%s: Adapter: %s\n", nowf(), adapter);
algorithm = sensors_get_algorithm_name (chip->bus);
if (algorithm)
fprintf (sensorsLog, "%s: Algorithm: %s\n", nowf(), algorithm);
/* assert adapter || algorithm */
for (index0 = 0; knownChips[index0].names; ++ index0)
for (subindex = 0; knownChips[index0].names[subindex]; ++ subindex)
if (!strcmp (chip->prefix, knownChips[index0].names[subindex]))
chipindex = index0;
if (chipindex >= 0)
ret = readKnownChip (chip, knownChips + chipindex);
else
ret = readUnknownChip (chip);
return ret;
}
static int
readChips
(void) {
const sensors_chip_name *chip;
int index0 = 0;
int ret = 0;
fprintf (sensorsLog, "%s: Sense.\n", nowf());
fflush (sensorsLog);
while (!done && (ret == 0) && ((chip = sensors_get_detected_chips (&index0)) != NULL)) {
ret = readChip (chip);
}
fprintf (sensorsLog, "%s: Done.\n", nowf());
fflush (sensorsLog);
return ret;
}
static int
rotateLog
(void) {
int ret = 0;
if (sensorsLog != NULL) {
fprintf (sensorsLog, "%s: Rotate.\n", nowf());
fclose (sensorsLog);
}
if (!(sensorsLog = fopen (sensorsLogFile, "a"))) {
syslog (LOG_ERR, "Error opening sensors log: %s", sensorsLogFile);
ret = 1;
} else {
fprintf (sensorsLog, "%s: Started.\n", nowf());
fflush (sensorsLog);
}
rotate = 0;
return ret;
}
char cfgPath[4096] = "";
static int
initSensors
(void) {
struct stat stats;
FILE *cfg = NULL;
int ret = 0;
if (!cfgPath[0]) {
if (sensorsCfgFile[0] == '/') {
strcpy (cfgPath, sensorsCfgFile);
} else {
int index0;
for (index0 = 0; sensorsCfgPaths[index0]; ++ index0) {
sprintf (cfgPath, "%s/%s", sensorsCfgPaths[index0], sensorsCfgFile);
if (stat (cfgPath, &stats) == 0)
break;
}
if (!sensorsCfgPaths[index0]) {
syslog (LOG_ERR, "Error locating sensors configuration: %s", sensorsCfgFile);
return 9;
}
}
}
if (stat (cfgPath, &stats) < 0) {
syslog (LOG_ERR, "Error stating sensors configuration: %s", cfgPath);
ret = 10;
} else if (!cfgLoaded || (difftime (stats.st_mtime, cfgLastModified) > 0.0)) {
if (!(cfg = fopen (cfgPath, "r"))) {
syslog (LOG_ERR, "Error opening sensors configuration: %s", cfgPath);
ret = 11;
} else if (sensors_init (cfg)) {
syslog (LOG_ERR, "Error loading sensors configuration: %s", cfgPath);
ret = 11;
} else {
cfgLastModified = stats.st_mtime;
cfgLoaded = 1;
}
if (cfg)
fclose (cfg);
}
return ret;
}
static int
sensord
(void) {
int ret = 0;
openlog ("sensord", 0, LOG_DAEMON);
initSignals ();
sensorLog (LOG_INFO, "sensord started");
while (!done && (ret == 0)) {
if (rotate || (sensorsLog == NULL))
ret = rotateLog ();
if (ret == 0)
ret = initSensors ();
ret = reloadLib ();
if (ret == 0)
ret = readChips ();
if (!done && !rotate && (ret == 0))
if (!done && (ret == 0))
sleep (sleepTime);
}
if (cfgLoaded)
sensors_cleanup ();
if (sensorsLog) {
fprintf (sensorsLog, "%s: %s.\n", nowf(), ret ? "Failed" : "Stopped");
fclose (sensorsLog);
}
closelog ();
sensorLog (LOG_INFO, "sensord %s", ret ? "failed" : "stopped");
return ret;
}
static void
syntaxError
(void) {
printf ("Syntax: sensord [options]\n"
"\t-i <interval> -- seconds between samples (default 300)\n"
"\t-l <log-file> -- log file (default /var/log/sensors)\n"
"\t-c <config-file> -- configuration file (default /etc/sensors.conf)\n"
"\t-v -- display version and exit\n"
"\t-h -- display help and exit\n");
exit (EXIT_FAILURE);
}
static void
parseArgs
(int argc, char **argv) {
int i;
for (i = 1; i < argc; ++ i) {
if (!strcmp (argv[i], "-i") && (i < argc - 1)) {
sleepTime = atoi (argv[++ i]);
} else if (!strcmp (argv[i], "-l") && (i < argc - 1)) {
sensorsLogFile = argv[++ i];
} else if (!strcmp (argv[i], "-c") && (i < argc - 1)) {
sensorsCfgFile = argv[++ i];
} else if (!strcmp (argv[i], "-v")) {
printf ("sensord version %s\n", version);
exit (EXIT_SUCCESS);
} else {
syntaxError ();
}
}
}
static void
daemonize
(void) {
int pid;
if ((pid = fork ()) == -1) {
fprintf (stderr, "Error forking daemon\n");
exit (EXIT_FAILURE);
} else if (pid != 0) {
exit (EXIT_SUCCESS);
}
openlog ("sensord", 0, syslogFacility);
logOpened = 1;
if (chdir ("/") < 0) {
perror ("chdir()");
exit (EXIT_FAILURE);
}
/* I should use sigaction but... */
if (signal (SIGTERM, signalHandler) == SIG_ERR) {
perror ("signal(SIGTERM)");
exit (EXIT_FAILURE);
}
if ((pid = fork ()) == -1) {
perror ("fork()");
exit (EXIT_FAILURE);
} else if (pid != 0) {
exit (EXIT_SUCCESS);
}
if (setsid () < 0) {
perror ("setsid()");
@@ -367,10 +122,35 @@ daemonize
close (STDERR_FILENO);
}
static void
undaemonize
(void) {
closelog ();
}
int
main
(int argc, char **argv) {
parseArgs (argc, argv);
daemonize ();
return sensord ();
int ret;
if (parseArgs (argc, argv) ||
parseChips (argc, argv))
exit (EXIT_FAILURE);
if (initLib () ||
loadLib ())
exit (EXIT_FAILURE);
if (isDaemon) {
daemonize ();
ret = sensord ();
undaemonize ();
} else {
ret = readChips ();
}
if (unloadLib ())
exit (EXIT_FAILURE);
return ret;
}
prog/sensord/sensord.h
+44 -9
View File
@@ -1,10 +1,9 @@
/*
* sensord
*
* A daemon that logs all sensor information to /var/log/sensors
* every 5 minutes.
* A daemon that periodically logs sensor information to syslog.
*
* Copyright (c) 1999 Merlin Hughes <merlin@merlin.org>
* Copyright (c) 1999-2000 Merlin Hughes <merlin@merlin.org>
*
* 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
@@ -21,19 +20,55 @@
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#define version "0.3.0"
#include "lib/sensors.h"
extern void sensorLog (int priority, const char *fmt, ...);
/* from args.c */
extern int isDaemon;
extern const char *sensorsCfgFile;
extern int sleepTime;
extern int logTime;
extern int syslogFacility;
extern int doSet;
extern sensors_chip_name chipNames[];
extern int numChipNames;
extern int parseArgs (int argc, char **argv);
extern int parseChips (int argc, char **argv);
/* from lib.c */
extern int initLib (void);
extern int loadLib (void);
extern int reloadLib (void);
extern int unloadLib (void);
/* from sense.c */
extern int readChips (void);
/* from chips.c */
#define MAX_DATA 5
typedef char * (*FormatterFN) (double[]);
typedef char * (*FormatterFN) (double values[], int alarm, int beep);
typedef struct {
FormatterFN format;
int labelNumber;
int dataNumbers[MAX_DATA + 1];
int alarmMask;
int beepMask;
const int dataNumbers[MAX_DATA + 1]; /* First entry is used for the label */
} FeatureDescriptor;
typedef struct {
char **names;
FeatureDescriptor *features;
const char * const *names;
const FeatureDescriptor *features;
int alarmNumber;
int beepNumber;
} ChipDescriptor;
extern ChipDescriptor knownChips[];
extern const ChipDescriptor * const knownChips[];